diff --git a/types/aframe/test/aframe-io-tests.ts b/types/aframe/test/aframe-io-tests.ts
index 77fe716390..1120b50be8 100644
--- a/types/aframe/test/aframe-io-tests.ts
+++ b/types/aframe/test/aframe-io-tests.ts
@@ -533,9 +533,10 @@ AFRAME.registerComponent('audioanalyser-waveform', {
 		rings.forEach(function transformRing(ring: THREE.Line, index: number) {
 			var normLevel;
 			normLevel = levels[RINGCOUNT - index - 1] + 0.01; // Avoid scaling by 0.
-			(ring.material as THREE.LineBasicMaterial).color.setHSL(colors[index], 1, normLevel);
-			ring.material.linewidth = normLevel * 3;
-			ring.material.opacity = normLevel;
+			const lineMaterial = ring.material as THREE.LineBasicMaterial;
+			lineMaterial.color.setHSL(colors[index], 1, normLevel);
+			lineMaterial.linewidth = normLevel * 3;
+			lineMaterial.opacity = normLevel;
 			ring.scale.z = normLevel;
 		});
 	},
diff --git a/types/ajv-errors/index.d.ts b/types/ajv-errors/index.d.ts
index fed9e4585f..3b5c2d2322 100644
--- a/types/ajv-errors/index.d.ts
+++ b/types/ajv-errors/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/epoberezkin/ajv-errors
 // Definitions by: Afshawn Lotfi <https://github.com/afshawnlotfi>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 import { Ajv } from "ajv";
 
diff --git a/types/amplitude-js/amplitude-js-tests.ts b/types/amplitude-js/amplitude-js-tests.ts
index 4f3c2ea307..c5ffbe9898 100644
--- a/types/amplitude-js/amplitude-js-tests.ts
+++ b/types/amplitude-js/amplitude-js-tests.ts
@@ -1,85 +1,110 @@
 // Tests for Amplitude SDK TypeScript definitions
 
 module Amplitude.Tests {
+
     function all() {
-        amplitude.init('YOUR_API_KEY_HERE', null, {
-            // optional configuration options
+        var client: amplitude.AmplitudeClient = new amplitude.AmplitudeClient();
+        var identify: amplitude.Identify = new amplitude.Identify();
+        var revenue: amplitude.Revenue = new amplitude.Revenue();
+
+        client = amplitude.getInstance();
+        client = amplitude.getInstance('some name');
+
+        amplitude.__VERSION__ === '1.2.3';
+        amplitude.options.logLevel = 'WARN';
+
+        amplitude.init('API_KEY', 'USER_ID', {
             saveEvents: true,
             includeUtm: true,
             includeReferrer: true,
             batchEvents: true,
             eventUploadThreshold: 50
-        });
-        amplitude.init('YOUR_API_KEY_HERE', 'USER_ID_HERE', null, () => {});
+        }, function () { });
+        amplitude.init('API_KEY', 'USER_ID', { includeReferrer: true, includeUtm: true });
+        amplitude.init('API_KEY', 'USER_ID');
+        amplitude.init('API_KEY');
 
-        amplitude.logEvent('EVENT_IDENTIFIER_HERE');
-        amplitude.setUserId('USER_ID_HERE');
-        amplitude.init('YOUR_API_KEY_HERE', 'USER_ID_HERE');
-        amplitude.setUserId(null); // not string 'null'
-        amplitude.setVersionName('VERSION_NAME_HERE');
-
-        amplitude.regenerateDeviceId();
-        amplitude.setDeviceId('CUSTOM_DEVICE_ID');
-
-        amplitude.logEvent('EVENT_IDENTIFIER_HERE', {
-            'color': 'blue',
-            'age': 20,
-            'key': 'value'
-        });
+        amplitude.logEvent('Clicked Homepage Button', { 'finished_flow': false, 'clicks': 15 });
+        amplitude.logEvent('EVENT_IDENTIFIER_HERE', { 'color': 'blue', 'age': 20, 'key': 'value' });
         amplitude.logEvent("EVENT_IDENTIFIER_HERE", null, (httpCode, response) => { });
+        amplitude.logEventWithGroups('initialize_game', { 'key': 'value' }, { 'sport': 'soccer' });
+
+        amplitude.setDeviceId('45f0954f-eb79-4463-ac8a-233a6f45a8f0');
+        amplitude.setDomain('.amplitude.com');
+        amplitude.setGroup('orgId', '15');
+        amplitude.setGroup('orgId', ['15', '16']);
+        amplitude.setUserId('joe@gmail.com');
+        amplitude.setUserProperties({ 'gender': 'female', 'sign_up_complete': true })
+        amplitude.setVersionName('1.12.3');
+        amplitude.isNewSession();
+        amplitude.getSessionId() === 123;
 
-        let identify = new amplitude.Identify().set('gender', 'female').set('age', 20);
         amplitude.identify(identify);
+        amplitude.logRevenue(3.99, 1, 'product_1234');
+        amplitude.logRevenueV2(revenue);
 
-        identify = new amplitude.Identify().setOnce('sign_up_date', '08/24/2015');
-        amplitude.identify(identify);
 
-        identify = new amplitude.Identify().setOnce('sign_up_date', '09/14/2015');
-        amplitude.identify(identify);
+        client.init('API_KEY', 'USER_ID', {
+            saveEvents: true,
+            includeUtm: true,
+            includeReferrer: true,
+            batchEvents: true,
+            eventUploadThreshold: 50
+        }, function () { });
+        client.init('API_KEY', 'USER_ID', { includeReferrer: true, includeUtm: true });
+        client.init('API_KEY', 'USER_ID');
+        client.init('API_KEY');
 
-        identify = new amplitude.Identify().unset('gender').unset('age');
-        amplitude.identify(identify);
+        client.logEvent('Clicked Homepage Button', { 'finished_flow': false, 'clicks': 15 });
+        client.logEvent('EVENT_IDENTIFIER_HERE', { 'color': 'blue', 'age': 20, 'key': 'value' });
+        client.logEvent("EVENT_IDENTIFIER_HERE", null, (httpCode, response) => { });
+        client.logEventWithGroups('initialize_game', { 'key': 'value' }, { 'sport': 'soccer' });
+        client.logEventWithTimestamp('EVENT_IDENTIFIER_HERE', { 'key': 'value' }, 1505430378000, (httpCode, response) => { });
 
+
+        client.setDeviceId('45f0954f-eb79-4463-ac8a-233a6f45a8f0');
+        client.setDomain('.amplitude.com');
+        client.setUserId('joe@gmail.com');
+        client.setOptOut(true);
+        client.setGroup('type', 'name');
+        client.setGroup('type', ['name', 'name2']);
+        client.setUserProperties({ 'gender': 'female', 'sign_up_complete': true });
+        client.setGlobalUserProperties({ 'gender': 'female', 'sign_up_complete': true });
+        client.setVersionName('1.12.3');
+        client.setSessionId(1505430378000);
+
+        client.options.logLevel = 'WARN';
+        client.getSessionId() === 123;
+        client.isNewSession() === true;
+        client.regenerateDeviceId();
+        client.clearUserProperties();
+
+        client.identify(identify);
+        client.logRevenue(3.99, 1, 'product_1234');
+        client.logRevenueV2(revenue);
+
+
+        identify = new amplitude.Identify().set('colors', ['rose', 'gold']).add('karma', 1).setOnce('sign_up_date', '2016-03-31');
         identify = new amplitude.Identify().add('karma', 1).add('friends', 1);
-        amplitude.identify(identify);
-
-        identify = new amplitude.Identify().append('ab-tests', 'new-user-test').append('some_list', [1, 2, 3, 4, 'values']);
-        amplitude.identify(identify);
-
-        identify = new amplitude.Identify().prepend('ab-tests', 'new-user-test').prepend('some_list', [1, 2, 3, 4, 'values']);
-        amplitude.identify(identify);
-
-        identify = new amplitude.Identify()
-            .set('karma', 10)
-            .add('karma', 1)
-            .unset('karma');
-        amplitude.identify(identify);
-
+        identify = new amplitude.Identify().set('karma', 10).add('karma', 1).unset('karma');
+        identify = new amplitude.Identify().append('ab-tests', 'new-user-tests');
+        identify.append('some_list', [1, 2, 3, 4, 'values']);
+        identify = new amplitude.Identify().prepend('ab-tests', 'new-user-tests');
+        identify.prepend('some_list', [1, 2, 3, 4, 'values']);
+        identify = new amplitude.Identify().set('user_type', 'beta');
+        identify.set('name', { 'first': 'John', 'last': 'Doe' });
+        identify = new amplitude.Identify().setOnce('sign_up_date', '2016-04-01');
+        identify = new amplitude.Identify().unset('user_type').unset('age');
         identify = new amplitude.Identify()
             .set('colors', ['rose', 'gold'])
             .append('ab-tests', 'campaign_a')
             .append('existing_list', [4, 5]);
-        amplitude.identify(identify);
 
-        amplitude.setUserProperties({
-            gender: 'female',
-            age: 20
-        });
 
-        amplitude.clearUserProperties();
-
-        amplitude.setOptOut(true);
-        amplitude.setOptOut(false);
-
-        amplitude.setGroup('orgId', '15');
-        amplitude.setGroup('sport', ['soccer', 'tennis']);
-
-        // TODO: Implement those.
-        /*
-        var revenue = new amplitude.Revenue().setProductId('com.company.productId').setPrice(3.99).setQuantity(3);
-        amplitude.logRevenueV2(revenue);
-
-        amplitude.logEventWithGroups('initialize_game', { 'key': 'value' }, { 'sport': 'soccer' });
-        */
+        revenue = new amplitude.Revenue().setProductId('productIdentifier').setPrice(10.99);
+        revenue = new amplitude.Revenue().setProductId('productIdentifier').setPrice(10.99).setEventProperties({ 'city': 'San Francisco' });
+        revenue = new amplitude.Revenue().setProductId('productIdentifier').setPrice(10.99).setQuantity(5);
+        revenue = new amplitude.Revenue().setProductId('productIdentifier').setPrice(10.99).setRevenueType('purchase');
     }
+
 }
diff --git a/types/amplitude-js/index.d.ts b/types/amplitude-js/index.d.ts
index 613f5ad5d8..1cdb843589 100644
--- a/types/amplitude-js/index.d.ts
+++ b/types/amplitude-js/index.d.ts
@@ -1,61 +1,146 @@
-// Type definitions for Amplitude SDK 2.12.1
+// Type definitions for Amplitude SDK 4.4.0
 // Project: https://github.com/amplitude/Amplitude-Javascript
 // Definitions by: Arvydas Sidorenko <https://github.com/Asido>
-// Definitions: https://github.com/Asido/DefinitelyTyped
+//                 Dan Manastireanu <https://github.com/danmana>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 declare module amplitude {
+
+    type Callback = (responseCode: number, responseBody: string, details?: { reason: string; }) => void;
+    type LogReturn = number | void;
+
     interface Config {
+        apiEndpoint?: string;
         batchEvents?: boolean;
         cookieExpiration?: number;
         cookieName?: string;
+        userId?: string;
         deviceId?: string;
+        deviceIdFromUrlParam?: boolean;
         domain?: string;
         eventUploadPeriodMillis?: number;
         eventUploadThreshold?: number;
+        forceHttps?: boolean;
+        includeGclid?: boolean;
         includeReferrer?: boolean;
         includeUtm?: boolean;
         language?: string;
+        logLevel?: 'DISABLE' | 'ERROR' | 'WARN' | 'INFO';
         optOut?: boolean;
         platform?: string;
         saveEvents?: boolean;
         savedMaxCount?: number;
+        saveParamsReferrerOncePerSession?: boolean;
         sessionTimeout?: number;
+        trackingOptions?: {
+            city?: boolean;
+            country?: boolean;
+            device_model?: boolean;
+            dma?: boolean;
+            ip_address?: boolean;
+            language?: boolean;
+            os_name?: boolean;
+            os_version?: boolean;
+            platform?: boolean;
+            region?: boolean;
+            version_name?: boolean;
+        },
+        unsentKey?: string;
+        unsentIdentifyKey?: string;
         uploadBatchSize?: number;
     }
 
     export class Identify {
         set(key: string, value: any): Identify;
         setOnce(key: string, value: any): Identify;
-        add(key: string, value: number): Identify;
+        add(key: string, value: number | string): Identify;
         append(key: string, value: any): Identify;
         prepend(key: string, value: any): Identify;
 
         unset(key: string): Identify;
     }
 
-    export function init(apiKey: string): void;
-    export function init(apiKey: string, userId: string): void;
-    export function init(apiKey: string, userId: string, options: Config): void;
-    export function init(apiKey: string, userId: string, options: Config, callback: () => void): void;
+    export class Revenue {
+
+        setProductId(productId: string): Revenue;
+        setQuantity(quantity: number): Revenue;
+        setPrice(price: number): Revenue;
+        setRevenueType(revenueType: string): Revenue;
+        setEventProperties(eventProperties: any): Revenue;
+    }
+
+    export class AmplitudeClient {
+
+        constructor(instanceName?: string);
+
+        options: Config;
+
+        init(apiKey: string, userId?: string, config?: Config, callback?: (client: AmplitudeClient) => void): void;
+
+        setVersionName(versionName: string): void;
+
+        isNewSession(): boolean;
+        setSessionId(sessionId: number): void;
+        getSessionId(): number;
+
+        setDomain(domain: string): void;
+        setUserId(userId: string): void;
+
+        setDeviceId(id: string): void;
+        regenerateDeviceId(): void;
+
+        identify(identify_obj: Identify, opt_callback?: Callback): void;
+
+        setUserProperties(properties: any): void;
+        setGlobalUserProperties(properties: any): void;
+        clearUserProperties(): void;
+
+        setOptOut(enable: boolean): void;
+
+        setGroup(groupType: string, groupName: string | string[]): void;
+
+        logEvent(event: string, data?: any, callback?: Callback): LogReturn;
+        logEventWithGroups(event: string, data?: any, groups?: any, callback?: Callback): LogReturn;
+        logRevenueV2(revenue_obj: Revenue): LogReturn;
+        logRevenue(pric: number, quantity: number, product: string): LogReturn;
+        logEventWithTimestamp(event: string, data?: any, timestamp?: number, callback?: Callback): LogReturn;
+    }
+
+    // Proxy methods that get executed on the default AmplitudeClient instance (not all client methods are proxied)
+
+    export function init(apiKey: string, userId?: string, options?: Config, callback?: (client: AmplitudeClient) => void): void;
 
     export function setVersionName(version: string): void;
+
+    export function isNewSession(): boolean;
+    export function getSessionId(): number;
+
+    export function setDomain(domain: string): void;
+
     export function setUserId(userId: string): void;
 
     export function setDeviceId(id: string): void;
     export function regenerateDeviceId(): void;
 
-    export function identify(identify: Identify): void;
+    export function identify(identify: Identify, callback?: Callback): void;
 
-    export function setUserProperties(properties: Object): void;
+    export function setUserProperties(properties: any): void;
+    export function setGlobalUserProperties(properties: any): void;
     export function clearUserProperties(): void;
 
     export function setOptOut(optOut: boolean): void;
 
     export function setGroup(groupType: string, groupName: string | string[]): void;
 
-    export function logEvent(event: string): void;
-    export function logEvent(event: string, data: Object): void;
-    export function logEvent(event: string, data: Object, callback: (httpCode: number, response: any) => void): void;
+    export function logEvent(event: string, data?: any, callback?: Callback): LogReturn;
+    export function logEventWithGroups(event: string, data?: any, groups?: any, callback?: Callback): LogReturn;
+    export function logRevenueV2(revenue_obj: Revenue): LogReturn;
+    export function logRevenue(pric: number, quantity: number, product: string): LogReturn;
+    export function logEventWithTimestamp(event: string, data?: any, timestamp?: number, callback?: Callback): LogReturn;
 
+
+
+    export function getInstance(instanceName?: string): AmplitudeClient;
+    export const __VERSION__: string;
     export var options: Config;
 }
diff --git a/types/amqplib/tslint.json b/types/amqplib/tslint.json
index bfc9508c49..f64a783725 100644
--- a/types/amqplib/tslint.json
+++ b/types/amqplib/tslint.json
@@ -2,6 +2,7 @@
     "extends": "dtslint/dt.json",
     "rules": {
         // All are TODOs
+        "no-any-union": false,
         "no-empty-interface": false,
         "prefer-const": false
     }
diff --git a/types/angular-pdfjs-viewer/tsconfig.json b/types/angular-pdfjs-viewer/tsconfig.json
index bdae87bf50..05a851782e 100644
--- a/types/angular-pdfjs-viewer/tsconfig.json
+++ b/types/angular-pdfjs-viewer/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/angular-q-extras/tsconfig.json b/types/angular-q-extras/tsconfig.json
index 3047a809eb..973131f033 100644
--- a/types/angular-q-extras/tsconfig.json
+++ b/types/angular-q-extras/tsconfig.json
@@ -6,7 +6,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/ansi-styles/index.d.ts b/types/ansi-styles/index.d.ts
index a07ac962ab..b67cdada41 100644
--- a/types/ansi-styles/index.d.ts
+++ b/types/ansi-styles/index.d.ts
@@ -3,7 +3,7 @@
 // Definitions by: bryn austin bellomy <https://github.com/brynbellomy>
 //                 plylrnsdy <https://github.com/plylrnsdy>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
+// TypeScript Version: 2.1
 
 import { EscapeCode } from './escape-code';
 
diff --git a/types/apollo-codegen/index.d.ts b/types/apollo-codegen/index.d.ts
index ea5d415418..4309db4116 100644
--- a/types/apollo-codegen/index.d.ts
+++ b/types/apollo-codegen/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/apollographql/apollo-codegen
 // Definitions by: Bradley Ayers <https://github.com/bradleyayers>, Maria Carrasco <https://github.com/kostspielig>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.6
 
 import { Options } from 'graphql/utilities/schemaPrinter';
 
diff --git a/types/apollo-upload-client/index.d.ts b/types/apollo-upload-client/index.d.ts
index 7c1e3cb7b6..c6476f2ae9 100644
--- a/types/apollo-upload-client/index.d.ts
+++ b/types/apollo-upload-client/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/jaydenseric/apollo-upload-client#readme
 // Definitions by: Edward Sammut Alessi <https://github.com/Slessi>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.2
+// TypeScript Version: 2.6
 
 import { ApolloLink } from "apollo-link";
 import { HttpOptions } from "apollo-link-http-common";
diff --git a/types/apollo-upload-client/tsconfig.json b/types/apollo-upload-client/tsconfig.json
index 2a023ff111..a78e75500c 100644
--- a/types/apollo-upload-client/tsconfig.json
+++ b/types/apollo-upload-client/tsconfig.json
@@ -2,7 +2,9 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6", "dom"
+            "es6",
+            "dom",
+            "esnext.asynciterable"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/arangodb/index.d.ts b/types/arangodb/index.d.ts
index 32ad04210b..76641f5270 100644
--- a/types/arangodb/index.d.ts
+++ b/types/arangodb/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/arangodb/arangodb
 // Definitions by: Alan Plum <https://github.com/pluma>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.6
 
 /// <reference types="node" />
 
diff --git a/types/arangodb/tsconfig.json b/types/arangodb/tsconfig.json
index f778fd7c47..d30610b604 100644
--- a/types/arangodb/tsconfig.json
+++ b/types/arangodb/tsconfig.json
@@ -1,7 +1,7 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": ["es6"],
+        "lib": ["es6", "esnext.asynciterable"],
         "noImplicitAny": true,
         "noImplicitThis": true,
         "strictNullChecks": true,
diff --git a/types/astring/index.d.ts b/types/astring/index.d.ts
new file mode 100644
index 0000000000..c2768e7d5f
--- /dev/null
+++ b/types/astring/index.d.ts
@@ -0,0 +1,50 @@
+// Type definitions for astring 1.3
+// Project: https://github.com/davidbonnet/astring
+// Definitions by: Nikolaj Kappler <https://github.com/nkappler>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+import * as ESTree from 'estree';
+import 'node';
+import { Stream } from 'stream';
+
+export interface Options {
+    /** string to use for indentation (defaults to "  ") */
+    indent?: string;
+    /** string to use for line endings (defaults to "\n") */
+    lineEnd?: string;
+    /** indent level to start from (defaults to 0) */
+    startingIndentLevel?: number;
+    /** generate comments if true (defaults to false) */
+    comments?: boolean;
+    /** custom code generator (defaults to astring.baseGenerator) */
+    generator?: object;
+    /** source map generator (defaults to null), see https://github.com/mozilla/source-map#sourcemapgenerator */
+    sourceMap?: any;
+}
+
+/** Returns a string representing the rendered code of the provided AST `node`. However, if an `output` stream is provided in the options, it writes to that stream and returns it. */
+export function generate(node: ESTree.Node, options?: Options): string;
+/** Returns a string representing the rendered code of the provided AST `node`. However, if an `output` stream is provided in the options, it writes to that stream and returns it. */
+export function generate(node: ESTree.Node, options: Options & {
+    /** output stream to write the rendered code to (defaults to null) */
+    output: Stream;
+}): Stream;
+
+/**
+ * A code generator consists of a mapping of node names and functions that take two arguments: `node` and `state`.
+ * The `node` points to the node from which to generate the code and the `state` exposes the `write` method that takes generated code strings.
+ */
+export type Generator = { [key in ESTree.Node["type"]]: (node: Extract<ESTree.Node, { type: key }>, state: { write(s: string): void }) => void };
+
+/** Base generator that can be used to extend Astring. See https://github.com/davidbonnet/astring#extending */
+export const baseGenerator: Generator;
+
+declare global {
+    interface astring {
+        generate: typeof generate;
+        /** Base generator that can be used to extend Astring. See https://github.com/davidbonnet/astring#extending */
+        baseGenerator: Generator;
+    }
+    const astring: astring;
+}
diff --git a/types/astring/test/astring-global.test.ts b/types/astring/test/astring-global.test.ts
new file mode 100644
index 0000000000..c756c9c60e
--- /dev/null
+++ b/types/astring/test/astring-global.test.ts
@@ -0,0 +1,5 @@
+// global scope function
+astring.generate(null);
+
+// global scope function
+astring.baseGenerator.Program(null, { write(s: string) { return; } });
diff --git a/types/astring/test/astring.test.ts b/types/astring/test/astring.test.ts
new file mode 100644
index 0000000000..782af01017
--- /dev/null
+++ b/types/astring/test/astring.test.ts
@@ -0,0 +1,32 @@
+import { baseGenerator, generate } from "astring";
+import { FunctionExpression, MemberExpression, Program } from "estree";
+import { Stream } from "stream";
+
+const ast: Program = null;
+const functionE: FunctionExpression = null;
+const memberE: MemberExpression = null;
+
+// should accept different nodes
+generate(ast);
+generate(functionE);
+generate(memberE);
+
+// options without output option should generate string
+const string: string = generate(ast, {
+    comments: true,
+    generator: baseGenerator,
+    indent: "\t",
+    lineEnd: "\n",
+    startingIndentLevel: 42,
+    sourceMap: null
+});
+
+// options with output option should return Stream
+const stream: Stream = generate(ast, {
+    output: new Stream()
+});
+
+// Generator should map node types to functions whose first parameter is same node type
+baseGenerator.Program(ast, { write(s: string) { return; } });
+baseGenerator.FunctionExpression(functionE, { write(s: string) { return; } });
+baseGenerator.MemberExpression(memberE, { write(s: string) { return; } });
diff --git a/types/astring/tsconfig.json b/types/astring/tsconfig.json
new file mode 100644
index 0000000000..b00d44f643
--- /dev/null
+++ b/types/astring/tsconfig.json
@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": false,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "test/astring.test.ts",
+        "test/astring-global.test.ts"
+    ]
+}
\ No newline at end of file
diff --git a/types/astring/tslint.json b/types/astring/tslint.json
new file mode 100644
index 0000000000..f93cf8562a
--- /dev/null
+++ b/types/astring/tslint.json
@@ -0,0 +1,3 @@
+{
+    "extends": "dtslint/dt.json"
+}
diff --git a/types/async/index.d.ts b/types/async/index.d.ts
index 961dd73ebb..e6cfd3bcaa 100644
--- a/types/async/index.d.ts
+++ b/types/async/index.d.ts
@@ -2,34 +2,34 @@
 // Project: https://github.com/caolan/async
 // Definitions by: Boris Yankov <https://github.com/borisyankov>, Arseniy Maximov <https://github.com/kern0>, Joe Herman <https://github.com/Penryn>, Angus Fenying <https://github.com/fenying>, Pascal Martin <https://github.com/pascalmartin>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
+// TypeScript Version: 2.3
 
 export as namespace async;
 
 export interface Dictionary<T> { [key: string]: T; }
 export type IterableCollection<T> = T[] | IterableIterator<T> | Dictionary<T>
 
-export interface ErrorCallback<T> { (err?: T): void; }
-export interface AsyncBooleanResultCallback<E> { (err?: E, truthValue?: boolean): void; }
-export interface AsyncResultCallback<T, E> { (err?: E, result?: T): void; }
-export interface AsyncResultArrayCallback<T, E> { (err?: E, results?: Array<T | undefined>): void; }
-export interface AsyncResultObjectCallback<T, E> { (err: E | undefined, results: Dictionary<T | undefined>): void; }
+export interface ErrorCallback<E = Error> { (err?: E | null): void; }
+export interface AsyncBooleanResultCallback<E = Error> { (err?: E | null, truthValue?: boolean): void; }
+export interface AsyncResultCallback<T, E = Error> { (err?: E | null, result?: T): void; }
+export interface AsyncResultArrayCallback<T, E = Error> { (err?: E | null, results?: Array<T | undefined>): void; }
+export interface AsyncResultObjectCallback<T, E = Error> { (err: E | undefined, results: Dictionary<T | undefined>): void; }
 
-export interface AsyncFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
-export interface AsyncFunctionEx<T, E> { (callback: (err?: E, ...results: T[]) => void): void; }
-export interface AsyncIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
-export interface AsyncForEachOfIterator<T, E> { (item: T, key: number|string, callback: ErrorCallback<E>): void; }
-export interface AsyncResultIterator<T, R, E> { (item: T, callback: AsyncResultCallback<R, E>): void; }
-export interface AsyncMemoIterator<T, R, E> { (memo: R | undefined, item: T, callback: AsyncResultCallback<R, E>): void; }
-export interface AsyncBooleanIterator<T, E> { (item: T, callback: AsyncBooleanResultCallback<E>): void; }
+export interface AsyncFunction<T, E = Error> { (callback: (err?: E | null, result?: T) => void): void; }
+export interface AsyncFunctionEx<T, E = Error> { (callback: (err?: E | null, ...results: T[]) => void): void; }
+export interface AsyncIterator<T, E = Error> { (item: T, callback: ErrorCallback<E>): void; }
+export interface AsyncForEachOfIterator<T, E = Error> { (item: T, key: number|string, callback: ErrorCallback<E>): void; }
+export interface AsyncResultIterator<T, R, E = Error> { (item: T, callback: AsyncResultCallback<R, E>): void; }
+export interface AsyncMemoIterator<T, R, E = Error> { (memo: R | undefined, item: T, callback: AsyncResultCallback<R, E>): void; }
+export interface AsyncBooleanIterator<T, E = Error> { (item: T, callback: AsyncBooleanResultCallback<E>): void; }
 
-export interface AsyncWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
-export interface AsyncVoidFunction<E> { (callback: ErrorCallback<E>): void; }
+export interface AsyncWorker<T, E = Error> { (task: T, callback: ErrorCallback<E>): void; }
+export interface AsyncVoidFunction<E = Error> { (callback: ErrorCallback<E>): void; }
 
 export type AsyncAutoTasks<R extends Dictionary<any>, E> = { [K in keyof R]: AsyncAutoTask<R[K], R, E> }
 export type AsyncAutoTask<R1, R extends Dictionary<any>, E> = AsyncAutoTaskFunctionWithoutDependencies<R1, E> | (keyof R | AsyncAutoTaskFunction<R1, R, E>)[];
-export interface AsyncAutoTaskFunctionWithoutDependencies<R1, E> { (cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
-export interface AsyncAutoTaskFunction<R1, R extends Dictionary<any>, E> { (results: R, cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
+export interface AsyncAutoTaskFunctionWithoutDependencies<R1, E = Error> { (cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
+export interface AsyncAutoTaskFunction<R1, R extends Dictionary<any>, E = Error> { (results: R, cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
 
 export interface AsyncQueue<T> {
     length(): number;
@@ -37,9 +37,8 @@ export interface AsyncQueue<T> {
     running(): number;
     idle(): boolean;
     concurrency: number;
-    push<E>(task: T | T[], callback?: ErrorCallback<E>): void;
-    push<R,E>(task: T, callback?: AsyncResultCallback<R, E>): void;
-    unshift<E>(task: T | T[], callback?: ErrorCallback<E>): void;
+    push<R,E = Error>(task: T | T[], callback?: AsyncResultCallback<R, E>): void;
+    unshift<E = Error>(task: T | T[], callback?: ErrorCallback<E>): void;
     saturated: () => any;
     empty: () => any;
     drain: () => any;
@@ -61,7 +60,7 @@ export interface AsyncPriorityQueue<T> {
     concurrency: number;
     started: boolean;
     paused: boolean;
-    push<R,E>(task: T | T[], priority: number, callback?: AsyncResultArrayCallback<R, E>): void;
+    push<R,E = Error>(task: T | T[], priority: number, callback?: AsyncResultArrayCallback<R, E>): void;
     saturated: () => any;
     empty: () => any;
     drain: () => any;
@@ -94,112 +93,113 @@ export interface AsyncCargo {
 }
 
 // Collections
-export function each<T, E>(arr: IterableCollection<T>, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
+export function each<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
 export const eachSeries: typeof each;
-export function eachLimit<T, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
+export function eachLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
 export const forEach: typeof each;
 export const forEachSeries: typeof each;
 export const forEachLimit: typeof eachLimit;
-export function forEachOf<T, E>(obj: IterableCollection<T>, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
+export function forEachOf<T, E = Error>(obj: IterableCollection<T>, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
 export const forEachOfSeries: typeof forEachOf;
-export function forEachOfLimit<T, E>(obj: IterableCollection<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
+export function forEachOfLimit<T, E = Error>(obj: IterableCollection<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
 export const eachOf: typeof forEachOf;
 export const eachOfSeries: typeof forEachOf;
 export const eachOfLimit: typeof forEachOfLimit;
-export function map<T, R, E>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
-export function map<T, R, E>(arr: Dictionary<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function map<T, R, E = Error>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function map<T, R, E = Error>(arr: Dictionary<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
 export const mapSeries: typeof map;
-export function mapLimit<T, R, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
-export function mapValuesLimit<T, R, E>(obj: Dictionary<T>, limit: number, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
-export function mapValues<T, R, E>(obj: Dictionary<T>, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
+export function mapLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function mapValuesLimit<T, R, E = Error>(obj: Dictionary<T>, limit: number, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
+export function mapValues<T, R, E = Error>(obj: Dictionary<T>, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
 export const mapValuesSeries: typeof mapValues;
-export function filter<T, E>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
+export function filter<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
 export const filterSeries: typeof filter;
-export function filterLimit<T, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
+export function filterLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
 export const select: typeof filter;
 export const selectSeries: typeof filter;
 export const selectLimit: typeof filterLimit;
 export const reject: typeof filter;
 export const rejectSeries: typeof filter;
 export const rejectLimit: typeof filterLimit;
-export function reduce<T, R, E>(arr: T[] | IterableIterator<T>, memo: R, iterator: AsyncMemoIterator<T, R, E>, callback?: AsyncResultCallback<R, E>): void;
+export function reduce<T, R, E = Error>(arr: T[] | IterableIterator<T>, memo: R, iterator: AsyncMemoIterator<T, R, E>, callback?: AsyncResultCallback<R, E>): void;
 export const inject: typeof reduce;
 export const foldl: typeof reduce;
 export const reduceRight: typeof reduce;
 export const foldr: typeof reduce;
-export function detect<T, E>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
+export function detect<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
 export const detectSeries: typeof detect;
-export function detectLimit<T, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
+export function detectLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
 export const find: typeof detect;
 export const findSeries: typeof detect;
 export const findLimit: typeof detectLimit;
-export function sortBy<T, V, E>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, V, E>, callback?: AsyncResultArrayCallback<T, E>): void;
-export function some<T, E>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function sortBy<T, V, E = Error>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, V, E>, callback?: AsyncResultArrayCallback<T, E>): void;
+export function some<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
 export const someSeries: typeof some;
-export function someLimit<T, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function someLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
 export const any: typeof some;
 export const anySeries: typeof someSeries;
 export const anyLimit: typeof someLimit;
-export function every<T, E>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function every<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
 export const everySeries: typeof every;
-export function everyLimit<T, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function everyLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
 export const all: typeof every;
 export const allSeries: typeof every;
 export const allLimit: typeof everyLimit;
 
-export function concat<T, R, E>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
-export function concatLimit<T, R, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function concat<T, R, E = Error>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function concatLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
 export const concatSeries: typeof concat;
 
 // Control Flow
-export function series<T, E>(tasks: AsyncFunction<T, E>[], callback?: AsyncResultArrayCallback<T, E>): void;
-export function series<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
-export function parallel<T, E>(tasks: Array<AsyncFunction<T, E>>, callback?: AsyncResultArrayCallback<T, E>): void;
-export function parallel<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
-export function parallelLimit<T, E>(tasks: Array<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultArrayCallback<T, E>): void;
-export function parallelLimit<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultObjectCallback<T, E>): void;
-export function whilst<E>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-export function doWhilst<T, E>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
-export function until<E>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-export function doUntil<T, E>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
-export function during<E>(test: (testCallback : AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-export function doDuring<E>(fn: AsyncVoidFunction<E>, test: (testCallback: AsyncBooleanResultCallback<E>) => void, callback: ErrorCallback<E>): void;
-export function forever<E>(next: (next : ErrorCallback<E>) => void, errBack: ErrorCallback<E>) : void;
-export function waterfall<T, E>(tasks: Function[], callback?: AsyncResultCallback<T, E | Error>): void;
+export function series<T, E = Error>(tasks: AsyncFunction<T, E>[], callback?: AsyncResultArrayCallback<T, E>): void;
+export function series<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
+export function parallel<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback?: AsyncResultArrayCallback<T, E>): void;
+export function parallel<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
+export function parallelLimit<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultArrayCallback<T, E>): void;
+export function parallelLimit<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultObjectCallback<T, E>): void;
+export function whilst<E = Error>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
+export function doWhilst<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
+export function until<E = Error>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
+export function doUntil<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
+export function during<E = Error>(test: (testCallback : AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
+export function doDuring<E = Error>(fn: AsyncVoidFunction<E>, test: (testCallback: AsyncBooleanResultCallback<E>) => void, callback: ErrorCallback<E>): void;
+export function forever<E = Error>(next: (next : ErrorCallback<E>) => void, errBack: ErrorCallback<E>) : void;
+export function waterfall<T, E = Error>(tasks: Function[], callback?: AsyncResultCallback<T, E>): void;
 export function compose(...fns: Function[]): Function;
 export function seq(...fns: Function[]): Function;
 export function applyEach(fns: Function[], ...argsAndCallback: any[]): void;           // applyEach(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
 export function applyEachSeries(fns: Function[], ...argsAndCallback: any[]): void;     // applyEachSeries(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
-export function queue<T, E>(worker: AsyncWorker<T, E>, concurrency?: number): AsyncQueue<T>;
-export function queue<T, R, E>(worker: AsyncResultIterator<T, R, E>, concurrency?: number): AsyncQueue<T>;
-export function priorityQueue<T, E>(worker: AsyncWorker<T, E>, concurrency: number): AsyncPriorityQueue<T>;
-export function cargo<E>(worker : (tasks: any[], callback : ErrorCallback<E>) => void, payload? : number) : AsyncCargo;
-export function auto<R extends Dictionary<any>, E>(tasks: AsyncAutoTasks<R, E>, concurrency?: number, callback?: AsyncResultCallback<R, E>): void;
-export function autoInject<E>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
-export function retry<T, E>(opts: number, task: (callback : AsyncResultCallback<T, E>, results: any) => void, callback:  AsyncResultCallback<any, E | Error>): void;
-export function retry<T, E>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T, E>, results : any) => void, callback:  AsyncResultCallback<any, E | Error>): void;
-export function retryable<T, E>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E | Error>;
-export function apply<E>(fn: Function, ...args: any[]): AsyncFunction<any,E | Error>;
+export function queue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency?: number): AsyncQueue<T>;
+export function queue<T, R, E = Error>(worker: AsyncResultIterator<T, R, E>, concurrency?: number): AsyncQueue<T>;
+export function priorityQueue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency: number): AsyncPriorityQueue<T>;
+export function cargo<E = Error>(worker : (tasks: any[], callback : ErrorCallback<E>) => void, payload? : number) : AsyncCargo;
+export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, concurrency?: number, callback?: AsyncResultCallback<R, E>): void;
+export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, callback?: AsyncResultCallback<R, E>): void;
+export function autoInject<E = Error>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
+export function retry<T, E = Error>(opts: number, task: (callback : AsyncResultCallback<T, E>, results: any) => void, callback:  AsyncResultCallback<any, E>): void;
+export function retry<T, E = Error>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T, E>, results : any) => void, callback:  AsyncResultCallback<any, E>): void;
+export function retryable<T, E = Error>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E>;
+export function apply<E = Error>(fn: Function, ...args: any[]): AsyncFunction<any,E>;
 export function nextTick(callback: Function, ...args: any[]): void;
 export const setImmediate: typeof nextTick;
 
-export function reflect<T, E>(fn: AsyncFunction<T, E>) : (callback: (err: null, result: {error?: E, value?: T}) => void) => void;
-export function reflectAll<T, E>(tasks: AsyncFunction<T, E>[]): ((callback: (err: null, result: {error?: E, value?: T}) => void) => void)[];
+export function reflect<T, E = Error>(fn: AsyncFunction<T, E>) : (callback: (err: null, result: {error?: E, value?: T}) => void) => void;
+export function reflectAll<T, E = Error>(tasks: AsyncFunction<T, E>[]): ((callback: (err: null, result: {error?: E, value?: T}) => void) => void)[];
 
-export function timeout<T, E>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E | Error>;
-export function timeout<T, R, E>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E | Error>;
+export function timeout<T, E = Error>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E>;
+export function timeout<T, R, E = Error>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E>;
 
 export function times<T, E> (n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
-export function timesSeries<T, E>(n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
-export function timesLimit<T, E>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
+export function timesSeries<T, E = Error>(n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
+export function timesLimit<T, E = Error>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
 
-export function transform<T, R, E>(arr: T[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
-export function transform<T, R, E>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
+export function transform<T, R, E = Error>(arr: T[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
+export function transform<T, R, E = Error>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
 
-export function transform<T, R, E>(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
-export function transform<T, R, E>(arr: {[key: string] : T}, acc: {[key: string] : R}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
+export function transform<T, R, E = Error>(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
+export function transform<T, R, E = Error>(arr: {[key: string] : T}, acc: {[key: string] : R}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
 
-export function race<T, E>(tasks: (AsyncFunction<T, E>)[], callback: AsyncResultCallback<T, E | Error>) : void;
+export function race<T, E = Error>(tasks: (AsyncFunction<T, E>)[], callback: AsyncResultCallback<T, E>) : void;
 
 // Utils
 export function memoize(fn: Function, hasher?: Function): Function;
diff --git a/types/async/test/index.ts b/types/async/test/index.ts
index 3c6c2f5dfe..0081dd3dcd 100644
--- a/types/async/test/index.ts
+++ b/types/async/test/index.ts
@@ -114,7 +114,7 @@ async.series([
 ],
 function (err, results) { });
 
-async.series<string,Error>([
+async.series<string>([
     function (callback) {
         callback(undefined, 'one');
     },
@@ -138,7 +138,7 @@ async.series({
 },
 function (err, results) { });
 
-async.series<number,Error>({
+async.series<number>({
     one: function (callback) {
         setTimeout(function () {
             callback(undefined, 1);
@@ -178,7 +178,7 @@ async.parallel([
 ],
 function (err, results) { });
 
-async.parallel<string,Error>([
+async.parallel<string>([
     function (callback) {
         setTimeout(function () {
             callback(undefined, 'one');
@@ -207,7 +207,7 @@ async.parallel({
 },
 function (err, results) { });
 
-async.parallel<number,Error>({
+async.parallel<number>({
     one: function (callback) {
         setTimeout(function () {
             callback(undefined, 1);
@@ -273,7 +273,7 @@ async.waterfall([
 ], function (err, result) { });
 
 
-var q = async.queue<any,Error>(function (task: any, callback: (err?:Error,msg?:string) => void) {
+var q = async.queue<any>(function (task: any, callback: (err?:Error,msg?:string) => void) {
     console.log('hello ' + task.name);
     callback(undefined,'a message.');
 }, 2);
@@ -293,7 +293,7 @@ q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) {
     console.log('finished processing bar');
 });
 
-q.push<string,Error>({name: 'foo'}, function (err,msg) {
+q.push<string>({name: 'foo'}, function (err, msg) {
   console.log('foo finished with a message "'+ msg! + '"');
 });
 
@@ -330,7 +330,7 @@ q.resume();
 q.kill();
 
 // tests for strongly typed tasks
-var q2 = async.queue<string,Error>(function (task: string, callback: () => void) {
+var q2 = async.queue<string>(function (task: string, callback: () => void) {
     console.log('Task: ' + task);
     callback();
 }, 1);
@@ -356,7 +356,7 @@ q2.unshift(['task3', 'task4', 'task5'], function (error) {
 });
 
 
-var aq = async.queue<number, number, Error>(function (level: number, callback: (error?: Error, newLevel?: number) => void) {
+var aq = async.queue<number, number>(function (level: number, callback: (error?: Error, newLevel?: number) => void) {
     console.log('hello ' + level);
     callback(undefined, level+1);
 });
@@ -387,14 +387,47 @@ cargo.push({ name: 'baz' }, function (err: Error) {
 
 var filename = '';
 async.auto({
-    get_data: function (callback: any) { },
-    make_folder: function (callback: any) { },
+    get_data: function (callback: AsyncResultCallback<any>) { },
+    make_folder: function (callback: AsyncResultCallback<any>) { },
     //arrays with different types are not accepted by TypeScript.
-    write_file: ['get_data', 'make_folder', <any>function (callback: any) {
+    write_file: ['get_data', 'make_folder', <any>function (callback: AsyncResultCallback<any>) {
         callback(null, filename);
     }],
     //arrays with different types are not accepted by TypeScript.
-    email_link: ['write_file', <any>function (callback: any, results: any) { }]
+    email_link: ['write_file', <any>function (callback: AsyncResultCallback<any>, results: any) { }]
+});
+
+async.auto({
+    get_data: function (callback: AsyncResultCallback<any>) { },
+    make_folder: function (callback: AsyncResultCallback<any>) { },
+    //arrays with different types are not accepted by TypeScript.
+    write_file: ['get_data', 'make_folder', <any>function (callback: AsyncResultCallback<any>) {
+        callback(null, filename);
+    }],
+    //arrays with different types are not accepted by TypeScript.
+    email_link: ['write_file', <any>function (callback: AsyncResultCallback<any>, results: any) { }]
+}, function (err, results) {
+    console.log('finished auto');
+});
+
+interface A {
+    get_data: any;
+    make_folder: any;
+    write_file: any;
+    email_link: any;
+}
+
+async.auto<A>({
+    get_data: function (callback: AsyncResultCallback<any>) { },
+    make_folder: function (callback: AsyncResultCallback<any>) { },
+    //arrays with different types are not accepted by TypeScript.
+    write_file: ['get_data', 'make_folder', <any>function (callback: AsyncResultCallback<any>) {
+        callback(null, filename);
+    }],
+    //arrays with different types are not accepted by TypeScript.
+    email_link: ['write_file', <any>function (callback: AsyncResultCallback<any>, results: any) { }]
+}, 1, function (err, results) {
+    console.log('finished auto');
 });
 
 async.retry(3, function (callback, results) { }, function (err, result) { });
@@ -459,10 +492,10 @@ async.dir(function (name: string, callback: any) {
 
 // each
 
-async.each<number,Error>({
+async.each<number>({
     "a": 1,
     "b": 2
-}, function(val: number, next: ErrorCallback<Error>): void {
+}, function(val: number, next: ErrorCallback): void {
 
     setTimeout(function(): void {
 
@@ -478,10 +511,10 @@ async.each<number,Error>({
 
 });
 
-async.eachSeries<number, Error>({
+async.eachSeries<number>({
     "a": 1,
     "b": 2
-}, function(val: number, next: ErrorCallback<Error>): void {
+}, function(val: number, next: ErrorCallback): void {
 
     setTimeout(function(): void {
 
@@ -497,14 +530,14 @@ async.eachSeries<number, Error>({
 
 });
 
-async.eachLimit<number, Error>({
+async.eachLimit<number>({
     "a": 1,
     "b": 2,
     "c": 3,
     "d": 4,
     "e": 5,
     "f": 6
-}, 2, function(val: number, next: ErrorCallback<Error>): void {
+}, 2, function(val: number, next: ErrorCallback): void {
 
     setTimeout(function(): void {
 
@@ -522,10 +555,10 @@ async.eachLimit<number, Error>({
 
 // forEachOf/eachOf
 
-async.eachOf<number, Error>({
+async.eachOf<number>({
     "a": 1,
     "b": 2
-}, function(val: number, key: string, next: ErrorCallback<Error>): void {
+}, function(val: number, key: string, next: ErrorCallback): void {
 
     setTimeout(function(): void {
 
@@ -541,10 +574,10 @@ async.eachOf<number, Error>({
 
 });
 
-async.forEachOfSeries<number, Error>({
+async.forEachOfSeries<number>({
     "a": 1,
     "b": 2
-}, function(val: number, key: string, next: ErrorCallback<Error>): void {
+}, function(val: number, key: string, next: ErrorCallback): void {
 
     setTimeout(function(): void {
 
@@ -560,14 +593,14 @@ async.forEachOfSeries<number, Error>({
 
 });
 
-async.forEachOfLimit<number, Error>({
+async.forEachOfLimit<number>({
     "a": 1,
     "b": 2,
     "c": 3,
     "d": 4,
     "e": 5,
     "f": 6
-}, 2, function(val: number, key: string, next: ErrorCallback<Error>): void {
+}, 2, function(val: number, key: string, next: ErrorCallback): void {
 
     setTimeout(function(): void {
 
@@ -585,11 +618,11 @@ async.forEachOfLimit<number, Error>({
 
 // map
 
-async.map<number, string, Error>({
+async.map<number, string>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: AsyncResultCallback<string, Error>): void {
+}, function(val: number, next: AsyncResultCallback<string>): void {
 
     setTimeout(function(): void {
 
@@ -605,11 +638,11 @@ async.map<number, string, Error>({
 
 });
 
-async.mapSeries<number, string, Error>({
+async.mapSeries<number, string>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: AsyncResultCallback<string, Error>): void {
+}, function(val: number, next: AsyncResultCallback<string>): void {
 
     setTimeout(function(): void {
 
@@ -625,14 +658,14 @@ async.mapSeries<number, string, Error>({
 
 });
 
-async.mapLimit<number, string, Error>({
+async.mapLimit<number, string>({
     "a": 1,
     "b": 2,
     "c": 3,
     "d": 4,
     "e": 5,
     "f": 6
-}, 2, function(val: number, next: AsyncResultCallback<string, Error>): void {
+}, 2, function(val: number, next: AsyncResultCallback<string>): void {
 
     setTimeout(function(): void {
 
@@ -650,11 +683,11 @@ async.mapLimit<number, string, Error>({
 
 // mapValues
 
-async.mapValues<number, string, Error>({
+async.mapValues<number, string>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, key: string, next: AsyncResultCallback<string, Error>): void {
+}, function(val: number, key: string, next: AsyncResultCallback<string>): void {
 
     setTimeout(function(): void {
 
@@ -670,11 +703,11 @@ async.mapValues<number, string, Error>({
 
 });
 
-async.mapValuesSeries<number, string, Error>({
+async.mapValuesSeries<number, string>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, key: string, next: AsyncResultCallback<string, Error>): void {
+}, function(val: number, key: string, next: AsyncResultCallback<string>): void {
 
     setTimeout(function(): void {
 
@@ -692,11 +725,11 @@ async.mapValuesSeries<number, string, Error>({
 
 // filter/select/reject
 
-async.filter<number, Error>({
+async.filter<number>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: AsyncBooleanResultCallback<Error>): void {
+}, function(val: number, next: AsyncBooleanResultCallback): void {
 
     setTimeout(function(): void {
 
@@ -712,11 +745,11 @@ async.filter<number, Error>({
 
 });
 
-async.reject<number, Error>({
+async.reject<number>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: AsyncBooleanResultCallback<Error>): void {
+}, function(val: number, next: AsyncBooleanResultCallback): void {
 
     setTimeout(function(): void {
 
@@ -734,11 +767,11 @@ async.reject<number, Error>({
 
 // concat
 
-async.concat<string, string, Error>({
+async.concat<string, string>({
     "a": "1",
     "b": "2",
     "c": "3"
-}, function(item: string, next: AsyncResultCallback<string[], Error>): void {
+}, function(item: string, next: AsyncResultCallback<string[]>): void {
 
     console.log(`async.concat: ${item}`);
 
@@ -752,11 +785,11 @@ async.concat<string, string, Error>({
 
 // detect/find
 
-async.detect<number, Error>({
+async.detect<number>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(item: number, next: AsyncBooleanResultCallback<Error>): void {
+}, function(item: number, next: AsyncBooleanResultCallback): void {
 
     console.log(`async.detect/find: ${item}`);
 
@@ -777,11 +810,11 @@ async.detect<number, Error>({
 
 // every/all
 
-async.every<number,Error>({
+async.every<number>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(item: number, next: AsyncBooleanResultCallback<Error>): void {
+}, function(item: number, next: AsyncBooleanResultCallback): void {
 
     console.log(`async.every/all: ${item}`);
 
@@ -795,11 +828,11 @@ async.every<number,Error>({
 
 // some/any
 
-async.some<number, Error>({
+async.some<number>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(item: number, next: AsyncBooleanResultCallback<Error>): void {
+}, function(item: number, next: AsyncBooleanResultCallback): void {
 
     console.log(`async.some/any: ${item}`);
 
diff --git a/types/atlassian-crowd-client/lib/models/session.d.ts b/types/atlassian-crowd-client/lib/models/session.d.ts
index 2ef16a0814..2369f976bc 100644
--- a/types/atlassian-crowd-client/lib/models/session.d.ts
+++ b/types/atlassian-crowd-client/lib/models/session.d.ts
@@ -3,7 +3,7 @@ declare class Session {
     readonly token: string;
     readonly createdAt: Date;
     readonly expiresAt: Date;
- 
+
     constructor(token: string, createdAt: Date, expiresAt: Date);
     toCrowd(): SessionObj;
     static fromCrowd(obj: SessionObj): Session;
diff --git a/types/atlassian-crowd-client/settings.d.ts b/types/atlassian-crowd-client/settings.d.ts
index 755c26038a..4c56a85e06 100644
--- a/types/atlassian-crowd-client/settings.d.ts
+++ b/types/atlassian-crowd-client/settings.d.ts
@@ -3,7 +3,7 @@ export interface Settings {
     readonly application: {
         readonly name: string;
         readonly password: string;
-    }
+    };
     readonly nesting?: boolean;
     readonly sessionTimeout?: number;
     readonly debug?: boolean;
diff --git a/types/atom/tslint.json b/types/atom/tslint.json
index 4c3e6e9036..3811d3257c 100644
--- a/types/atom/tslint.json
+++ b/types/atom/tslint.json
@@ -4,6 +4,9 @@
         "await-promise": [true, "CancellablePromise"],
         "indent": [true, "spaces", 4],
         "max-line-length": [true, 100],
-        "no-any": true
+        "no-any": true,
+
+        // TODOs
+        "no-declare-current-package": false
     }
 }
diff --git a/types/auth-header/auth-header-tests.ts b/types/auth-header/auth-header-tests.ts
new file mode 100644
index 0000000000..e8b510531c
--- /dev/null
+++ b/types/auth-header/auth-header-tests.ts
@@ -0,0 +1,6 @@
+import * as auth from 'auth-header';
+
+const basic: string = auth.format('Basic');
+const basic2: string = auth.format({scheme: 'Basic'});
+
+const parsed: {scheme: string, token: null | string | string[]} = auth.parse('');
diff --git a/types/auth-header/index.d.ts b/types/auth-header/index.d.ts
new file mode 100644
index 0000000000..fab462be9e
--- /dev/null
+++ b/types/auth-header/index.d.ts
@@ -0,0 +1,27 @@
+// Type definitions for auth-header 1.0
+// Project: https://github.com/izaakschroeder/auth-header
+// Definitions by: ForbesLindesay <https://github.com/ForbesLindesay>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
+
+type Params =
+    | Array<[string, string | ReadonlyArray<string>]>
+    | {[key: string]: string | ReadonlyArray<string>};
+export {Params};
+
+export interface TokenOptions {
+    scheme: string;
+    token?: string;
+    params?: Params;
+}
+
+export interface Token {
+    scheme: string;
+    params: {[key: string]: string | string[]};
+    token: null | string | string[];
+}
+
+export function format(token: TokenOptions): string;
+export function format(scheme: string, token?: string, params?: Params): string;
+
+export function parse(header: string): Token;
diff --git a/types/auth-header/tsconfig.json b/types/auth-header/tsconfig.json
new file mode 100644
index 0000000000..58c6fad6d7
--- /dev/null
+++ b/types/auth-header/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictFunctionTypes": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "auth-header-tests.ts"
+    ]
+}
diff --git a/types/auth-header/tslint.json b/types/auth-header/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/auth-header/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/auth0-lock/index.d.ts b/types/auth0-lock/index.d.ts
index a2d52cfc84..8c3a7da850 100644
--- a/types/auth0-lock/index.d.ts
+++ b/types/auth0-lock/index.d.ts
@@ -98,6 +98,7 @@ interface Auth0LockAuthOptions {
     params?: Auth0LockAuthParamsOptions;
     redirect?: boolean;
     redirectUrl?: string;
+    responseMode?: string;
     responseType?: string;
     sso?: boolean;
     audience?: string;
diff --git a/types/axe-webdriverjs/tsconfig.json b/types/axe-webdriverjs/tsconfig.json
index d8637d03e4..4eaf433c1c 100644
--- a/types/axe-webdriverjs/tsconfig.json
+++ b/types/axe-webdriverjs/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/axios-token-interceptor/index.d.ts b/types/axios-token-interceptor/index.d.ts
index 85121f8165..a09fb7591b 100644
--- a/types/axios-token-interceptor/index.d.ts
+++ b/types/axios-token-interceptor/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/sandrinodimattia/axios-token-interceptor#readme
 // Definitions by: Mike Dodge <https://github.com/innovation-team>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
 import { AxiosRequestConfig } from 'axios';
 
diff --git a/types/baidumap-web-sdk/tslint.json b/types/baidumap-web-sdk/tslint.json
index aab43caa1d..eccb336643 100644
--- a/types/baidumap-web-sdk/tslint.json
+++ b/types/baidumap-web-sdk/tslint.json
@@ -2,14 +2,21 @@
     "extends": "dtslint/dt.json",
     "rules": {
         // All are TODOs
-        "eofline": false,
+        "adjacent-overload-signatures": false,
+        "array-type": false,
+        "ban-types": false,
         "comment-format": false,
         "dt-header": false,
+        "eofline": false,
         "max-line-length": false,
         "member-access": false,
+        "no-consecutive-blank-lines": false,
+        "no-empty-interface": false,
         "no-namespace": false,
+        "no-unnecessary-class": false,
         "no-useless-files": false,
         "no-var": false,
-        "semicolon": false
+        "semicolon": false,
+        "space-before-function-paren": false
     }
 }
diff --git a/types/boom/v4/boom-tests.ts b/types/boom/v4/boom-tests.ts
index 33e86699e8..ee2a8eefb8 100644
--- a/types/boom/v4/boom-tests.ts
+++ b/types/boom/v4/boom-tests.ts
@@ -1,5 +1,4 @@
 import Boom = require('boom');
-import * as Hapi from 'hapi';
 
 // 4xx and data type
 
diff --git a/types/bootstrap3-dialog/tsconfig.json b/types/bootstrap3-dialog/tsconfig.json
index cdf93479b7..774e895668 100644
--- a/types/bootstrap3-dialog/tsconfig.json
+++ b/types/bootstrap3-dialog/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/broccoli-plugin/broccoli-plugin-tests.ts b/types/broccoli-plugin/broccoli-plugin-tests.ts
new file mode 100644
index 0000000000..4434fce10c
--- /dev/null
+++ b/types/broccoli-plugin/broccoli-plugin-tests.ts
@@ -0,0 +1,46 @@
+import Plugin = require('broccoli-plugin');
+
+declare function copySync(src: string, dest: string): void;
+declare function setTimeout(callback: () => void, duration: number): void;
+
+class SlowItDown extends Plugin {
+    constructor(private readonly waitInMS: number) {
+        super([], {
+            annotation: `${waitInMS} ms`,
+            needsCache: false
+        });
+    }
+
+    async build() {
+        await new Promise(resolve => setTimeout(resolve, this.waitInMS));
+    }
+}
+
+class FileCopier extends Plugin {
+    constructor(inputNodes: Plugin.BroccoliNode[]) {
+        super(inputNodes, {
+            name: 'CopyFiles',
+            persistentOutput: true
+        });
+    }
+
+    build() {
+        for (const input of this.inputPaths) {
+            copySync(input, this.outputPath);
+        }
+    }
+
+    getCallbackObject() {
+        return this;
+    }
+}
+
+new FileCopier([
+    new SlowItDown(5000),
+    'src',
+    'assets'
+]);
+
+new Plugin(); // $ExpectError
+new Plugin([{}]); // $ExpectError
+new Plugin([], { foo: 'bar' }); // $ExpectError
diff --git a/types/broccoli-plugin/index.d.ts b/types/broccoli-plugin/index.d.ts
new file mode 100644
index 0000000000..36b1da65e2
--- /dev/null
+++ b/types/broccoli-plugin/index.d.ts
@@ -0,0 +1,78 @@
+// Type definitions for broccoli-plugin 1.3
+// Project: https://github.com/broccolijs/broccoli-plugin
+// Definitions by: Dan Freeman <https://github.com/dfreeman>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
+
+export = BroccoliPlugin;
+
+declare namespace BroccoliPlugin {
+    type BroccoliNode = BroccoliPlugin | string;
+
+    interface BroccoliPluginOptions {
+        /**
+         * The name of this plugin. Defaults to `this.constructor.name`.
+         */
+        name?: string;
+
+        /**
+         * A descriptive annotation. Useful for debugging, to tell multiple
+         * instances of the same plugin apart.
+         */
+        annotation?: string;
+
+        /**
+         * If `true`, the output directory is not automatically emptied between
+         * builds. Defaults to `false`.
+         */
+        persistentOutput?: boolean;
+
+        /**
+         * If `true`, a cache directory is created automatically and the path is
+         * set at `cachePath`. If `false`, a cache directory is not created and
+         * `this.cachePath` is `undefined`. Defaults to `true`.
+         */
+        needsCache?: boolean;
+    }
+}
+
+declare class BroccoliPlugin {
+    constructor(inputNodes: BroccoliPlugin.BroccoliNode[], options?: BroccoliPlugin.BroccoliPluginOptions);
+
+    /**
+     * An array of paths on disk corresponding to each node in `inputNodes`.
+     * Your plugin will read files from these paths.
+     */
+    readonly inputPaths: ReadonlyArray<string>;
+
+    /**
+     * The path on disk corresponding to this plugin instance (this node).
+     * Your plugin will write files to this path. This directory is emptied by
+     * Broccoli before each build, unless the `persistentOutput` options is
+     * `true`.
+     */
+    readonly outputPath: string;
+
+    /**
+     * The path on disk to an auxiliary cache directory. Use this to store
+     * files that you want preserved between builds. This directory will
+     * only be deleted when Broccoli exits. If a cache directory is not
+     * needed, set `needsCache` to false when calling `broccoli-plugin`
+     * constructor.
+     */
+    readonly cachePath?: string;
+
+    /**
+     * Override this method in your subclass. It will be called on each
+     * (re-)build. All paths stay the same between builds.
+     * To perform asynchronous work, return a promise.
+     */
+    build(): void | Promise<any>;
+
+    /**
+     * Advanced usage only.
+     * Return the object on which Broccoli will call `obj.build()`. Called
+     * once after instantiation. By default, returns `this`.
+     */
+    getCallbackObject(): { build(): void | Promise<any> };
+}
diff --git a/types/broccoli-plugin/tsconfig.json b/types/broccoli-plugin/tsconfig.json
new file mode 100644
index 0000000000..0f36813dc1
--- /dev/null
+++ b/types/broccoli-plugin/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "broccoli-plugin-tests.ts"
+    ]
+}
diff --git a/types/broccoli-plugin/tslint.json b/types/broccoli-plugin/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/broccoli-plugin/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/bunyan-winston-adapter/index.d.ts b/types/bunyan-winston-adapter/index.d.ts
index 718c9804e1..1ce6ae0a8b 100644
--- a/types/bunyan-winston-adapter/index.d.ts
+++ b/types/bunyan-winston-adapter/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/gluwer/bunyan-winston-adapter
 // Definitions by: Steve Hipwell <https://github.com/stevehipwell>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
+// TypeScript Version: 2.2
 
 import * as bunyan from "bunyan";
 import { Logger } from "winston";
diff --git a/types/chai-fs/index.d.ts b/types/chai-fs/index.d.ts
index 144d7d6739..3b82eee078 100644
--- a/types/chai-fs/index.d.ts
+++ b/types/chai-fs/index.d.ts
@@ -1,6 +1,6 @@
 // Type definitions for chai-fs 2.0
 // Project: https://github.com/chaijs/chai-fs
-// Definitions by: Dimitar Danailov <https://github.com/Nemo157>
+// Definitions by: Dimitar Danailov <https://github.com/dimitardanailov>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.2
 
diff --git a/types/chai-http/tsconfig.json b/types/chai-http/tsconfig.json
index 3554b4ab09..45d92cf188 100644
--- a/types/chai-http/tsconfig.json
+++ b/types/chai-http/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/chart.js/chart.js-tests.ts b/types/chart.js/chart.js-tests.ts
index 41ab453e0f..705392baed 100644
--- a/types/chart.js/chart.js-tests.ts
+++ b/types/chart.js/chart.js-tests.ts
@@ -19,7 +19,7 @@ const chart: Chart = new Chart(new CanvasRenderingContext2D(), {
                 backgroundColor: "#000000",
                 borderWidth: 1,
                 label: "test",
-                data: [1]
+                data: [1, null, 3]
             }
         ]
     },
@@ -36,6 +36,7 @@ const chart: Chart = new Chart(new CanvasRenderingContext2D(), {
         tooltips: {
             filter: data => Number(data.yLabel) > 0,
             intersect: true,
+            mode: 'index',
             itemSort: (a, b) => Math.random() - 0.5,
             position: "average",
             caretPadding: 2,
@@ -125,6 +126,7 @@ const chartConfig: Chart.ChartConfiguration = {
             backgroundColor: '#37738353',
             borderColor: '#37738353',
             borderWidth: 3,
+            borderCapStyle: 'round',
             fill: true
         }]
     },
diff --git a/types/chart.js/index.d.ts b/types/chart.js/index.d.ts
index f779cdc57d..884ddaa760 100644
--- a/types/chart.js/index.d.ts
+++ b/types/chart.js/index.d.ts
@@ -10,7 +10,6 @@
 //                 Guillaume Rodriguez <https://github.com/guillaume-ro-fr>
 //                 Simon Archer <https://github.com/archy-bold>
 //                 Ken Elkabany <https://github.com/braincore>
-//                 Slavik Nychkalo <https://github.com/gebeto>
 //                 Francesco Benedetto <https://github.com/frabnt>
 //                 Alexandros Dorodoulis <https://github.com/alexdor>
 //                 Manuel Heidrich <https://github.com/mahnuh>
@@ -174,6 +173,8 @@ declare namespace Chart {
 
     type PositionType = 'left' | 'right' | 'top' | 'bottom';
 
+    type InteractionMode = 'point' | 'nearest' | 'single' | 'label' | 'index' | 'x-axis' | 'dataset' | 'x' | 'y';
+
     interface ChartArea {
         top: number;
         right: number;
@@ -185,10 +186,10 @@ declare namespace Chart {
         text?: string;
         fillStyle?: string;
         hidden?: boolean;
-        lineCap?: string;
+        lineCap?: 'butt' | 'round' | 'square';
         lineDash?: number[];
         lineDashOffset?: number;
-        lineJoin?: string;
+        lineJoin?: 'bevel' | 'round' | 'miter';
         lineWidth?: number;
         strokeStyle?: string;
         pointStyle?: PointStyle;
@@ -331,7 +332,7 @@ declare namespace Chart {
     interface ChartTooltipOptions {
         enabled?: boolean;
         custom?(a: any): void;
-        mode?: string;
+        mode?: InteractionMode;
         intersect?: boolean;
         backgroundColor?: ChartColor;
         titleFontFamily?: string;
@@ -373,7 +374,7 @@ declare namespace Chart {
     type ChartTooltipPositioner = (elements: any[], eventPosition: Point) => Point;
 
     interface ChartHoverOptions {
-        mode?: string;
+        mode?: InteractionMode;
         animationDuration?: number;
         intersect?: boolean;
         onHover?(this: Chart, event: MouseEvent, activeElements: Array<{}>): any;
@@ -479,7 +480,12 @@ declare namespace Chart {
         fontStyle?: string;
     }
 
-    interface TickOptions {
+    interface TickOptions extends NestedTickOptions {
+        minor?: NestedTickOptions | false;
+        major?: NestedTickOptions | false;
+    }
+
+    interface NestedTickOptions {
         autoSkip?: boolean;
         autoSkipPadding?: number;
         backdropColor?: ChartColor;
@@ -541,12 +547,12 @@ declare namespace Chart {
         backgroundColor?: ChartColor | ChartColor[];
         borderWidth?: number | number[];
         borderColor?: ChartColor | ChartColor[];
-        borderCapStyle?: string;
+        borderCapStyle?: 'butt' | 'round' | 'square';
         borderDash?: number[];
         borderDashOffset?: number;
-        borderJoinStyle?: string;
+        borderJoinStyle?: 'bevel' | 'round' | 'miter';
         borderSkipped?: PositionType;
-        data?: number[] | ChartPoint[];
+        data?: Array<number | null | undefined> | ChartPoint[];
         fill?: boolean | number | string;
         hoverBackgroundColor?: string | string[];
         hoverBorderColor?: string | string[];
@@ -566,7 +572,7 @@ declare namespace Chart {
         pointStyle?: PointStyle | HTMLImageElement | HTMLCanvasElement | Array<PointStyle | HTMLImageElement | HTMLCanvasElement>;
         xAxisID?: string;
         yAxisID?: string;
-        type?: string;
+        type?: ChartType | string;
         hidden?: boolean;
         hideInLegendAndTooltip?: boolean;
         showLine?: boolean;
diff --git a/types/chartist/chartist-tests.ts b/types/chartist/chartist-tests.ts
index bd7006723e..cb7f884264 100644
--- a/types/chartist/chartist-tests.ts
+++ b/types/chartist/chartist-tests.ts
@@ -197,6 +197,7 @@ new Chartist.Bar('.ct-chart', {
 }, {
     // Default mobile configuration
     stackBars: true,
+    stackMode: 'accumulate',
     axisX: {
         labelInterpolationFnc: (value: string) => {
             return value.split(/\s+/).map((word: string) => {
diff --git a/types/chartist/index.d.ts b/types/chartist/index.d.ts
index 3d72210c73..9b096839cc 100644
--- a/types/chartist/index.d.ts
+++ b/types/chartist/index.d.ts
@@ -283,6 +283,7 @@ declare namespace Chartist {
          * If set to true this property will cause the series bars to be stacked and form a total for each series point. This will also influence the y-axis and the overall bounds of the chart. In stacked mode the seriesBarDistance property will have no effect.
          */
         stackBars?: boolean;
+        stackMode?: 'overlap' | 'accumulate';
 
         horizontalBars?: boolean;
         distributeSeries?: boolean;
diff --git a/types/chartmogul-node/common.d.ts b/types/chartmogul-node/common.d.ts
index ced10f98d7..d12587f090 100644
--- a/types/chartmogul-node/common.d.ts
+++ b/types/chartmogul-node/common.d.ts
@@ -1,5 +1,5 @@
 export interface Map {
-    [key: string]: any
+    [key: string]: any;
 }
 export interface CursorParams {
     page?: number;
@@ -15,9 +15,9 @@ export interface Cursor {
     total_pages?: number;
 }
 export interface Entries<T> extends Cursor {
-    entries: T[]
+    entries: T[];
 }
-interface Summary {
+export interface Summary {
     current: number;
     previous: number;
     ['percentage-change']: number;
@@ -25,4 +25,4 @@ interface Summary {
 export interface EntriesSummary<T> {
     entries: T[];
     summary: Summary;
-}
\ No newline at end of file
+}
diff --git a/types/codemirror/codemirror-panel.d.ts b/types/codemirror/codemirror-panel.d.ts
new file mode 100644
index 0000000000..2059c8ff72
--- /dev/null
+++ b/types/codemirror/codemirror-panel.d.ts
@@ -0,0 +1,51 @@
+// Type definitions for CodeMirror
+// Project: https://github.com/marijnh/CodeMirror
+// Definitions by: Nikolaj Kappler <https://github.com/nkappler>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// See docs https://codemirror.net/doc/manual.html#addon_panel
+
+import * as CodeMirror from "codemirror";
+
+declare module "codemirror" {
+    interface Panel {
+        /**Removes the panel from the editor */
+        clear(): void;
+        /**Notifies panel that height of DOM node has changed */
+        changed(height?: number): void;
+    }
+
+    interface ShowPanelOptions {
+        /**Controls the position of the newly added panel. The following values are recognized:  
+         * `top` (default): Adds the panel at the very top.  
+         *  `after-top`: Adds the panel at the bottom of the top panels.  
+         *  `bottom`: Adds the panel at the very bottom.  
+         *  `before-bottom`: Adds the panel at the top of the bottom panels.  
+        */
+        position?: "top" | "after-top" | "bottom" | "before-bottom";
+        /**The new panel will be added before the given panel. */
+        before?: Panel;
+        /**The new panel will be added after the given panel. */
+        after?: Panel;
+        /**The new panel will replace the given panel. */
+        replace?: Panel;
+        /**Whether to scroll the editor to keep the text's vertical position stable, when adding a panel above it. Defaults to false. */
+        stable?: boolean;
+    }
+
+    interface Editor {
+
+        /**
+         * Places a DOM node above or below an editor and shrinks the editor to make room for the node.
+         * When using the `after`, `before` or `replace` options, if the panel doesn't exists or has been removed, the value of the `position` option will be used as a fallback.
+         * @param node the DOM node
+         * @param options optional options object
+         */
+        addPanel(node: HTMLElement, options?: ShowPanelOptions): Panel;
+
+    }
+}
+
+declare module "codemirror/addon/display/panel" {
+    export = CodeMirror;
+}
diff --git a/types/codemirror/index.d.ts b/types/codemirror/index.d.ts
index 2b49326e0b..c1ea6c99b9 100644
--- a/types/codemirror/index.d.ts
+++ b/types/codemirror/index.d.ts
@@ -260,16 +260,7 @@ declare namespace CodeMirror {
         line should be either an integer or a line handle, and node should be a DOM node, which will be displayed below the given line.
         options, when given, should be an object that configures the behavior of the widget.
         Note that the widget node will become a descendant of nodes with CodeMirror-specific CSS classes, and those classes might in some cases affect it. */
-        addLineWidget(line: any, node: HTMLElement, options?: {
-            /** Whether the widget should cover the gutter. */
-            coverGutter?: boolean;
-            /** Whether the widget should stay fixed in the face of horizontal scrolling. */
-            noHScroll?: boolean;
-            /** Causes the widget to be placed above instead of below the text of the line. */
-            above?: boolean;
-            /** When true, will cause the widget to be rendered even if the line it is associated with is hidden. */
-            showIfHidden?: boolean;
-        }): CodeMirror.LineWidget;
+        addLineWidget(line: any, node: HTMLElement, options?: CodeMirror.LineWidgetOptions): CodeMirror.LineWidget;
 
 
         /** Programatically set the size of the editor (overriding the applicable CSS rules).
@@ -728,6 +719,17 @@ declare namespace CodeMirror {
         changed(): void;
     }
 
+    interface LineWidgetOptions {
+        /** Whether the widget should cover the gutter. */
+        coverGutter?: boolean;
+        /** Whether the widget should stay fixed in the face of horizontal scrolling. */
+        noHScroll?: boolean;
+        /** Causes the widget to be placed above instead of below the text of the line. */
+        above?: boolean;
+        /** When true, will cause the widget to be rendered even if the line it is associated with is hidden. */
+        showIfHidden?: boolean;
+    }
+
     interface EditorChange {
         /** Position (in the pre-change coordinate system) where the change started. */
         from: CodeMirror.Position;
diff --git a/types/codemirror/test/panel.ts b/types/codemirror/test/panel.ts
new file mode 100644
index 0000000000..3cf200beae
--- /dev/null
+++ b/types/codemirror/test/panel.ts
@@ -0,0 +1,17 @@
+
+var cm: CodeMirror.Editor = CodeMirror(document.body);
+
+var panel1 = cm.addPanel(document.body);
+
+var panel2: CodeMirror.Panel = cm.addPanel(document.body, {
+    position: "top",
+    after: panel1,
+    before: panel1,
+    replace: panel1,
+    stable: true
+});
+
+panel2.changed();
+panel2.changed(100);
+
+panel2.clear();
diff --git a/types/codemirror/tsconfig.json b/types/codemirror/tsconfig.json
index a2c6a52430..79d2eae5c3 100644
--- a/types/codemirror/tsconfig.json
+++ b/types/codemirror/tsconfig.json
@@ -20,11 +20,13 @@
     "files": [
         "index.d.ts",
         "codemirror-matchbrackets.d.ts",
+        "codemirror-panel.d.ts",
         "codemirror-runmode.d.ts",
         "codemirror-showhint.d.ts",
         "searchcursor.d.ts",
         "test/index.ts",
         "test/matchbrackets.ts",
+        "test/panel.ts",
         "test/runmode.ts",
         "test/searchcursor.ts",
         "test/showhint.ts"
diff --git a/types/critters-webpack-plugin/critters-webpack-plugin-tests.ts b/types/critters-webpack-plugin/critters-webpack-plugin-tests.ts
new file mode 100644
index 0000000000..cb975b1cc0
--- /dev/null
+++ b/types/critters-webpack-plugin/critters-webpack-plugin-tests.ts
@@ -0,0 +1,10 @@
+import Critters from 'critters-webpack-plugin';
+
+new Critters({
+    compress: true,
+    external: true,
+    inlineFonts: false,
+    preloadFonts: true,
+    keyframes: 'critical',
+    noscriptFallback: true,
+});
diff --git a/types/critters-webpack-plugin/index.d.ts b/types/critters-webpack-plugin/index.d.ts
new file mode 100644
index 0000000000..df758a42e7
--- /dev/null
+++ b/types/critters-webpack-plugin/index.d.ts
@@ -0,0 +1,65 @@
+// Type definitions for critters-webpack-plugin 1.3
+// Project: https://github.com/GoogleChromeLabs/critters
+// Definitions by: Juan José González Giraldo <https://github.com/JuanJoseGonGi>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+import { Plugin } from 'webpack';
+
+export default Critters;
+declare class Critters extends Plugin {
+    constructor(options?: Critters.CrittersOptions);
+}
+
+declare namespace Critters {
+    interface CrittersOptions {
+        /**
+         * Inline styles from external stylesheets.
+         * @default true
+         */
+        external?: boolean;
+        /**
+         * The mechanism to use for lazy-loading stylesheets. [JS] indicates that a strategy requires JavaScript (falls back to <noscript>).
+         * - default: Move stylesheet links to the end of the document and insert preload meta tags in their place.
+         * - "body": Move all external stylesheet links to the end of the document.
+         * - "media": Load stylesheets asynchronously by adding media="not x" and removing once loaded. [JS]
+         * - "swap": Convert stylesheet links to preloads that swap to rel="stylesheet" once loaded. [JS]
+         * - "js": Inject an asynchronous CSS loader similar to LoadCSS and use it to load stylesheets. [JS]
+         * - "js-lazy": Like "js", but the stylesheet is disabled until fully loaded.
+         */
+        preload?: 'body' | 'media' | 'swap' | 'js' | 'js-lazy';
+        /**
+         * Add <noscript> fallback to JS-based strategies
+         */
+        noscriptFallback?: boolean;
+        /**
+         * Inline critical font-face rules.
+         * @default false
+         */
+        inlineFonts?: boolean;
+        /**
+         * Preloads critical fonts.
+         * @default true
+         */
+        preloadFonts?: boolean;
+        /**
+         * Shorthand for setting inlineFonts+preloadFonts - Values:
+         * - true to inline critical font-face rules and preload the fonts.
+         * - false to don"t inline any font-face rules and don"t preload fonts.
+         */
+        fonts?: boolean;
+        /**
+         * Controls which keyframes rules are inlined. - Values:
+         * - "critical": Inline keyframes rules used by the critical CSS.
+         * - "all" Inline all keyframes rules.
+         * - "none" Remove all keyframes rules
+         * @default "critical"
+         */
+        keyframes?: 'critical' | 'all' | 'none';
+        /**
+         * Compress resulting critical CSS.
+         * @default true
+         */
+        compress?: boolean;
+    }
+}
diff --git a/types/critters-webpack-plugin/tsconfig.json b/types/critters-webpack-plugin/tsconfig.json
new file mode 100644
index 0000000000..7e571e7b68
--- /dev/null
+++ b/types/critters-webpack-plugin/tsconfig.json
@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": ["es6"],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": ["../"],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": ["index.d.ts", "critters-webpack-plugin-tests.ts"]
+}
diff --git a/types/critters-webpack-plugin/tslint.json b/types/critters-webpack-plugin/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/critters-webpack-plugin/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/d3-array/d3-array-tests.ts b/types/d3-array/d3-array-tests.ts
index 1c6cbcaea8..11f208f869 100644
--- a/types/d3-array/d3-array-tests.ts
+++ b/types/d3-array/d3-array-tests.ts
@@ -596,6 +596,7 @@ numbersArray = d3Array.pairs(readonlyMergedArray, (a, b) => {
 // getting a permutation of array elements
 mergedArray = d3Array.permute(mergedArray, [1, 0, 2, 5, 3, 4, 6]);
 mergedArray = d3Array.permute(readonlyMergedArray, [1, 0, 2, 5, 3, 4, 6]);
+mergedArray = d3Array.permute(readonlyMergedArray, nums);
 
 // Getting an ordered array with object properties
 
@@ -606,7 +607,10 @@ const testObject = {
     more: [10, 30, 40]
 };
 
-const x: Array<number | string | Date | number[]> = d3Array.permute(testObject, ['name', 'val', 'when', 'more']);
+const p1: Array<number | string | Date | number[]> = d3Array.permute(testObject, ['name', 'val', 'when', 'more']);
+const p2: Array<Date | number[]> = d3Array.permute(testObject, ['when', 'more']);
+// $ExpectError
+const p3 = d3Array.permute(testObject, ['when', 'unknown']);
 
 // range() ---------------------------------------------------------------------
 
@@ -913,7 +917,7 @@ mixedObject = binMixedObject_DateOrUndefined[0];
 dateOrUndefined = binMixedObject_DateOrUndefined.x0;
 dateOrUndefined = binMixedObject_DateOrUndefined.x1;
 
-// Histogram Tresholds =========================================================
+// Histogram Thresholds ========================================================
 
 numbersArray = [-1, 0, 1, 1, 3, 20, 234];
 typedArray = new Uint8Array(numbersArray);
diff --git a/types/d3-array/index.d.ts b/types/d3-array/index.d.ts
index 45bd86a704..391e2786be 100644
--- a/types/d3-array/index.d.ts
+++ b/types/d3-array/index.d.ts
@@ -228,19 +228,23 @@ export function pairs<T>(array: ArrayLike<T>): Array<[T, T]>;
  * Returns the empty array if the input array has fewer than two elements.
  *
  * @param array Array of input elements
- * @param reducer A reducer function taking as input to adjecent elements of the input array and returning a reduced value.
+ * @param reducer A reducer function taking as input to adjacent elements of the input array and returning a reduced value.
  */
 export function pairs<T, U>(array: ArrayLike<T>, reducer: (a: T, b: T) => U): U[];
 
 /**
- * Given the specified array, return an array corresponding to the list of indices in 'keys'.
+ * Returns a permutation of the specified array using the specified array of indexes.
+ * The returned array contains the corresponding element in array for each index in indexes, in order.
+ * For example, `permute(["a", "b", "c"], [1, 2, 0]) // ["b", "c", "a"]`
  */
 export function permute<T>(array: { [key: number]: T }, keys: ArrayLike<number>): T[];
 
 /**
- * Given the specified object, return an array corresponding to the list of property names in 'keys'.
+ * Extract the values from an object into an array with a stable order. For example:
+ * `var object = {yield: 27, year: 1931, site: "University Farm"};`
+ * `d3.permute(object, ["site", "yield"]); // ["University Farm", 27]`
  */
-export function permute<T>(object: { [key: string]: T }, keys: ArrayLike<string>): T[];
+export function permute<T, K extends keyof T>(object: T, keys: ArrayLike<K>): Array<T[K]>;
 
 /**
  * Generates a 0-based numeric sequence. The output range does not include 'stop'.
@@ -347,6 +351,11 @@ export type ThresholdNumberArrayGenerator<Value extends number | undefined> =
 export type ThresholdDateArrayGenerator<Value extends Date | undefined> =
     (values: ArrayLike<Value>, min: Date, max: Date) => Value[];
 
+/**
+ * @deprecated Use ThresholdNumberArrayGenerator or ThresholdDateArrayGenerator.
+ */
+export type ThresholdArrayGenerator = ThresholdNumberArrayGenerator<number>;
+
 /**
  * @deprecated Use `HistogramGeneratorNumber<Datum, Value>` for `number` values and `HistogramGeneratorDate<Datum, Value> for `Date` values.
  */
@@ -403,7 +412,7 @@ export interface HistogramGeneratorDate<Datum, Value extends Date | undefined> e
      * and the last bin.x1 is always equal to the maximum domain value.
      *
      * @param thresholds A function which accepts as arguments the array of materialized values, and
-     * optionally the domain minimum and maximum. The function calcutates and returns the array of values to be used as
+     * optionally the domain minimum and maximum. The function calculates and returns the array of values to be used as
      * thresholds in determining the bins.
      */
     thresholds(thresholds: ThresholdDateArrayGenerator<Value>): this;
@@ -434,7 +443,7 @@ export interface HistogramGeneratorNumber<Datum, Value extends number | undefine
      * and the last bin.x1 is always equal to the maximum domain value.
      *
      * @param count A function which accepts as arguments the array of materialized values, and
-     * optionally the domain minimum and maximum. The function calcutates and returns the suggested
+     * optionally the domain minimum and maximum. The function calculates and returns the suggested
      * number of bins.
      */
     thresholds(count: ThresholdCountGenerator<Value>): this;
@@ -456,7 +465,7 @@ export interface HistogramGeneratorNumber<Datum, Value extends number | undefine
      * and the last bin.x1 is always equal to the maximum domain value.
      *
      * @param thresholds A function which accepts as arguments the array of materialized values, and
-     * optionally the domain minimum and maximum. The function calcutates and returns the array of values to be used as
+     * optionally the domain minimum and maximum. The function calculates and returns the array of values to be used as
      * thresholds in determining the bins.
      */
     thresholds(thresholds: ThresholdNumberArrayGenerator<Value>): this;
diff --git a/types/d3-graphviz/d3-graphviz-tests.ts b/types/d3-graphviz/d3-graphviz-tests.ts
new file mode 100644
index 0000000000..eef9436a09
--- /dev/null
+++ b/types/d3-graphviz/d3-graphviz-tests.ts
@@ -0,0 +1,16 @@
+import { select, BaseType } from 'd3-selection';
+import * as d3Graphviz from 'd3-graphviz';
+
+let graphviz: d3Graphviz.Graphviz<BaseType, any, BaseType, any>;
+
+// Can get a graphviz render using extension method on d3-select
+graphviz = select('test').graphviz();
+
+// Can use graphviz method as selector
+graphviz = d3Graphviz.graphviz('test');
+
+// Can get the options
+const options: d3Graphviz.GraphvizOptions = d3Graphviz.graphviz('').options();
+
+// Can set the options
+graphviz = graphviz.options(options);
diff --git a/types/d3-graphviz/index.d.ts b/types/d3-graphviz/index.d.ts
new file mode 100644
index 0000000000..9d3dc1ac61
--- /dev/null
+++ b/types/d3-graphviz/index.d.ts
@@ -0,0 +1,455 @@
+// Type definitions for d3-graphviz 2.6
+// Project: https://github.com/magjac/d3-graphviz
+// Definitions by: Dom Parfitt <https://github.com/DomParfitt>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+import { ZoomBehavior } from 'd3-zoom';
+import { Selection, BaseType, ValueFn } from 'd3-selection';
+import { Transition } from 'd3-transition';
+
+/**
+ * Define methods which act as extensions to d3-selection
+ */
+declare module 'd3-selection' {
+    interface Selection<GElement extends BaseType, Datum, PElement extends BaseType, PDatum> {
+        /**
+         * Returns a new graphviz renderer instance on the first element in the given selection. If a graphviz renderer instance already exists
+         * on that element, instead returns the existing graphviz renderer instance.
+         * @param options either a GraphvizOptions object representing the options of the graphviz renderer or a boolean representing the
+         *                  useWorker option.
+         */
+        graphviz(options?: GraphvizOptions | boolean): Graphviz<GElement, Datum, BaseType, PDatum>;
+
+        /**
+         * For each selected element, selects the first descendant element that matches the specified selector string in the same ways as
+         * d3-selection.select, but does not propagate any associated data from the current element to the corresponding selected element.
+         */
+        selectWithoutDataPropagation(): Selection<GElement, Datum, PElement, PDatum>;
+    }
+}
+
+/**
+ * Creates a new graphviz renderer instance on the first element matching the given selector string. If the selector is not a string,
+ * instead creates a new graphviz renderer instance on the specified node. If a graphviz renderer instance already exists on that
+ * element, instead returns the existing graphviz renderer instance.
+ * @param selector either a string representing a selector for a given node or an instance of a node
+ * @param options the options to be applied to the graphviz renderer
+ */
+export function graphviz(selector: string | BaseType, options?: GraphvizOptions | boolean): Graphviz<BaseType, any, BaseType, any>;
+
+/**
+ * Interface representing the Graphviz Renderer. Methods generally return the instance of the
+ * object they were called on (i.e this) in order to allow for easy method chaining.
+ */
+export interface Graphviz<GElement extends BaseType, Datum, PElement extends BaseType, PDatum> {
+    // Options
+    /**
+     * Gets the currently set options object on the renderer
+     */
+    options(): GraphvizOptions;
+
+    /**
+     * Sets the options provided. Does not overwrite existing options that are not
+     * provided in the options parameter.
+     * @param options the options to set on the renderer
+     */
+    options(options: GraphvizOptions): this;
+
+    // Rendering
+    /**
+     * Renders an SVG graph from the specified src string and appends it to the selection the grapviz
+     * renderer instance was generated on.
+     * @param src a string representing a valid string in the DOT language
+     * @param callback
+     */
+    renderDot(src: string, callback?: () => void): this;
+
+    /**
+     * Starts computation of the layout of a graph from the specified dotSrc string and saves the data for
+     * rendering the SVG with {@link render} at a later stage.
+     * @param src a string representing a valid string in the DOT language
+     * @param callback
+     */
+    dot(src: string, callback?: () => void): this;
+
+    /**
+     * Starts rendering of an SVG graph from data saved by {@link dot} and appends it to the selection
+     * the grapviz renderer instance was generated on.
+     * @param callback
+     */
+    render(callback?: () => void): this;
+
+    /**
+     * Sets the Graphviz layout engine name to the specified engine string.
+     * @param engine a string taking one of the following values:
+     *            - circo
+     *            - dot
+     *            - fdp
+     *            - neato
+     *            - osage
+     *            - patchwork
+     *            - twopi
+     */
+    engine(engine: Engine): this;
+
+    /**
+     * Sets the callback that is called if the layout computation encounters
+     * an error. If no callback is passed then it removes the existing callback.
+     * @param callback the call back function triggered by an error
+     */
+    onerror(callback?: (errorMessage: any) => void): this;
+
+    // Images
+    /**
+     * Add an image reference. Must be called before {@link renderDot} ir {@link dot}
+     * are called.
+     * @param path the path of the image, may be a filename, relative or absolute path or a URL
+     * @param width the width of the image, if a string is used then it may specify units. Allowed
+     *               units are: in, px, pc, pt, cm, or mm. If no units are given or dimensions are
+     *               given as numbers, points (pt) are used.
+     * @param height the height of the image, which follows the same unit rules as width.
+     */
+    addImage(path: string, width: number | string, height: number | string): this;
+
+    // Creating Transitions
+    /**
+     * Applies the specified transition name to subsequent SVG rendering. Accepts the same arguments
+     * as {@link d3-select.transition} or a function, but returns the graph renderer instance, not the
+     * transition. If name is a function, it is taken to be a transition factory. A transition factory
+     * is a function that returns a transition.
+     * @param name either a function returning a transition, a transition object or a string naming a
+     *              transition
+     */
+    transition(name?: () => Transition<GElement, Datum, PElement, PDatum> | string | Transition<GElement, Datum, PElement, PDatum>): this;
+
+    /**
+     * Returns the active transition on the generated graph's top level svg with the specified name,
+     * if any. Returns null if there is no such active transition on the top level svg node.
+     * @param name the name of the transition
+     */
+    active(name?: string): Transition<GElement, Datum, PElement, PDatum> | null;
+
+    // Controlling SVG and Graph Size
+    /**
+     * Sets the SVG width attribute.
+     * @param width the width in pixels
+     */
+    width(width: number): this;
+
+    /**
+     * Sets the SVG height attribute
+     * @param height the height in pixels
+     */
+    height(height: number): this;
+
+    /**
+     * Sets whether the graph's viewbox is affected by the size of its parent SVG's size
+     * @param fit true, if the graph should scale to fit its parent, false if it should
+     *             remain at its original size
+     */
+    fit(fit: boolean): this;
+
+    /**
+     * Sets the value the graph should scale by in relation to its parent SVG. Scaling
+     * only occurs if fit is set to true
+     * @param scale the scale value with 1.0 being 100%, 0.5 being 50% etc.
+     */
+    scale(scale: number): this;
+
+    // Control Flow
+    /**
+     * Adds or removes a listener to the graphviz renderer instance for the specified event typenames.
+     * @param typenames
+     * @param callback
+     */
+    on(typenames: TypeNames, callback?: () => void): this;
+
+    /**
+     * Sets whether events are logged or not.
+     * @param enable true if events should be logged, false if not
+     */
+    logEvents(enable: boolean): this;
+
+    // Controlling Fade
+    /**
+     * Sets whether fade in and out of nodes is enabled.
+     * @param enable true to enable fade in and out, false to disable
+     */
+    fade(enable: boolean): this;
+
+    // Controlling Animated Growth of Entering Edges
+    /**
+     * Sets whether animated growth of entering edges is enabled.
+     * @param enable true to animate entering edges, false to disable
+     */
+    growEnteringEdges(enable: boolean): this;
+
+    // Controlling Path Tweening
+    /**
+     * Enables or disables path tweening
+     * @param enable true if path tweening should be enabled, false if it should be disabled
+     */
+    tweenPaths(enable: boolean): this;
+
+    /**
+     * Sets the precision of path tweening. If precision is a number, sets the precision used
+     * during path tweening to precision points. The precision is the length of each path
+     * segment during tweening. If instead precision is a string containing '%', sets the
+     * relative precision.
+     * @param precision the precision as either a number of a string containing a percentage
+     */
+    tweenPrecision(precision: number | string): this;
+
+    // Controlling Shape Tweening
+    /**
+     * Enables or disables shape tweening during transitions. Implicitly sets path tweening
+     * as enabled due to SVGs handling for them.
+     * @param enable true if shape tweening should be enabled, false if it should be disabled
+     */
+    tweenShapes(enable: boolean): this;
+
+    /**
+     * Enables or disables conversion of polygons with an equal number of sides during shape
+     * tweening.
+     * @param enable true if conversion should be enabled, false if it should be disabled.
+     */
+    convertEqualSidedPolygons(enable: boolean): this;
+
+    // Controlling Panning & Zooming
+    /**
+     * Enables or disables zooming and panning.
+     * @param enable true if zooming should be enabled, false if it should be disabled.
+     */
+    zoom(enable: boolean): this;
+
+    /**
+     * Returns the zoom behaviour of a graph. If the zoom is disable or the graph has not
+     * yet been rendered then returns null.
+     */
+    zoomBehavior(): ZoomBehavior<Element, Datum> | null;
+
+    /**
+     * Returns the selection to which zoom behaviour has been applied. If zoom is disabled
+     * or the graph has not yet been rendered then returns null.
+     */
+    zoomSelection(): Element | null;
+
+    /**
+     * Sets the scale extend for zooming where the first number is the minimum allowed zoom
+     * and the second is the maximum.
+     * @param extent a tuple containing the minimum and maximum allowed zoom
+     */
+    zoomScaleExtent(extent?: [number, number]): this;
+
+    /**
+     * Sets the translate extent which restricts panning.
+     * @param extent a tuple of the form ((x0, y0), (x1, y1)) where (x0, y0) is the top-left
+     *               corner of the "world" and (x1, y1) is the bottom-right corner
+     */
+    zoomTranslateExtent(extent?: [[number, number], [number, number]]): this;
+
+    /**
+     * Resets any transformations made by panning and zooming.
+     * @param transition an optional transition to apply during reset.
+     */
+    resetZoom(transition?: string | Transition<GElement, Datum, PElement, PDatum>): this;
+
+    // Maintaining Object Constancy
+    /**
+     * Sets the key mode to the the provided mode string. Must be set before passing in
+     * any DOT strings.
+     * @param keyMode
+     */
+    keyMode(keyMode: KeyMode): this;
+
+    // Customizing Graph Attributes
+    /**
+     *
+     * @param callback
+     */
+    attributer(callback?: ValueFn<GElement, Datum, void>): this;
+
+    // Accessing Extracted Data
+    /**
+     * Returns the data extracted by {@link dot} or null if none exists.
+     */
+    data(): Datum;
+
+    // Modifying an Existing Graph and Animating the Changes
+    // Edges
+    /**
+     * Draws a straight edge from (x1, y1) to (x2, y2) using coordinates relative to top level G container element of the graph.
+     * @param x1 the starting x co-ordinate
+     * @param y1 the starting y co-ordinate
+     * @param x2 the ending x co-ordinate
+     * @param y2 the ending y co-ordinate
+     * @param attributes object containing DOT attributes
+     * @param options object containing the options used when drawing the edge
+     */
+    drawEdge(x1: number, y1: number, x2: number, y2: number, attributes?: DotAttributes, options?: EdgeOptions): this;
+
+    /**
+     * Updates properties and attributes of the edge currently drawn with {@link drawEdge},
+     * using the same arguments. This method cannot be used after the edge has been inserted
+     * into the graph data with {@link insertDrawnEdge.}
+     * @param x1 the starting x co-ordinate
+     * @param y1 the starting y co-ordinate
+     * @param x2 the ending x co-ordinate
+     * @param y2 the ending y co-ordinate
+     * @param attributes object containing DOT attributes
+     * @param options object containing the options used when drawing the edge
+     */
+    updateDrawnEdge(x1: number, y1: number, x2: number, y2: number, attributes?: DotAttributes, options?: EdgeOptions): this;
+
+    /**
+     * Updates the end point of the edge currently drawn with {@link drawEdge},
+     * accepting the same options argument. This method cannot be used after the
+     * edge has been inserted into the graph data with {@link insertDrawnEdge}.
+     * @param x2 the ending x co-ordinate
+     * @param y2 the ending y co-ordinate
+     * @param options object containing the options used when drawing the edge
+     */
+    moveDrawnEdgeEndPoint(x2: number, y2: number, options?: EdgeOptions): this;
+
+    /**
+     * Inserts the edge into the graph data, making it available for an animated
+     * transition into a subsequent new layout.
+     * @param name the name of the edge.
+     */
+    insertDrawnEdge(name: string): this;
+
+    /**
+     * Removes the edge currently drawn with {@link drawEdge}. This method cannot
+     * be used after the edge has been inserted into the graph data with
+     * {@link insertDrawnEdge}.
+     */
+    removeDrawnEdge(): this;
+
+    /**
+     * Returns a {@link Selection} containing the edge currently being drawn. The selection is empty
+     * if no edge has been drawn or the lastest drawn edge has been inserted into the graph data with
+     * {@link insertDrawnNode}.
+     */
+    drawnEdgeSelection(): Selection<GElement, Datum, PElement, PDatum>;
+
+    // Nodes
+    /**
+     * Draws a node with the upper left corner of its bounding box at (x, y), using
+     * coordinates relative to the top level G container element of the graph.
+     * @param x x co-ordinate of the top-left bounding box of the node
+     * @param y y co-ordinate of the top-left bounding box of the node
+     * @param nodeId the ID of the node
+     * @param attributes object containing DOT attributes
+     * @param options object containing the options used when drawing the node, currently unused
+     */
+    drawNode(x: number, y: number, nodeId: string, attributes?: DotAttributes, options?: any): this;
+
+    /**
+     * Updates properties and attributes of the node currently drawn with {@link drawNode},
+     * using the same arguments. This method cannot be used after the node has been inserted
+     *  into the graph data with {@link insertDrawnNode}.
+     * @param x x co-ordinate of the top-left bounding box of the node
+     * @param y y co-ordinate of the top-left bounding box of the node
+     * @param nodeId the ID of the node
+     * @param attributes object containing DOT attributes
+     * @param options object containing the options used when drawing the node, currently unused
+     */
+    updateDrawnNode(x: number, y: number, nodeId: string, attributes?: DotAttributes, options?: any): this;
+
+    /**
+     * Updates the position of the upper left corner of the node currently drawn
+     * with {@link drawNode}, accepting the same options argument. This method
+     * cannot be used after the node has been inserted into the graph data with
+     * {@link insertDrawnNode}.
+     * @param x new x co-ordinate of the top-left bounding box of the node
+     * @param y new y co-ordinate of the top-left bounding box of the node
+     * @param options object containing the options used when drawing the node, currently unused
+     */
+    moveDrawnNode(x: number, y: number, options?: any): this;
+
+    /**
+     * Inserts the node into the graph data, making it available for an animated
+     * transition into a subsequent new layout.
+     * @param nodeId the ID of the node
+     */
+    insertDrawnNode(nodeId: string): this;
+
+    /**
+     * Removes the node currently drawn with {@link drawNode}. This method cannot
+     * be used after the node has been inserted into the graph data with {@link insertDrawnNode}.
+     */
+    removeDrawnNode(): this;
+
+    /**
+     * Returns a {@link Selection} containing the node currently being drawn. The selection is empty
+     * if no node has been drawn or the lastest drawn node has been inserted into the graph data with
+     * {@link insertDrawnNode}.
+     */
+    drawnNodeSelection(): Selection<GElement, Datum, PElement, PDatum>;
+
+    // Large Graphs
+    /**
+     * Sets the total memory available to Viz.js to size bytes, which should be a power of 2.
+     * @param size the size in bytes of memory allocated to Viz.js
+     */
+    totalMemory(size: number): this;
+}
+
+/**
+ * Enum defining the valid strings that can be passed in as an engine
+ */
+export type Engine = 'circo' | 'dot' | 'fdp' | 'neato' | 'osage' | 'patchwork' | 'twopi';
+
+/**
+ * Enum defining the valid strings that can be passed as TypeNames
+ */
+export type TypeNames = 'initEnd' | 'start' | 'layoutStart' | 'layoutEnd' | 'dataExtractEnd' |
+    'dataProcessPass1End' | 'dataProcessPass2End' | 'dataProcessEnd' |
+    'renderStart' | 'renderEnd' | 'transitionStart' | 'transitionEnd' |
+    'resotreEnd' | 'end' | string; // string included to allow for optional addition of a name, e.g. initEnd.foo
+
+/**
+ * Enum defining the valid strings that can be passed as KeyModes
+ */
+export type KeyMode = 'title' | 'id' | 'tag-index' | 'index';
+
+/**
+ * Interface defining the options present on the Graphviz Renderer.
+ * Most map directly to methods that can be used to set their values.
+ */
+export interface GraphvizOptions {
+    useWorker?: boolean;
+    engine?: Engine;
+    totalMemory?: number;
+    keyMode?: KeyMode;
+    fade?: boolean;
+    tweenPaths?: boolean;
+    tweenShapes?: boolean;
+    convertEqualSidedPolygons?: boolean;
+    tweenPrecision?: number | string;
+    growEnteringEdges?: boolean;
+    zoom?: boolean;
+    zoomScaleExtent?: [number, number];
+    zoomTranslateExtent?: [[number, number], [number, number]];
+    width?: number;
+    height?: number;
+    scale?: number;
+    fit?: boolean;
+}
+
+/**
+ * Interface defining the attributes available per the DOT language
+ */
+export interface DotAttributes {
+    style?: any;
+    URL?: any;
+    tooltip?: any;
+}
+
+/**
+ * Interface defining the options available for rendering edges
+ */
+export interface EdgeOptions {
+    shortening: number;
+}
diff --git a/types/d3-graphviz/tsconfig.json b/types/d3-graphviz/tsconfig.json
new file mode 100644
index 0000000000..55afef6cff
--- /dev/null
+++ b/types/d3-graphviz/tsconfig.json
@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "d3-graphviz-tests.ts"
+    ]
+}
diff --git a/types/d3-graphviz/tslint.json b/types/d3-graphviz/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/d3-graphviz/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/d3/index.d.ts b/types/d3/index.d.ts
index 8b44deac1a..c249edf3cc 100644
--- a/types/d3/index.d.ts
+++ b/types/d3/index.d.ts
@@ -1,6 +1,9 @@
 // Type definitions for D3JS d3 standard bundle 5.0
 // Project: https://github.com/d3/d3
-// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 denisname <https://github.com/denisname>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
@@ -11,7 +14,11 @@
 
 export as namespace d3;
 
+/**
+ * Version number in format _Major.Minor.BugFix_, like 5.0.0.
+ */
 export const version: string;
+
 export * from 'd3-array';
 export * from 'd3-axis';
 export * from 'd3-brush';
diff --git a/types/d3/tsconfig.json b/types/d3/tsconfig.json
index 8ec0a8e64e..bc3e8cf886 100644
--- a/types/d3/tsconfig.json
+++ b/types/d3/tsconfig.json
@@ -7,7 +7,7 @@
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
-        "strictNullChecks": false,
+        "strictNullChecks": true,
         "strictFunctionTypes": true,
         "baseUrl": "../",
         "typeRoots": [
diff --git a/types/d3/v4/index.d.ts b/types/d3/v4/index.d.ts
index b4b784884b..12448e60c8 100644
--- a/types/d3/v4/index.d.ts
+++ b/types/d3/v4/index.d.ts
@@ -1,6 +1,9 @@
 // Type definitions for D3JS d3 standard bundle 4.13
 // Project: https://github.com/d3/d3
-// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 denisname <https://github.com/denisname>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
@@ -8,7 +11,11 @@
 
 export as namespace d3;
 
+/**
+ * Version number in format _Major.Minor.BugFix_, like 4.13.0.
+ */
 export const version: string;
+
 export * from 'd3-array';
 export * from 'd3-axis';
 export * from 'd3-brush';
diff --git a/types/d3/v4/tsconfig.json b/types/d3/v4/tsconfig.json
index d4341019c7..bf267af99d 100644
--- a/types/d3/v4/tsconfig.json
+++ b/types/d3/v4/tsconfig.json
@@ -7,7 +7,7 @@
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
-        "strictNullChecks": false,
+        "strictNullChecks": true,
         "strictFunctionTypes": true,
         "baseUrl": "../../",
         "typeRoots": [
diff --git a/types/datadog-tracer/index.d.ts b/types/datadog-tracer/index.d.ts
index e7a11245fe..a3efea0a65 100644
--- a/types/datadog-tracer/index.d.ts
+++ b/types/datadog-tracer/index.d.ts
@@ -2,6 +2,8 @@
 // Project: https://github.com/rochdev/datadog-tracer-js#readme
 // Definitions by: Dinesh Saravanan Kumaraswamy <https://github.com/dineshsaravanan>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
+
 import * as opentracing from "opentracing";
 import { EventEmitter } from "events";
 
diff --git a/types/datatables.net-autofill/tsconfig.json b/types/datatables.net-autofill/tsconfig.json
index e17d5de5da..f9373c0cbc 100644
--- a/types/datatables.net-autofill/tsconfig.json
+++ b/types/datatables.net-autofill/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/dd-trace/src/opentracing/span_context.d.ts b/types/dd-trace/src/opentracing/span_context.d.ts
index d966771c2f..7e2b06dd4d 100644
--- a/types/dd-trace/src/opentracing/span_context.d.ts
+++ b/types/dd-trace/src/opentracing/span_context.d.ts
@@ -22,7 +22,7 @@ interface SpanContextLike {
     trace?: {
         started: number[],
         finished: number[]
-    }
+    };
 }
 
 export = DatadogSpanContext;
diff --git a/types/debounce/debounce-tests.ts b/types/debounce/debounce-tests.ts
index 81924d2a28..4acff7c446 100644
--- a/types/debounce/debounce-tests.ts
+++ b/types/debounce/debounce-tests.ts
@@ -13,3 +13,8 @@ const imm1: number = (debounce((x: number) => x * 2, 100, true))(2);
 
 const clearable = debounce(doThings);
 clearable.clear();
+
+// Intentionally asserts that the member variable has all the same benefits as the direct export.
+// Eventually, if debounce stop supporting the CommonJS-only module calling (`require("debounce")(...)`),
+// we can remove this and change the top import&require to `import { debounce } from "debounce";`.
+const assertsSame: typeof debounce = debounce.debounce;
diff --git a/types/debounce/index.d.ts b/types/debounce/index.d.ts
index 09a9c82e38..fa244351d6 100644
--- a/types/debounce/index.d.ts
+++ b/types/debounce/index.d.ts
@@ -1,7 +1,13 @@
-// Type definitions for debounce 1.0
+// Type definitions for debounce 3.0
 // Project: https://github.com/component/debounce
 // Definitions by: Denis Sokolov <https://github.com/denis-sokolov>
+//                 Josh Goldberg <https://github.com/joshuakgoldberg>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-declare function debounce<A extends Function>(f: A, interval?: number, immediate?: boolean): A & { clear(): void; };
-export = debounce;
+declare namespace _debounce {
+    const debounce: typeof _debounce;
+}
+
+declare function _debounce<A extends Function>(f: A, interval?: number, immediate?: boolean): A & { clear(): void; };
+
+export = _debounce;
diff --git a/types/detox/detox-tests.ts b/types/detox/detox-tests.ts
index 7fc2aaa579..58fe5c1912 100644
--- a/types/detox/detox-tests.ts
+++ b/types/detox/detox-tests.ts
@@ -21,6 +21,9 @@ describe('Test', () => {
         await element(by.id('scrollView')).swipe('down', 'fast');
         await element(by.type('UIPickerView')).setColumnToValue(1, "6");
 
+        await expect(element(by.id('element').withAncestor(by.id('parent_element')))).toNotExist();
+        await expect(element(by.id('element').withDescendant(by.id('child_element')))).toNotExist();
+
         await waitFor(element(by.id('element'))).toBeVisible().withTimeout(2000);
         await device.pressBack();
         await waitFor(element(by.text('Text5'))).toBeVisible().whileElement(by.id('ScrollView630')).scroll(50, 'down');
diff --git a/types/detox/index.d.ts b/types/detox/index.d.ts
index d2eae49f8d..7ef085e25d 100644
--- a/types/detox/index.d.ts
+++ b/types/detox/index.d.ts
@@ -1,6 +1,6 @@
-// Type definitions for detox 7.3
+// Type definitions for detox 9.0
 // Project: https://github.com/wix/detox
-// Definitions by: Tareq El-Masri <https://github.com/TareqElMasri>
+// Definitions by: Tareq El-Masri <https://github.com/TareqElMasri>, Steve Chun <https://github.com/stevechun>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 declare const detox: Detox.Detox;
@@ -22,7 +22,7 @@ declare namespace Detox {
          *      await detox.init(config);
          * });
          */
-        init(config: any, options: DetoxInitOptions): Promise<void>;
+        init(config: any, options?: DetoxInitOptions): Promise<void>;
         /**
          * Artifacts currently include only logs from the app process before each task
          * @param args
@@ -157,18 +157,6 @@ declare namespace Detox {
     interface Element {
         (by: Matchers): DetoxAny;
 
-        /**
-         * Select by parent element
-         * @param parent
-         * @example await element(by.id('Grandson883').withAncestor(by.id('Son883')));
-         */
-        withAncestor(parent: Element): DetoxAny;
-        /**
-         * Select by child element
-         * @param parent
-         * @example await element(by.id('Son883').withDescendant(by.id('Grandson883')));
-         */
-        withDescendant(child: Element): DetoxAny;
         /**
          * Choose from multiple elements matching the same matcher using index
          * @param index
@@ -177,6 +165,8 @@ declare namespace Detox {
         atIndex(index: number): DetoxAny;
     }
     interface Matchers {
+        (by: Matchers): Matchers;
+
         /**
          * by.id will match an id that is given to the view via testID prop.
          * @param id
@@ -209,6 +199,24 @@ declare namespace Detox {
          * @example await element(by.traits(['button']));
          */
         traits(traits: string[]): Matchers;
+        /**
+         * Find an element by a matcher with a parent matcher
+         * @param parentBy
+         * @example await element(by.id('Grandson883').withAncestor(by.id('Son883')));
+         */
+        withAncestor(parentBy: Matchers): Matchers;
+        /**
+         * Find an element by a matcher with a child matcher
+         * @param childBy
+         * @example await element(by.id('Son883').withDescendant(by.id('Grandson883')));
+         */
+        withDescendant(childBy: Matchers): Matchers;
+        /**
+         * Find an element by multiple matchers
+         * @param by
+         * @example await element(by.text('Product').and(by.id('product_name'));
+         */
+        and(by: Matchers): Matchers;
     }
     interface Expect<R> {
         (element: Element): Expect<any>;
@@ -275,7 +283,7 @@ declare namespace Detox {
         withTimeout(millis: number): Promise<void>;
         /**
          * Performs the action repeatedly on the element until an expectation is met
-         * @param element
+         * @param by
          * @example await waitFor(element(by.text('Text5'))).toBeVisible().whileElement(by.id('ScrollView630')).scroll(50, 'down');
          */
         whileElement(by: Matchers): DetoxAny;
diff --git a/types/dotenv-safe/index.d.ts b/types/dotenv-safe/index.d.ts
index 114edce926..c4d4398da8 100644
--- a/types/dotenv-safe/index.d.ts
+++ b/types/dotenv-safe/index.d.ts
@@ -2,7 +2,6 @@
 // Project: https://github.com/rolodato/dotenv-safe
 // Definitions by: Stan Goldmann <https://github.com/krenor>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
 
 import env = require("dotenv")
 
diff --git a/types/dotenv-safe/tsconfig.json b/types/dotenv-safe/tsconfig.json
index 46b51afc29..8858caf94a 100644
--- a/types/dotenv-safe/tsconfig.json
+++ b/types/dotenv-safe/tsconfig.json
@@ -2,7 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es5"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/dwt/addon.pdf.d.ts b/types/dwt/addon.pdf.d.ts
index 2e7b1d5a84..6a2a8636ee 100644
--- a/types/dwt/addon.pdf.d.ts
+++ b/types/dwt/addon.pdf.d.ts
@@ -6,7 +6,7 @@
 *
 * Copyright 2018, Dynamsoft Corporation
 * Author: Dynamsoft Support Team
-* Version: 13.4
+* Version: 14.2
 */
 
 declare enum EnumDWT_ConvertMode {
diff --git a/types/dwt/index.d.ts b/types/dwt/index.d.ts
index 0656236f08..12813a9b40 100644
--- a/types/dwt/index.d.ts
+++ b/types/dwt/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for dwt 13.4
+// Type definitions for dwt 14.2
 // Project: http://www.dynamsoft.com/Products/WebTWAIN_Overview.aspx
 // Definitions by: Xiao Ling <https://github.com/yushulx>
 //                 Josh Hall <https://github.com/jbh>
@@ -14,7 +14,7 @@
 *
 * Copyright 2018, Dynamsoft Corporation
 * Author: Dynamsoft Support Team
-* Version: 13.4
+* Version: 14.2
 */
 
 /**
@@ -2889,12 +2889,12 @@ interface WebTwain {
      * @return {number}
      */
     GetImageYResolution(sImageIndex: number): number;
-
+	
     /**
      * Return the runtime license info.
      * @method WebTwain#GetLicenseInfo
      */
-    GetLicenseInfo(): { Domain: string, Detail: LicenseDetailItem[] };
+    GetLicenseInfo(optionalAsyncSuccessFunc?: (result: any) => void, optionalAsyncFailureFunc?: (errorCode: number, errorString: string) => void): boolean;
 
     /**
      * Returns the index of the selected image.
diff --git a/types/egg-mock/index.d.ts b/types/egg-mock/index.d.ts
index 7308d52184..bb1831b693 100644
--- a/types/egg-mock/index.d.ts
+++ b/types/egg-mock/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/eggjs/egg-mock
 // Definitions by: Eward Song <https://github.com/sheperdwind>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.8
 
 import { Application, Context } from 'egg';
 
diff --git a/types/egjs__axes/tsconfig.json b/types/egjs__axes/tsconfig.json
index 3086687bc3..2cbbfa45c3 100644
--- a/types/egjs__axes/tsconfig.json
+++ b/types/egjs__axes/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/egjs__axes/tslint.json b/types/egjs__axes/tslint.json
index 3db14f85ea..f182565c48 100644
--- a/types/egjs__axes/tslint.json
+++ b/types/egjs__axes/tslint.json
@@ -1 +1,9 @@
-{ "extends": "dtslint/dt.json" }
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        // All are TODOs
+        "ban-types": false,
+        "interface-name": false,
+        "strict-export-declare-modifiers": false
+    }
+}
diff --git a/types/elasticsearch/elasticsearch-tests.ts b/types/elasticsearch/elasticsearch-tests.ts
index 68625bd5bb..ee57f847fa 100644
--- a/types/elasticsearch/elasticsearch-tests.ts
+++ b/types/elasticsearch/elasticsearch-tests.ts
@@ -338,6 +338,21 @@ client.indices.updateAliases({
   // ...
 });
 
+client.reindex({
+    body: {
+        source: {
+          index: "twitter"
+        },
+        dest: {
+          index: "new_twitter"
+        }
+      }
+})
+.then(response => {
+    const { took, timed_out } = response;
+    // ...
+});
+
 // Errors
 function testErrors() {
     throw new elasticsearch.errors.AuthenticationException();
diff --git a/types/elasticsearch/index.d.ts b/types/elasticsearch/index.d.ts
index 69c881e700..0d16cc6a4b 100644
--- a/types/elasticsearch/index.d.ts
+++ b/types/elasticsearch/index.d.ts
@@ -281,26 +281,13 @@ export interface DeleteDocumentByQueryParams extends GenericParams {
     scrollSize?: number;
     waitForCompletion?: boolean;
     requestsPerSecond?: number;
+    slices?: number;
     index?: string;
     type?: string;
 }
 
-export interface DeleteDocumentByQueryResponse {
-    took: number;
-    timed_out: boolean;
-    deleted: number;
-    batches: number;
-    version_conflicts: number;
-    noops: number;
-    retries: {
-        bulk: number;
-        search: number;
-    };
-    throttled_millis: number;
-    requests_per_second: number;
-    throttled_until_millis: number;
-    total: number;
-    failures: any[];
+export interface DeleteDocumentByQueryResponse extends ReindexResponse {
+    // DeleteDocumentByQueryResponse, UpdateDocumentByQueryResponse and ReindexResponse are identical
 }
 
 export interface DeleteScriptParams extends GenericParams {
@@ -531,6 +518,7 @@ export interface ReindexParams extends GenericParams {
     waitForActiveShards?: string;
     waitForCompletion?: boolean;
     requestsPerSecond?: number;
+    slices?: number;
     body: {
         conflicts?: string;
         source: {
@@ -559,20 +547,6 @@ export interface ReindexParams extends GenericParams {
     };
 }
 
-export interface ReindexResponse {
-    took: number;
-    updated: number;
-    created: number;
-    batches: number;
-    version_conflicts: number;
-    retries: {
-        bulk: number;
-        search: number;
-    };
-    throttled_millis: number;
-    failures: any[];
-}
-
 export interface ReindexRethrottleParams extends GenericParams {
     requestsPerSecond: number;
     taskId: string;
@@ -784,13 +758,28 @@ export interface UpdateDocumentByQueryParams extends GenericParams {
     scrollSize?: number;
     waitForCompletion?: boolean;
     requestsPerSecond?: number;
+    slices?: number;
     index: NameList;
     type: NameList;
 }
 
-export interface UpdateDocumentByQueryResponse {
+export interface UpdateDocumentByQueryResponse extends ReindexResponse {
+    // DeleteDocumentByQueryResponse, UpdateDocumentByQueryResponse and ReindexResponse are identical
+}
+
+export interface ReindexResponse extends ReindexResponseBase {
     took: number;
     timed_out: boolean;
+    failures: any[];
+    slices?: ReindexOrByQueryResponseSlice[];
+}
+
+export interface ReindexOrByQueryResponseSlice extends ReindexResponseBase {
+    slice_id: number;
+}
+
+export interface ReindexResponseBase {
+    total: number;
     updated: number;
     deleted: number;
     batches: number;
@@ -803,8 +792,6 @@ export interface UpdateDocumentByQueryResponse {
     throttled_millis: number;
     requests_per_second: number;
     throttled_until_millis: number;
-    total: number;
-    failures: any[];
 }
 
 export interface Cat {
diff --git a/types/electron-notifications/index.d.ts b/types/electron-notifications/index.d.ts
index 870fcb1bbc..08506be8aa 100644
--- a/types/electron-notifications/index.d.ts
+++ b/types/electron-notifications/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/blainesch/electron-notifications
 // Definitions by: Daniel Pereira <https://github.com/djpereira>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
+// TypeScript Version: 2.2
 
 import * as Electron from 'electron';
 
diff --git a/types/electron-notify/index.d.ts b/types/electron-notify/index.d.ts
index 16f786d379..eeb778864c 100644
--- a/types/electron-notify/index.d.ts
+++ b/types/electron-notify/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/hankbao/electron-notify
 // Definitions by: Daniel Pereira <https://github.com/djpereira>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
+// TypeScript Version: 2.2
 
 /// <reference types="electron" />
 
diff --git a/types/electron-spellchecker/index.d.ts b/types/electron-spellchecker/index.d.ts
index 8c02cc8794..fc10d13f34 100644
--- a/types/electron-spellchecker/index.d.ts
+++ b/types/electron-spellchecker/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/paulcbetts/electron-spellchecker
 // Definitions by: Daniel Perez Alvarez <https://github.com/unindented>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 /// <reference types="electron"/>
 
diff --git a/types/electron-spellchecker/tsconfig.json b/types/electron-spellchecker/tsconfig.json
index cc5add76a0..475b985475 100644
--- a/types/electron-spellchecker/tsconfig.json
+++ b/types/electron-spellchecker/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/electron-window-state/index.d.ts b/types/electron-window-state/index.d.ts
index 1ff0a15878..3e48f9fb87 100644
--- a/types/electron-window-state/index.d.ts
+++ b/types/electron-window-state/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/mawie81/electron-window-state
 // Definitions by: rhysd <https://github.com/rhysd>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
+// TypeScript Version: 2.2
 
 /// <reference types="electron" />
 
diff --git a/types/electron-window-state/package.json b/types/electron-window-state/package.json
index 880e1b40f6..89bd2f24e6 100644
--- a/types/electron-window-state/package.json
+++ b/types/electron-window-state/package.json
@@ -1,6 +1,6 @@
 {
     "private": true,
     "dependencies": {
-        "electron": "^1.7.5"
+        "electron": "*"
     }
 }
diff --git a/types/ember-data/tsconfig.json b/types/ember-data/tsconfig.json
index 03cadac59d..f476362aaf 100644
--- a/types/ember-data/tsconfig.json
+++ b/types/ember-data/tsconfig.json
@@ -14,18 +14,31 @@
             "../"
         ],
         "paths": {
-            "@ember/debug": ["ember__debug"],
-            "@ember/debug/*": ["ember__debug/*"],
-            "@ember/service": ["ember__service"],
+            "@ember/application": ["ember__application"],
+            "@ember/application/*": ["ember__application/*"],
             "@ember/array": ["ember__array"],
             "@ember/array/*": ["ember__array/*"],
+            "@ember/component": ["ember__component"],
+            "@ember/component/*": ["ember__component/*"],
+            "@ember/controller": ["ember__controller"],
             "@ember/debug": ["ember__debug"],
             "@ember/debug/*": ["ember__debug/*"],
-            "@ember/controller": ["ember__controller"],
+            "@ember/engine": ["ember__engine"],
+            "@ember/engine/*": ["ember__engine/*"],
+            "@ember/error": ["ember__error"],
+            "@ember/object": ["ember__object"],
+            "@ember/object/*": ["ember__object/*"],
+            "@ember/polyfills": ["ember__polyfills"],
             "@ember/routing": ["ember__routing"],
             "@ember/routing/*": ["ember__routing/*"],
-            "@ember/object": ["ember__object"],
-            "@ember/object/*": ["ember__object/*"]
+            "@ember/runloop": ["ember__runloop"],
+            "@ember/runloop/*": ["ember__runloop/*"],
+            "@ember/service": ["ember__service"],
+            "@ember/string": ["ember__string"],
+            "@ember/test": ["ember__test"],
+            "@ember/test/*": ["ember__test/*"],
+            "@ember/utils": ["ember__utils"],
+            "@ember/utils/*": ["ember__utils/*"]
         },
         "types": [],
         "noEmit": true,
diff --git a/types/ember-feature-flags/tsconfig.json b/types/ember-feature-flags/tsconfig.json
index 54f7acecb3..5b5dc17f2d 100644
--- a/types/ember-feature-flags/tsconfig.json
+++ b/types/ember-feature-flags/tsconfig.json
@@ -14,9 +14,31 @@
             "../"
         ],
         "paths": {
-            "@ember/service": ["ember__service"],
+            "@ember/application": ["ember__application"],
+            "@ember/application/*": ["ember__application/*"],
+            "@ember/array": ["ember__array"],
+            "@ember/array/*": ["ember__array/*"],
+            "@ember/component": ["ember__component"],
+            "@ember/component/*": ["ember__component/*"],
+            "@ember/controller": ["ember__controller"],
+            "@ember/debug": ["ember__debug"],
+            "@ember/debug/*": ["ember__debug/*"],
+            "@ember/engine": ["ember__engine"],
+            "@ember/engine/*": ["ember__engine/*"],
+            "@ember/error": ["ember__error"],
             "@ember/object": ["ember__object"],
-            "@ember/object/*": ["ember__object/*"]
+            "@ember/object/*": ["ember__object/*"],
+            "@ember/polyfills": ["ember__polyfills"],
+            "@ember/routing": ["ember__routing"],
+            "@ember/routing/*": ["ember__routing/*"],
+            "@ember/runloop": ["ember__runloop"],
+            "@ember/runloop/*": ["ember__runloop/*"],
+            "@ember/service": ["ember__service"],
+            "@ember/string": ["ember__string"],
+            "@ember/test": ["ember__test"],
+            "@ember/test/*": ["ember__test/*"],
+            "@ember/utils": ["ember__utils"],
+            "@ember/utils/*": ["ember__utils/*"]
         },
         "types": [],
         "noEmit": true,
diff --git a/types/ember-mocha/ember-mocha-tests.ts b/types/ember-mocha/ember-mocha-tests.ts
index 09662096b6..fd637a81b3 100644
--- a/types/ember-mocha/ember-mocha-tests.ts
+++ b/types/ember-mocha/ember-mocha-tests.ts
@@ -248,6 +248,6 @@ describe('rendering test', function() {
         // render the component
         await this.render(hbs`{{ x-foo value=value}}`);
 
-        chai.expect(this.element.querySelector('div>.value').textContent.trim()).to.equal('cat', 'The component shows the correct value');
+        chai.expect(this.element.querySelector('div>.value')!.textContent!.trim()).to.equal('cat', 'The component shows the correct value');
     });
 });
diff --git a/types/ember-mocha/tsconfig.json b/types/ember-mocha/tsconfig.json
index 2c00d52341..4e9b406e2e 100644
--- a/types/ember-mocha/tsconfig.json
+++ b/types/ember-mocha/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
@@ -13,12 +14,31 @@
             "../"
         ],
         "paths": {
-            "@ember/engine": ["ember__engine"],
-            "@ember/engine/*": ["ember__engine/*"],
             "@ember/application": ["ember__application"],
             "@ember/application/*": ["ember__application/*"],
+            "@ember/array": ["ember__array"],
+            "@ember/array/*": ["ember__array/*"],
+            "@ember/component": ["ember__component"],
+            "@ember/component/*": ["ember__component/*"],
+            "@ember/controller": ["ember__controller"],
+            "@ember/debug": ["ember__debug"],
+            "@ember/debug/*": ["ember__debug/*"],
+            "@ember/engine": ["ember__engine"],
+            "@ember/engine/*": ["ember__engine/*"],
+            "@ember/error": ["ember__error"],
             "@ember/object": ["ember__object"],
-            "@ember/object/*": ["ember__object/*"]
+            "@ember/object/*": ["ember__object/*"],
+            "@ember/polyfills": ["ember__polyfills"],
+            "@ember/routing": ["ember__routing"],
+            "@ember/routing/*": ["ember__routing/*"],
+            "@ember/runloop": ["ember__runloop"],
+            "@ember/runloop/*": ["ember__runloop/*"],
+            "@ember/service": ["ember__service"],
+            "@ember/string": ["ember__string"],
+            "@ember/test": ["ember__test"],
+            "@ember/test/*": ["ember__test/*"],
+            "@ember/utils": ["ember__utils"],
+            "@ember/utils/*": ["ember__utils/*"]
         },
         "types": [],
         "noEmit": true,
diff --git a/types/ember-modal-dialog/tsconfig.json b/types/ember-modal-dialog/tsconfig.json
index 9a842ee744..0b0b6f91fb 100644
--- a/types/ember-modal-dialog/tsconfig.json
+++ b/types/ember-modal-dialog/tsconfig.json
@@ -14,10 +14,31 @@
             "../"
         ],
         "paths": {
+            "@ember/application": ["ember__application"],
+            "@ember/application/*": ["ember__application/*"],
+            "@ember/array": ["ember__array"],
+            "@ember/array/*": ["ember__array/*"],
+            "@ember/component": ["ember__component"],
+            "@ember/component/*": ["ember__component/*"],
+            "@ember/controller": ["ember__controller"],
+            "@ember/debug": ["ember__debug"],
+            "@ember/debug/*": ["ember__debug/*"],
+            "@ember/engine": ["ember__engine"],
+            "@ember/engine/*": ["ember__engine/*"],
+            "@ember/error": ["ember__error"],
             "@ember/object": ["ember__object"],
             "@ember/object/*": ["ember__object/*"],
-            "@ember/component": ["ember__component"],
-            "@ember/component/*": ["ember__component/*"]
+            "@ember/polyfills": ["ember__polyfills"],
+            "@ember/routing": ["ember__routing"],
+            "@ember/routing/*": ["ember__routing/*"],
+            "@ember/runloop": ["ember__runloop"],
+            "@ember/runloop/*": ["ember__runloop/*"],
+            "@ember/service": ["ember__service"],
+            "@ember/string": ["ember__string"],
+            "@ember/test": ["ember__test"],
+            "@ember/test/*": ["ember__test/*"],
+            "@ember/utils": ["ember__utils"],
+            "@ember/utils/*": ["ember__utils/*"]
         },
         "types": [],
         "noEmit": true,
diff --git a/types/ember-qunit/tsconfig.json b/types/ember-qunit/tsconfig.json
index 7b184205af..df4899b37c 100644
--- a/types/ember-qunit/tsconfig.json
+++ b/types/ember-qunit/tsconfig.json
@@ -14,14 +14,31 @@
             "../"
         ],
         "paths": {
-            "@ember/engine": ["ember__engine"],
-            "@ember/engine/*": ["ember__engine/*"],
             "@ember/application": ["ember__application"],
             "@ember/application/*": ["ember__application/*"],
+            "@ember/array": ["ember__array"],
+            "@ember/array/*": ["ember__array/*"],
+            "@ember/component": ["ember__component"],
+            "@ember/component/*": ["ember__component/*"],
+            "@ember/controller": ["ember__controller"],
+            "@ember/debug": ["ember__debug"],
+            "@ember/debug/*": ["ember__debug/*"],
+            "@ember/engine": ["ember__engine"],
+            "@ember/engine/*": ["ember__engine/*"],
+            "@ember/error": ["ember__error"],
+            "@ember/object": ["ember__object"],
+            "@ember/object/*": ["ember__object/*"],
+            "@ember/polyfills": ["ember__polyfills"],
+            "@ember/routing": ["ember__routing"],
+            "@ember/routing/*": ["ember__routing/*"],
+            "@ember/runloop": ["ember__runloop"],
+            "@ember/runloop/*": ["ember__runloop/*"],
+            "@ember/service": ["ember__service"],
+            "@ember/string": ["ember__string"],
             "@ember/test": ["ember__test"],
             "@ember/test/*": ["ember__test/*"],
-            "@ember/object": ["ember__object"],
-            "@ember/object/*": ["ember__object/*"]
+            "@ember/utils": ["ember__utils"],
+            "@ember/utils/*": ["ember__utils/*"]
         },
         "types": [],
         "noEmit": true,
diff --git a/types/ember-resolver/tsconfig.json b/types/ember-resolver/tsconfig.json
index e8dfb6e8ce..bc476c5723 100644
--- a/types/ember-resolver/tsconfig.json
+++ b/types/ember-resolver/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
@@ -13,12 +14,31 @@
             "../"
         ],
         "paths": {
-            "@ember/engine": ["ember__engine"],
-            "@ember/engine/*": ["ember__engine/*"],
             "@ember/application": ["ember__application"],
             "@ember/application/*": ["ember__application/*"],
+            "@ember/array": ["ember__array"],
+            "@ember/array/*": ["ember__array/*"],
+            "@ember/component": ["ember__component"],
+            "@ember/component/*": ["ember__component/*"],
+            "@ember/controller": ["ember__controller"],
+            "@ember/debug": ["ember__debug"],
+            "@ember/debug/*": ["ember__debug/*"],
+            "@ember/engine": ["ember__engine"],
+            "@ember/engine/*": ["ember__engine/*"],
+            "@ember/error": ["ember__error"],
             "@ember/object": ["ember__object"],
-            "@ember/object/*": ["ember__object/*"]
+            "@ember/object/*": ["ember__object/*"],
+            "@ember/polyfills": ["ember__polyfills"],
+            "@ember/routing": ["ember__routing"],
+            "@ember/routing/*": ["ember__routing/*"],
+            "@ember/runloop": ["ember__runloop"],
+            "@ember/runloop/*": ["ember__runloop/*"],
+            "@ember/service": ["ember__service"],
+            "@ember/string": ["ember__string"],
+            "@ember/test": ["ember__test"],
+            "@ember/test/*": ["ember__test/*"],
+            "@ember/utils": ["ember__utils"],
+            "@ember/utils/*": ["ember__utils/*"]
         },
         "types": [],
         "noEmit": true,
diff --git a/types/ember-resolver/v4/index.d.ts b/types/ember-resolver/v4/index.d.ts
index fd5359cff4..88ace683f3 100644
--- a/types/ember-resolver/v4/index.d.ts
+++ b/types/ember-resolver/v4/index.d.ts
@@ -3,7 +3,7 @@
 // Definitions by: Dan Freeman <https://github.com/dfreeman>
 //                 Mike North <https://github.com/mike-north>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.4
+// TypeScript Version: 2.8
 
 import Ember from 'ember';
 
diff --git a/types/ember-resolver/v4/tsconfig.json b/types/ember-resolver/v4/tsconfig.json
index 2539233e16..2c47c95ba1 100644
--- a/types/ember-resolver/v4/tsconfig.json
+++ b/types/ember-resolver/v4/tsconfig.json
@@ -2,12 +2,13 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
         "strictNullChecks": true,
-        "strictFunctionTypes": true,
+        "strictFunctionTypes": false,
         "baseUrl": "../../",
         "typeRoots": [
             "../../"
diff --git a/types/ember-test-helpers/tsconfig.json b/types/ember-test-helpers/tsconfig.json
index 2d9eb44d16..2e0ddf49b1 100644
--- a/types/ember-test-helpers/tsconfig.json
+++ b/types/ember-test-helpers/tsconfig.json
@@ -14,12 +14,31 @@
             "../"
         ],
         "paths": {
-            "@ember/engine": ["ember__engine"],
-            "@ember/engine/*": ["ember__engine/*"],
             "@ember/application": ["ember__application"],
             "@ember/application/*": ["ember__application/*"],
+            "@ember/array": ["ember__array"],
+            "@ember/array/*": ["ember__array/*"],
+            "@ember/component": ["ember__component"],
+            "@ember/component/*": ["ember__component/*"],
+            "@ember/controller": ["ember__controller"],
+            "@ember/debug": ["ember__debug"],
+            "@ember/debug/*": ["ember__debug/*"],
+            "@ember/engine": ["ember__engine"],
+            "@ember/engine/*": ["ember__engine/*"],
+            "@ember/error": ["ember__error"],
             "@ember/object": ["ember__object"],
-            "@ember/object/*": ["ember__object/*"]
+            "@ember/object/*": ["ember__object/*"],
+            "@ember/polyfills": ["ember__polyfills"],
+            "@ember/routing": ["ember__routing"],
+            "@ember/routing/*": ["ember__routing/*"],
+            "@ember/runloop": ["ember__runloop"],
+            "@ember/runloop/*": ["ember__runloop/*"],
+            "@ember/service": ["ember__service"],
+            "@ember/string": ["ember__string"],
+            "@ember/test": ["ember__test"],
+            "@ember/test/*": ["ember__test/*"],
+            "@ember/utils": ["ember__utils"],
+            "@ember/utils/*": ["ember__utils/*"]
         },
         "types": [],
         "noEmit": true,
diff --git a/types/ember/tsconfig.json b/types/ember/tsconfig.json
index 8a2cec5578..be47225e72 100755
--- a/types/ember/tsconfig.json
+++ b/types/ember/tsconfig.json
@@ -15,31 +15,31 @@
             "../"
         ],
         "paths": {
-            "@ember/string": ["ember__string"],
+            "@ember/application": ["ember__application"],
+            "@ember/application/*": ["ember__application/*"],
+            "@ember/array": ["ember__array"],
+            "@ember/array/*": ["ember__array/*"],
+            "@ember/component": ["ember__component"],
+            "@ember/component/*": ["ember__component/*"],
+            "@ember/controller": ["ember__controller"],
+            "@ember/debug": ["ember__debug"],
+            "@ember/debug/*": ["ember__debug/*"],
             "@ember/engine": ["ember__engine"],
             "@ember/engine/*": ["ember__engine/*"],
             "@ember/error": ["ember__error"],
-            "@ember/service": ["ember__service"],
-            "@ember/utils": ["ember__utils"],
-            "@ember/utils/*": ["ember__utils/*"],
-            "@ember/array": ["ember__array"],
-            "@ember/array/*": ["ember__array/*"],
-            "@ember/debug": ["ember__debug"],
-            "@ember/debug/*": ["ember__debug/*"],
-            "@ember/runloop": ["ember__runloop"],
-            "@ember/runloop/*": ["ember__runloop/*"],
-            "@ember/routing": ["ember__routing"],
-            "@ember/routing/*": ["ember__routing/*"],
-            "@ember/test": ["ember__test"],
-            "@ember/test/*": ["ember__test/*"],
             "@ember/object": ["ember__object"],
             "@ember/object/*": ["ember__object/*"],
-            "@ember/component": ["ember__component"],
-            "@ember/component/*": ["ember__component/*"],
-            "@ember/application": ["ember__application"],
-            "@ember/application/*": ["ember__application/*"],
-            "@ember/controller": ["ember__controller"],
-            "@ember/polyfills": ["ember__polyfills"]
+            "@ember/polyfills": ["ember__polyfills"],
+            "@ember/routing": ["ember__routing"],
+            "@ember/routing/*": ["ember__routing/*"],
+            "@ember/runloop": ["ember__runloop"],
+            "@ember/runloop/*": ["ember__runloop/*"],
+            "@ember/service": ["ember__service"],
+            "@ember/string": ["ember__string"],
+            "@ember/test": ["ember__test"],
+            "@ember/test/*": ["ember__test/*"],
+            "@ember/utils": ["ember__utils"],
+            "@ember/utils/*": ["ember__utils/*"]
         },
         "types": [],
         "noEmit": true,
diff --git a/types/ember__application/tsconfig.json b/types/ember__application/tsconfig.json
index c83da0b13d..46e1acb468 100644
--- a/types/ember__application/tsconfig.json
+++ b/types/ember__application/tsconfig.json
@@ -21,8 +21,10 @@
             "@ember/engine/*": ["ember__engine/*"],
             "@ember/routing": ["ember__routing"],
             "@ember/routing/*": ["ember__routing/*"],
+            "@ember/service": ["ember__service"],
             "@ember/application": ["ember__application"],
-            "@ember/application/*": ["ember__application/*"]
+            "@ember/application/*": ["ember__application/*"],
+            "@ember/controller": ["ember__controller"]
         },
         "types": [],
         "noEmit": true,
diff --git a/types/ember__object/test/core.ts b/types/ember__object/test/core.ts
index 984f5eec12..740daa78b0 100644
--- a/types/ember__object/test/core.ts
+++ b/types/ember__object/test/core.ts
@@ -1,8 +1,8 @@
-import Ember from 'ember';
 import { assertType } from './lib/assert';
+import CoreObject from '@ember/object/core';
 
 /** Newable tests */
-const co1 = new Ember.CoreObject();
+const co1 = new CoreObject();
 
 // TODO: Enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
 // co1.concatenatedProperties; // $ExpectType string[]
@@ -12,7 +12,7 @@ co1.destroy(); // $ExpectType CoreObject
 co1.toString(); // $ExpectType string
 
 /** .create tests */
-const co2 = Ember.CoreObject.create();
+const co2 = CoreObject.create();
 // TODO: Enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
 // co2.concatenatedProperties; // $ExpectType string[]
 co2.isDestroyed; // $ExpectType boolean
@@ -21,13 +21,13 @@ co2.destroy(); // $ExpectType CoreObject
 co2.toString(); // $ExpectType string
 
 /** .create tests w/ initial instance data passed in */
-const co3 = Ember.CoreObject.create({ foo: '123', bar: 456 });
+const co3 = CoreObject.create({ foo: '123', bar: 456 });
 
 co3.foo; // $ExpectType string
 co3.bar; // $ExpectType number
 
 /** .extend with a zero-argument .create()  */
-const co4 = Ember.CoreObject.extend({
+const co4 = CoreObject.extend({
     foo: '123',
     bar: 456,
     baz(): [string, number] {
@@ -40,8 +40,8 @@ co4.bar; // $ExpectType number
 co4.baz; // $ExpectType () => [string, number]
 
 /** .extend with inconsistent arguments passed into .create()  */
-const class05 = Ember.CoreObject.extend({
-    foo: '123' as (string | boolean),
+const class05 = CoreObject.extend({
+    foo: '123' as string | boolean,
     bar: 456,
     baz() {
         return [this.foo, this.bar];
@@ -54,33 +54,36 @@ assertType<string>(c05b.foo); // $ExpectError
 assertType<boolean>(c05c.foo); // $ExpectError
 
 /** two .extend arguments with a zero-argument .create() */
-const co6 = Ember.CoreObject.extend({
-    foo: '123',
-    bar: 456,
-    baz() {
-        return [this.foo, this.bar];
+const co6 = CoreObject.extend(
+    {
+        foo: '123',
+        bar: 456,
+        baz() {
+            return [this.foo, this.bar];
+        },
+        func1() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.foo; // $ExpectType string
+            // this does not include stuff from later extend args
+            this.bee; // $ExpectError
+        }
     },
-    func1() {
-        // this includes stuff from CoreObject
-        this.init; // $ExpectType () => void
-        // this includes stuff from this extend-arg
-        this.foo; // $ExpectType string
-        // this does not include stuff from later extend args
-        this.bee; // $ExpectError
+    {
+        foo: 99,
+        bee: 'honey',
+        func2() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+            this.foo; // $ExpectType string & number
+            // this includes stuff from earlier extend-args
+            this.bar; // $ExpectType number
+        }
     }
-}, {
-    foo: 99,
-    bee: 'honey',
-    func2() {
-        // this includes stuff from CoreObject
-        this.init; // $ExpectType () => void
-        // this includes stuff from this extend-arg
-        // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-        this.foo; // $ExpectType string & number
-        // this includes stuff from earlier extend-args
-        this.bar; // $ExpectType number
-    }
-}).create();
+).create();
 
 // TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
 // assertType<string>(co6.foo); // $ExpectError
@@ -88,45 +91,49 @@ assertType<number>(co6.bar); // $ExpectType number
 assertType<() => Array<string | number>>(co6.baz); // $ExpectType () => (string | number)[]
 
 /** three .extend arguments with a zero-argument .create() */
-const co7 = Ember.CoreObject.extend({
-    foo: '123',
-    bar: 456,
-    baz() {
-        return [this.foo, this.bar];
+const co7 = CoreObject.extend(
+    {
+        foo: '123',
+        bar: 456,
+        baz() {
+            return [this.foo, this.bar];
+        },
+        func1() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.foo; // $ExpectType string
+            // this does not include stuff from later extend args
+            this.bee; // $ExpectError
+        }
     },
-    func1() {
-        // this includes stuff from CoreObject
-        this.init; // $ExpectType () => void
-        // this includes stuff from this extend-arg
-        this.foo; // $ExpectType string
-        // this does not include stuff from later extend args
-        this.bee; // $ExpectError
+    {
+        foo: 99,
+        bee: 'honey',
+        func2() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+            this.foo; // $ExpectType string & number
+            // this includes stuff from earlier extend-args
+            this.bar; // $ExpectType number
+        }
+    },
+    {
+        foo: '99',
+        money: 'in the banana stand',
+        func3() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.money; // $ExpectType string
+            // this includes stuff from earlier extend-args
+            this.bee; // $ExpectType string
+            this.bar; // $ExpectType number
+        }
     }
-}, {
-    foo: 99,
-    bee: 'honey',
-    func2() {
-        // this includes stuff from CoreObject
-        this.init; // $ExpectType () => void
-        // this includes stuff from this extend-arg
-        // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-        this.foo; // $ExpectType string & number
-        // this includes stuff from earlier extend-args
-        this.bar; // $ExpectType number
-    }
-}, {
-    foo: '99',
-    money: 'in the banana stand',
-    func3() {
-        // this includes stuff from CoreObject
-        this.init; // $ExpectType () => void
-        // this includes stuff from this extend-arg
-        this.money; // $ExpectType string
-        // this includes stuff from earlier extend-args
-        this.bee; // $ExpectType string
-        this.bar; // $ExpectType number
-    }
-}).create();
+).create();
 // TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
 // assertType<number>(co7.foo); // $ExpectError
 assertType<number>(co7.bar); // $ExpectType number
@@ -134,62 +141,67 @@ assertType<string>(co7.money); // $ExpectType string
 assertType<() => Array<string | number>>(co7.baz); // $ExpectType () => (string | number)[]
 
 /** four .extend arguments with a zero-argument .create() */
-const co8 = Ember.CoreObject.extend({
-    foo: '123',
-    bar: 456,
-    baz() {
-        return [this.foo, this.bar];
+const co8 = CoreObject.extend(
+    {
+        foo: '123',
+        bar: 456,
+        baz() {
+            return [this.foo, this.bar];
+        },
+        func1() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.foo; // $ExpectType string
+            // this does not include stuff from later extend args
+            this.bee; // $ExpectError
+        }
     },
-    func1() {
-        // this includes stuff from CoreObject
-        this.init; // $ExpectType () => void
-        // this includes stuff from this extend-arg
-        this.foo; // $ExpectType string
-        // this does not include stuff from later extend args
-        this.bee; // $ExpectError
+    {
+        foo: 99,
+        bee: 'honey',
+        func2() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+            this.foo; // $ExpectType string & number
+            // this includes stuff from earlier extend-args
+            this.bar; // $ExpectType number
+            // this does not include stuff from later extend args
+            this.money; // $ExpectError
+        }
+    },
+    {
+        foo: '99',
+        money: 'in the banana stand',
+        func3() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.money; // $ExpectType string
+            // this includes stuff from earlier extend-args
+            this.bee; // $ExpectType string
+            this.bar; // $ExpectType number
+            // this does not include stuff from later extend args
+            this.neighborhood; // $ExpectError
+        }
+    },
+    {
+        foo: '99',
+        neighborhood: 'sudden valley',
+        func4() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.neighborhood; // $ExpectType string
+            // this includes stuff from earlier extend-args
+            this.bee; // $ExpectType string
+            this.bar; // $ExpectType number
+            this.money; // $ExpectType string
+        }
     }
-}, {
-    foo: 99,
-    bee: 'honey',
-    func2() {
-        // this includes stuff from CoreObject
-        this.init; // $ExpectType () => void
-        // this includes stuff from this extend-arg
-        // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-        this.foo; // $ExpectType string & number
-        // this includes stuff from earlier extend-args
-        this.bar; // $ExpectType number
-        // this does not include stuff from later extend args
-        this.money; // $ExpectError
-    }
-}, {
-    foo: '99',
-    money: 'in the banana stand',
-    func3() {
-        // this includes stuff from CoreObject
-        this.init; // $ExpectType () => void
-        // this includes stuff from this extend-arg
-        this.money; // $ExpectType string
-        // this includes stuff from earlier extend-args
-        this.bee; // $ExpectType string
-        this.bar; // $ExpectType number
-        // this does not include stuff from later extend args
-        this.neighborhood; // $ExpectError
-    }
-}, {
-    foo: '99',
-    neighborhood: 'sudden valley',
-    func4() {
-        // this includes stuff from CoreObject
-        this.init; // $ExpectType () => void
-        // this includes stuff from this extend-arg
-        this.neighborhood; // $ExpectType string
-        // this includes stuff from earlier extend-args
-        this.bee; // $ExpectType string
-        this.bar; // $ExpectType number
-        this.money; // $ExpectType string
-    }
-}).create();
+).create();
 
 // TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
 // assertType<number>(co8.foo); // $ExpectError
diff --git a/types/ember__object/test/create-negative.ts b/types/ember__object/test/create-negative.ts
index 2298ae8cf3..dadd2a2176 100644
--- a/types/ember__object/test/create-negative.ts
+++ b/types/ember__object/test/create-negative.ts
@@ -1,5 +1,4 @@
 import { assertType } from './lib/assert';
-import Ember from 'ember';
 import { PersonWithNumberName, Person } from './create';
 
 Person.create({ firstName: 99 }); // $ExpectError
diff --git a/types/ember__test-helpers/tsconfig.json b/types/ember__test-helpers/tsconfig.json
index 18e1faee35..7b167f14d5 100644
--- a/types/ember__test-helpers/tsconfig.json
+++ b/types/ember__test-helpers/tsconfig.json
@@ -17,14 +17,31 @@
         "noEmit": true,
         "forceConsistentCasingInFileNames": true,
         "paths": {
+            "@ember/application": ["ember__application"],
+            "@ember/application/*": ["ember__application/*"],
+            "@ember/array": ["ember__array"],
+            "@ember/array/*": ["ember__array/*"],
+            "@ember/component": ["ember__component"],
+            "@ember/component/*": ["ember__component/*"],
+            "@ember/controller": ["ember__controller"],
+            "@ember/debug": ["ember__debug"],
+            "@ember/debug/*": ["ember__debug/*"],
             "@ember/engine": ["ember__engine"],
             "@ember/engine/*": ["ember__engine/*"],
             "@ember/error": ["ember__error"],
-            "@ember/application": ["ember__application"],
-            "@ember/application/*": ["ember__application/*"],
             "@ember/object": ["ember__object"],
             "@ember/object/*": ["ember__object/*"],
-            "@ember/test-helpers": ["ember__test-helpers"]
+            "@ember/polyfills": ["ember__polyfills"],
+            "@ember/routing": ["ember__routing"],
+            "@ember/routing/*": ["ember__routing/*"],
+            "@ember/runloop": ["ember__runloop"],
+            "@ember/runloop/*": ["ember__runloop/*"],
+            "@ember/service": ["ember__service"],
+            "@ember/string": ["ember__string"],
+            "@ember/test": ["ember__test"],
+            "@ember/test/*": ["ember__test/*"],
+            "@ember/utils": ["ember__utils"],
+            "@ember/utils/*": ["ember__utils/*"]
         }
     },
     "files": [
diff --git a/types/ember__test/tsconfig.json b/types/ember__test/tsconfig.json
index e5405575cc..da00f05337 100644
--- a/types/ember__test/tsconfig.json
+++ b/types/ember__test/tsconfig.json
@@ -15,12 +15,31 @@
             "../"
         ],
         "paths": {
-            "@ember/engine": ["ember__engine"],
-            "@ember/engine/*": ["ember__engine/*"],
             "@ember/application": ["ember__application"],
             "@ember/application/*": ["ember__application/*"],
+            "@ember/array": ["ember__array"],
+            "@ember/array/*": ["ember__array/*"],
+            "@ember/component": ["ember__component"],
+            "@ember/component/*": ["ember__component/*"],
+            "@ember/controller": ["ember__controller"],
+            "@ember/debug": ["ember__debug"],
+            "@ember/debug/*": ["ember__debug/*"],
+            "@ember/engine": ["ember__engine"],
+            "@ember/engine/*": ["ember__engine/*"],
+            "@ember/error": ["ember__error"],
+            "@ember/object": ["ember__object"],
+            "@ember/object/*": ["ember__object/*"],
+            "@ember/polyfills": ["ember__polyfills"],
+            "@ember/routing": ["ember__routing"],
+            "@ember/routing/*": ["ember__routing/*"],
+            "@ember/runloop": ["ember__runloop"],
+            "@ember/runloop/*": ["ember__runloop/*"],
+            "@ember/service": ["ember__service"],
+            "@ember/string": ["ember__string"],
             "@ember/test": ["ember__test"],
-            "@ember/test/*": ["ember__test/*"]
+            "@ember/test/*": ["ember__test/*"],
+            "@ember/utils": ["ember__utils"],
+            "@ember/utils/*": ["ember__utils/*"]
         },
         "types": [],
         "noEmit": true,
diff --git a/types/esri-leaflet/tsconfig.json b/types/esri-leaflet/tsconfig.json
index 596c74f0a2..803c09f1d9 100644
--- a/types/esri-leaflet/tsconfig.json
+++ b/types/esri-leaflet/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/expect-puppeteer/tsconfig.json b/types/expect-puppeteer/tsconfig.json
index 7ca516e3c2..8a3d56b626 100644
--- a/types/expect-puppeteer/tsconfig.json
+++ b/types/expect-puppeteer/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/expo/index.d.ts b/types/expo/index.d.ts
index 54c34ebe24..043cc726a4 100644
--- a/types/expo/index.d.ts
+++ b/types/expo/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for expo 27.0
+// Type definitions for expo 30.0
 // Project: https://github.com/expo/expo-sdk
 // Definitions by: Konstantin Kai <https://github.com/KonstantinKai>
 //                 Martynas Kadiša <https://github.com/martynaskadisa>
@@ -1403,8 +1403,8 @@ export namespace FileSystem {
 }
 
 /** Use TouchID/FaceID (iOS) or the Fingerprint API (Android) to authenticate the user with a fingerprint scan. */
-export namespace Fingerprint {
-    type FingerprintAuthenticationResult = {
+export namespace LocalAuthentication {
+    type LocalAuthenticationResult = {
         success: true
     } | {
         success: false,
@@ -1413,10 +1413,10 @@ export namespace Fingerprint {
         error: string
     };
 
-    /** Determine whether the Fingerprint scanner is available on the device. */
+    /** Determine whether a face or fingerprint scanner is available on the device. */
     function hasHardwareAsync(): Promise<boolean>;
 
-    /** Determine whether the device has saved fingerprints to use for authentication. */
+    /** Determine whether the device has saved fingerprints or facial data to use for authentication. */
     function isEnrolledAsync(): Promise<boolean>;
 
     /**
@@ -1424,7 +1424,7 @@ export namespace Fingerprint {
      *
      * @param promptMessage A message that is shown alongside the TouchID/FaceID prompt. (iOS only)
      */
-    function authenticateAsync(promptMessageIOS?: string): Promise<FingerprintAuthenticationResult>;
+    function authenticateAsync(promptMessageIOS?: string): Promise<LocalAuthenticationResult>;
 
     /** Cancels the fingerprint authentication flow. (Android only) */
     function cancelAuthenticate(): void;
@@ -2422,10 +2422,10 @@ export namespace Calendar {
         recurrenceRule?: RecurrenceRule;
 
         /** Date object or string representing the time when the event starts */
-        startDate?: string;
+        startDate?: string | Date;
 
         /** Date object or string representing the time when the event ends */
-        endDate?: string;
+        endDate?: string | Date;
 
         /** For recurring events, the start date for the first (original) instance of the event */
         originalStartDate?: string; // iOS
diff --git a/types/expo/tsconfig.json b/types/expo/tsconfig.json
index 7711f49776..e00f046e0e 100644
--- a/types/expo/tsconfig.json
+++ b/types/expo/tsconfig.json
@@ -1,10 +1,7 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": [
-            "dom",
-            "es6"
-        ],
+        "lib": ["es6"],
         "jsx": "react",
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/expo/v23/tsconfig.json b/types/expo/v23/tsconfig.json
index 295d9da342..d495e3101a 100644
--- a/types/expo/v23/tsconfig.json
+++ b/types/expo/v23/tsconfig.json
@@ -1,10 +1,7 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": [
-            "es6",
-            "dom"
-        ],
+        "lib": ["es6"],
         "jsx": "react",
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/expo/v24/tsconfig.json b/types/expo/v24/tsconfig.json
index dffdd0aa8c..b5b779edea 100644
--- a/types/expo/v24/tsconfig.json
+++ b/types/expo/v24/tsconfig.json
@@ -1,10 +1,7 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": [
-            "es6",
-            "dom"
-        ],
+        "lib": ["es6"],
         "jsx": "react",
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/expo/v25/tsconfig.json b/types/expo/v25/tsconfig.json
index db8203e995..436b8d29db 100644
--- a/types/expo/v25/tsconfig.json
+++ b/types/expo/v25/tsconfig.json
@@ -1,10 +1,7 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": [
-            "dom",
-            "es6"
-        ],
+        "lib": ["es6"],
         "jsx": "react",
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/expo/v26/tsconfig.json b/types/expo/v26/tsconfig.json
index 53a55b14f1..580bb8ac16 100644
--- a/types/expo/v26/tsconfig.json
+++ b/types/expo/v26/tsconfig.json
@@ -1,10 +1,7 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": [
-            "dom",
-            "es6"
-        ],
+        "lib": ["es6"],
         "jsx": "react",
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/expo/v27/expo-tests.tsx b/types/expo/v27/expo-tests.tsx
new file mode 100644
index 0000000000..e2d73a67f7
--- /dev/null
+++ b/types/expo/v27/expo-tests.tsx
@@ -0,0 +1,949 @@
+import * as React from 'react';
+import { Text } from 'react-native';
+
+import {
+    Accelerometer,
+    AdMobAppEvent,
+    AdMobBanner,
+    AdMobInterstitial,
+    AdMobRewarded,
+    Amplitude,
+    Asset,
+    AuthSession,
+    Audio,
+    AppLoading,
+    BarCodeScanner,
+    BlurViewProps,
+    BlurView,
+    Brightness,
+    Camera,
+    CameraObject,
+    DocumentPicker,
+    Facebook,
+    FacebookAds,
+    FileSystem,
+    ImagePicker,
+    ImageManipulator,
+    FaceDetector,
+    Linking,
+    Svg,
+    IntentLauncherAndroid,
+    KeepAwake,
+    LinearGradient,
+    Permissions,
+    PublisherBanner,
+    registerRootComponent,
+    ScreenOrientation,
+    SQLite,
+    Calendar,
+    MailComposer,
+    Location,
+    Updates,
+    MediaLibrary,
+    Haptic,
+    Constants
+} from 'expo';
+
+const reverseGeocode: Promise<Location.GeocodeData[]> = Location.reverseGeocodeAsync({
+    latitude: 0,
+    longitude: 0
+});
+
+Accelerometer.addListener((obj) => {
+    obj.x;
+    obj.y;
+    obj.z;
+});
+Accelerometer.removeAllListeners();
+Accelerometer.setUpdateInterval(1000);
+
+() => (
+    <AdMobBanner
+        bannerSize="leaderboard"
+        adUnitID="ca-app-pub-3940256099942544/6300978111"
+        testDeviceID="EMULATOR"
+        didFailToReceiveAdWithError={(error: string) => console.log(error)}
+        style={{ flex: 1 }}
+    />
+);
+
+() => (
+    <PublisherBanner
+        bannerSize="leaderboard"
+        adUnitID="ca-app-pub-3940256099942544/6300978111"
+        testDeviceID="EMULATOR"
+        didFailToReceiveAdWithError={(error: string) => console.log(error)}
+        onAdMobDispatchAppEvent={(event: AdMobAppEvent) => console.log(event)}
+        style={{ flex: 1 }}
+    />
+);
+
+AdMobInterstitial.setAdUnitID('ca-app-pub-3940256099942544/1033173712'); // Test ID, Replace with your-admob-unit-id
+AdMobInterstitial.setTestDeviceID('EMULATOR');
+async () => {
+    await AdMobInterstitial.requestAdAsync();
+    await AdMobInterstitial.showAdAsync();
+};
+
+AdMobRewarded.setAdUnitID('ca-app-pub-3940256099942544/1033173712'); // Test ID, Replace with your-admob-unit-id
+AdMobRewarded.setTestDeviceID('EMULATOR');
+async () => {
+    await AdMobRewarded.requestAdAsync();
+    await AdMobRewarded.showAdAsync();
+};
+
+Amplitude.initialize('key');
+Amplitude.setUserId('userId');
+Amplitude.setUserProperties({key: 1});
+Amplitude.clearUserProperties();
+Amplitude.logEvent('name');
+Amplitude.logEventWithProperties('event', {key: 'value'});
+Amplitude.setGroup('type', ['value']);
+
+const asset = Asset.fromModule(1);
+asset.downloadAsync();
+Asset.loadAsync(1);
+Asset.loadAsync([1, 2, 3]);
+const asset1 = new Asset({
+    uri: 'uri',
+    type: 'type',
+    name: 'name',
+    hash: 'hash',
+    width: 122,
+    height: 122
+});
+
+const url = AuthSession.getRedirectUrl();
+AuthSession.dismiss();
+AuthSession.startAsync({
+    authUrl: 'url1',
+    returnUrl: 'url2'
+}).then(result => {
+    switch (result.type) {
+        case 'success':
+            result.event;
+            result.params;
+            break;
+        case 'error':
+            result.errorCode;
+            result.params;
+            result.event;
+            break;
+        case 'dismissed':
+        case 'cancel':
+            result.type;
+            break;
+    }
+});
+AuthSession.startAsync({
+    authUrl: 'url1',
+    returnUrl: undefined
+});
+
+Audio.setAudioModeAsync({
+    shouldDuckAndroid: false,
+    playsInSilentModeIOS: true,
+    interruptionModeIOS: 2,
+    interruptionModeAndroid: 1,
+    allowsRecordingIOS: true
+});
+Audio.setIsEnabledAsync(true);
+
+Audio.INTERRUPTION_MODE_IOS_MIX_WITH_OTHERS === 0;
+Audio.INTERRUPTION_MODE_IOS_DO_NOT_MIX === 1;
+Audio.INTERRUPTION_MODE_IOS_DUCK_OTHERS === 2;
+
+Audio.INTERRUPTION_MODE_ANDROID_DO_NOT_MIX === 1;
+Audio.INTERRUPTION_MODE_ANDROID_DUCK_OTHERS === 2;
+
+Audio.RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_DEFAULT === 0;
+Audio.RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_THREE_GPP === 1;
+Audio.RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_MPEG_4 === 2;
+Audio.RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_AMR_NB === 3;
+Audio.RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_AMR_WB === 4;
+Audio.RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_AAC_ADIF === 5;
+Audio.RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_AAC_ADTS === 6;
+Audio.RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_RTP_AVP === 7;
+Audio.RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_MPEG2TS === 8;
+Audio.RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_WEBM === 9;
+
+Audio.RECORDING_OPTION_ANDROID_AUDIO_ENCODER_DEFAULT === 0;
+Audio.RECORDING_OPTION_ANDROID_AUDIO_ENCODER_AMR_NB === 1;
+Audio.RECORDING_OPTION_ANDROID_AUDIO_ENCODER_AMR_WB === 2;
+Audio.RECORDING_OPTION_ANDROID_AUDIO_ENCODER_AAC === 3;
+Audio.RECORDING_OPTION_ANDROID_AUDIO_ENCODER_HE_AAC === 4;
+Audio.RECORDING_OPTION_ANDROID_AUDIO_ENCODER_AAC_ELD === 5;
+Audio.RECORDING_OPTION_ANDROID_AUDIO_ENCODER_VORBIS === 6;
+
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_LINEARPCM === 'lpcm';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_AC3 === 'ac-3';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_60958AC3 === 'cac3';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_APPLEIMA4 === 'ima4';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC === 'aac ';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4CELP === 'celp';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4HVXC === 'hvxc';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4TWINVQ === 'twvq';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MACE3 === 'MAC3';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MACE6 === 'MAC6';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_ULAW === 'ulaw';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_ALAW === 'alaw';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_QDESIGN === 'QDMC';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_QDESIGN2 === 'QDM2';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_QUALCOMM === 'Qclp';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEGLAYER1 === '.mp1';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEGLAYER2 === '.mp2';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEGLAYER3 === '.mp3';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_APPLELOSSLESS === 'alac';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC_HE === 'aach';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC_LD === 'aacl';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC_ELD === 'aace';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC_ELD_SBR === 'aacf';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC_ELD_V2 === 'aacg';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC_HE_V2 === 'aacp';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC_SPATIAL === 'aacs';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_AMR === 'samr';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_AMR_WB === 'sawb';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_AUDIBLE === 'AUDB';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_ILBC === 'ilbc';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_DVIINTELIMA === 0x6d730011;
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MICROSOFTGSM === 0x6d730031;
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_AES3 === 'aes3';
+Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_ENHANCEDAC3 === 'ec-3';
+
+Audio.RECORDING_OPTION_IOS_AUDIO_QUALITY_MIN === 0;
+Audio.RECORDING_OPTION_IOS_AUDIO_QUALITY_LOW === 0x20;
+Audio.RECORDING_OPTION_IOS_AUDIO_QUALITY_MEDIUM === 0x40;
+Audio.RECORDING_OPTION_IOS_AUDIO_QUALITY_HIGH === 0x60;
+Audio.RECORDING_OPTION_IOS_AUDIO_QUALITY_MAX === 0x7f;
+
+Audio.RECORDING_OPTION_IOS_BIT_RATE_STRATEGY_CONSTANT === 0;
+Audio.RECORDING_OPTION_IOS_BIT_RATE_STRATEGY_LONG_TERM_AVERAGE === 1;
+Audio.RECORDING_OPTION_IOS_BIT_RATE_STRATEGY_VARIABLE_CONSTRAINED === 2;
+Audio.RECORDING_OPTION_IOS_BIT_RATE_STRATEGY_VARIABLE === 3;
+
+Audio.RECORDING_OPTIONS_PRESET_HIGH_QUALITY;
+Audio.RECORDING_OPTIONS_PRESET_LOW_QUALITY;
+async () => {
+    const result = await Audio.Sound.create({uri: 'uri'}, {
+        volume: 0.55,
+        rate: 16.5
+    }, null, true);
+
+    const sound = result.sound;
+    const status = result.status;
+
+    if (!status.isLoaded) {
+        status.error;
+    } else {
+        status.didJustFinish;
+        // etc.
+    }
+
+    const _status = await sound.getStatusAsync();
+    await sound.loadAsync({uri: 'uri'});
+};
+
+() => (
+    <AppLoading
+        startAsync={() => Promise.resolve()}
+        onFinish={() => {}}
+        onError={(error) => console.log(error)} />
+);
+() => (
+    <AppLoading />
+);
+
+const barcodeReadCallback = () => {};
+() => (
+    <BarCodeScanner
+        type="front"
+        torchMode="off"
+        barCodeTypes={[BarCodeScanner.Constants.BarCodeType.aztec]}
+        onBarCodeRead={barcodeReadCallback} />
+);
+
+() => (
+    <BlurView
+        tint="dark"
+        intensity={2} />
+);
+
+async () => {
+    await Brightness.setBrightnessAsync(0.65);
+    await Brightness.setSystemBrightnessAsync(0.75);
+    const br1 = await Brightness.getBrightnessAsync();
+    const br2 = await Brightness.getSystemBrightnessAsync();
+};
+
+Camera.Constants.AutoFocus;
+Camera.Constants.Type;
+Camera.Constants.FlashMode;
+Camera.Constants.WhiteBalance;
+Camera.Constants.VideoQuality;
+Camera.Constants.BarCodeType;
+() => {
+    return(<Camera ref={(component: any) => {
+        if (component) {
+            component.recordAsync();
+        }
+    }} />);
+};
+async (camera: CameraObject) => {
+    const picture = await camera.takePictureAsync({
+        quality: 0.5,
+        base64: true,
+        exif: true
+    });
+
+    picture.uri;
+    picture.width;
+    picture.height;
+    picture.exif;
+    picture.base64;
+
+    camera.takePictureAsync({
+        quality: 1,
+        onPictureSaved: pic => {
+            pic.uri;
+            pic.width;
+            pic.height;
+            pic.exif;
+            pic.base64;
+        }
+    });
+};
+
+async () => {
+    const result = await DocumentPicker.getDocumentAsync();
+
+    if (result.type === 'success') {
+        result.name;
+        result.uri;
+        result.size;
+    }
+};
+
+async () => {
+    const { type, expires, token } = await Facebook.logInWithReadPermissionsAsync("appId");
+};
+
+() => (
+    <FacebookAds.BannerView
+        type="large"
+        placementId="str"
+        onPress={() => {}}
+        onError={() => {}} />
+);
+
+async () => {
+    const info = await FileSystem.getInfoAsync('file');
+
+    info.exists;
+    info.isDirectory;
+
+    if (info.exists) {
+        info.md5;
+        info.uri;
+        info.size;
+        info.modificationTime;
+    }
+
+    const string: string = await FileSystem.readAsStringAsync('file');
+    await FileSystem.writeAsStringAsync('file', 'content');
+    await FileSystem.deleteAsync('file');
+    await FileSystem.moveAsync({ from: 'from', to: 'to'});
+    await FileSystem.copyAsync({ from: 'from', to: 'to' });
+    await FileSystem.makeDirectoryAsync('dir');
+    const dirs: string[] = await FileSystem.readDirectoryAsync('dir');
+    const result = await FileSystem.downloadAsync('from', 'to');
+
+    result.headers;
+    result.status;
+    result.uri;
+    result.md5;
+};
+
+async () => {
+    // Video test
+    const result = await ImagePicker.launchImageLibraryAsync({
+        mediaTypes: ImagePicker.MediaTypeOptions.Videos,
+    });
+
+    if (!result.cancelled) {
+        result.uri;
+        result.width;
+        result.height;
+        result.duration;
+        result.type;
+    }
+};
+
+async () => {
+    // Image test
+    const result = await ImagePicker.launchImageLibraryAsync({
+        mediaTypes: ImagePicker.MediaTypeOptions.Images,
+        base64: true,
+        aspect: [4, 3],
+        quality: 1,
+        exif: true,
+    });
+
+    if (!result.cancelled) {
+        result.uri;
+        result.width;
+        result.height;
+        result.exif;
+        result.base64;
+        result.type;
+    }
+};
+
+async () => {
+    const result = await ImageManipulator.manipulate('url', [
+        { rotate: 90 },
+        { resize: { width: 300 } },
+        { resize: { height: 300 } },
+        { resize: { height: 300, width: 300 } },
+    ], {
+        compress: 0.75
+    });
+
+    result.height;
+    result.uri;
+    result.width;
+};
+
+FaceDetector.Constants.Mode.fast;
+FaceDetector.Constants.Mode.accurate;
+FaceDetector.Constants.Landmarks.all;
+FaceDetector.Constants.Landmarks.none;
+FaceDetector.Constants.Classifications.all;
+FaceDetector.Constants.Classifications.none;
+async () => {
+    const result = await FaceDetector.detectFaces('url', {
+        mode: FaceDetector.Constants.Mode.fast,
+        detectLandmarks: FaceDetector.Constants.Landmarks.all,
+        runClassifications: FaceDetector.Constants.Classifications.none
+    });
+
+    result.faces[0];
+};
+
+async () => {
+    function isBoolean(x: boolean) {
+    }
+    function isString(x: string) {
+    }
+    // Two examples of members inherited from react-native Linking
+    // to prove that inheritence is working.
+    Linking.addEventListener('url', (e) => {
+        e.url === '';
+    });
+    isBoolean(await Linking.canOpenURL('expo://'));
+
+    // Extensions added by expo.
+
+    isString(Linking.makeUrl('path'));
+    isString(Linking.makeUrl('path', { q: 2, u: 'ery', }));
+
+    const {
+        path,
+        queryParams,
+    } = Linking.parse('');
+    isString(path);
+    isString(queryParams['x'] || '');
+
+    const {
+        path: path2,
+        queryParams: queryParams2,
+    } = await Linking.parseInitialURLAsync();
+    isString(path2);
+    isString(queryParams2['y'] || '');
+};
+
+() => (
+    <Svg width={100} height={50}>
+        <Svg.Rect
+            x={25}
+            y={5}
+            width={150}
+            height={50}
+            fill='rgb(0,0,255)'
+            strokeWidth={3}
+            stroke='rgb(0,0,0)'
+            transform="translate(0, 0)"
+        />
+        <Svg.Circle
+            cx={50}
+            cy={50}
+            r={50}
+            fill="pink"
+            transform="translate(0, 0)"
+        />
+        <Svg.Ellipse
+            cx={55}
+            cy={55}
+            rx={50}
+            ry={30}
+            stroke="purple"
+            strokeWidth={2}
+            fill="yellow"
+            transform="translate(0, 0)"
+        />
+        <Svg.Line
+            x1={0}
+            y1={0}
+            x2={100}
+            y2={100}
+            stroke="red"
+            strokeWidth={2}
+            transform="translate(0, 0)"
+        />
+        <Svg.Polygon
+            points="40,5 70,80 25,95"
+            fill="lime"
+            stroke="purple"
+            strokeWidth={1}
+            transform="translate(0, 0)"
+        />
+        <Svg.Polyline
+            points="10,10 20,12 30,20 40,60 60,70 95,90"
+            fill="none"
+            stroke="black"
+            strokeWidth={3}
+            transform="translate(0, 0)"
+        />
+        <Svg.Text
+            fill="none"
+            stroke="purple"
+            fontSize={20}
+            fontWeight="bold"
+            x={100}
+            y={20}
+            textAnchor="middle"
+            transform="translate(0, 0)"
+        >
+            STROKED TEXT
+        </Svg.Text>
+        <Svg.Defs>
+            <Svg.Path
+                id="path"
+                d=""
+            />
+        </Svg.Defs>
+        <Svg.G transform="translate(0, 0)" y={20}>
+            <Svg.Text fill="blue" transform={{ translateX: 0, translateY: 0 }}>
+                <Svg.TextPath href="#path" startOffset="-10%">
+                    We go up and down,
+                    <Svg.TSpan fill="red" dy="5,5,5">then up again</Svg.TSpan>
+                </Svg.TextPath>
+            </Svg.Text>
+            <Svg.Path
+                d=""
+                fill="none"
+                stroke="red"
+                strokeWidth={1}
+            />
+        </Svg.G>
+        <Svg.Use href="#shape" transform="translate(0, 0)" x="20" y="0" />
+        <Svg.Use href="#shape" transform={{ translateX: 0, translateY: 0 }} x="20" y="0" width="20" height="20"/>
+        <Svg.Symbol id="symbol" viewBox="0 0 150 110" width="100" height="50">
+            <Svg.Circle cx="50" cy="50" r="40" strokeWidth="8" stroke="red" fill="red"/>
+            <Svg.Circle cx="90" cy="60" r="40" strokeWidth="8" stroke="green" fill="white"/>
+        </Svg.Symbol>
+        <Svg.Defs>
+            <Svg.ClipPath id="clip">
+                <Svg.Circle cx="50%" cy="50%" r="40%"/>
+            </Svg.ClipPath>
+            <Svg.RadialGradient id="grad" cx="50%" cy="50%" rx="50%" ry="50%" fx="50%" fy="50%" gradientUnits="userSpaceOnUse">
+                <Svg.Stop
+                    offset="0%"
+                    stopColor="#ff0"
+                    stopOpacity="1"
+                />
+            </Svg.RadialGradient>
+            <Svg.LinearGradient id="grad" x1="0" y1="0" x2="170" y2="0">
+                <Svg.Stop offset="1" stopColor="red" stopOpacity="1" />
+            </Svg.LinearGradient>
+        </Svg.Defs>
+    </Svg>
+);
+
+IntentLauncherAndroid.ACTION_ACCESSIBILITY_SETTINGS === 'android.settings.ACCESSIBILITY_SETTINGS';
+IntentLauncherAndroid.ACTION_APP_NOTIFICATION_REDACTION === 'android.settings.ACTION_APP_NOTIFICATION_REDACTION';
+IntentLauncherAndroid.ACTION_CONDITION_PROVIDER_SETTINGS === 'android.settings.ACTION_CONDITION_PROVIDER_SETTINGS';
+IntentLauncherAndroid.ACTION_NOTIFICATION_LISTENER_SETTINGS === 'android.settings.ACTION_NOTIFICATION_LISTENER_SETTINGS';
+IntentLauncherAndroid.ACTION_PRINT_SETTINGS === 'android.settings.ACTION_PRINT_SETTINGS';
+IntentLauncherAndroid.ACTION_ADD_ACCOUNT_SETTINGS === 'android.settings.ADD_ACCOUNT_SETTINGS';
+IntentLauncherAndroid.ACTION_AIRPLANE_MODE_SETTINGS === 'android.settings.AIRPLANE_MODE_SETTINGS';
+IntentLauncherAndroid.ACTION_APN_SETTINGS === 'android.settings.APN_SETTINGS';
+IntentLauncherAndroid.ACTION_APPLICATION_DETAILS_SETTINGS === 'android.settings.APPLICATION_DETAILS_SETTINGS';
+IntentLauncherAndroid.ACTION_APPLICATION_DEVELOPMENT_SETTINGS === 'android.settings.APPLICATION_DEVELOPMENT_SETTINGS';
+IntentLauncherAndroid.ACTION_APPLICATION_SETTINGS === 'android.settings.APPLICATION_SETTINGS';
+IntentLauncherAndroid.ACTION_APP_NOTIFICATION_SETTINGS === 'android.settings.APP_NOTIFICATION_SETTINGS';
+IntentLauncherAndroid.ACTION_APP_OPS_SETTINGS === 'android.settings.APP_OPS_SETTINGS';
+IntentLauncherAndroid.ACTION_BATTERY_SAVER_SETTINGS === 'android.settings.BATTERY_SAVER_SETTINGS';
+IntentLauncherAndroid.ACTION_BLUETOOTH_SETTINGS === 'android.settings.BLUETOOTH_SETTINGS';
+IntentLauncherAndroid.ACTION_CAPTIONING_SETTINGS === 'android.settings.CAPTIONING_SETTINGS';
+IntentLauncherAndroid.ACTION_CAST_SETTINGS === 'android.settings.CAST_SETTINGS';
+IntentLauncherAndroid.ACTION_DATA_ROAMING_SETTINGS === 'android.settings.DATA_ROAMING_SETTINGS';
+IntentLauncherAndroid.ACTION_DATE_SETTINGS === 'android.settings.DATE_SETTINGS';
+IntentLauncherAndroid.ACTION_DEVICE_INFO_SETTINGS === 'android.settings.DEVICE_INFO_SETTINGS';
+IntentLauncherAndroid.ACTION_DEVICE_NAME === 'android.settings.DEVICE_NAME';
+IntentLauncherAndroid.ACTION_DISPLAY_SETTINGS === 'android.settings.DISPLAY_SETTINGS';
+IntentLauncherAndroid.ACTION_DREAM_SETTINGS === 'android.settings.DREAM_SETTINGS';
+IntentLauncherAndroid.ACTION_HARD_KEYBOARD_SETTINGS === 'android.settings.HARD_KEYBOARD_SETTINGS';
+IntentLauncherAndroid.ACTION_HOME_SETTINGS === 'android.settings.HOME_SETTINGS';
+IntentLauncherAndroid.ACTION_IGNORE_BACKGROUND_DATA_RESTRICTIONS_SETTINGS === 'android.settings.IGNORE_BACKGROUND_DATA_RESTRICTIONS_SETTINGS';
+IntentLauncherAndroid.ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS === 'android.settings.IGNORE_BATTERY_OPTIMIZATION_SETTINGS';
+IntentLauncherAndroid.ACTION_INPUT_METHOD_SETTINGS === 'android.settings.INPUT_METHOD_SETTINGS';
+IntentLauncherAndroid.ACTION_INPUT_METHOD_SUBTYPE_SETTINGS === 'android.settings.INPUT_METHOD_SUBTYPE_SETTINGS';
+IntentLauncherAndroid.ACTION_INTERNAL_STORAGE_SETTINGS === 'android.settings.INTERNAL_STORAGE_SETTINGS';
+IntentLauncherAndroid.ACTION_LOCALE_SETTINGS === 'android.settings.LOCALE_SETTINGS';
+IntentLauncherAndroid.ACTION_LOCATION_SOURCE_SETTINGS === 'android.settings.LOCATION_SOURCE_SETTINGS';
+IntentLauncherAndroid.ACTION_MANAGE_ALL_APPLICATIONS_SETTINGS === 'android.settings.MANAGE_ALL_APPLICATIONS_SETTINGS';
+IntentLauncherAndroid.ACTION_MANAGE_APPLICATIONS_SETTINGS === 'android.settings.MANAGE_APPLICATIONS_SETTINGS';
+IntentLauncherAndroid.ACTION_MANAGE_DEFAULT_APPS_SETTINGS === 'android.settings.MANAGE_DEFAULT_APPS_SETTINGS';
+IntentLauncherAndroid.ACTION_MEMORY_CARD_SETTINGS === 'android.settings.MEMORY_CARD_SETTINGS';
+IntentLauncherAndroid.ACTION_MONITORING_CERT_INFO === 'android.settings.MONITORING_CERT_INFO';
+IntentLauncherAndroid.ACTION_NETWORK_OPERATOR_SETTINGS === 'android.settings.NETWORK_OPERATOR_SETTINGS';
+IntentLauncherAndroid.ACTION_NFCSHARING_SETTINGS === 'android.settings.NFCSHARING_SETTINGS';
+IntentLauncherAndroid.ACTION_NFC_PAYMENT_SETTINGS === 'android.settings.NFC_PAYMENT_SETTINGS';
+IntentLauncherAndroid.ACTION_NFC_SETTINGS === 'android.settings.NFC_SETTINGS';
+IntentLauncherAndroid.ACTION_NIGHT_DISPLAY_SETTINGS === 'android.settings.NIGHT_DISPLAY_SETTINGS';
+IntentLauncherAndroid.ACTION_NOTIFICATION_POLICY_ACCESS_SETTINGS === 'android.settings.NOTIFICATION_POLICY_ACCESS_SETTINGS';
+IntentLauncherAndroid.ACTION_NOTIFICATION_SETTINGS === 'android.settings.NOTIFICATION_SETTINGS';
+IntentLauncherAndroid.ACTION_PAIRING_SETTINGS === 'android.settings.PAIRING_SETTINGS';
+IntentLauncherAndroid.ACTION_PRIVACY_SETTINGS === 'android.settings.PRIVACY_SETTINGS';
+IntentLauncherAndroid.ACTION_QUICK_LAUNCH_SETTINGS === 'android.settings.QUICK_LAUNCH_SETTINGS';
+IntentLauncherAndroid.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS === 'android.settings.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS';
+IntentLauncherAndroid.ACTION_SECURITY_SETTINGS === 'android.settings.SECURITY_SETTINGS';
+IntentLauncherAndroid.ACTION_SETTINGS === 'android.settings.SETTINGS';
+IntentLauncherAndroid.ACTION_SHOW_ADMIN_SUPPORT_DETAILS === 'android.settings.SHOW_ADMIN_SUPPORT_DETAILS';
+IntentLauncherAndroid.ACTION_SHOW_INPUT_METHOD_PICKER === 'android.settings.SHOW_INPUT_METHOD_PICKER';
+IntentLauncherAndroid.ACTION_SHOW_REGULATORY_INFO === 'android.settings.SHOW_REGULATORY_INFO';
+IntentLauncherAndroid.ACTION_SHOW_REMOTE_BUGREPORT_DIALOG === 'android.settings.SHOW_REMOTE_BUGREPORT_DIALOG';
+IntentLauncherAndroid.ACTION_SOUND_SETTINGS === 'android.settings.SOUND_SETTINGS';
+IntentLauncherAndroid.ACTION_STORAGE_MANAGER_SETTINGS === 'android.settings.STORAGE_MANAGER_SETTINGS';
+IntentLauncherAndroid.ACTION_SYNC_SETTINGS === 'android.settings.SYNC_SETTINGS';
+IntentLauncherAndroid.ACTION_SYSTEM_UPDATE_SETTINGS === 'android.settings.SYSTEM_UPDATE_SETTINGS';
+IntentLauncherAndroid.ACTION_TETHER_PROVISIONING_UI === 'android.settings.TETHER_PROVISIONING_UI';
+IntentLauncherAndroid.ACTION_TRUSTED_CREDENTIALS_USER === 'android.settings.TRUSTED_CREDENTIALS_USER';
+IntentLauncherAndroid.ACTION_USAGE_ACCESS_SETTINGS === 'android.settings.USAGE_ACCESS_SETTINGS';
+IntentLauncherAndroid.ACTION_USER_DICTIONARY_INSERT === 'android.settings.USER_DICTIONARY_INSERT';
+IntentLauncherAndroid.ACTION_USER_DICTIONARY_SETTINGS === 'android.settings.USER_DICTIONARY_SETTINGS';
+IntentLauncherAndroid.ACTION_USER_SETTINGS === 'android.settings.USER_SETTINGS';
+IntentLauncherAndroid.ACTION_VOICE_CONTROL_AIRPLANE_MODE === 'android.settings.VOICE_CONTROL_AIRPLANE_MODE';
+IntentLauncherAndroid.ACTION_VOICE_CONTROL_BATTERY_SAVER_MODE === 'android.settings.VOICE_CONTROL_BATTERY_SAVER_MODE';
+IntentLauncherAndroid.ACTION_VOICE_CONTROL_DO_NOT_DISTURB_MODE === 'android.settings.VOICE_CONTROL_DO_NOT_DISTURB_MODE';
+IntentLauncherAndroid.ACTION_VOICE_INPUT_SETTINGS === 'android.settings.VOICE_INPUT_SETTINGS';
+IntentLauncherAndroid.ACTION_VPN_SETTINGS === 'android.settings.VPN_SETTINGS';
+IntentLauncherAndroid.ACTION_VR_LISTENER_SETTINGS === 'android.settings.VR_LISTENER_SETTINGS';
+IntentLauncherAndroid.ACTION_WEBVIEW_SETTINGS === 'android.settings.WEBVIEW_SETTINGS';
+IntentLauncherAndroid.ACTION_WIFI_IP_SETTINGS === 'android.settings.WIFI_IP_SETTINGS';
+IntentLauncherAndroid.ACTION_WIFI_SETTINGS === 'android.settings.WIFI_SETTINGS';
+IntentLauncherAndroid.ACTION_WIRELESS_SETTINGS === 'android.settings.WIRELESS_SETTINGS';
+IntentLauncherAndroid.ACTION_ZEN_MODE_AUTOMATION_SETTINGS === 'android.settings.ZEN_MODE_AUTOMATION_SETTINGS';
+IntentLauncherAndroid.ACTION_ZEN_MODE_EVENT_RULE_SETTINGS === 'android.settings.ZEN_MODE_EVENT_RULE_SETTINGS';
+IntentLauncherAndroid.ACTION_ZEN_MODE_EXTERNAL_RULE_SETTINGS === 'android.settings.ZEN_MODE_EXTERNAL_RULE_SETTINGS';
+IntentLauncherAndroid.ACTION_ZEN_MODE_PRIORITY_SETTINGS === 'android.settings.ZEN_MODE_PRIORITY_SETTINGS';
+IntentLauncherAndroid.ACTION_ZEN_MODE_SCHEDULE_RULE_SETTINGS === 'android.settings.ZEN_MODE_SCHEDULE_RULE_SETTINGS';
+IntentLauncherAndroid.ACTION_ZEN_MODE_SETTINGS === 'android.settings.ZEN_MODE_SETTINGS';
+
+KeepAwake.activate();
+KeepAwake.deactivate();
+
+() => (
+    <LinearGradient
+        colors={['#fff']}
+        start={[1, 1]} />
+);
+
+() => (
+    <LinearGradient
+        colors={['#fff']}
+        style={{ flex: 1 }} />
+);
+
+Permissions.CAMERA === 'camera';
+Permissions.CAMERA_ROLL === 'cameraRoll';
+Permissions.AUDIO_RECORDING === 'audioRecording';
+Permissions.CONTACTS === 'contacts';
+Permissions.NOTIFICATIONS === 'remoteNotifications';
+Permissions.REMOTE_NOTIFICATIONS === 'remoteNotifications';
+Permissions.SYSTEM_BRIGHTNESS === 'systemBrightness';
+Permissions.USER_FACING_NOTIFICATIONS === 'userFacingNotifications';
+Permissions.REMINDERS === 'reminders';
+async () => {
+    const result = await Permissions.askAsync(Permissions.CAMERA);
+
+    result.status === 'granted';
+    result.status === 'denied';
+    result.status === 'undetermined';
+
+    result.expires === 'never';
+};
+
+ScreenOrientation.Orientation.ALL;
+ScreenOrientation.allow(ScreenOrientation.Orientation.ALL);
+
+class __TestEntry__ extends React.Component {
+    render() {
+        return(
+            <Text>test</Text>
+        );
+    }
+}
+registerRootComponent(__TestEntry__);
+
+Calendar.EntityTypes.EVENT === 'event';
+Calendar.EntityTypes.REMINDER === 'reminder';
+
+Calendar.CalendarType.LOCAL === 'local';
+Calendar.CalendarType.CALDAV === 'caldav';
+Calendar.CalendarType.EXCHANGE === 'exchange';
+Calendar.CalendarType.SUBSCRIBED === 'subscribed';
+Calendar.CalendarType.BIRTHDAYS === 'birthdays';
+
+async () => {
+    const result = await Calendar.getCalendarsAsync(Calendar.EntityTypes.EVENT);
+    result.length;
+
+    const calendar = result[0];
+    calendar.id === '';
+    calendar.title === '';
+    calendar.sourceId === '';
+    calendar.type === Calendar.CalendarType.BIRTHDAYS;
+    calendar.color === '';
+    calendar.entityType === Calendar.EntityTypes.EVENT;
+    calendar.allowsModifications === true;
+    calendar.allowedAvailabilities === [''];
+    calendar.isPrimary === true;
+    calendar.name === '';
+    calendar.ownerAccount === '';
+    calendar.timeZone === '';
+    calendar.allowedReminders === [''];
+    calendar.allowedAttendeeTypes === [''];
+    calendar.isVisible === false;
+    calendar.isSynced === false;
+    calendar.accessLevel === Calendar.CalendarAccessLevel.CONTRIBUTOR;
+
+    if (calendar.source) {
+        calendar.source.id === '';
+        calendar.source.type === '';
+        calendar.source.name === '';
+        calendar.source.isLocalAccount === false;
+    }
+
+    const id1 =  await Calendar.createCalendarAsync({
+        accessLevel: Calendar.CalendarAccessLevel.EDITOR
+    });
+
+    id1 === '';
+
+    const id2 = await Calendar.updateCalendarAsync('1234', {
+        isVisible: false
+    });
+
+    id2 === '';
+
+    const id3 = await Calendar.updateCalendarAsync('1234', null);
+
+    await Calendar.deleteCalendarAsync('1234');
+
+    const events = await Calendar.getEventsAsync(
+        ['123', '124'],
+        new Date(),
+        new Date()
+    );
+
+    const event1 = events[0];
+
+    event1.accessLevel === Calendar.EventAccessLevel.CONFIDENTIAL;
+    event1.alarms === [];
+    event1.allDay === true;
+    event1.availability === Calendar.Availability.FREE;
+    event1.calendarId === '';
+    event1.creationDate === '';
+    event1.endDate === '';
+    event1.endTimeZone === '';
+    event1.guestsCanInviteOthers === true;
+    event1.guestsCanModify === true;
+    event1.guestsCanSeeGuests === false;
+    event1.id === '';
+    event1.instanceId === '';
+    event1.isDetached === false;
+
+    const event2 = await Calendar.getEventAsync('123', {
+        futureEvents: true
+    });
+
+    const eventId1 = await Calendar.createEventAsync('123');
+
+    const eventId2 = await Calendar.updateEventAsync('1234');
+
+    await Calendar.deleteEventAsync('1234');
+
+    const attendees = await Calendar.getAttendeesForEventAsync('123');
+
+    const aId1 = await Calendar.createAttendeeAsync('123');
+
+    const aId2 = await Calendar.updateAttendeeAsync('123');
+
+    await Calendar.deleteAttendeeAsync('123');
+
+    const reminders = await Calendar.getRemindersAsync(['123']);
+
+    const reminder = await Calendar.getReminderAsync('123');
+
+    const remId1 = await Calendar.createReminderAsync('123');
+
+    const remId2 = await Calendar.updateReminderAsync('123');
+
+    await Calendar.deleteReminderAsync('123');
+
+    const sources = await Calendar.getSourcesAsync();
+
+    const source = await Calendar.getSourceAsync('123');
+
+    Calendar.openEventInCalendar('123');
+};
+
+async () => {
+    const result = await MailComposer.composeAsync({
+        subject: 'sss'
+    });
+
+    result.status === 'saved';
+};
+
+async () => {
+    const updateEventListener: Updates.UpdateEventListener = ({ type, manifest, message }) => {
+        switch (type) {
+            case Updates.EventType.DOWNLOAD_STARTED:
+            case Updates.EventType.DOWNLOAD_PROGRESS:
+            case Updates.EventType.DOWNLOAD_FINISHED:
+            case Updates.EventType.NO_UPDATE_AVAILABLE:
+            case Updates.EventType.ERROR:
+                return true;
+        }
+    };
+
+    Updates.reload();
+
+    Updates.reloadFromCache();
+
+    Updates.addListener(updateEventListener);
+
+    const updateCheckResult = await Updates.checkForUpdateAsync();
+
+    if (updateCheckResult.isAvailable) {
+        console.log(updateCheckResult.manifest);
+    }
+
+    Updates.fetchUpdateAsync({ eventListener: updateEventListener });
+
+    const bundleFetchResult = await Updates.fetchUpdateAsync();
+
+    if (bundleFetchResult.isNew) {
+        console.log(bundleFetchResult.manifest);
+    }
+};
+
+async () => {
+  const asset: MediaLibrary.Asset = await MediaLibrary.createAssetAsync('some-url');
+  const getAssetsOptions: MediaLibrary.GetAssetsOptions = {
+    first: 0,
+    after: 'lastAssetId',
+    album: 'albumId',
+    sortBy: MediaLibrary.SortBy.creationTime,
+    mediaType: MediaLibrary.MediaType.photo
+  };
+  const assetsList: MediaLibrary.GetAssetsResult = await MediaLibrary.getAssetsAsync(getAssetsOptions);
+  const endCursor: string = assetsList.endCursor;
+  const hasNextPage: boolean = assetsList.hasNextPage;
+  const totalCount: number = assetsList.totalCount;
+  const asset1: MediaLibrary.Asset = await MediaLibrary.getAssetInfoAsync(asset);
+  if (await MediaLibrary.deleteAssetsAsync(assetsList.assets)) {
+    console.log('assets deleted');
+  }
+  const albums: MediaLibrary.Album[] = await MediaLibrary.getAlbumsAsync();
+  const album: MediaLibrary.Album | null = await MediaLibrary.getAlbumAsync('albumName');
+  const album1: MediaLibrary.Album = await MediaLibrary.createAlbumAsync('albumName', asset1);
+  if (await MediaLibrary.addAssetsToAlbumAsync([asset, asset1], album1, true)) {
+    console.log('assets added');
+  }
+
+  const moments: MediaLibrary.Album[] = await MediaLibrary.getMomentsAsync();
+
+  switch (getAssetsOptions.mediaType) {
+    case MediaLibrary.MediaType.audio:
+    case MediaLibrary.MediaType.photo:
+    case MediaLibrary.MediaType.video:
+    case MediaLibrary.MediaType.unknow:
+      return true;
+  }
+
+  switch (getAssetsOptions.sortBy) {
+    case MediaLibrary.SortBy.default:
+    case MediaLibrary.SortBy.id:
+    case MediaLibrary.SortBy.creationTime:
+    case MediaLibrary.SortBy.modificationTime:
+    case MediaLibrary.SortBy.mediaType:
+    case MediaLibrary.SortBy.width:
+    case MediaLibrary.SortBy.height:
+    case MediaLibrary.SortBy.duration:
+      return true;
+  }
+};
+// #region MediaLibrary
+async () => {
+  const mlAsset: MediaLibrary.Asset = await MediaLibrary.createAssetAsync('localUri');
+  const mlAssetResult: MediaLibrary.GetAssetsResult = await MediaLibrary.getAssetsAsync({
+    first: 0,
+    after: '',
+    album: 'Album',
+    sortBy: MediaLibrary.SortBy.creationTime,
+    mediaType: MediaLibrary.MediaType.photo
+  });
+  const mlAsset1: MediaLibrary.Asset = await MediaLibrary.getAssetInfoAsync(mlAsset);
+  const areDeleted: boolean = await MediaLibrary.deleteAssetsAsync([mlAsset]);
+  const albums: MediaLibrary.Album[] = await MediaLibrary.getAlbumsAsync();
+  const album: MediaLibrary.Album = await MediaLibrary.getAlbumAsync('album');
+  const album1: MediaLibrary.Album = await MediaLibrary.createAlbumAsync('album', mlAsset);
+  const areAddedToAlbum: boolean = await MediaLibrary.addAssetsToAlbumAsync([mlAsset, mlAsset1], 'album');
+  const areDeletedFromAlbum: boolean = await MediaLibrary.removeAssetsFromAlbumAsync([mlAsset, mlAsset1], 'album');
+  const momuents: MediaLibrary.Album[] = await MediaLibrary.getMomentsAsync();
+};
+//#endregion
+
+// #region Haptic
+Haptic.impact(Haptic.ImpactStyles.Heavy);
+Haptic.impact(Haptic.ImpactStyles.Light);
+Haptic.impact(Haptic.ImpactStyles.Medium);
+
+Haptic.notification(Haptic.NotificationType.Error);
+Haptic.notification(Haptic.NotificationType.Success);
+Haptic.notification(Haptic.NotificationType.Error);
+
+Haptic.selection();
+// #endregion
+
+// #region Constants
+async () => {
+    const appOwnerShip = Constants.appOwnership;
+    const expoVersion = Constants.expoVersion;
+    const installationId = Constants.installationId;
+    const deviceId = Constants.deviceId;
+    const deviceName = Constants.deviceName;
+    const deviceYearClass = Constants.deviceYearClass;
+    const isDevice = Constants.isDevice;
+    const platform = Constants.platform;
+    const sessionId = Constants.sessionId;
+    const statusBarHeight = Constants.statusBarHeight;
+    const systemFonts = Constants.systemFonts;
+    const manifest = Constants.manifest;
+    const linkingUri = Constants.linkingUri;
+    const userAgent: string = await Constants.getWebViewUserAgentAsync();
+};
+// #endregion
diff --git a/types/expo/v27/index.d.ts b/types/expo/v27/index.d.ts
new file mode 100644
index 0000000000..a80fb657ee
--- /dev/null
+++ b/types/expo/v27/index.d.ts
@@ -0,0 +1,3146 @@
+// Type definitions for expo 27.0
+// Project: https://github.com/expo/expo-sdk
+// Definitions by: Konstantin Kai <https://github.com/KonstantinKai>
+//                 Martynas Kadiša <https://github.com/martynaskadisa>
+//                 Jan Aagaard <https://github.com/janaagaard75>
+//                 Sergio Sánchez <https://github.com/ssanchezmarc>
+//                 Fernando Helwanger <https://github.com/fhelwanger>
+//                 Umidbek Karimov <https://github.com/umidbekkarimov>
+//                 Moshe Feuchtwanger <https://github.com/moshfeu>
+//                 Michael Prokopchuk <https://github.com/prokopcm>
+//                 Tina Roh <https://github.com/tinaroh>
+//                 Nathan Phillip Brink <https://github.com/binki>
+//                 Martin Olsson <https://github.com/mo>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+import { EventSubscription } from 'fbemitter';
+import { Component, ComponentClass, Ref, ComponentType } from 'react';
+import {
+    ColorPropType,
+    ImageRequireSource,
+    ImageURISource,
+    LinkingStatic as ReactNativeLinkingStatic,
+    NativeEventEmitter,
+    ViewProps,
+    ViewStyle,
+    Permission,
+    StyleProp
+} from 'react-native';
+
+export type Axis = number;
+export type BarCodeReadCallback = (params: { type: string; data: string; }) => void;
+export type Md5 = string;
+export type Orientation = 'portrait' | 'landscape';
+export type RequireSource = ImageRequireSource;
+export type ResizeModeContain = 'contain';
+export type ResizeModeCover = 'cover';
+export type ResizeModeStretch = 'stretch';
+export type URISource = ImageURISource;
+
+export interface HashMap { [key: string]: any; }
+export interface StringHashMap { [key: string]: string; }
+
+/** Access the device accelerometer sensor(s) to respond to changes in acceleration in 3d space. */
+export namespace Accelerometer {
+    interface AccelerometerObject {
+        x: Axis;
+        y: Axis;
+        z: Axis;
+    }
+
+    /**
+     * Subscribe for updates to the accelerometer.
+     * @param listener A callback that is invoked when an accelerometer update is available. When invoked, the listener is provided a single argumument that is an object containing keys x, y, z.
+     * @returns An EventSubscription object that you can call remove() on when you would like to unsubscribe the listener.
+     */
+    function addListener(listener: (obj: AccelerometerObject) => any): EventSubscription;
+
+    /** Remove all listeners. */
+    function removeAllListeners(): void;
+
+    /**
+     * Subscribe for updates to the accelerometer.
+     * @param intervalMs Desired interval in milliseconds between accelerometer updates.
+     */
+    function setUpdateInterval(intervalMs: number): void;
+}
+
+/**
+ * Admob
+ */
+export type AdMobBannerSize =
+    | 'banner'
+    | 'largeBanner'
+    | 'mediumRectangle'
+    | 'fullBanner'
+    | 'leaderboard'
+    | 'smartBannerPortrait'
+    | 'smartBannerLandscape';
+export interface AdMobBannerProperties extends ViewProps {
+    bannerSize?: AdMobBannerSize;
+    adUnitID?: string;
+    testDeviceID?: string;
+    didFailToReceiveAdWithError?(errorDescription: string): void;
+    adViewDidReceiveAd?(): void;
+    adViewWillPresentScreen?(): void;
+    adViewWillDismissScreen?(): void;
+    adViewDidDismissScreen?(): void;
+    adViewWillLeaveApplication?(): void;
+}
+
+export class AdMobBanner extends Component<AdMobBannerProperties> { }
+export interface AdMobAppEvent {
+    name: string;
+    info: string;
+}
+export interface PublisherBannerProperties extends AdMobBannerProperties {
+    onAdMobDispatchAppEvent?(event: AdMobAppEvent): void;
+}
+export class PublisherBanner extends Component<PublisherBannerProperties> { }
+
+export type AdMobInterstitialEmptyEvent =
+    | 'interstitialDidLoad'
+    | 'interstitialDidOpen'
+    | 'interstitialDidClose'
+    | 'interstitialWillLeaveApplication';
+export type AdMobInterstitialEvent = AdMobInterstitialEmptyEvent | 'interstitialDidFailToLoad';
+export namespace AdMobInterstitial {
+    function setAdUnitID(id: string): void;
+    function setTestDeviceID(id: string): void;
+    function requestAdAsync(): Promise<void>;
+    function showAdAsync(): Promise<void>;
+    function dismissAdAsync(): Promise<void>;
+    function getIsReadyAsync(): Promise<boolean>;
+    function addEventListener(event: 'interstitialDidFailToLoad', handler: (error: string) => void): void;
+    function addEventListener(event: AdMobInterstitialEmptyEvent, handler: () => void): void;
+    function removeEventListener(event: 'interstitialDidFailToLoad', handler: (error: string) => void): void;
+    function removeEventListener(event: AdMobInterstitialEmptyEvent, handler: () => void): void;
+    function removeAllListeners(): void;
+}
+
+export type AdMobRewardedEmptyEvent =
+    | 'rewardedVideoDidLoad'
+    | 'rewardedVideoDidOpen'
+    | 'rewardedVideoDidStart'
+    | 'rewardedVideoDidClose'
+    | 'rewardedVideoWillLeaveApplication';
+export type AdMobRewardedEvent = AdMobRewardedEmptyEvent | 'rewardedVideoDidRewardUser' | 'rewardedVideoDidFailToLoad';
+export namespace AdMobRewarded {
+    function setAdUnitID(id: string): void;
+    function setTestDeviceID(id: string): void;
+    function requestAdAsync(): Promise<void>;
+    function showAdAsync(): Promise<void>;
+    function dismissAdAsync(): Promise<void>;
+    function getIsReadyAsync(): Promise<boolean>;
+    function addEventListener(event: 'rewardedVideoDidRewardUser', handler: (type: string, amount: number) => void): void;
+    function addEventListener(event: 'rewardedVideoDidFailToLoad', handler: (error: string) => void): void;
+    function addEventListener(event: AdMobRewardedEmptyEvent, handler: () => void): void;
+    function removeEventListener(event: 'rewardedVideoDidRewardUser', handler: (type: string, amount: number) => void): void;
+    function removeEventListener(event: 'rewardedVideoDidFailToLoad', handler: (error: string) => void): void;
+    function removeEventListener(event: AdMobRewardedEmptyEvent, handler: () => void): void;
+    function removeAllListeners(): void;
+}
+
+/**
+ * Provides access to Amplitude mobile analytics which basically lets you log various events to the Cloud. This module wraps Amplitude’s iOS and Android SDKs.
+ *
+ * Note: Session tracking may not work correctly when running Experiences in the main Expo app. It will work correctly if you create a standalone app.
+ */
+export namespace Amplitude {
+    /** Initializes Amplitude with your Amplitude API key. */
+    function initialize(apiKey: string): void;
+
+    /** Assign a user ID to the current user. If you don’t have a system for user IDs you don’t need to call this. */
+    function setUserId(userId: string): void;
+
+    /** Set properties for the current user. */
+    function setUserProperties(userProperties: HashMap): void;
+
+    /** Clear properties set by `setUserProperties()`. */
+    function clearUserProperties(): void;
+
+    /** Log an event to Amplitude. */
+    function logEvent(eventName: string): void;
+
+    /** Log an event to Amplitude with custom properties. */
+    function logEventWithProperties(
+        eventName: string,
+
+        /** A map of custom properties. */
+        properties: HashMap
+    ): void;
+
+    /** Add the current user to a group. */
+    function setGroup(
+        /** The group name, e.g. `'sports'`. */
+        groupType: string,
+
+        /** An array of group names, e.g. `['tennis', 'soccer']`. */
+        groupNames: string[]
+    ): void;
+}
+
+// #region AppLoading
+/** The following props are recommended, but optional for the sake of backwards compatibility (they were introduced in SDK21). If you do not provide any props, you are responsible for coordinating loading assets, handling errors, and updating state to unmount the `AppLoading` component. */
+export interface AppLoadingProps {
+    /** A `function` that returns a `Promise`. The `Promise` should resolve when the app is done loading data and assets. */
+    startAsync?: () => Promise<void>;
+
+    /** Required if you provide `startAsync`. Called when `startAsync` resolves or rejects. This should be used to set state and unmount the `AppLoading` component. */
+    onFinish?: () => void;
+
+    /** If `startAsync` throws an error, it is caught and passed into the function provided to `onError`. */
+    onError?: (error: Error) => void;
+}
+
+/**
+ * A React component that tells Expo to keep the app loading screen open if it is the first and only component rendered in your app. When it is removed, the loading screen will disappear and your app will be visible.
+ *
+ * This is incredibly useful to let you download and cache fonts, logo and icon images and other assets that you want to be sure the user has on their device for an optimal experience before rendering they start using the app.
+ */
+export class AppLoading extends Component<AppLoadingProps> { }
+// #endregion AppLoading
+
+/** This module provides an interface to Expo’s asset system. An asset is any file that lives alongside the source code of your app that the app needs at runtime. Examples include images, fonts and sounds. Expo’s asset system integrates with React Native’s, so that you can refer to files with require('path/to/file'). This is how you refer to static image files in React Native for use in an Image component, for example. */
+export class Asset {
+    constructor({ name, type, hash, uri, width, height }: {
+        name: string;
+        type: string;
+        hash: string;
+        uri: string;
+        width?: number;
+        height?: number;
+    });
+
+    /** The MD5 hash of the asset’s data. */
+    hash: Md5;
+
+    /** The name of the asset file without the extension. Also without the part from @ onward in the filename (used to specify scale factor for images). */
+    name: string;
+
+    /** The extension of the asset filename. */
+    type: string;
+
+    /** A URI that points to the asset’s data on the remote server. When running the published version of your app, this refers to the the location on Expo’s asset server where Expo has stored your asset. When running the app from XDE during development, this URI points to XDE’s server running on your computer and the asset is served directly from your computer. */
+    uri: string;
+
+    /** If the asset has been downloaded (by calling `downloadAsync()`), the `file://` URI pointing to the local file on the device that contains the asset data. */
+    localUri: string;
+
+    /** If the asset is an image, the width of the image data divided by the scale factor. The scale factor is the number after `@` in the filename, or `1` if not present. */
+    width?: number;
+
+    /** If the asset is an image, the height of the image data divided by the scale factor. The scale factor is the number after `@` in the filename, or `1` if not present. */
+    height?: number;
+
+    downloading: boolean;
+    downloaded: boolean;
+    downloadCallbacks: Array<{ resolve: () => any, reject: (e?: any) => any }>;
+
+    /** Downloads the asset data to a local file in the device’s cache directory. Once the returned promise is fulfilled without error, the localUri field of this asset points to a local file containing the asset data. The asset is only downloaded if an up-to-date local file for the asset isn’t already present due to an earlier download. */
+    downloadAsync(): Promise<void>;
+
+    /** Returns the `Expo.Asset` instance representing an asset given its module. */
+    static fromModule(module: RequireSource): Asset;
+
+    /**
+     * A helper that wraps `Expo.Asset.fromModule(module).downloadAsync` for convenience.
+     * @param moduleIds An array of `require('path/to/file')`. Can also be just one module without an Array.
+     */
+    static loadAsync(module: RequireSource[] | RequireSource): Promise<void>;
+}
+
+/**
+ * Provides basic sample playback and recording.
+ *
+ * Note that Expo does not yet support backgrounding, so audio is not available to play in the background of your experience. Audio also automatically stops if headphones / bluetooth audio devices are disconnected.
+ */
+export namespace Audio {
+    enum InterruptionModeIos {
+        /** This is the default option. If this option is set, your experience’s audio is mixed with audio playing in background apps. */
+        INTERRUPTION_MODE_IOS_MIX_WITH_OTHERS = 0,
+
+        /** If this option is set, your experience’s audio interrupts audio from other apps. */
+        INTERRUPTION_MODE_IOS_DO_NOT_MIX = 1,
+
+        /** If this option is set, your experience’s audio lowers the volume ("ducks") of audio from other apps while your audio plays. */
+        INTERRUPTION_MODE_IOS_DUCK_OTHERS = 2
+    }
+
+    const INTERRUPTION_MODE_IOS_MIX_WITH_OTHERS: 0;
+    const INTERRUPTION_MODE_IOS_DO_NOT_MIX: 1;
+    const INTERRUPTION_MODE_IOS_DUCK_OTHERS: 2;
+
+    enum InterruptionModeAndroid {
+        /** If this option is set, your experience’s audio interrupts audio from other apps. */
+        INTERRUPTION_MODE_ANDROID_DO_NOT_MIX = 1,
+
+        /** This is the default option. If this option is set, your experience’s audio lowers the volume ("ducks") of audio from other apps while your audio plays. */
+        INTERRUPTION_MODE_ANDROID_DUCK_OTHERS = 2
+    }
+
+    const INTERRUPTION_MODE_ANDROID_DO_NOT_MIX: 1;
+    const INTERRUPTION_MODE_ANDROID_DUCK_OTHERS: 2;
+
+    const RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_DEFAULT: 0;
+    const RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_THREE_GPP: 1;
+    const RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_MPEG_4: 2;
+    const RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_AMR_NB: 3;
+    const RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_AMR_WB: 4;
+    const RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_AAC_ADIF: 5;
+    const RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_AAC_ADTS: 6;
+    const RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_RTP_AVP: 7;
+    const RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_MPEG2TS: 8;
+    const RECORDING_OPTION_ANDROID_OUTPUT_FORMAT_WEBM: 9;
+
+    const RECORDING_OPTION_ANDROID_AUDIO_ENCODER_DEFAULT: 0;
+    const RECORDING_OPTION_ANDROID_AUDIO_ENCODER_AMR_NB: 1;
+    const RECORDING_OPTION_ANDROID_AUDIO_ENCODER_AMR_WB: 2;
+    const RECORDING_OPTION_ANDROID_AUDIO_ENCODER_AAC: 3;
+    const RECORDING_OPTION_ANDROID_AUDIO_ENCODER_HE_AAC: 4;
+    const RECORDING_OPTION_ANDROID_AUDIO_ENCODER_AAC_ELD: 5;
+    const RECORDING_OPTION_ANDROID_AUDIO_ENCODER_VORBIS: 6;
+
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_LINEARPCM: 'lpcm';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_AC3: 'ac-3';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_60958AC3: 'cac3';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_APPLEIMA4: 'ima4';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC: 'aac ';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4CELP: 'celp';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4HVXC: 'hvxc';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4TWINVQ: 'twvq';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MACE3: 'MAC3';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MACE6: 'MAC6';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_ULAW: 'ulaw';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_ALAW: 'alaw';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_QDESIGN: 'QDMC';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_QDESIGN2: 'QDM2';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_QUALCOMM: 'Qclp';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEGLAYER1: '.mp1';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEGLAYER2: '.mp2';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEGLAYER3: '.mp3';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_APPLELOSSLESS: 'alac';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC_HE: 'aach';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC_LD: 'aacl';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC_ELD: 'aace';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC_ELD_SBR: 'aacf';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC_ELD_V2: 'aacg';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC_HE_V2: 'aacp';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC_SPATIAL: 'aacs';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_AMR: 'samr';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_AMR_WB: 'sawb';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_AUDIBLE: 'AUDB';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_ILBC: 'ilbc';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_DVIINTELIMA: 0x6d730011;
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_MICROSOFTGSM: 0x6d730031;
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_AES3: 'aes3';
+    const RECORDING_OPTION_IOS_OUTPUT_FORMAT_ENHANCEDAC3: 'ec-3';
+
+    const RECORDING_OPTION_IOS_AUDIO_QUALITY_MIN: 0;
+    const RECORDING_OPTION_IOS_AUDIO_QUALITY_LOW: 0x20;
+    const RECORDING_OPTION_IOS_AUDIO_QUALITY_MEDIUM: 0x40;
+    const RECORDING_OPTION_IOS_AUDIO_QUALITY_HIGH: 0x60;
+    const RECORDING_OPTION_IOS_AUDIO_QUALITY_MAX: 0x7f;
+
+    const RECORDING_OPTION_IOS_BIT_RATE_STRATEGY_CONSTANT: 0;
+    const RECORDING_OPTION_IOS_BIT_RATE_STRATEGY_LONG_TERM_AVERAGE: 1;
+    const RECORDING_OPTION_IOS_BIT_RATE_STRATEGY_VARIABLE_CONSTRAINED: 2;
+    const RECORDING_OPTION_IOS_BIT_RATE_STRATEGY_VARIABLE: 3;
+
+    type RecordingStatus = {
+        canRecord: false,
+        isDoneRecording: false
+    } | {
+        canRecord: true,
+        isRecording: boolean,
+        durationMillis: number
+    } | {
+        canRecord: false,
+        isDoneRecording: true,
+        durationMillis: number
+    };
+
+    const RECORDING_OPTIONS_PRESET_HIGH_QUALITY: RecordingOptions;
+    const RECORDING_OPTIONS_PRESET_LOW_QUALITY: RecordingOptions;
+
+    interface RecordingOptions {
+        android: {
+            extension: string;
+            outputFormat: number;
+            audioEncoder: number;
+            sampleRate?: number;
+            numberOfChannels?: number;
+            bitRate?: number;
+            maxFileSize?: number;
+        };
+        ios: {
+            extension: string;
+            outputFormat?: string | number;
+            audioQuality: number;
+            sampleRate: number;
+            numberOfChannels: number;
+            bitRate: number;
+            bitRateStrategy?: number;
+            bitDepthHint?: number;
+            linearPCMBitDepth?: number;
+            linearPCMIsBigEndian?: boolean;
+            linearPCMIsFloat?: boolean;
+        };
+    }
+
+    interface AudioMode {
+        /** Boolean selecting if your experience’s audio should play in silent mode on iOS. This value defaults to `false`. */
+        playsInSilentModeIOS: boolean;
+
+        /** Boolean selecting if recording is enabled on iOS. This value defaults to `false`. NOTE: when this flag is set to true, playback may be routed to the phone receiver instead of to the speaker. */
+        allowsRecordingIOS: boolean;
+
+        /** Enum selecting how your experience’s audio should interact with the audio from other apps on iOS. */
+        interruptionModeIOS: InterruptionModeIos;
+
+        /** Boolean selecting if your experience’s audio should automatically be lowered in volume ("duck") if audio from another app interrupts your experience. This value defaults to true. If false, audio from other apps will pause your audio. */
+        shouldDuckAndroid: boolean;
+
+        /** an enum selecting how your experience’s audio should interact with the audio from other apps on Android: */
+        interruptionModeAndroid: InterruptionModeAndroid;
+    }
+
+    function setIsEnabledAsync(value: boolean): Promise<void>;
+    function setAudioModeAsync(mode: AudioMode): Promise<void>;
+
+    /** This class represents a sound corresponding to an Asset or URL. */
+    class Sound extends PlaybackObject {
+        constructor();
+
+        /**
+         * Creates and loads a sound from source, with optional `initialStatus`, `onPlaybackStatusUpdate`, and `downloadFirst`.
+         *
+         * @returns A `Promise` that is rejected if creation failed, or fulfilled with the following dictionary if creation succeeded:
+         * - `sound`: The newly created and loaded Sound object.
+         * - `status`: The PlaybackStatus of the Sound object. See the AV documentation for further information.
+         */
+        static create(
+            /**
+             * The source of the sound. The following forms are supported:
+             *
+             * - A dictionary of the form `{ uri: 'http://path/to/file' }` with a network URL pointing to an audio file on the web.
+             * - `require('path/to/file')` for an audio file asset in the source code directory.
+             * - An `Expo.Asset` object for an audio file asset.
+             */
+            source: PlaybackSource,
+
+            /** The initial intended PlaybackStatusToSet of the sound, whose values will override the default initial playback status. This value defaults to `{}` if no parameter is passed. */
+            initialStatus?: PlaybackStatusToSet,
+
+            /** A function taking a single parameter PlaybackStatus. This value defaults to `null` if no parameter is passed. */
+            onPlaybackStatusUpdate?: ((status: PlaybackStatus) => void) | null,
+
+            /** If set to true, the system will attempt to download the resource to the device before loading. This value defaults to `true`. Note that at the moment, this will only work for `source`s of the form `require('path/to/file')` or `Asset` objects. */
+            downloadFirst?: boolean
+        ): Promise<{ sound: Sound, status: PlaybackStatus }>;
+    }
+
+    class Recording {
+        constructor();
+
+        /** Gets the `status` of the `Recording`. */
+        getStatusAsync(): Promise<RecordingStatus>;
+
+        /** Sets a function to be called regularly with the `status` of the `Recording`. */
+        setOnRecordingStatusUpdate(onRecordingStatusUpdate?: (status: RecordingStatus) => void): void;
+
+        /** Sets the interval with which onRecordingStatusUpdate is called while the recording can record. This value defaults to 500 milliseconds. */
+        setProgressUpdateInterval(progressUpdateIntervalMillis: number): void;
+
+        /** Loads the recorder into memory and prepares it for recording. This must be called before calling `startAsync()`. This method can only be called if the `Recording` instance has never yet been prepared. */
+        prepareToRecordAsync(
+            /** Options for the recording, including sample rate, bitrate, channels, format, encoder, and extension. If no options are passed to `prepareToRecordAsync()`, the recorder will be created with options `Expo.Audio.RECORDING_OPTIONS_PRESET_LOW_QUALITY`. */
+            options?: RecordingOptions
+        ): Promise<RecordingStatus>;
+
+        /** Begins recording. This method can only be called if the `Recording` has been prepared. */
+        startAsync(): Promise<RecordingStatus>;
+
+        /**
+         * Pauses recording. This method can only be called if the Recording has been prepared.
+         *
+         * NOTE: This is only available on Android API version 24 and later.
+         */
+        pauseAsync(): Promise<RecordingStatus>;
+
+        /** Stops the recording and deallocates the recorder from memory. This reverts the Recording instance to an unprepared state, and another Recording instance must be created in order to record again. This method can only be called if the `Recording` has been prepared. */
+        stopAndUnloadAsync(): Promise<RecordingStatus>;
+
+        /**
+         * Gets the local URI of the Recording. Note that this will only succeed once the Recording is prepared to record.
+         *
+         * @returns A string with the local URI of the `Recording`, or `null` if the `Recording` is not prepared to record.
+         */
+        getURI(): string | null | undefined;
+
+        /**
+         * Creates and loads a new `Sound` object to play back the `Recording`. Note that this will only succeed once the `Recording` is done recording (once `stopAndUnloadAsync()` has been called).
+         *
+         * @returns A Promise that is rejected if creation failed, or fulfilled with the following dictionary if creation succeeded:
+         * - `sound`: the newly created and loaded Sound object.
+         * - `status`: the PlaybackStatus of the Sound object.
+         */
+        createNewLoadedSound(
+            /** The initial intended `PlaybackStatusToSet` of the sound, whose values will override the default initial playback status. This value defaults to `{}` if no parameter is passed. */
+            initialStatus?: PlaybackStatusToSet,
+
+            /** A function taking a single parameter `PlaybackStatus`. This value defaults to `null` if no parameter is passed. */
+            onPlaybackStatusUpdate?: ((status: PlaybackStatus) => void) | null
+        ): Promise<{ sound: Sound, status: PlaybackStatus }>;
+    }
+}
+
+/**
+ * AuthSession
+ */
+export namespace AuthSession {
+    type StartAsyncResponse = {
+        type: 'cancel';
+    } | {
+        type: 'dismissed';
+    } | {
+        type: 'success';
+        params: HashMap;
+        event: HashMap;
+    } | {
+        type: 'error';
+        params: HashMap;
+        errorCode: string;
+        event: HashMap;
+    };
+
+    function startAsync(options: { authUrl: string; returnUrl?: string; }): Promise<StartAsyncResponse>;
+    function dismiss(): void;
+    function getRedirectUrl(): string;
+}
+
+// #region AV
+/**
+ * AV
+ */
+export type PlaybackStatus = {
+    isLoaded: false;
+    androidImplementation?: string;
+
+    /** Populated exactly once when an error forces the object to unload. */
+    error?: string;
+} | {
+    isLoaded: true;
+    androidImplementation?: string;
+    uri: string;
+    progressUpdateIntervalMillis: number;
+    durationMillis?: number;
+    positionMillis: number;
+    playableDurationMillis?: number;
+    shouldPlay: boolean;
+    isPlaying: boolean;
+    isBuffering: boolean;
+    rate: number;
+    shouldCorrectPitch: boolean;
+    volume: number;
+    isMuted: boolean;
+    isLooping: boolean;
+
+    /** True exactly once when the track plays to finish. */
+    didJustFinish: boolean;
+};
+
+export interface PlaybackStatusToSet {
+    androidImplementation?: string;
+    isLooping?: boolean;
+    isMuted?: boolean;
+    positionMillis?: number;
+    progressUpdateIntervalMillis?: number;
+    /** The desired playback rate of the media. This value must be between `0.0` and `32.0`. Only available on Android API version 23 and later and iOS. */
+    rate?: number;
+    shouldCorrectPitch?: boolean;
+    shouldPlay?: boolean;
+    /** A number between `0.0` (silence) and `1.0` (maximum volume). */
+    volume?: number;
+}
+
+export type PlaybackSource = RequireSource | { uri: string } | Asset;
+
+export class PlaybackObject {
+    /**
+     * Gets the `PlaybackStatus` of the `playbackObject`.
+     *
+     * Returns a `Promise` that is fulfilled with the `PlaybackStatus` of the `playbackObject`.
+     */
+    getStatusAsync(): Promise<PlaybackStatus>;
+
+    /**
+     * Loads the media from source into memory and prepares it for playing. This must be called before calling setStatusAsync() or any of the convenience set status methods. This method can only be called if the playbackObject is in an unloaded state.
+     *
+     * Returns a `Promise` that is fulfilled with the `PlaybackStatus` of the `playbackObject` once it is loaded, or rejects if loading failed. The `Promise` will also reject if the `playbackObject` was already loaded. See below for details on `PlaybackStatus`.
+     */
+    loadAsync(
+        /**
+         * The source of the media. The following forms are supported:
+         * - A dictionary of the form `{ uri: 'http://path/to/file' }` with a network URL pointing to a media file on the web.
+         * - `require('path/to/file')` for a media file asset in the source code directory.
+         * - An `Expo.Asset object` for a media file asset.
+         */
+        source: PlaybackSource,
+
+        /** The initial intended `PlaybackStatusToSet` of the `playbackObject`, whose values will override the default initial playback status. This value defaults to `{}` if no parameter is passed. See below for details on `PlaybackStatusToSet` and the default initial playback status. */
+        initialStatus?: PlaybackStatusToSet,
+
+        /** If set to `true`, the system will attempt to download the resource to the device before loading. This value defaults to true. Note that at the moment, this will only work for sources of the form `require('path/to/file')` or `Expo.Asset` objects. */
+        downloadFirst?: boolean
+    ): Promise<PlaybackStatus>;
+
+    /** This is equivalent to `playbackObject.setStatusAsync({ shouldPlay: false })`. */
+    pauseAsync(): Promise<PlaybackStatus>;
+
+    /**
+     * This is equivalent to `playbackObject.setStatusAsync({ shouldPlay: true })`.
+     *
+     * Playback may not start immediately after calling this function for reasons such as buffering. Make sure to update your UI based on the `isPlaying` and `isBuffering` properties of the `PlaybackStatus`.
+     */
+    playAsync(): Promise<PlaybackStatus>;
+
+    /**
+     * This is equivalent to `playbackObject.setStatusAsync({ shouldPlay: true, positionMillis: millis })`.
+     *
+     * Playback may not start immediately after calling this function for reasons such as buffering. Make sure to update your UI based on the isPlaying and `isBuffering` properties of the `PlaybackStatus`.
+     */
+    playFromPositionAsync(
+        /** The desired position of playback in milliseconds. */
+        positionMillis: number,
+
+        /** This is equivalent to `playbackObject.setStatusAsync({ positionMillis: millis, seekMillisToleranceBefore: toleranceMillisBefore, seekMillisToleranceAfter: toleranceMillisAfter })`. The tolerances are used only on iOS. */
+        tolerances?: {
+            toleranceMillisBefore: number,
+            toleranceMillisAfter: number
+        }
+    ): Promise<PlaybackStatus>;
+
+    /**
+     * Replays the item. When using `playFromPositionAsync(0)` the item is seeked to the position at `0` ms. On iOS this method uses internal implementation of the player and is able to play the item from the beginning immediately.
+     *
+     * Returns a `Promise` that is fulfilled with the `PlaybackStatus` of the `playbackObject` once the new status has been set successfully, or rejects if setting the new status failed.
+     */
+    replayAsync(
+        /** The new `PlaybackStatusToSet` of the `playbackObject`, whose values will override the current playback status. */
+        status: PlaybackStatusToSet
+    ): Promise<PlaybackStatus>;
+
+    /** This is equivalent to `playbackObject.setStatusAsync({ isLooping: value })`. */
+    setIsLoopingAsync(
+        /** A boolean describing if the media should play once (`false`) or loop indefinitely (`true`). */
+        isLooping: boolean
+    ): Promise<PlaybackStatus>;
+
+    /** This is equivalent to `playbackObject.setStatusAsync({ isMuted: value })`. */
+    setIsMutedAsync(
+        /**  A boolean describing if the audio of this media should be muted. */
+        isMuted: boolean
+    ): Promise<PlaybackStatus>;
+
+    /**
+     * Sets a function to be called regularly with the `PlaybackStatus` of the `playbackObject`. See below for details on `PlaybackStatus` and an example use case of this function.
+     *
+     * `onPlaybackStatusUpdate` will be called whenever a call to the API for this `playbackObject` completes (such as `setStatusAsync()`, `getStatusAsync()`, or `unloadAsync()`), and will also be called at regular intervals while the media is in the loaded state. Set `progressUpdateIntervalMillis` via `setStatusAsync()` or `setProgressUpdateIntervalAsync()` to modify the interval with which `onPlaybackStatusUpdate` is called while loaded.
+     */
+    setOnPlaybackStatusUpdate(
+        /** A function taking a single parameter `PlaybackStatus`. */
+        onPlaybackStatusUpdate?: (status: PlaybackStatus) => void
+    ): void;
+
+    /** This is equivalent to `playbackObject.setStatusAsync({ positionMillis: millis })`. */
+    setPositionAsync(
+        positionMillis: number,
+
+        /** This is equivalent to `playbackObject.setStatusAsync({ positionMillis: millis, seekMillisToleranceBefore: toleranceMillisBefore, seekMillisToleranceAfter: toleranceMillisAfter })`. The tolerances are used only on iOS. */
+        tolerances?: {
+            toleranceMillisBefore: number,
+            toleranceMillisAfter: number
+        }
+    ): Promise<PlaybackStatus>;
+
+    /** This is equivalent to `playbackObject.setStatusAsync({ progressUpdateIntervalMillis: millis })`. */
+    setProgressUpdateIntervalAsync(
+        /** The new minimum interval in milliseconds between calls of `onPlaybackStatusUpdate`. */
+        progressUpdateIntervalMillis: number
+    ): Promise<PlaybackStatus>;
+
+    /** This is equivalent to `playbackObject.setStatusAsync({ rate: value, shouldCorrectPitch: shouldCorrectPitch })`. */
+    setRateAsync(
+        /** The desired playback rate of the media. This value must be between `0.0` and `32.0`. Only available on Android API version 23 and later and iOS. */
+        rate: number,
+        /** A boolean describing if we should correct the pitch for a changed rate. If set to `true`, the pitch of the audio will be corrected (so a rate different than `1.0` will timestretch the audio). */
+        shouldCorrectPitch: boolean
+    ): Promise<PlaybackStatus>;
+
+    /** Sets a new `PlaybackStatusToSet` on the `playbackObject`. This method can only be called if the media has been loaded. Return a `Promise` that is fulfilled with the `PlaybackStatus` of the `playbackObject` once the new status has been set successfully, or rejects if setting the new status failed. */
+    setStatusAsync(
+        /** The new `PlaybackStatusToSet` of the `playbackObject`, whose values will override the current playback status. */
+        status: PlaybackStatusToSet
+    ): Promise<PlaybackStatus>;
+
+    /** This is equivalent to `playbackObject.setStatusAsync({ volume: value })`. */
+    setVolumeAsync(
+        /** A number between `0.0` (silence) and `1.0` (maximum volume). */
+        volume: number
+    ): Promise<PlaybackStatus>;
+
+    /** This is equivalent to `playbackObject.setStatusAsync({ shouldPlay: false, positionMillis: 0 })`. */
+    stopAsync(): Promise<PlaybackStatus>;
+
+    /**
+     * Unloads the media from memory. `loadAsync()` must be called again in order to be able to play the media.
+     *
+     * Returns a `Promise` that is fulfilled with the `PlaybackStatus` of the `playbackObject` once it is unloaded, or rejects if unloading failed. See below for details on `PlaybackStatus`.
+     */
+    unloadAsync(): Promise<PlaybackStatus>;
+}
+// #endregion
+
+// #region BarCodeScanner
+/**
+ * BarCodeScanner
+ */
+export interface BarCodeScannerProps extends ViewProps {
+    type?: 'front' | 'back';
+    torchMode?: 'on' | 'off';
+    barCodeTypes?: string[];
+    onBarCodeRead?: BarCodeReadCallback;
+}
+
+export class BarCodeScanner extends Component<BarCodeScannerProps> {
+    static Constants: {
+        TorchMode: {
+            on: string;
+            off: string
+        }
+    } & CameraConstants;
+}
+// #endregion
+
+// #region BlurView
+/**
+ * BlurView
+ */
+export interface BlurViewProps extends ViewProps {
+    tint: 'light' | 'default' | 'dark';
+    intensity: number;
+}
+export class BlurView extends Component<BlurViewProps> { }
+// #endregion
+
+/**
+ * An API to get and set screen brightness.
+ */
+export namespace Brightness {
+    /** Sets screen brightness. */
+    function setBrightnessAsync(
+        /** A number between `0` and `1`, representing the desired screen brightness. */
+        brightnessValue: number
+    ): Promise<void>;
+
+    /**
+     * Gets screen brightness.
+     * @returns A Promise that is resolved with a number between `0` and `1`, representing the current screen brightness.
+     */
+    function getBrightnessAsync(): Promise<number>;
+
+    /**
+     * Gets global system screen brightness.
+     * @returns A Promise that is resolved with a number between `0` and `1`, representing the current system screen brightness.
+     */
+    function getSystemBrightnessAsync(): Promise<number>;
+
+    /** Sets global system screen brightness, requires `WRITE_SETTINGS` permissions on Android. */
+    function setSystemBrightnessAsync(
+        /** A number between `0` and `1`, representing the desired screen brightness. */
+        brightnessValue: number
+    ): Promise<void>;
+}
+
+// #region Camera
+/**
+ * Camera
+ */
+export interface PictureOptions {
+    quality?: number;
+    base64?: boolean;
+    exif?: boolean;
+    onPictureSaved?: (data: PictureResponse) => void;
+}
+
+export interface PictureResponse {
+    uri: string;
+    width: number;
+    height: number;
+    exif: string;
+    base64: string;
+}
+
+export interface RecordingOptions {
+    quality?: string | number;
+    maxDuration?: number;
+    maxFileSize?: number;
+}
+
+export class CameraObject {
+    takePictureAsync(options?: PictureOptions): Promise<PictureResponse>;
+    recordAsync(options: RecordingOptions): Promise<{ uri: string; }>;
+    stopRecording(): void;
+    getSupportedRatiosAsync(): Promise<string[]>; // Android only
+}
+
+export interface CameraProps extends ViewProps {
+    autoFocus?: string | number | boolean;
+    barCodeTypes?: Array<string | number>;
+    faceDetectionClassifications?: number;
+    faceDetectionLandmarks?: number;
+    faceDetectionMode?: number;
+    flashMode?: string | number;
+    /** Distance to plane of sharpest focus. A value between `0` and `1`. `0`: infinity focus, `1`: focus as close as possible. Default: `0`. For Android this is available only for some devices and when `useCamera2Api` is set to `true`. */
+    focusDepth?: number;
+    onBarCodeRead?: BarCodeReadCallback;
+    onCameraReady?: () => void;
+    onFacesDetected?: (options: { faces: TrackedFaceFeature[] }) => void;
+    onMountError?: () => void;
+    ratio?: string;
+    ref?: Ref<CameraObject>;
+    type?: string | number;
+    whiteBalance?: string | number;
+    /** A value between `0` and `1` being a percentage of device's max zoom. `0`: not zoomed, `1`: maximum zoom. Default: `0`. */
+    zoom?: number;
+}
+
+export interface CameraConstants {
+    readonly Type: {
+        back: string;
+        front: string;
+    };
+    readonly FlashMode: {
+        on: string;
+        off: string;
+        auto: string;
+        torch: string;
+    };
+    readonly AutoFocus: {
+        on: string;
+        off: string;
+    };
+    readonly WhiteBalance: {
+        auto: string;
+        sunny: string;
+        cloudy: string;
+        shadow: string;
+        fluorescent: string;
+        incandescent: string;
+    };
+    readonly VideoQuality: {
+        [videoQuality: string]: number;
+    };
+    readonly BarCodeType: {
+        aztec: string;
+        codabar: string;
+        code39: string;
+        code93: string;
+        code128: string;
+        code138: string;
+        code39mod43: string;
+        datamatrix: string;
+        ean13: string;
+        ean8: string;
+        interleaved2of5: string;
+        itf14: string;
+        maxicode: string;
+        pdf417: string;
+        rss14: string;
+        rssexpanded: string;
+        upc_a: string;
+        upc_e: string;
+        upc_ean: string;
+        qr: string;
+    };
+}
+
+export class Camera extends Component<CameraProps> {
+    static readonly Constants: CameraConstants;
+}
+// #endregion
+
+/**
+ * Constants
+ */
+export namespace Constants {
+    const appOwnership: 'expo' | 'standalone' | 'guest';
+    const expoVersion: string;
+    const installationId: string;
+    const deviceId: string;
+    const deviceName: string;
+    const deviceYearClass: number;
+    const isDevice: boolean;
+
+    interface Platform {
+        ios?: {
+            platform: string;
+            model: string;
+            userInterfaceIdiom: string;
+            buildNumber: string;
+        };
+        android?: {
+            versionCode: string;
+        };
+    }
+    const platform: Platform;
+    const sessionId: string;
+    const statusBarHeight: number;
+    const systemFonts: string[];
+
+    interface Manifest {
+        name: string;
+        description?: string;
+        slug?: string;
+        sdkVersion?: string;
+        version?: string;
+        orientation?: Orientation;
+        primaryColor?: string;
+        privacy?: 'public' | 'unlisted';
+        scheme?: string;
+        icon?: string;
+        platforms?: string[];
+        githubUrl?: string;
+        notification?: {
+            icon?: string,
+            color?: string,
+            androidMode?: 'default' | 'collapse',
+            androidCollapsedTitle?: string
+        };
+        loading?: {
+            icon?: string,
+            exponentIconColor?: 'white' | 'blue',
+            exponentIconGrayscale?: 1 | 0,
+            backgroundImage?: string,
+            backgroundColor?: string,
+            hideExponentText?: boolean
+        };
+        appKey?: string;
+        androidStatusBar?: {
+            barStyle?: 'light-content' | 'dark-content',
+            backgroundColor?: string
+        };
+        androidShowExponentNotificationInShellApp?: boolean;
+        extra?: {
+            [propName: string]: any
+        };
+        rnCliPath?: any;
+        entryPoint?: string;
+        packagerOpts?: {
+            hostType?: string,
+            dev?: boolean,
+            strict?: boolean,
+            minify?: boolean,
+            urlType?: string,
+            urlRandomness?: string,
+            lanType?: string,
+            [propName: string]: any
+        };
+        ignoreNodeModulesValidation?: any;
+        nodeModulesPath?: string;
+        ios?: {
+            bundleIdentifier?: string,
+            buildNumber?: string,
+            config?: {
+                usesNonExemptEncryption?: boolean,
+                googleSignIn?: {
+                    reservedClientId: string
+                }
+            },
+            supportsTablet?: boolean,
+            infoPlist?: any
+        };
+        android?: {
+            package?: string,
+            versionCode?: string,
+            config?: {
+                fabric?: {
+                    apiKey: string,
+                    buildSecret: string
+                },
+                googleMaps?: {
+                    apiKey: string
+                },
+                googleSignIn?: {
+                    apiKey: string,
+                    certificateHash: string
+                }
+            }
+        };
+        facebookScheme?: any;
+        facebookAppId?: string;
+        facebookDisplayName?: string;
+        splash?: {
+            backgroundColor?: string;
+            resizeMode?: ResizeModeContain | ResizeModeCover;
+            image?: string;
+        };
+        assetBundlePatterns?: string[];
+        releaseChannel: string;
+        [propName: string]: any;
+    }
+    const manifest: Manifest;
+    const linkingUri: string;
+
+    function getWebViewUserAgentAsync(): Promise<string>;
+}
+
+/**
+ * Contacts
+ */
+export namespace Contacts {
+    type PhoneNumbers = 'phoneNumbers';
+    type Emails = 'emails';
+    type Addresses = 'addresses';
+    type Image = 'image';
+    type Thumbnail = 'thumbnail';
+    type Note = 'note';
+    type Birthday = 'birthday';
+    type NonGregorianBirthday = 'nonGregorianBirthday';
+    type NamePrefix = 'namePrefix';
+    type NameSuffix = 'nameSuffix';
+    type PhoneticFirstName = 'phoneticFirstName';
+    type PhoneticMiddleName = 'phoneticMiddleName';
+    type PhoneticLastName = 'phoneticLastName';
+    type SocialProfiles = 'socialProfiles';
+    type InstantMessageAddresses = 'instantMessageAddresses';
+    type UrlAddresses = 'urlAddresses';
+    type Dates = 'dates';
+    type Relationships = 'relationships';
+
+    const PHONE_NUMBERS: PhoneNumbers;
+    const EMAILS: Emails;
+    const ADDRESSES: Addresses;
+    const IMAGE: Image;
+    const THUMBNAIL: Thumbnail;
+    const NOTE: Note;
+    const BIRTHDAY: Birthday;
+    const NON_GREGORIAN_BIRTHDAY: NonGregorianBirthday;
+    const NAME_PREFIX: NamePrefix;
+    const NAME_SUFFIX: NameSuffix;
+    const PHONETIC_FIRST_NAME: PhoneticFirstName;
+    const PHONETIC_MIDDLE_NAME: PhoneticMiddleName;
+    const PHONETIC_LAST_NAME: PhoneticLastName;
+    const SOCIAL_PROFILES: SocialProfiles;
+    const IM_ADDRESSES: InstantMessageAddresses;
+    const URLS: UrlAddresses;
+    const DATES: Dates;
+    const RELATIONSHIPS: Relationships;
+
+    type FieldType = PhoneNumbers | Emails | Addresses | Image | Thumbnail |
+        Note | Birthday | NonGregorianBirthday | NamePrefix | NameSuffix |
+        PhoneticFirstName | PhoneticMiddleName | PhoneticLastName | SocialProfiles |
+        InstantMessageAddresses | UrlAddresses | Dates | Relationships;
+
+    interface Options {
+        pageSize?: number;
+        pageOffset?: number;
+        fields?: FieldType[];
+    }
+
+    interface Contact {
+        id: string;
+        contactType: string;
+        name: string;
+        firstName?: string;
+        middleName?: string;
+        lastName?: string;
+        previousLastName?: string;
+        namePrefix?: string;
+        nameSuffix?: string;
+        nickname?: string;
+        phoneticFirstName?: string;
+        phoneticMiddleName?: string;
+        phoneticLastName?: string;
+        emails?: Array<{
+            email?: string;
+            primary?: boolean;
+            label: string;
+            id: string;
+        }>;
+        phoneNumbers?: Array<{
+            number?: string;
+            primary?: boolean;
+            digits?: string;
+            countryCode?: string;
+            label: string;
+            id: string;
+        }>;
+        addresses?: Array<{
+            street?: string;
+            city?: string;
+            country?: string;
+            region?: string;
+            neighborhood?: string;
+            postalCode?: string;
+            poBox?: string;
+            isoCountryCode?: string;
+            label: string;
+            id: string;
+        }>;
+        socialProfiles?: Array<{
+            service?: string;
+            localizedProfile?: string;
+            url?: string;
+            username?: string;
+            userId?: string;
+            label: string;
+            id: string;
+        }>;
+        instantMessageAddresses?: Array<{
+            service?: string;
+            username?: string;
+            localizedService?: string;
+            label: string;
+            id: string;
+        }>;
+        urls?: {
+            label: string;
+            url?: string;
+            id: string;
+        };
+        company?: string;
+        jobTitle?: string;
+        department?: string;
+        imageAvailable?: boolean;
+        image?: {
+            uri?: string;
+        };
+        thumbnail?: {
+            uri?: string;
+        };
+        note?: string;
+        dates?: Array<{
+            day?: number;
+            month?: number;
+            year?: number;
+            id: string;
+            label: string;
+        }>;
+        relationships?: Array<{
+            label: string;
+            name?: string;
+            id: string;
+        }>;
+    }
+
+    interface Response {
+        data: Contact[];
+        total: number;
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+    }
+
+    function getContactsAsync(options: Options): Promise<Response>;
+    function getContactByIdAsync(options: { id?: string; fields?: FieldType[] }): Promise<Contact>;
+}
+
+/**
+ * DocumentPicker
+ */
+export namespace DocumentPicker {
+    interface Options {
+        type?: string;
+    }
+
+    type Response = {
+        type: 'success';
+        uri: string;
+        name: string;
+        size: number;
+    } | {
+        type: 'cancel';
+    };
+
+    function getDocumentAsync(options?: Options): Promise<Response>;
+}
+
+/**
+ * ErrorRecovery
+ */
+export namespace ErrorRecovery {
+    function setRecoveryProps(props: HashMap): void;
+}
+
+/**
+ * Facebook
+ */
+export namespace Facebook {
+    interface Options {
+        permissions?: string[];
+        behavior?: 'web' | 'native' | 'browser' | 'system';
+    }
+    interface Response {
+        type: 'cancel' | 'success';
+        token?: string;
+        expires?: number;
+    }
+    function logInWithReadPermissionsAsync(appId: string, options?: Options): Promise<Response>;
+}
+
+/**
+ * Facebook Ads
+ */
+export namespace FacebookAds {
+    /**
+     * Interstitial Ads
+     */
+    namespace InterstitialAdManager {
+        function showAd(placementId: string): Promise<boolean>;
+    }
+
+    /**
+     * Native Ads
+     */
+    type MediaCachePolicy = 'none' | 'icon' | 'image' | 'all';
+    class NativeAdsManager {
+        constructor(placementId: string, numberOfAdsToRequest?: number);
+        disableAutoRefresh(): void;
+        setMediaCachePolicy(cachePolicy: MediaCachePolicy): void;
+    }
+
+    function withNativeAd(component: Component<{
+        icon?: string;
+        coverImage?: string;
+        title?: string;
+        subtitle?: string;
+        description?: string;
+        callToActionText?: string;
+        socialContext?: string;
+    }>): Component<{ adsManager: NativeAdsManager }, { ad: any, canRequestAds: boolean }>;
+
+    /**
+     * Banner View
+     */
+    type AdType = 'large' | 'rectangle' | 'standard';
+
+    interface BannerViewProps {
+        type: AdType;
+        placementId: string;
+        onPress: () => void;
+        onError: () => void;
+    }
+
+    class BannerView extends Component<BannerViewProps> { }
+
+    /**
+     * Ad Settings
+     */
+    namespace AdSettings {
+        const currentDeviceHash: string;
+        function addTestDevice(device: string): void;
+        function clearTestDevices(): void;
+        type SDKLogLevel = 'none' | 'debug' | 'verbose' | 'warning' | 'error' | 'notification';
+        function setLogLevel(logLevel: SDKLogLevel): void;
+        function setIsChildDirected(isDirected: boolean): void;
+        function setMediationService(mediationService: string): void;
+        function setUrlPrefix(urlPrefix: string): void;
+    }
+}
+
+/**
+ * FaceDetector
+ */
+export interface Point {
+    x: Axis;
+    y: Axis;
+}
+
+export interface FaceFeature {
+    bounds: {
+        size: {
+            width: number;
+            height: number;
+        },
+        origin: Point;
+    };
+    smilingProbability?: number;
+    leftEarPosition?: Point;
+    rightEarPosition?: Point;
+    leftEyePosition?: Point;
+    leftEyeOpenProbability?: number;
+    rightEyePosition?: Point;
+    rightEyeOpenProbability?: number;
+    leftCheekPosition?: Point;
+    rightCheekPosition?: Point;
+    leftMouthPosition?: Point;
+    mouthPosition?: Point;
+    rightMouthPosition?: Point;
+    bottomMouthPosition?: Point;
+    noseBasePosition?: Point;
+    yawAngle?: number;
+    rollAngle?: number;
+}
+
+export interface TrackedFaceFeature extends FaceFeature {
+    faceID?: number;
+}
+
+export namespace FaceDetector {
+    interface DetectFaceResult {
+        faces: FaceFeature[];
+        image: {
+            uri: string;
+            width: number;
+            height: number;
+            orientation: number;
+        };
+    }
+    interface Mode {
+        fast: 'fast';
+        accurate: 'accurate';
+    }
+    interface _Shared {
+        all: 'all';
+        none: 'none';
+    }
+    type Landmarks = _Shared;
+    type Classifications = _Shared;
+    interface _Constants {
+        Mode: Mode;
+        Landmarks: Landmarks;
+        Classifications: Classifications;
+    }
+
+    const Constants: _Constants;
+
+    interface DetectionOptions {
+        mode?: keyof Mode;
+        detectLandmarks?: keyof Landmarks;
+        runClassifications?: keyof Classifications;
+    }
+
+    function detectFaces(uri: string, options?: DetectionOptions): Promise<DetectFaceResult>;
+}
+/**
+ * FileSystem
+ */
+export namespace FileSystem {
+    type FileInfo = {
+        exists: true;
+        isDirectory: boolean;
+        uri: string;
+        size: number;
+        modificationTime: number;
+        md5?: Md5;
+    } | {
+        exists: false;
+        isDirectory: false;
+    };
+
+    interface DownloadResult {
+        uri: string;
+        status: number;
+        headers: { [name: string]: string };
+        md5?: Md5;
+    }
+
+    const documentDirectory: string;
+    const cacheDirectory: string;
+
+    function getInfoAsync(fileUri: string, options?: { md5?: string, size?: boolean; }): Promise<FileInfo>;
+    function readAsStringAsync(fileUri: string): Promise<string>;
+    function writeAsStringAsync(fileUri: string, contents: string): Promise<void>;
+    function deleteAsync(fileUri: string, options?: { idempotent: boolean; }): Promise<void>;
+    function moveAsync(options: { from: string, to: string; }): Promise<void>;
+    function copyAsync(options: { from: string, to: string; }): Promise<void>;
+    function makeDirectoryAsync(dirUri: string, options?: { intermediates: boolean }): Promise<void>;
+    function readDirectoryAsync(dirUri: string): Promise<string[]>;
+    function downloadAsync(uri: string, fileUri: string, options?: { md5?: boolean; }): Promise<DownloadResult>;
+    function createDownloadResumable(
+        uri: string,
+        fileUri: string,
+        options?: DownloadOptions,
+        callback?: (totalBytesWritten: number, totalBytesExpectedToWrite: number) => void,
+        resumeData?: string | null
+    ): DownloadResumable;
+
+    interface PauseResult {
+        url: string;
+        fileUri: string;
+        options: { md5: boolean; };
+        resumeData: string;
+    }
+
+    interface DownloadOptions {
+        md5?: boolean;
+        headers?: { [name: string]: string };
+    }
+
+    interface DownloadProgressData {
+        totalBytesWritten: number;
+        totalBytesExpectedToWrite: number;
+    }
+
+    type DownloadProgressCallback = (data: DownloadProgressData) => void;
+
+    class DownloadResumable {
+        constructor(
+            url: string,
+            fileUri: string,
+            options: DownloadOptions,
+            callback?: DownloadProgressCallback,
+            resumeData?: string
+        );
+
+        downloadAsync(): Promise<DownloadResult>;
+        pauseAsync(): Promise<PauseResult>;
+        resumeAsync(): Promise<DownloadResult>;
+        savable(): PauseResult;
+    }
+}
+
+/** Use TouchID/FaceID (iOS) or the Fingerprint API (Android) to authenticate the user with a fingerprint scan. */
+export namespace Fingerprint {
+    type FingerprintAuthenticationResult = {
+        success: true
+    } | {
+        success: false,
+
+        /** Error code in the case where authentication fails. */
+        error: string
+    };
+
+    /** Determine whether the Fingerprint scanner is available on the device. */
+    function hasHardwareAsync(): Promise<boolean>;
+
+    /** Determine whether the device has saved fingerprints to use for authentication. */
+    function isEnrolledAsync(): Promise<boolean>;
+
+    /**
+     * Attempts to authenticate via Fingerprint. Android: When using the fingerprint module on Android, you need to provide a UI component to prompt the user to scan their fingerprint, as the OS has no default alert for it.
+     *
+     * @param promptMessage A message that is shown alongside the TouchID/FaceID prompt. (iOS only)
+     */
+    function authenticateAsync(promptMessageIOS?: string): Promise<FingerprintAuthenticationResult>;
+
+    /** Cancels the fingerprint authentication flow. (Android only) */
+    function cancelAuthenticate(): void;
+}
+
+/**
+ * Font
+ */
+export namespace Font {
+    interface FontMap {
+        [name: string]: RequireSource;
+    }
+
+    function loadAsync(name: string, url: string): Promise<void>;
+    function loadAsync(map: FontMap): Promise<void>;
+}
+
+// #region GLView
+export interface ExpoWebGLRenderingContext extends WebGLRenderingContext {
+    endFrameEXP(): void;
+}
+
+/**
+ * A View that acts as an OpenGL ES render target. On mounting, an OpenGL ES
+ * context is created. Its drawing buffer is presented as the contents of
+ * the View every frame.
+ */
+export interface GLViewProps extends ViewProps {
+    /**
+     * A function that will be called when the OpenGL ES context is created.
+     * Passes an object with a WebGLRenderingContext interface as an argument.
+     */
+    onContextCreate(gl: ExpoWebGLRenderingContext): void;
+
+    /** Number of MSAA samples to use on iOS. Defaults to 4. Ignored on Android. */
+    msaaSamples?: number;
+}
+
+export class GLView extends Component<GLViewProps, { msaaSamples: number }> { }
+// #endregion
+
+/**
+ * Google
+ */
+export namespace Google {
+    interface LogInConfig {
+        androidClientId?: string;
+        androidStandaloneAppClientId?: string;
+        iosClientId?: string;
+        iosStandaloneAppClientId?: string;
+        webClientId?: string;
+        behavior?: 'system' | 'web';
+        scopes?: string[];
+    }
+
+    type LogInResult = {
+        type: 'cancel';
+    } | {
+        type: 'success';
+        accessToken: string;
+        idToken?: string;
+        refreshToken?: string;
+        serverAuthCode?: string;
+        user: {
+            id: string;
+            name: string;
+            givenName: string;
+            familyName: string;
+            photoUrl?: string;
+            email?: string;
+        }
+    };
+
+    function logInAsync(config: LogInConfig): Promise<LogInResult>;
+}
+
+/** Access the device gyroscope sensor to respond to changes in rotation in 3d space. */
+export namespace Gyroscope {
+    interface GyroscopeObject {
+        x: Axis;
+        y: Axis;
+        z: Axis;
+    }
+
+    /** A callback that is invoked when an gyroscope update is available. */
+    function addListener(listener: (obj: GyroscopeObject) => any): EventSubscription;
+
+    /** Remove all listeners. */
+    function removeAllListeners(): void;
+
+    /** Subscribe for updates to the gyroscope. */
+    function setUpdateInterval(intervalMs: number): void;
+}
+
+/**
+ * ImageManipulator
+ */
+export namespace ImageManipulator {
+    type Action = Resize | Rotate | Flip | Crop;
+
+    interface Resize {
+        resize: { width?: number, height?: number };
+    }
+
+    interface Rotate {
+        rotate: number;
+    }
+
+    interface Flip {
+        flip?: { vertical?: boolean; horizontal?: boolean };
+    }
+
+    interface Crop {
+        originX: number;
+        originY: number;
+        width: number;
+        height: number;
+    }
+
+    interface ImageResult {
+        uri: string;
+        width: number;
+        height: number;
+        base64?: string;
+    }
+
+    interface SaveOptions {
+        base64?: boolean;
+        /** A value in range `0` - `1` specifying compression level of the result image. `1` means no compression and `0` the highest compression. */
+        compress?: number;
+        format?: 'jpeg' | 'png';
+    }
+
+    function manipulate(uri: string, actions: Action[], saveOptions?: SaveOptions): Promise<ImageResult>;
+}
+
+/**
+ * Image Picker
+ */
+export namespace ImagePicker {
+    interface ImageInfo {
+        uri: string;
+        width: number;
+        height: number;
+        type: 'video' | 'image';
+        base64?: string;
+        exif?: object;
+        duration?: number;
+    }
+
+    type ImageResult = { cancelled: true } | ({ cancelled: false } & ImageInfo);
+
+    interface _MediaTypeOptions {
+        All: 'All';
+        Videos: 'Videos';
+        Images: 'Images';
+    }
+
+    const MediaTypeOptions: _MediaTypeOptions;
+
+    interface ImageLibraryOptions {
+        allowsEditing?: boolean;
+        aspect?: [number, number];
+        quality?: number;
+        base64?: boolean;
+        exif?: boolean;
+        mediaTypes?: keyof _MediaTypeOptions;
+    }
+
+    /**
+     * require Permissions.CAMERA_ROLL
+     */
+    function launchImageLibraryAsync(options?: ImageLibraryOptions): Promise<ImageResult>;
+
+    interface CameraOptions {
+        allowsEditing?: boolean;
+        aspect?: [number, number];
+        quality?: number;
+        base64?: boolean;
+        exif?: boolean;
+    }
+
+    /**
+     * require Permissions.CAMERA_ROLL
+     */
+    function launchCameraAsync(options?: CameraOptions): Promise<ImageResult>;
+}
+
+/**
+ * IntentLauncherAndroid
+ */
+export namespace IntentLauncherAndroid {
+    const ACTION_ACCESSIBILITY_SETTINGS: 'android.settings.ACCESSIBILITY_SETTINGS';
+    const ACTION_APP_NOTIFICATION_REDACTION: 'android.settings.ACTION_APP_NOTIFICATION_REDACTION';
+    const ACTION_CONDITION_PROVIDER_SETTINGS: 'android.settings.ACTION_CONDITION_PROVIDER_SETTINGS';
+    const ACTION_NOTIFICATION_LISTENER_SETTINGS: 'android.settings.ACTION_NOTIFICATION_LISTENER_SETTINGS';
+    const ACTION_PRINT_SETTINGS: 'android.settings.ACTION_PRINT_SETTINGS';
+    const ACTION_ADD_ACCOUNT_SETTINGS: 'android.settings.ADD_ACCOUNT_SETTINGS';
+    const ACTION_AIRPLANE_MODE_SETTINGS: 'android.settings.AIRPLANE_MODE_SETTINGS';
+    const ACTION_APN_SETTINGS: 'android.settings.APN_SETTINGS';
+    const ACTION_APPLICATION_DETAILS_SETTINGS: 'android.settings.APPLICATION_DETAILS_SETTINGS';
+    const ACTION_APPLICATION_DEVELOPMENT_SETTINGS: 'android.settings.APPLICATION_DEVELOPMENT_SETTINGS';
+    const ACTION_APPLICATION_SETTINGS: 'android.settings.APPLICATION_SETTINGS';
+    const ACTION_APP_NOTIFICATION_SETTINGS: 'android.settings.APP_NOTIFICATION_SETTINGS';
+    const ACTION_APP_OPS_SETTINGS: 'android.settings.APP_OPS_SETTINGS';
+    const ACTION_BATTERY_SAVER_SETTINGS: 'android.settings.BATTERY_SAVER_SETTINGS';
+    const ACTION_BLUETOOTH_SETTINGS: 'android.settings.BLUETOOTH_SETTINGS';
+    const ACTION_CAPTIONING_SETTINGS: 'android.settings.CAPTIONING_SETTINGS';
+    const ACTION_CAST_SETTINGS: 'android.settings.CAST_SETTINGS';
+    const ACTION_DATA_ROAMING_SETTINGS: 'android.settings.DATA_ROAMING_SETTINGS';
+    const ACTION_DATE_SETTINGS: 'android.settings.DATE_SETTINGS';
+    const ACTION_DEVICE_INFO_SETTINGS: 'android.settings.DEVICE_INFO_SETTINGS';
+    const ACTION_DEVICE_NAME: 'android.settings.DEVICE_NAME';
+    const ACTION_DISPLAY_SETTINGS: 'android.settings.DISPLAY_SETTINGS';
+    const ACTION_DREAM_SETTINGS: 'android.settings.DREAM_SETTINGS';
+    const ACTION_HARD_KEYBOARD_SETTINGS: 'android.settings.HARD_KEYBOARD_SETTINGS';
+    const ACTION_HOME_SETTINGS: 'android.settings.HOME_SETTINGS';
+    const ACTION_IGNORE_BACKGROUND_DATA_RESTRICTIONS_SETTINGS: 'android.settings.IGNORE_BACKGROUND_DATA_RESTRICTIONS_SETTINGS';
+    const ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS: 'android.settings.IGNORE_BATTERY_OPTIMIZATION_SETTINGS';
+    const ACTION_INPUT_METHOD_SETTINGS: 'android.settings.INPUT_METHOD_SETTINGS';
+    const ACTION_INPUT_METHOD_SUBTYPE_SETTINGS: 'android.settings.INPUT_METHOD_SUBTYPE_SETTINGS';
+    const ACTION_INTERNAL_STORAGE_SETTINGS: 'android.settings.INTERNAL_STORAGE_SETTINGS';
+    const ACTION_LOCALE_SETTINGS: 'android.settings.LOCALE_SETTINGS';
+    const ACTION_LOCATION_SOURCE_SETTINGS: 'android.settings.LOCATION_SOURCE_SETTINGS';
+    const ACTION_MANAGE_ALL_APPLICATIONS_SETTINGS: 'android.settings.MANAGE_ALL_APPLICATIONS_SETTINGS';
+    const ACTION_MANAGE_APPLICATIONS_SETTINGS: 'android.settings.MANAGE_APPLICATIONS_SETTINGS';
+    const ACTION_MANAGE_DEFAULT_APPS_SETTINGS: 'android.settings.MANAGE_DEFAULT_APPS_SETTINGS';
+    const ACTION_MEMORY_CARD_SETTINGS: 'android.settings.MEMORY_CARD_SETTINGS';
+    const ACTION_MONITORING_CERT_INFO: 'android.settings.MONITORING_CERT_INFO';
+    const ACTION_NETWORK_OPERATOR_SETTINGS: 'android.settings.NETWORK_OPERATOR_SETTINGS';
+    const ACTION_NFCSHARING_SETTINGS: 'android.settings.NFCSHARING_SETTINGS';
+    const ACTION_NFC_PAYMENT_SETTINGS: 'android.settings.NFC_PAYMENT_SETTINGS';
+    const ACTION_NFC_SETTINGS: 'android.settings.NFC_SETTINGS';
+    const ACTION_NIGHT_DISPLAY_SETTINGS: 'android.settings.NIGHT_DISPLAY_SETTINGS';
+    const ACTION_NOTIFICATION_POLICY_ACCESS_SETTINGS: 'android.settings.NOTIFICATION_POLICY_ACCESS_SETTINGS';
+    const ACTION_NOTIFICATION_SETTINGS: 'android.settings.NOTIFICATION_SETTINGS';
+    const ACTION_PAIRING_SETTINGS: 'android.settings.PAIRING_SETTINGS';
+    const ACTION_PRIVACY_SETTINGS: 'android.settings.PRIVACY_SETTINGS';
+    const ACTION_QUICK_LAUNCH_SETTINGS: 'android.settings.QUICK_LAUNCH_SETTINGS';
+    const ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS: 'android.settings.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS';
+    const ACTION_SECURITY_SETTINGS: 'android.settings.SECURITY_SETTINGS';
+    const ACTION_SETTINGS: 'android.settings.SETTINGS';
+    const ACTION_SHOW_ADMIN_SUPPORT_DETAILS: 'android.settings.SHOW_ADMIN_SUPPORT_DETAILS';
+    const ACTION_SHOW_INPUT_METHOD_PICKER: 'android.settings.SHOW_INPUT_METHOD_PICKER';
+    const ACTION_SHOW_REGULATORY_INFO: 'android.settings.SHOW_REGULATORY_INFO';
+    const ACTION_SHOW_REMOTE_BUGREPORT_DIALOG: 'android.settings.SHOW_REMOTE_BUGREPORT_DIALOG';
+    const ACTION_SOUND_SETTINGS: 'android.settings.SOUND_SETTINGS';
+    const ACTION_STORAGE_MANAGER_SETTINGS: 'android.settings.STORAGE_MANAGER_SETTINGS';
+    const ACTION_SYNC_SETTINGS: 'android.settings.SYNC_SETTINGS';
+    const ACTION_SYSTEM_UPDATE_SETTINGS: 'android.settings.SYSTEM_UPDATE_SETTINGS';
+    const ACTION_TETHER_PROVISIONING_UI: 'android.settings.TETHER_PROVISIONING_UI';
+    const ACTION_TRUSTED_CREDENTIALS_USER: 'android.settings.TRUSTED_CREDENTIALS_USER';
+    const ACTION_USAGE_ACCESS_SETTINGS: 'android.settings.USAGE_ACCESS_SETTINGS';
+    const ACTION_USER_DICTIONARY_INSERT: 'android.settings.USER_DICTIONARY_INSERT';
+    const ACTION_USER_DICTIONARY_SETTINGS: 'android.settings.USER_DICTIONARY_SETTINGS';
+    const ACTION_USER_SETTINGS: 'android.settings.USER_SETTINGS';
+    const ACTION_VOICE_CONTROL_AIRPLANE_MODE: 'android.settings.VOICE_CONTROL_AIRPLANE_MODE';
+    const ACTION_VOICE_CONTROL_BATTERY_SAVER_MODE: 'android.settings.VOICE_CONTROL_BATTERY_SAVER_MODE';
+    const ACTION_VOICE_CONTROL_DO_NOT_DISTURB_MODE: 'android.settings.VOICE_CONTROL_DO_NOT_DISTURB_MODE';
+    const ACTION_VOICE_INPUT_SETTINGS: 'android.settings.VOICE_INPUT_SETTINGS';
+    const ACTION_VPN_SETTINGS: 'android.settings.VPN_SETTINGS';
+    const ACTION_VR_LISTENER_SETTINGS: 'android.settings.VR_LISTENER_SETTINGS';
+    const ACTION_WEBVIEW_SETTINGS: 'android.settings.WEBVIEW_SETTINGS';
+    const ACTION_WIFI_IP_SETTINGS: 'android.settings.WIFI_IP_SETTINGS';
+    const ACTION_WIFI_SETTINGS: 'android.settings.WIFI_SETTINGS';
+    const ACTION_WIRELESS_SETTINGS: 'android.settings.WIRELESS_SETTINGS';
+    const ACTION_ZEN_MODE_AUTOMATION_SETTINGS: 'android.settings.ZEN_MODE_AUTOMATION_SETTINGS';
+    const ACTION_ZEN_MODE_EVENT_RULE_SETTINGS: 'android.settings.ZEN_MODE_EVENT_RULE_SETTINGS';
+    const ACTION_ZEN_MODE_EXTERNAL_RULE_SETTINGS: 'android.settings.ZEN_MODE_EXTERNAL_RULE_SETTINGS';
+    const ACTION_ZEN_MODE_PRIORITY_SETTINGS: 'android.settings.ZEN_MODE_PRIORITY_SETTINGS';
+    const ACTION_ZEN_MODE_SCHEDULE_RULE_SETTINGS: 'android.settings.ZEN_MODE_SCHEDULE_RULE_SETTINGS';
+    const ACTION_ZEN_MODE_SETTINGS: 'android.settings.ZEN_MODE_SETTINGS';
+
+    function startActivityAsync(activity: string, data?: HashMap): Promise<boolean>;
+}
+
+/**
+ * KeepAwake
+ */
+export class KeepAwake extends Component {
+    static activate(): void;
+    static deactivate(): void;
+}
+
+// #region LinearGradient
+/**
+ * LinearGradient
+ */
+export interface LinearGradientProps {
+    colors: string[];
+    start?: [number, number];
+    end?: [number, number];
+    locations?: number[];
+    style?: StyleProp<ViewStyle>;
+}
+
+export class LinearGradient extends Component<LinearGradientProps> { }
+// #endregion
+
+/**
+ * Linking
+ */
+export interface LinkInfo {
+    path: string;
+    queryParams: Partial<StringHashMap>;
+}
+
+export interface LinkingStatic extends ReactNativeLinkingStatic {
+    makeUrl(path: string, queryParams?: HashMap): string;
+    parse(url: string): LinkInfo;
+    parseInitialURLAsync(): Promise<LinkInfo>;
+}
+export const Linking: LinkingStatic;
+
+/**
+ * Location
+ */
+export namespace Location {
+    interface LocationOptions {
+        enableHighAccuracy?: boolean;
+        timeInterval?: number;
+        distanceInterval?: number;
+    }
+
+    interface LocationProps {
+        latitude: number;
+        longitude: number;
+    }
+
+    interface Coords extends LocationProps {
+        altitude: number;
+        accuracy: number;
+    }
+
+    interface LocationData {
+        coords: {
+            heading: number;
+            speed: number
+        } & Coords;
+        timestamp: number;
+    }
+
+    interface ProviderStatus {
+        locationServicesEnabled: boolean;
+        gpsAvailable?: boolean;
+        networkAvailable?: boolean;
+        passiveAvailable?: boolean;
+    }
+
+    interface HeadingStatus {
+        magHeading: number;
+        trueHeading: number;
+        accuracy: number;
+    }
+
+    interface GeocodeData {
+        city: string;
+        street: string;
+        region: string;
+        postalCode: string;
+        country: string;
+        name: string;
+    }
+
+    type LocationCallback = (data: LocationData) => void;
+
+    function getCurrentPositionAsync(options: LocationOptions): Promise<LocationData>;
+    function watchPositionAsync(options: LocationOptions, callback: LocationCallback): EventSubscription;
+    function getProviderStatusAsync(): Promise<ProviderStatus>;
+    function getHeadingAsync(): Promise<HeadingStatus>;
+    function watchHeadingAsync(callback: (status: HeadingStatus) => void): EventSubscription;
+    function geocodeAsync(address: string): Promise<Coords>;
+    function reverseGeocodeAsync(location: LocationProps): Promise<GeocodeData[]>;
+    function setApiKey(key: string): void;
+}
+
+/**
+ * Magnetometer
+ */
+export namespace Magnetometer {
+    interface MagnetometerObject {
+        x: Axis;
+        y: Axis;
+        z: Axis;
+    }
+
+    function addListener(listener: (obj: MagnetometerObject) => any): EventSubscription;
+    function removeAllListeners(): void;
+    function setUpdateInterval(intervalMs: number): void;
+}
+
+/**
+ * Notifications
+ */
+export namespace Notifications {
+    interface Notification {
+        origin: 'selected' | 'received';
+        data: any;
+        remote: boolean;
+        isMultiple: boolean;
+    }
+
+    interface LocalNotification {
+        title: string;
+        body?: string;
+        data?: any;
+        ios?: {
+            sound?: boolean
+        };
+        android?: {
+            sound?: boolean;
+            icon?: string;
+            color?: string;
+            priority?: 'min' | 'low' | 'high' | 'max';
+            sticky?: boolean;
+            vibrate?: boolean | number[];
+            link?: string;
+        };
+    }
+
+    type LocalNotificationId = string | number;
+
+    function addListener(listener: (notification: Notification) => any): EventSubscription;
+    function getExpoPushTokenAsync(): Promise<string>;
+    function presentLocalNotificationAsync(localNotification: LocalNotification): Promise<LocalNotificationId>;
+    function scheduleLocalNotificationAsync(
+        localNotification: LocalNotification,
+        schedulingOptions: { time: Date | number, repeat?: 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year' }
+    ): Promise<LocalNotificationId>;
+    function dismissNotificationAsync(localNotificationId: LocalNotificationId): Promise<void>;
+    function dismissAllNotificationsAsync(): Promise<void>;
+    function cancelScheduledNotificationAsync(localNotificationId: LocalNotificationId): Promise<void>;
+    function cancelAllScheduledNotificationsAsync(): Promise<void>;
+    function getBadgeNumberAsync(): Promise<number>;
+    function setBadgeNumberAsync(number: number): Promise<void>;
+}
+
+/**
+ * Pedometer
+ */
+export namespace Pedometer {
+    function isAvailableAsync(): Promise<boolean>;
+    function getStepCountAsync(start: Date, end: Date): Promise<{ steps: number; }>;
+    function watchStepCount(callback: (params: { steps: number; }) => void): EventSubscription;
+}
+
+/**
+ * Permissions
+ */
+export namespace Permissions {
+    type PermissionType = 'audioRecording' | 'calendar' |
+    'cameraRoll' | 'camera' | 'contacts' | 'location' | 'reminders' |
+    'remoteNotifications' | 'systemBrightness' | 'userFacingNotifications';
+    type PermissionStatus = 'undetermined' | 'granted' | 'denied';
+    type PermissionExpires = 'never';
+
+    interface PermissionDetailsLocationIOS {
+        scope: 'whenInUse' | 'always';
+    }
+
+    interface PermissionDetailsLocationAndroid {
+        scope: 'fine' | 'coarse' | 'none';
+    }
+
+    interface PermissionResponse {
+        status: PermissionStatus;
+        expires: PermissionExpires;
+        ios?: PermissionDetailsLocationIOS;
+        android?: PermissionDetailsLocationAndroid;
+    }
+
+    function getAsync(type: PermissionType): Promise<PermissionResponse>;
+    function askAsync(type: PermissionType): Promise<PermissionResponse>;
+
+    type RemoteNotificationPermission = 'remoteNotifications';
+
+    const AUDIO_RECORDING: 'audioRecording';
+    const CALENDAR: 'calendar';
+    const CAMERA_ROLL: 'cameraRoll';
+    const CAMERA: 'camera';
+    const CONTACTS: 'contacts';
+    const LOCATION: 'location';
+    const NOTIFICATIONS: RemoteNotificationPermission;
+    const REMINDERS = 'reminders';
+    const REMOTE_NOTIFICATIONS: RemoteNotificationPermission;
+    const SYSTEM_BRIGHTNESS: 'systemBrightness';
+    const USER_FACING_NOTIFICATIONS = 'userFacingNotifications';
+}
+
+/**
+ * Register Root Component
+ */
+export function registerRootComponent(component: ComponentType): void;
+
+/**
+ * ScreenOrientation
+ */
+export namespace ScreenOrientation {
+    interface Orientations {
+        ALL: 'ALL';
+        ALL_BUT_UPSIDE_DOWN: 'ALL_BUT_UPSIDE_DOWN';
+        PORTRAIT: 'PORTRAIT';
+        PORTRAIT_UP: 'PORTRAIT_UP';
+        PORTRAIT_DOWN: 'PORTRAIT_DOWN';
+        LANDSCAPE: 'LANDSCAPE';
+        LANDSCAPE_LEFT: 'LANDSCAPE_LEFT';
+        LANDSCAPE_RIGHT: 'LANDSCAPE_RIGHT';
+    }
+
+    const Orientation: Orientations;
+
+    function allow(orientation: keyof Orientations): void;
+}
+
+/**
+ * SecureStore
+ */
+export namespace SecureStore {
+    interface SecureStoreOptions {
+        keychainService?: string;
+        keychainAccessible?: number;
+    }
+
+    function setItemAsync(key: string, value: string, options?: SecureStoreOptions): Promise<void>;
+    function getItemAsync(key: string, options?: SecureStoreOptions): Promise<string | null>;
+    function deleteItemAsync(key: string, options?: SecureStoreOptions): Promise<void>;
+}
+
+/**
+ * Segment
+ */
+export namespace Segment {
+    function initialize(keys: {
+        androidWriteKey: string;
+        iosWriteKey: string;
+    }): void;
+    function identify(userId: string): void;
+    function identifyWithTraits(userId: string, traits: object): void;
+    function track(event: string): void;
+    function reset(): void;
+    function trackWithProperties(event: string, properties: object): void;
+    function screen(screenName: string): void;
+    function screenWithProperties(screenName: string, properties: object): void;
+    function flush(): void;
+}
+
+/**
+ * Speech
+ */
+export namespace Speech {
+    interface SpeechOptions {
+        language?: string;
+        pitch?: number;
+        rate?: number;
+        onStart?: () => void;
+        onStopped?: () => void;
+        onDone?: () => void;
+        onError?: (error: string) => void;
+    }
+
+    function speak(text: string, options?: SpeechOptions): void;
+    function stop(): void;
+    function isSpeakingAsync(): Promise<boolean>;
+
+    /** Available on iOS only */
+    function pause(): void;
+
+    /** Available on iOS only */
+    function resume(): void;
+}
+
+/**
+ * SQLite
+ */
+export namespace SQLite {
+    type Error = any;
+
+    interface Database {
+        transaction(
+            callback: (transaction: Transaction) => any,
+            error?: (error: Error) => any,     // TODO def of error
+            success?: () => any
+        ): void;
+    }
+
+    interface Transaction {
+        executeSql(
+            sqlStatement: string,
+            arguments?: string[] | number[],
+            success?: (transaction: Transaction, resultSet: ResultSet) => any,
+            error?: (transaction: Transaction, error: Error) => any
+        ): void;
+    }
+
+    interface ResultSet {
+        insertId: number;
+        rowAffected: number;
+        rows: {
+            length: number;
+            item: (index: number) => any;
+            _array: HashMap[];
+        };
+    }
+
+    function openDatabase(
+        name: string | {
+            name: string,
+            version?: string,
+            description?: string,
+            size?: number,
+            callback?: () => any
+        },
+        version?: string,
+        description?: string,
+        size?: number,
+        callback?: () => any
+    ): any;
+}
+
+// #region Svg
+/**
+ * Svg
+ */
+export interface SvgCommonProps {
+    fill?: string;
+    fillOpacity?: number | string;
+    fillRule?: 'nonzero' | 'evenodd';
+    opacity?: number | string;
+    stroke?: string;
+    strokeWidth?: number | string;
+    strokeOpacity?: number | string;
+    strokeLinecap?: string;
+    strokeLineJoin?: string;
+    strokeDasharray?: any[];
+    strokeDashoffset?: any;
+    transform?: string | object;
+    x?: number | string;
+    y?: number | string;
+    rotate?: number | string;
+    rotation?: number | string;
+    scale?: number | string;
+    origin?: number | string;
+    originX?: number | string;
+    originY?: number | string;
+    id?: string;
+    disabled?: boolean;
+    onPress?: () => any;
+    onPressIn?: () => any;
+    onPressOut?: () => any;
+    onLongPress?: () => any;
+    delayPressIn?: number;
+    delayPressOut?: number;
+    delayLongPress?: number;
+}
+
+export interface SvgRectProps extends SvgCommonProps {
+    width: number | string;
+    height: number | string;
+}
+
+export interface SvgCircleProps extends SvgCommonProps {
+    cx: number | string;
+    cy: number | string;
+    r: number | string;
+}
+
+export interface SvgEllipseProps extends SvgCommonProps {
+    cx: number | string;
+    cy: number | string;
+    rx: number | string;
+    ry: number | string;
+}
+
+export interface SvgLineProps extends SvgCommonProps {
+    x1: number | string;
+    y1: number | string;
+    x2: number | string;
+    y2: number | string;
+}
+
+export interface SvgPolyProps extends SvgCommonProps {
+    points: string;
+}
+
+export interface SvgPathProps extends SvgCommonProps {
+    d: string;
+}
+
+export interface SvgTextProps extends SvgCommonProps {
+    textAnchor?: string;
+    fontSize?: number | string;
+    fontWeight?: string;
+}
+
+export interface SvgTSpanProps extends SvgTextProps {
+    dx?: string;
+    dy?: string;
+}
+
+export interface SvgTextPathProps extends SvgCommonProps {
+    href?: string;
+    startOffset?: string;
+}
+
+export interface SvgUseProps extends SvgCommonProps {
+    href: string;
+    x: number | string;
+    y: number | string;
+    width?: number | string;
+    height?: number | string;
+}
+
+export interface SvgSymbolProps extends SvgCommonProps {
+    viewBox: string;
+    width: number | string;
+    height: number | string;
+}
+
+export interface SvgLinearGradientProps extends SvgCommonProps {
+    x1: number | string;
+    x2: number | string;
+    y1: number | string;
+    y2: number | string;
+}
+
+export interface SvgRadialGradientProps extends SvgCommonProps {
+    cx: number | string;
+    cy: number | string;
+    rx: number | string;
+    ry: number | string;
+    fx: number | string;
+    fy: number | string;
+    gradientUnits?: string;
+}
+
+export interface SvgStopProps extends SvgCommonProps {
+    offset?: string;
+    stopColor?: string;
+    stopOpacity?: string;
+}
+
+export class Svg extends Component<{ width: number, height: number, viewBox?: string }> {
+    static Circle: ComponentClass<SvgCircleProps>;
+    static ClipPath: ComponentClass<SvgCommonProps>;
+    static Defs: ComponentClass;
+    static Ellipse: ComponentClass<SvgEllipseProps>;
+    static G: ComponentClass<SvgCommonProps>;
+    static Line: ComponentClass<SvgLineProps>;
+    static LinearGradient: ComponentClass<SvgLinearGradientProps>;
+    static Path: ComponentClass<SvgPathProps>;
+    static Polygon: ComponentClass<SvgPolyProps>;
+    static Polyline: ComponentClass<SvgPolyProps>;
+    static RadialGradient: ComponentClass<SvgRadialGradientProps>;
+    static Rect: ComponentClass<SvgRectProps>;
+    static Stop: ComponentClass<SvgStopProps>;
+    static Symbol: ComponentClass<SvgSymbolProps>;
+    static Text: ComponentClass<SvgTextProps>;
+    static TextPath: ComponentClass<SvgTextPathProps>;
+    static TSpan: ComponentClass<SvgTSpanProps>;
+    static Use: ComponentClass<SvgUseProps>;
+}
+// #endregion
+
+/**
+ * Take Snapshot
+ */
+export function takeSnapshotAsync(
+    view?: (number | React.ReactElement<any>),
+    options?: {
+        width?: number,
+        height?: number,
+        format?: 'png' | 'jpg' | 'jpeg' | 'webm',
+        quality?: number,
+        result?: 'file' | 'base64' | 'data-uri',
+    }
+): Promise<string>;
+
+/** Helpful utility functions that don’t fit anywhere else, including some localization and internationalization methods. */
+export namespace Util {
+    /** Returns the current device country code. */
+    function getCurrentDeviceCountryAsync(): Promise<string>;
+
+    /** Returns the current device locale as a string. */
+    function getCurrentLocaleAsync(): Promise<string>;
+
+    /** Returns the current device time zone name. */
+    function getCurrentTimeZoneAsync(): Promise<string>;
+
+    /** Reloads the current experience. This will fetch and load the newest available JavaScript supported by the device’s Expo environment. This is useful for triggering an update of your experience if you have published a new version. */
+    function reload(): void;
+
+    /** _Android only_. Invokes a callback when a new version of your app is successfully downloaded in the background. */
+    function addNewVersionListenerExperimental(listener: (event: {
+        manifest: object;
+    }) => void): { remove(): void; };
+}
+
+// #region Video
+/**
+ * Expo Video
+ */
+export interface NaturalSize {
+    width: number;
+    height: number;
+    orientation: Orientation;
+}
+
+export interface ReadyForDisplayEvent {
+    naturalSize: NaturalSize;
+    status: PlaybackStatus;
+}
+
+export enum FullscreenUpdateVariants {
+    IOS_FULLSCREEN_UPDATE_PLAYER_WILL_PRESENT = 0,
+    IOS_FULLSCREEN_UPDATE_PLAYER_DID_PRESENT = 1,
+    IOS_FULLSCREEN_UPDATE_PLAYER_WILL_DISMISS = 2,
+    IOS_FULLSCREEN_UPDATE_PLAYER_DID_DISMISS = 3
+}
+
+export interface FullscreenUpdateEvent {
+    fullscreenUpdate: FullscreenUpdateVariants;
+    status: PlaybackStatus;
+}
+
+export interface VideoProps {
+    source?: PlaybackSource | null;
+    posterSource?: URISource | RequireSource;
+
+    resizeMode?: ResizeModeContain | ResizeModeCover | ResizeModeStretch;
+    useNativeControls?: boolean;
+    usePoster?: boolean;
+
+    onPlaybackStatusUpdate?: (status: PlaybackStatus) => void;
+    onReadyForDisplay?: (event: ReadyForDisplayEvent) => void;
+    onIOSFullscreenUpdate?: (event: FullscreenUpdateEvent) => void;
+
+    onLoadStart?: () => void;
+    onLoad?: (status: PlaybackStatus) => void;
+    onError?: (error: string) => void;
+
+    status?: PlaybackStatusToSet;
+    progressUpdateIntervalMillis?: number;
+    positionMillis?: number;
+    shouldPlay?: boolean;
+    rate?: number;
+    shouldCorrectPitch?: boolean;
+    volume?: number;
+    isMuted?: boolean;
+    isLooping?: boolean;
+
+    scaleX?: number;
+    scaleY?: number;
+    translateX?: number;
+    translateY?: number;
+    rotation?: number;
+    ref?: Ref<PlaybackObject>;
+    style?: StyleProp<ViewStyle>;
+}
+
+export interface VideoState {
+    showPoster: boolean;
+}
+
+export class Video extends Component<VideoProps, VideoState> {
+    static RESIZE_MODE_CONTAIN: ResizeModeContain;
+    static RESIZE_MODE_COVER: ResizeModeCover;
+    static RESIZE_MODE_STRETCH: ResizeModeStretch;
+    static IOS_FULLSCREEN_UPDATE_PLAYER_WILL_PRESENT: FullscreenUpdateVariants.IOS_FULLSCREEN_UPDATE_PLAYER_WILL_PRESENT;
+    static IOS_FULLSCREEN_UPDATE_PLAYER_DID_PRESENT: FullscreenUpdateVariants.IOS_FULLSCREEN_UPDATE_PLAYER_DID_PRESENT;
+    static IOS_FULLSCREEN_UPDATE_PLAYER_WILL_DISMISS: FullscreenUpdateVariants.IOS_FULLSCREEN_UPDATE_PLAYER_WILL_DISMISS;
+    static IOS_FULLSCREEN_UPDATE_PLAYER_DID_DISMISS: FullscreenUpdateVariants.IOS_FULLSCREEN_UPDATE_PLAYER_DID_DISMISS;
+}
+// #endregion
+
+/**
+ * Web Browser
+ */
+export namespace WebBrowser {
+    function openBrowserAsync(url: string): Promise<{ type: 'cancelled' | 'dismissed' }>;
+    function openAuthSessionAsync(url: string, redirectUrl?: string): Promise<{ type: 'cancelled' | 'dismissed' }>;
+    function dismissBrowser(): Promise<{ type: 'dismissed' }>;
+}
+
+// #region Calendar
+/**
+ * Calendar
+ *
+ * Provides an API for interacting with the device’s system calendars, events, reminders, and associated records.
+ */
+export namespace Calendar {
+    interface Calendar {
+        /** Internal ID that represents this calendar on the device */
+        id?: string;
+
+        /** Visible name of the calendar */
+        title?: string;
+
+        sourceId?: string; // iOS
+
+        /** Object representing the source to be used for the calendar */
+        source?: Source;
+
+        /** Type of calendar this object represents */
+        type?: CalendarType; // iOS
+
+        /** Color used to display this calendar’s events */
+        color?: string;
+
+        /** Whether the calendar is used in the Calendar or Reminders OS app */
+        entityType?: EntityTypes; // iOS
+
+        /** Boolean value that determines whether this calendar can be modified */
+        allowsModifications?: boolean;
+
+        /** Availability types that this calendar supports */
+        allowedAvailabilities?: Availability[];
+
+        /** Boolean value indicating whether this is the device’s primary calendar */
+        isPrimary?: boolean; // Android
+
+        /** Internal system name of the calendar */
+        name?: string; // Android
+
+        /** Name for the account that owns this calendar */
+        ownerAccount?: string; // Android
+
+        /** Time zone for the calendar	 */
+        timeZone?: string; // Android
+
+        /** Alarm methods that this calendar supports */
+        allowedReminders?: AlarmMethod[]; // Android
+
+        /** Attendee types that this calendar supports */
+        allowedAttendeeTypes?: AttendeeType[]; // Android
+
+        /** Indicates whether the OS displays events on this calendar */
+        isVisible?: boolean; // Android
+
+        /** Indicates whether this calendar is synced and its events stored on the device */
+        isSynced?: boolean; // Android
+
+        /** Level of access that the user has for the calendar */
+        accessLevel?: CalendarAccessLevel; // Android
+    }
+
+    interface Source {
+        /** Internal ID that represents this source on the device */
+        id?: string; // iOS only ??
+
+        /** Type of account that owns this calendar */
+        type?: string;
+
+        /** Name for the account that owns this calendar */
+        name?: string;
+
+        /** Whether this source is the local phone account */
+        isLocalAccount?: boolean; // Android
+    }
+
+    interface Event {
+        /** Internal ID that represents this event on the device */
+        id?: string;
+
+        /** ID of the calendar that contains this event */
+        calendarId?: string;
+
+        /** Visible name of the event */
+        title?: string;
+
+        /** Location field of the event	 */
+        location?: string;
+
+        /** Date when the event record was created */
+        creationDate?: string; // iOS
+
+        /** Date when the event record was last modified */
+        lastModifiedDate?: string; // iOS
+
+        /** Time zone the event is scheduled in */
+        timeZone?: string;
+
+        /** Time zone for the event end time */
+        endTimeZone?: string; // Android
+
+        /** URL for the event */
+        url?: string; // iOS
+
+        /** Description or notes saved with the event */
+        notes?: string;
+
+        /** Array of Alarm objects which control automated reminders to the user */
+        alarms?: Alarm[];
+
+        /** Object representing rules for recurring or repeating events. Null for one-time events. */
+        recurrenceRule?: RecurrenceRule;
+
+        /** Date object or string representing the time when the event starts */
+        startDate?: string | Date;
+
+        /** Date object or string representing the time when the event ends */
+        endDate?: string | Date;
+
+        /** For recurring events, the start date for the first (original) instance of the event */
+        originalStartDate?: string; // iOS
+
+        /** Boolean value indicating whether or not the event is a detached (modified) instance of a recurring event */
+        isDetached?: boolean; // iOS
+
+        /** Whether the event is displayed as an all-day event on the calendar */
+        allDay?: boolean;
+
+        /** The availability setting for the event */
+        availability?: Availability; // Availability
+
+        /** Status of the event */
+        status?: EventStatus; // Status
+
+        /** Organizer of the event, as an Attendee object */
+        organizer?: string; // Organizer - iOS
+
+        /** Email address of the organizer of the event */
+        organizerEmail?: string; // Android
+
+        /** User’s access level for the event */
+        accessLevel?: EventAccessLevel; // Android,
+
+        /** Whether invited guests can modify the details of the event */
+        guestsCanModify?: boolean; // Android,
+
+        /** Whether invited guests can invite other guests */
+        guestsCanInviteOthers?: boolean; // Android
+
+        /** Whether invited guests can see other guests */
+        guestsCanSeeGuests?: boolean; // Android
+
+        /** For detached (modified) instances of recurring events, the ID of the original recurring event */
+        originalId?: string; // Android
+
+        /** For instances of recurring events, volatile ID representing this instance; not guaranteed to always refer to the same instance */
+        instanceId?: string; // Android
+    }
+
+    interface Attendee {
+        /** Internal ID that represents this attendee on the device */
+        id?: string; // Android
+
+        /** Indicates whether or not this attendee is the current OS user */
+        isCurrentUser?: boolean; // iOS
+
+        /** Displayed name of the attendee */
+        name?: string;
+
+        /** Role of the attendee at the event */
+        role?: AttendeeRole;
+
+        /** Status of the attendee in relation to the event */
+        status?: AttendeeStatus;
+
+        /** Type of the attendee */
+        type?: AttendeeType;
+
+        /** URL for the attendee */
+        url?: string; // iOS
+
+        /** Email address of the attendee */
+        email?: string; // Android
+    }
+
+    interface Reminder {
+        /** Internal ID that represents this reminder on the device */
+        id?: string;
+
+        /** ID of the calendar that contains this reminder */
+        calendarId?: string;
+
+        /** Visible name of the reminder */
+        title?: string;
+
+        /** Location field of the reminder */
+        location?: string;
+
+        /** Date when the reminder record was created */
+        creationDate?: string;
+
+        /** Date when the reminder record was last modified */
+        lastModifiedDate?: string;
+
+        /** Time zone the reminder is scheduled in */
+        timeZone?: string;
+
+        /** URL for the reminder */
+        url?: string;
+
+        /** Description or notes saved with the reminder */
+        notes?: string;
+
+        /** Array of Alarm objects which control automated alarms to the user about the task */
+        alarms?: Alarm[];
+
+        /** Object representing rules for recurring or repeated reminders. Null for one-time tasks. */
+        recurrenceRule?: RecurrenceRule;
+
+        /** Date object or string representing the start date of the reminder task */
+        startDate?: string;
+
+        /** Date object or string representing the time when the reminder task is due */
+        dueDate?: string;
+
+        /** Indicates whether or not the task has been completed */
+        completed?: boolean;
+
+        /** Date object or string representing the date of completion, if completed is true */
+        completionDate?: string;
+    }
+
+    interface Alarm {
+        /** Date object or string representing an absolute time the alarm should occur; overrides relativeOffset and structuredLocation if specified alongside either */
+        absoluteDate?: string; // iOS
+
+        /** Number of minutes from the startDate of the calendar item that the alarm should occur; use negative values to have the alarm occur before the startDate */
+        relativeOffset?: string;
+        structuredLocation?: {
+            // iOS
+            title?: string;
+            proximity?: string; // Proximity
+            radius?: number;
+            coords?: {
+                latitude?: number;
+                longitude?: number;
+            };
+        };
+
+        /** Method of alerting the user that this alarm should use; on iOS this is always a notification */
+        method?: AlarmMethod; // Method, Android
+    }
+
+    interface RecurrenceRule {
+        /** How often the calendar item should recur */
+        frequency: Frequency; // Frequency
+
+        /** Interval at which the calendar item should recur. For example, an interval: 2 with frequency: DAILY would yield an event that recurs every other day. Defaults to 1 . */
+        interval?: number;
+
+        /** Date on which the calendar item should stop recurring; overrides occurrence if both are specified */
+        endDate?: string;
+
+        /** Number of times the calendar item should recur before stopping */
+        occurrence?: number;
+    }
+
+    enum EntityTypes {
+        EVENT = 'event',
+        REMINDER = 'reminder',
+    }
+
+    enum CalendarType {
+        LOCAL = 'local',
+        CALDAV = 'caldav',
+        EXCHANGE = 'exchange',
+        SUBSCRIBED = 'subscribed',
+        BIRTHDAYS = 'birthdays'
+    }
+
+    enum Availability {
+        NOT_SUPPORTED = 'notSupported', // iOS
+        BUSY = 'busy',
+        FREE = 'free',
+        TENTATIVE = 'tentative',
+        UNAVAILABLE = 'unavailable' // iOS
+    }
+
+    enum AlarmMethod {
+        ALARM = 'alarm',
+        ALERT = 'alert',
+        EMAIL = 'email',
+        SMS = 'sms',
+        DEFAULT = 'default',
+    }
+
+    enum AttendeeType {
+        UNKNOWN = 'unknown', // iOS
+        PERSON = 'person', // iOS
+        ROOM = 'room', // iOS
+        GROUP = 'group', // iOS
+        RESOURCE = 'resource',
+        OPTIONAL = 'optional', // Android
+        REQUIRED = 'required', // Android
+        NONE = 'none' // Android
+    }
+
+    enum CalendarAccessLevel {
+        CONTRIBUTOR = 'contributor',
+        EDITOR = 'editor',
+        FREEBUSY = 'freebusy',
+        OVERRIDE = 'override',
+        OWNER = 'owner',
+        READ = 'read',
+        RESPOND = 'respond',
+        ROOT = 'root',
+        NONE = 'none'
+    }
+
+    enum EventAccessLevel {
+        CONFIDENTIAL = 'confidential',
+        PRIVATE = 'private',
+        PUBLIC = 'public',
+        DEFAULT = 'default'
+    }
+
+    enum EventStatus {
+        NONE = 'none',
+        CONFIRMED = 'confirmed',
+        TENTATIVE = 'tentative',
+        CANCELED = 'canceled'
+    }
+
+    enum AttendeeRole {
+        UNKNOWN = 'unknown', // iOS
+        REQUIRED = 'required', // iOS
+        OPTIONAL = 'optional', // iOS
+        CHAIR = 'chair', // iOS
+        NON_PARTICIPANT = 'nonParticipant', // iOS
+        ATTENDEE = 'attendee', // Android
+        ORGANIZER = 'organizer', // Android
+        PERFORMER = 'performer', // Android
+        SPEAKER = 'speaker', // Android
+        NONE = 'none' // Android
+    }
+
+    enum AttendeeStatus {
+        UNKNOWN = 'unknown', // iOS
+        PENDING = 'pending', // iOS
+        ACCEPTED = 'accepted',
+        DECLINED = 'declined',
+        TENTATIVE = 'tentative',
+        DELEGATED = 'delegated', // iOS
+        COMPLETED = 'completed', // iOS
+        IN_PROCESS = 'inProcess', // iOS
+        INVITED = 'invited', // Android
+        NONE = 'none' // Android
+    }
+
+    enum Frequency {
+        DAILY = 'daily',
+        WEEKLY = 'weekly',
+        MONTHLY = 'monthly',
+        YEARLY = 'yearly'
+    }
+
+    enum ReminderStatus {
+        COMPLETED = 'completed',
+        INCOMPLETE = 'incomplete'
+    }
+
+    interface RecurringEventOptions {
+        futureEvents?: boolean;
+        instanceStartDate?: string;
+    }
+
+    /** Gets an array of calendar objects with details about the different calendars stored on the device. */
+    function getCalendarsAsync(
+        /** (iOS only) Not required, but if defined, filters the returned calendars to a specific entity type.  */
+        entityType?: EntityTypes
+    ): Promise<Calendar[]>;
+
+    /** Creates a new calendar on the device, allowing events to be added later and displayed. */
+    function createCalendarAsync(details: Calendar): Promise<string>;
+
+    /** Updates the provided details of an existing calendar stored on the device. To remove a property, explicitly set it to null in details */
+    function updateCalendarAsync(id: string, details?: Calendar | null): Promise<string>;
+
+    /** Deletes an existing calendar and all associated events/reminders/attendees from the device. Use with caution. */
+    function deleteCalendarAsync(id: string): Promise<void>;
+
+    /** Returns all events in a given set of calendars over a specified time period. */
+    function getEventsAsync(
+        /** Array of IDs of calendars to search for events in. Required. */
+        calendarIds: string[],
+
+        /** Beginning of time period to search for events in. Required. */
+        startDate: Date,
+
+        /** End of time period to search for events in. Required. */
+        endDate: Date
+    ): Promise<Event[]>;
+
+    /** Returns a specific event selected by ID. If a specific instance of a recurring event is desired, the start date of this instance must also be provided, as instances of recurring events do not have their own unique and stable IDs on either iOS or Android. */
+    function getEventAsync(
+        /** ID of the event to return. Required. */
+        id: string,
+
+        /** A map of options for recurring events */
+        recurringEventOptions?: RecurringEventOptions
+    ): Promise<Event>;
+
+    /** Creates a new event on the specified calendar. */
+    function createEventAsync(
+        /** ID of the calendar to create this event in. Required. */
+        calendarId: string,
+        details?: Event
+    ): Promise<string>;
+
+    /** Updates the provided details of an existing calendar stored on the device. To remove a property, explicitly set it to null in details */
+    function updateEventAsync(
+        /** ID of the event to be updated. Required. */
+        id: string,
+
+        /** A map of properties to be updated  */
+        details?: Event | null,
+
+        /** A map of options for recurring events */
+        recurrentEventOptions?: RecurringEventOptions
+    ): Promise<string>;
+
+    /** Deletes an existing event from the device. Use with caution. */
+    function deleteEventAsync(
+        /** ID of the event to be deleted. Required. */
+        id: string,
+
+        /** A map of options for recurring events */
+        recurringEventOptions?: RecurringEventOptions
+    ): Promise<void>;
+
+    /** Gets all attendees for a given event (or instance of a recurring event). */
+    function getAttendeesForEventAsync(
+        /** ID of the event to return attendees for. Required. */
+        eventId: string,
+
+        /** A map of options for recurring events */
+        recurrentEventOptions?: RecurringEventOptions
+    ): Promise<Attendee[]>;
+
+    /** Available on Android only. Creates a new attendee record and adds it to the specified event. Note that if eventId specifies a recurring event, this will add the attendee to every instance of the event. */
+    function createAttendeeAsync(
+        /**  ID of the event to add this attendee to. Required. */
+        eventId: string,
+
+        /** A map of details for the attendee to be created  */
+        details?: Attendee
+    ): Promise<string>;
+
+    /** Available on Android only. Updates an existing attendee record. To remove a property, explicitly set it to null in details. */
+    function updateAttendeeAsync(
+        /** ID of the attendee record to be updated. Required. */
+        id: string,
+
+        /** A map of properties to be updated  */
+        details?: Attendee | null
+    ): Promise<string>;
+
+    /** Available on Android only. Deletes an existing attendee record from the device. Use with caution. */
+    function deleteAttendeeAsync(id: string): Promise<void>;
+
+    /** Available on iOS only. Returns a list of reminders matching the provided criteria. */
+    function getRemindersAsync(
+        /**  Array of IDs of calendars to search for reminders in. Required. */
+        calendarIds: string[],
+
+        status?: ReminderStatus,
+
+        /** Beginning of time period to search for reminders in. Required if status is defined. */
+        startDate?: Date,
+
+        /** End of time period to search for reminders in. Required if status is defined. */
+        endDate?: Date
+    ): Promise<Reminder[]>;
+
+    /** Available on iOS only. Returns a specific reminder selected by ID. */
+    function getReminderAsync(id: string): Promise<Reminder>;
+
+    /** Available on iOS only. Creates a new reminder on the specified calendar. */
+    function createReminderAsync(
+        /** ID of the calendar to create this reminder in. Required. */
+        calendarId: string,
+
+        /** A map of details for the reminder to be created */
+        details?: Reminder
+    ): Promise<string>;
+
+    /** Available on iOS only. Updates the provided details of an existing reminder stored on the device. To remove a property, explicitly set it to null in details. */
+    function updateReminderAsync(
+        /** ID of the reminder to be updated. Required. */
+        id: string,
+
+        /** A map of properties to be updated */
+        details?: Reminder | null
+    ): Promise<string>;
+
+    /** Available on iOS only. Deletes an existing reminder from the device. Use with caution. */
+    function deleteReminderAsync(id: string): Promise<void>;
+
+    /** Available on iOS only. */
+    function getSourcesAsync(): Promise<Source[]>;
+
+    /** Available on iOS only. Returns a specific source selected by ID. */
+    function getSourceAsync(id: string): Promise<Source>;
+
+    /** Available on Android only. Sends an intent to open the specified event in the OS Calendar app. */
+    function openEventInCalendar(
+        /** ID of the event to open. Required. */
+        id: string
+    ): void;
+}
+// #endregion
+
+// #region MailComposer
+/**
+ * An API to compose mails using OS specific UI.
+ */
+export namespace MailComposer {
+    interface ComposeOptions {
+        /** An array of e-mail addressess of the recipients. */
+        recipients?: string[];
+
+        /** An array of e-mail addressess of the CC recipients. */
+        ccRecipients?: string[];
+
+        /** An array of e-mail addressess of the BCC recipients. */
+        bccRecipients?: string[];
+
+        /** Subject of the mail. */
+        subject?: string;
+
+        /** Body of the mail. */
+        body?: string;
+
+        /** Whether the body contains HTML tags so it could be formatted properly. Not working perfectly on Android. */
+        isHtml?: boolean;
+
+        /** An array of app’s internal file uris to attach. */
+        attachments?: string[];
+    }
+
+    /** Resolves to a promise with object containing status field that could be either sent, saved or cancelled. Android does not provide such info so it always resolves to sent. */
+    function composeAsync(
+        /** A map defining the data to fill the mail */
+        options: ComposeOptions
+    ): Promise<{ status: 'sent' | 'saved' | 'cancelled' }>;
+}
+// #endregion
+
+export namespace Updates {
+    namespace EventType {
+        /** A new update is available and has started downloading. */
+        type DownloadStart = 'downloadStart';
+        /** A new update is currently being downloaded and will be stored in the device's cache. */
+        type DownloadProgress = 'downloadProgress';
+        /** A new update has finished downloading and is now stored in the device's cache. */
+        type DownloadFinished = 'downloadFinished';
+        /** No updates are available, and the most up-to-date bundle of this experience is already running. */
+        type NoUpdateAvailable = 'noUpdateAvailable';
+        /** An error occurred trying to fetch the latest update. */
+        type Error = 'error';
+
+        /** A new update is available and has started downloading. */
+        const DOWNLOAD_STARTED: DownloadStart;
+        /** A new update is currently being downloaded and will be stored in the device's cache. */
+        const DOWNLOAD_PROGRESS: DownloadProgress;
+        /** A new update has finished downloading and is now stored in the device's cache. */
+        const DOWNLOAD_FINISHED: DownloadFinished;
+        /** No updates are available, and the most up-to-date bundle of this experience is already running. */
+        const NO_UPDATE_AVAILABLE: NoUpdateAvailable;
+        /** An error occurred trying to fetch the latest update. */
+        const ERROR: Error;
+    }
+
+    interface UpdateCheck {
+        /** True if an update is available, false if you're already running the most up-to-date JS bundle. */
+        isAvailable: boolean;
+        /** If `isAvailable` is true, the manifest of the available update. Undefined otherwise. */
+        manifest?: Constants.Manifest;
+    }
+
+    interface UpdateBundle {
+        /** True if the fetched bundle is new (i.e. a different version that the what's currently running). */
+        isNew: boolean;
+        /** Manifest of the fetched update. */
+        manifest: Constants.Manifest;
+    }
+
+    /** An object that is passed into each event listener when a new version is available. */
+    interface UpdateEvent {
+        /** Type of the event */
+        type: EventType.DownloadStart
+            | EventType.DownloadProgress
+            | EventType.DownloadFinished
+            | EventType.NoUpdateAvailable
+            | EventType.Error;
+        /** If `type === Expo.Updates.EventType.DOWNLOAD_FINISHED`, the manifest of the newly downloaded update. Undefined otherwise. */
+        manifest?: Constants.Manifest;
+        /** If `type === Expo.Updates.EventType.ERROR`, the error message. Undefined otherwise. */
+        message?: string;
+    }
+
+    /** An optional params object passed to fetchUpdateAsync. */
+    interface FetchUpdateAsyncParams {
+        eventListener: UpdateEventListener;
+    }
+
+    type UpdateEventListener = (event: UpdateEvent) => any;
+
+    /**
+     * Invokes a callback when updates-related events occur,
+     * either on the initial app load or as a result of a call to `Expo.Updates.fetchUpdateAsync`.
+     */
+    function addListener(listener: UpdateEventListener): EventSubscription;
+
+    /**
+     * Check if a new published version of your project is available.
+     * Does not actually download the update.
+     * Rejects if `updates.enabled` is `false` in app.json.
+     */
+    function checkForUpdateAsync(): Promise<UpdateCheck>;
+
+    /**
+     * Downloads the most recent published version of your experience to the device's local cache.
+     * Rejects if `updates.enabled` is `false` in app.json.
+     */
+    function fetchUpdateAsync(params?: FetchUpdateAsyncParams): Promise<UpdateBundle>;
+
+    /**
+     * Immediately reloads the current experience.
+     * This will use your app.json updates configuration to fetch and load the newest available JS supported by the device's Expo environment.
+     * This is useful for triggering an update of your experience if you have published a new version.
+     */
+    function reload(): void;
+
+    /**
+     * Immediately reloads the current experience using the most recent cached version.
+     * This is useful for triggering an update of your experience if you have published and already downloaded a new version.
+     */
+    function reloadFromCache(): void;
+}
+
+// #region MediaLibrary
+/**
+ * https://docs.expo.io/versions/latest/sdk/media-library
+ * Provides access to user's media library
+ * Requires Permissions.CAMERA_ROLL permissions.
+ */
+
+export namespace MediaLibrary {
+  /**
+   * Creates an asset from existing file. The most common use case is to save a picture taken by Camera.
+   */
+  function createAssetAsync(localUri: string): Promise<Asset>;
+
+  /**
+   * Fetches a page of assets matching the provided criteria.
+   */
+  function getAssetsAsync(options: GetAssetsOptions): Promise<GetAssetsResult>;
+
+  /**
+   * Provides more informations about an asset, including GPS location, local URI and EXIF metadata.
+   */
+  function getAssetInfoAsync(asset: string | Asset): Promise<Asset>;
+
+  /**
+   * Deletes assets from the library. On iOS it deletes assets from all albums they belong to, while on Android it keeps all copies of them
+   * (album is strictly connected to the asset). Also, there is additional dialog on iOS that requires user to confirm this action.
+   */
+  function deleteAssetsAsync(asset: string[] | Asset[]): Promise<boolean>;
+
+  /**
+   * Queries for user-created albums in media gallery.
+   */
+  function getAlbumsAsync(): Promise<Album[]>;
+
+  /**
+   * Queries for an album with a specific name.
+   */
+  function getAlbumAsync(albumName: string): Promise<Album>;
+
+  /**
+   * Creates an album with given name and initial asset.
+   * The asset parameter is required on Android, since it's not possible to create empty album on this platform.
+   */
+  function createAlbumAsync(albumName: string, asset: string | Asset): Promise<Album>;
+
+  /**
+   * Adds array of assets to the album.
+   * On Android, by default it copies assets from the current album to provided one, however it's also possible to move them by passing false as copyAssets argument.
+   * In case they're copied you should keep in mind that getAssetsAsync will return duplicated assets.
+   */
+  function addAssetsToAlbumAsync(assets: Asset[], album: string | Album, copyAssets?: boolean /* default true */): Promise<boolean>;
+
+  /**
+   * Removes given assets from album.
+   * On Android, album will be automatically deleted if there are no more assets inside.
+   */
+  function removeAssetsFromAlbumAsync(assets: Asset[], album: string | Album): Promise<boolean>;
+
+  /**
+   * Available on iOS only. Fetches a list of moments, which is a group of assets taken around the same place and time.
+   */
+  function getMomentsAsync(): Promise<Album[]>;
+
+  enum MediaType {
+    audio = 'audio',
+    photo = 'photo',
+    video = 'video',
+    unknow = 'unknow'
+  }
+
+  enum SortBy {
+    default = 'default',
+    id = 'id',
+    creationTime = 'creationTime',
+    modificationTime = 'modificationTime',
+    mediaType = 'mediaType',
+    width = 'width',
+    height = 'height',
+    duration = 'duration'
+  }
+
+  // region Asset
+  interface AssetAndroid {
+    albumId?: string;
+  }
+
+  interface AssetIos {
+    mediaSubtypes?: MediaType[];
+    // *
+    orientation: number;
+    // *
+    isFavorite: boolean;
+  }
+
+  interface Asset extends AssetAndroid, AssetIos {
+    id: string;
+    filename: string;
+    uri: string;
+    mediaType: string;
+    width: number;
+    height: number;
+    creationTime: number;
+    modificationTime: number;
+    duration: number;
+    // *
+    localUri?: string;
+    // *
+    location?: Location.LocationProps;
+    // *
+    exif?: object;
+  }
+
+  /**
+   * These fields can be obtained only by calling getAssetInfoAsync method
+   */
+  //#endregion
+
+  // #region Album
+  interface AlbumIos {
+    type?: string;
+    // *
+    startTime: number;
+    // *
+    endTime: number;
+    // *
+    approximateLocation?: Location.LocationProps;
+    // *
+    locationNames?: string[];
+  }
+
+  /**
+   * These fields apply only to albums whose type is moment
+   */
+
+  interface Album extends AlbumIos {
+    id: string;
+    title: string;
+    assetCount: number;
+  }
+  // #endregion
+
+  interface GetAssetsOptions {
+    first?: number;
+    after?: string;
+    album?: string | Album;
+    sortBy?: SortBy;
+    mediaType?: MediaType;
+  }
+
+  interface GetAssetsResult {
+    assets: Asset[];
+    endCursor: string;
+    hasNextPage: boolean;
+    totalCount: number;
+  }
+}
+// #endregion
+
+// #region Haptic
+/**
+ * https://docs.expo.io/versions/latest/sdk/haptic
+ * Provides haptic feedback for iOS 10+ devices using the Taptic Engine.
+ * If this is used in Android the device will use ReactNative.Vibrate instead, it's best to just avoid this.
+ */
+export namespace Haptic {
+  /**
+   * Used to let a user know when a selection change has been registered
+   */
+  function selection(): void;
+  function notification(notificationType?: NotificationType): void;
+  function impact(impactStyles?: ImpactStyles): void;
+
+  enum ImpactStyles {
+    Light = 'light',
+    Medium = 'medium',
+    Heavy = 'heavy'
+  }
+
+  enum NotificationType {
+    Success = 'success',
+    Warning = 'warning',
+    Error = 'error'
+  }
+}
+// #endregion
diff --git a/types/expo/v27/tsconfig.json b/types/expo/v27/tsconfig.json
new file mode 100644
index 0000000000..d493a7f59a
--- /dev/null
+++ b/types/expo/v27/tsconfig.json
@@ -0,0 +1,30 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": ["es6"],
+        "jsx": "react",
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../../",
+        "typeRoots": [
+            "../../"
+        ],
+        "paths": {
+            "expo": [
+                "expo/v27"
+            ],
+            "expo/*": [
+                "expo/v27/*"
+            ]
+        },
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "expo-tests.tsx"
+    ]
+}
diff --git a/types/expo/v27/tslint.json b/types/expo/v27/tslint.json
new file mode 100644
index 0000000000..8270136207
--- /dev/null
+++ b/types/expo/v27/tslint.json
@@ -0,0 +1,7 @@
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        "void-return": false,
+        "max-line-length": false
+    }
+}
diff --git a/types/expo__vector-icons/tsconfig.json b/types/expo__vector-icons/tsconfig.json
index 318f7f537c..542a4f4643 100644
--- a/types/expo__vector-icons/tsconfig.json
+++ b/types/expo__vector-icons/tsconfig.json
@@ -1,10 +1,7 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": [
-            "dom",
-            "es6"
-        ],
+        "lib": ["es6"],
         "noImplicitAny": true,
         "noImplicitThis": true,
         "strictNullChecks": true,
diff --git a/types/express-graphql/index.d.ts b/types/express-graphql/index.d.ts
index 78c988204f..5f49e62308 100644
--- a/types/express-graphql/index.d.ts
+++ b/types/express-graphql/index.d.ts
@@ -7,7 +7,7 @@
 //                 Margus Lamp <https://github.com/mlamp>
 //                 Firede <https://github.com/firede>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.6
 
 import { Request, Response } from "express";
 import { DocumentNode, GraphQLSchema, GraphQLError } from "graphql";
diff --git a/types/express-graphql/tsconfig.json b/types/express-graphql/tsconfig.json
index 7924c82706..ac6ad5f138 100644
--- a/types/express-graphql/tsconfig.json
+++ b/types/express-graphql/tsconfig.json
@@ -3,7 +3,8 @@
         "module": "commonjs",
         "target": "es2015",
         "lib": [
-            "es6"
+            "es6",
+            "esnext.asynciterable"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/express-sitemap-xml/express-sitemap-xml-tests.ts b/types/express-sitemap-xml/express-sitemap-xml-tests.ts
index f68dbf9696..9882f11c2a 100644
--- a/types/express-sitemap-xml/express-sitemap-xml-tests.ts
+++ b/types/express-sitemap-xml/express-sitemap-xml-tests.ts
@@ -1,16 +1,22 @@
 import * as express from 'express';
 
-import expressSitemapXml from 'express-sitemap-xml';
+import expressSitemapXml, { LeafObject } from 'express-sitemap-xml';
 
-const urls = ['/page1', '/page2'];
+const page2Leaf: LeafObject = {
+    changeFreq: 'weekly',
+    lastMod: new Date(),
+    url: '/page2'
+};
+
+const leaves = ['/page1', page2Leaf];
 const base = 'http://example.com';
-const getUrls = () => urls;
-const getUrlsPromise = () => Promise.resolve(urls);
+const getLeaves = () => leaves;
+const getLeavesPromise = () => Promise.resolve(leaves);
 
-expressSitemapXml.buildSitemaps(urls, base).then(sitemap => typeof sitemap === 'object');
+expressSitemapXml.buildSitemaps(leaves, base).then(sitemap => typeof sitemap === 'object');
 
-const sitemap1 = expressSitemapXml(getUrls, base);
-const sitemap2 = expressSitemapXml(getUrlsPromise, base);
+const sitemap1 = expressSitemapXml(getLeaves, base);
+const sitemap2 = expressSitemapXml(getLeavesPromise, base);
 
 express().use(sitemap1);
 express().use(sitemap2);
diff --git a/types/express-sitemap-xml/index.d.ts b/types/express-sitemap-xml/index.d.ts
index 6460fad25a..1926878bb5 100644
--- a/types/express-sitemap-xml/index.d.ts
+++ b/types/express-sitemap-xml/index.d.ts
@@ -6,14 +6,22 @@
 
 import * as express from 'express';
 
-export interface Sitemap {
-    [url: string]: string;
+export interface LeafObject {
+    changeFreq?: string;
+    lastMod?: string | Date;
+    url: string;
 }
 
-declare function expressSitemapXml(getUrls: (() => (string[] | Promise<string[]>)), base: string): express.RequestHandler;
+export type SitemapLeaf = string | LeafObject;
+
+export interface Sitemap {
+    [leaf: string]: string;
+}
+
+declare function expressSitemapXml(getUrls: (() => (SitemapLeaf[] | Promise<SitemapLeaf[]>)), base: string): express.RequestHandler;
 
 declare namespace expressSitemapXml {
-    function buildSitemaps(urls: string[], base: string): Promise<Sitemap>;
+    function buildSitemaps(urls: SitemapLeaf[], base: string): Promise<Sitemap>;
 }
 
 export default expressSitemapXml;
diff --git a/types/fabric/tslint.json b/types/fabric/tslint.json
index 17bb596f5d..0074ea2879 100644
--- a/types/fabric/tslint.json
+++ b/types/fabric/tslint.json
@@ -1,14 +1,24 @@
 {
     "extends": "dtslint/dt.json",
     "rules": {
-        // TODOs
+        // All are TODOs
         "adjacent-overload-signatures": false,
         "ban-types": false,
         "interface-name": false,
+        "jsdoc-format": false,
         "no-any-union": false,
+        "no-consecutive-blank-lines": false,
         "no-empty-interface": false,
+        "no-padding": false,
+        "no-redundant-jsdoc-2": false,
+        "no-unnecessary-class": false,
+        "one-line": false,
+        "semicolon": false,
         "space-within-parens": false,
         "strict-export-declare-modifiers": false,
-        "unified-signatures": false
+        "trim-file": false,
+        "typedef-whitespace": false,
+        "unified-signatures": false,
+        "whitespace": false
     }
 }
diff --git a/types/fastify-jwt/package.json b/types/fastify-jwt/package.json
index 948a91ff5b..e8c68ab969 100644
--- a/types/fastify-jwt/package.json
+++ b/types/fastify-jwt/package.json
@@ -3,4 +3,4 @@
     "dependencies": {
         "fastify": "^1.11.2"
     }
-}
\ No newline at end of file
+}
diff --git a/types/feathersjs__authentication/index.d.ts b/types/feathersjs__authentication/index.d.ts
index f451b0deda..7bb88a903d 100644
--- a/types/feathersjs__authentication/index.d.ts
+++ b/types/feathersjs__authentication/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://feathersjs.com/
 // Definitions by: Abraao Alves <https://github.com/AbraaoAlves>, Jan Lohage <https://github.com/j2L4e>
 // Definitions: https://github.com/feathersjs-ecosystem/feathers-typescript
+// TypeScript Version: 2.3
 
 import { Hook } from '@feathersjs/feathers';
 import * as self from '@feathersjs/authentication';
diff --git a/types/ffi/index.d.ts b/types/ffi/index.d.ts
index cf562cea06..d8386a630a 100644
--- a/types/ffi/index.d.ts
+++ b/types/ffi/index.d.ts
@@ -161,6 +161,11 @@ export const FFI_FIRST_ABI: number;
 export const FFI_LAST_ABI: number;
 export const FFI_SYSV: number;
 export const FFI_UNIX64: number;
+export const FFI_WIN64: number;
+export const FFI_VFP: number;
+export const FFI_STDCALL: number;
+export const FFI_THISCALL: number;
+export const FFI_FASTCALL: number;
 export const RTLD_LAZY: number;
 export const RTLD_NOW: number;
 export const RTLD_LOCAL: number;
diff --git a/types/fibjs/declare/UrlObject.d.ts b/types/fibjs/declare/UrlObject.d.ts
index 5baa5b2d7d..73b9abbfef 100644
--- a/types/fibjs/declare/UrlObject.d.ts
+++ b/types/fibjs/declare/UrlObject.d.ts
@@ -7,7 +7,7 @@
  *                                                                         *
  ***************************************************************************/
 
-/** 
+/**
  * @author Richard <richardo2016@gmail.com>
  *
  */
@@ -23,252 +23,252 @@
 	*/
 
 declare class Class_UrlObject extends Class__object {
-	
+
 	/**
-	 * class prop 
+	 * class prop
+	 *
 	 *
-	 * 
 	 * @brief 查询和设置当前 UrlObject 对象中的完整 url 地址描述，此描述由其他所有属性组装而成
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 * @type String
 	 */
-	
+
 	href: string
-	
+
 	/**
-	 * class prop 
+	 * class prop
+	 *
 	 *
-	 * 
 	 * @brief 查询和设置当前 UrlObject 对象中的协议名称
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 * @type String
 	 */
-	
+
 	protocol: string
-	
+
 	/**
-	 * class prop 
+	 * class prop
+	 *
 	 *
-	 * 
 	 * @brief 查询和设置当前 UrlObject 对象是否包含双斜杠
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 * @type Boolean
 	 */
-	
+
 	slashes: boolean
-	
+
 	/**
-	 * class prop 
+	 * class prop
+	 *
 	 *
-	 * 
 	 * @brief 查询和设置当前 UrlObject 对象中的完整验证字符串，由 username 和 password 属性组装而成
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 * @type String
 	 */
-	
+
 	auth: string
-	
+
 	/**
-	 * class prop 
+	 * class prop
+	 *
 	 *
-	 * 
 	 * @brief 查询和设置当前 UrlObject 对象中的验证用户
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 * @type String
 	 */
-	
+
 	username: string
-	
+
 	/**
-	 * class prop 
+	 * class prop
+	 *
 	 *
-	 * 
 	 * @brief 查询和设置当前 UrlObject 对象中的验证密码
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 * @type String
 	 */
-	
+
 	password: string
-	
+
 	/**
-	 * class prop 
+	 * class prop
+	 *
 	 *
-	 * 
 	 * @brief 查询和设置当前 UrlObject 对象中的完整主机描述，由 hastname 和 port 组装而成
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 * @type String
 	 */
-	
+
 	host: string
-	
+
 	/**
-	 * class prop 
+	 * class prop
+	 *
 	 *
-	 * 
 	 * @brief 查询和设置当前 UrlObject 对象中的主机名
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 * @type String
 	 */
-	
+
 	hostname: string
-	
+
 	/**
-	 * class prop 
+	 * class prop
+	 *
 	 *
-	 * 
 	 * @brief 查询和设置当前 UrlObject 对象中的端口号
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 * @type String
 	 */
-	
+
 	port: string
-	
+
 	/**
-	 * class prop 
+	 * class prop
+	 *
 	 *
-	 * 
 	 * @brief 查询和设置当前 UrlObject 对象中的请求完整路径（含请求），由 pathname 和 query 组装而成
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 * @type String
 	 */
-	
+
 	path: string
-	
+
 	/**
-	 * class prop 
+	 * class prop
+	 *
 	 *
-	 * 
 	 * @brief 查询和设置当前 UrlObject 对象中的路径
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 * @type String
 	 */
-	
+
 	pathname: string
-	
+
 	/**
-	 * class prop 
+	 * class prop
+	 *
 	 *
-	 * 
 	 * @brief 查询和设置当前 UrlObject 对象中的请求字符串（含“?”），等效于“?”+query
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 * @type String
 	 */
-	
+
 	search: string
-	
+
 	/**
-	 * class prop 
+	 * class prop
+	 *
+	 *
+	 * @brief 查询和设置当前 UrlObject 对象中的请求字符串（ 不含“?”）
+	 *
+	 *
 	 *
-	 * 
-	 * @brief 查询和设置当前 UrlObject 对象中的请求字符串（ 不含“?”）
-	 * 
-	 * 
-	 * 
 	 * @type Value
 	 */
-	
+
 	query: any
-	
+
 	/**
-	 * class prop 
+	 * class prop
+	 *
 	 *
-	 * 
 	 * @brief 查询和设置当前 UrlObject 对象中的请求锚点（含“\#”）
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 * @type String
 	 */
-	
+
 	hash: string
-	
-	
-	
+
+
+
 	/**
-	 * 
+	 *
 	 * @brief UrlObject 对象构造函数，使用参数构造
 	 * @param args 指定构造参数的字典对象，支持的字段有：protocol, slashes, username, password, hostname, port, pathname, query, hash
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 */
 	constructor(args: object);
 
 	/**
-	 * 
+	 *
 	 * @brief UrlObject 对象构造函数，使用 url 字符串构造
 	 * @param url 指定构造 url 字符串
 	 * @param parseQueryString 指定是否解析 query
 	 * @param slashesDenoteHost  默认为false, 如果设置为true，则从字符串'//'之后到下一个'/'之前的字符串会被解析为host，例如'//foo/bar', 结果应该是{host: 'foo', pathname: '/bar'}而不是{pathname: '//foo/bar'}
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 */
 	constructor(url?: string/** = ""*/, parseQueryString?: boolean/** = false*/, slashesDenoteHost?: boolean/** = false*/);
 
 	/**
-	 * 
+	 *
 	 * @brief 解析一个 url 字符串
 	 * @param url 指定需要解析的 url 字符串
 	 * @param parseQueryString 指定是否解析 query
 	 * @param slashesDenoteHost  默认为false, 如果设置为true，则从字符串'//'之后到下一个'/'之前的字符串会被解析为host，例如'//foo/bar', 结果应该是{host: 'foo', pathname: '/bar'}而不是{pathname: '//foo/bar'}
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 */
 	parse(url: string, parseQueryString?: boolean/** = false*/, slashesDenoteHost?: boolean/** = false*/): void;
 
 	/**
-	 * 
+	 *
 	 * @brief 使用指定的参数构造 UrlObject
 	 * @param args 指定构造参数的字典对象，支持的字段有：protocol, slashes, username, password, hostname, port, pathname, query, hash
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 */
 	format(args: object): void;
 
 	/**
-	 * 
+	 *
 	 * @brief 重定位 url 路径，自动识别新路径为相对路径还是绝对路径
 	 * @param url 指定新的路径
 	 * @return 返回包含重定位数据的对象
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 */
 	resolve(url: string): Class_UrlObject;
 
 	/**
-	 * 
+	 *
 	 * @brief 标准化路径
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
 	 */
 	normalize(): void;
 
diff --git a/types/fibjs/declare/bson.d.ts b/types/fibjs/declare/bson.d.ts
index f9eeab19cb..6c86b3d53d 100644
--- a/types/fibjs/declare/bson.d.ts
+++ b/types/fibjs/declare/bson.d.ts
@@ -7,7 +7,7 @@
  *                                                                         *
  ***************************************************************************/
 
-/** 
+/**
  * @author Richard <richardo2016@gmail.com>
  *
  */
@@ -194,44 +194,43 @@
 
 
 
+declare module __bson {
+
+
+
+
+
+	/**
+	 *
+	 * @brief 以 bson 格式编码变量
+	 * @param data 要编码的变量
+	 * @return 返回编码的二进制数据
+	 *
+	 *
+	 *
+	 */
+	export function encode(data: object): Class_Buffer;
+
+	/**
+	 *
+	 * @brief 以 bson 方式解码字符串为一个变量
+	 * @param data 要解码的二进制数据
+	 * @return 返回解码的变量
+	 *
+	 *
+	 *
+	 */
+	export function decode(data: Class_Buffer): object;
+
+} /** end of `module bson` */
+
 /** module Or Internal Object */
 /**
 	* @brief bson 编码与解码模块
 	* @detail 引用方式：,```JavaScript,var encoding = require('encoding');,var bson = encoding.bson;,```,或者,```JavaScript,var bson = require('bson');,```
 	*/
 declare module "bson" {
-	
-
-	module bson {
-		
-		
-		
-		
-		
-		/**
-		 * 
-		 * @brief 以 bson 格式编码变量
-		 * @param data 要编码的变量
-		 * @return 返回编码的二进制数据
-		 * 
-		 * 
-		 * 
-		 */
-		export function encode(data: object): Class_Buffer;
-	
-		/**
-		 * 
-		 * @brief 以 bson 方式解码字符串为一个变量
-		 * @param data 要解码的二进制数据
-		 * @return 返回解码的变量
-		 * 
-		 * 
-		 * 
-		 */
-		export function decode(data: Class_Buffer): object;
-	
-	} /** end of `module bson` */
-	export = bson
+	export = __bson
 }
 
 /** endof `module Or Internal Object` */
diff --git a/types/fibjs/declare/encoding.d.ts b/types/fibjs/declare/encoding.d.ts
index 86db5533ac..6361ad9203 100644
--- a/types/fibjs/declare/encoding.d.ts
+++ b/types/fibjs/declare/encoding.d.ts
@@ -7,7 +7,7 @@
  *                                                                         *
  ***************************************************************************/
 
-/** 
+/**
  * @author Richard <richardo2016@gmail.com>
  *
  */
@@ -214,129 +214,127 @@
 	* @detail 引用方式：,```JavaScript,var encoding = require('encoding');,```
 	*/
 declare module "encoding" {
-	
+
 	import base32NS = require('base32')
 	import base64NS = require('base64')
 	import base64vlqNS = require('base64vlq')
 	import hexNS = require('hex')
-	import iconvNS = require('iconv')
 	import jsonNS = require('json')
-	import bsonNS = require('bson')
 
 	module encoding {
-		
-		
-		
+
+
+
 		/**
-		 * 
+		 *
 		 * @brief base32 编码与解码模块
-		 * 
-		 * 
+		 *
+		 *
 		 */
-		
+
 		export const base32: typeof base32NS
-		
+
 		/**
-		 * 
+		 *
 		 * @brief base64 编码与解码模块
-		 * 
-		 * 
+		 *
+		 *
 		 */
-		
+
 		export const base64: typeof base64NS
-		
+
 		/**
-		 * 
+		 *
 		 * @brief base64vlq 编码与解码模块
-		 * 
-		 * 
+		 *
+		 *
 		 */
-		
+
 		export const base64vlq: typeof base64vlqNS
-		
+
 		/**
-		 * 
+		 *
 		 * @brief hex 编码与解码模块
-		 * 
-		 * 
+		 *
+		 *
 		 */
-		
+
 		export const hex: typeof hexNS
-		
+
 		/**
-		 * 
+		 *
 		 * @brief iconv 编码与解码模块
-		 * 
-		 * 
+		 *
+		 *
 		 */
-		
-		export const iconv: typeof iconvNS
-		
+
+		export const iconv: typeof __iconv
+
 		/**
-		 * 
+		 *
 		 * @brief json 编码与解码模块
-		 * 
-		 * 
+		 *
+		 *
 		 */
-		
+
 		export const json: typeof jsonNS
-		
+
 		/**
-		 * 
+		 *
 		 * @brief bson 编码与解码模块
-		 * 
-		 * 
+		 *
+		 *
 		 */
-		
-		export const bson: typeof bsonNS
-		
-		
-		
+
+		export const bson: typeof __bson
+
+
+
 		/**
-		 * 
+		 *
 		 * @brief 将字符串编码为 javascript 转义字符串，用以在 javascript 代码中包含文本
 		 * @param str 要编码的字符串
 		 * @param json 是否生成json兼容字符串
 		 * @return 返回编码的字符串
-		 * 
-		 * 
-		 * 
+		 *
+		 *
+		 *
 		 */
 		export function jsstr(str: string, json?: boolean/** = false*/): string;
-	
+
 		/**
-		 * 
+		 *
 		 * @brief url 字符串安全编码
 		 * @param url 要编码的 url
 		 * @return 返回编码的字符串
-		 * 
-		 * 
-		 * 
+		 *
+		 *
+		 *
 		 */
 		export function encodeURI(url: string): string;
-	
+
 		/**
-		 * 
+		 *
 		 * @brief url 部件字符串安全编码
 		 * @param url 要编码的 url
 		 * @return 返回编码的字符串
-		 * 
-		 * 
-		 * 
+		 *
+		 *
+		 *
 		 */
 		export function encodeURIComponent(url: string): string;
-	
+
 		/**
-		 * 
+		 *
 		 * @brief url 安全字符串解码
 		 * @param url 要解码的 url
 		 * @return 返回解码的字符串
-		 * 
-		 * 
-		 * 
+		 *
+		 *
+		 *
 		 */
 		export function decodeURI(url: string): string;
-	
+
 	} /** end of `module encoding` */
 	export = encoding
 }
diff --git a/types/fibjs/declare/iconv.d.ts b/types/fibjs/declare/iconv.d.ts
index 443ae25e21..86d581fbf3 100644
--- a/types/fibjs/declare/iconv.d.ts
+++ b/types/fibjs/declare/iconv.d.ts
@@ -7,7 +7,7 @@
  *                                                                         *
  ***************************************************************************/
 
-/** 
+/**
  * @author Richard <richardo2016@gmail.com>
  *
  */
@@ -194,57 +194,49 @@
 
 
 
+declare module __iconv {
+	/**
+	 *
+	 * @brief 用 iconv 将文本转换为二进制数据
+	 * @param charset 指定字符集
+	 * @param data 要转换的文本
+	 * @return 返回解码的二进制数据
+	 *
+	 *
+	 *
+	 */
+	export function encode(charset: string, data: string): Class_Buffer;
+
+	/**
+	 *
+	 * @brief 用 iconv 将 Buffer 内容转换为文本
+	 * @param charset 指定字符集
+	 * @param data 要转换的二进制数据
+	 * @return 返回编码的字符串
+	 *
+	 *
+	 *
+	 */
+	export function decode(charset: string, data: Class_Buffer): string;
+
+	/**
+	 *
+	 * @brief 检测字符集是否被支持
+	 * @param charset 指定字符集
+	 * @return 返回是否支持该字符集
+	 *
+	 *
+	 *
+	 */
+	export function isEncoding(charset: string): boolean;
+} /** end of `module iconv` */
 /** module Or Internal Object */
 /**
 	* @brief iconv 编码与解码模块
 	* @detail 引用方式：,```JavaScript,var encoding = require('encoding');,var iconv = encoding.iconv;,```,或者,```JavaScript,var iconv = require('iconv');,```
 	*/
 declare module "iconv" {
-	
-
-	module iconv {
-		
-		
-		
-		
-		
-		/**
-		 * 
-		 * @brief 用 iconv 将文本转换为二进制数据
-		 * @param charset 指定字符集
-		 * @param data 要转换的文本
-		 * @return 返回解码的二进制数据
-		 * 
-		 * 
-		 * 
-		 */
-		export function encode(charset: string, data: string): Class_Buffer;
-	
-		/**
-		 * 
-		 * @brief 用 iconv 将 Buffer 内容转换为文本
-		 * @param charset 指定字符集
-		 * @param data 要转换的二进制数据
-		 * @return 返回编码的字符串
-		 * 
-		 * 
-		 * 
-		 */
-		export function decode(charset: string, data: Class_Buffer): string;
-	
-		/**
-		 * 
-		 * @brief 检测字符集是否被支持
-		 * @param charset 指定字符集
-		 * @return 返回是否支持该字符集
-		 * 
-		 * 
-		 * 
-		 */
-		export function isEncoding(charset: string): boolean;
-	
-	} /** end of `module iconv` */
-	export = iconv
+	export = __iconv
 }
 
 /** endof `module Or Internal Object` */
diff --git a/types/fibjs/declare/index.d.ts b/types/fibjs/declare/index.d.ts
index df0e02e683..1d26b1b8c7 100644
--- a/types/fibjs/declare/index.d.ts
+++ b/types/fibjs/declare/index.d.ts
@@ -7,7 +7,7 @@
  *                                                                         *
  ***************************************************************************/
 
-/** 
+/**
  * @author Richard <richardo2016@gmail.com>
  *
  */
@@ -63,8 +63,8 @@
 /// <reference path="xml.d.ts" />
 /// <reference path="constants.d.ts" />
 
-import _Global from 'global';
-import _Process from 'process';
+import _Global = require('global');
+import _Process = require('process');
 
 type GlobalExportsType = any;
 interface ModuleType {
diff --git a/types/fibjs/fibjs-tests.ts b/types/fibjs/fibjs-tests.ts
index 90b5f5ff6c..5d159b219b 100644
--- a/types/fibjs/fibjs-tests.ts
+++ b/types/fibjs/fibjs-tests.ts
@@ -1,8 +1,8 @@
-import assert = require('assert');
+// import assert = require('assert');  // TODO: this brings in ../types/assert
 import base32 = require('base32');
 import base64 = require('base64');
 import base64vlq = require('base64vlq');
-import bson = require('bson');
+// import bson = require('bson'); // TODO: this brings in ../types/bson
 import console = require('console');
 import constants = require('constants');
 import coroutine = require('coroutine');
@@ -18,7 +18,7 @@ import gui = require('gui');
 import hash = require('hash');
 import hex = require('hex');
 import http = require('http');
-import iconv = require('iconv');
+// import iconv = require('iconv'); // TODO: this brings in ../types/iconv
 import io = require('io');
 import json = require('json');
 import mq = require('mq');
@@ -39,10 +39,10 @@ import timers = require('timers');
 import tty = require('tty');
 import url = require('url');
 import util = require('util');
-import uuid = require('uuid');
+// import uuid = require('uuid');  // TODO: this brings in ../types/uuid
 import vm = require('vm');
-import ws = require('ws');
-import xml = require('xml');
+// import ws = require('ws'); // TODO: this brings in ../types/ws
+// import xml = require('xml'); // TODO: this brings in ../types/xml
 import zip = require('zip');
 import zlib = require('zlib');
-import zmq = require('zmq');
+// import zmq = require('zmq'); // TODO: this brings in ../types/zmq
diff --git a/types/fibjs/index.d.ts b/types/fibjs/index.d.ts
index 02201fd904..0be3f7bc29 100644
--- a/types/fibjs/index.d.ts
+++ b/types/fibjs/index.d.ts
@@ -2,5 +2,6 @@
 // Project: https://github.com/fibjs/fibjs
 // Definitions by: richardo2016 <https://github.com/richardo2016>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 /// <reference path="declare/index.d.ts" />
diff --git a/types/fibjs/tslint.json b/types/fibjs/tslint.json
index 3db14f85ea..f398172337 100644
--- a/types/fibjs/tslint.json
+++ b/types/fibjs/tslint.json
@@ -1 +1,19 @@
-{ "extends": "dtslint/dt.json" }
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        // All are TODOs
+        "ban-types": false,
+        "max-line-length": false,
+        "no-consecutive-blank-lines": false,
+        "no-internal-module": false,
+        "no-padding": false,
+        "no-redundant-jsdoc-2": false,
+        "no-single-declare-module": false,
+        "no-trailing-whitespace": false,
+        "jsdoc-format": false,
+        "semicolon": false,
+        "strict-export-declare-modifiers": false,
+        "trim-file": false,
+        "unified-signatures": false
+    }
+}
diff --git a/types/firefox-webext-browser/index.d.ts b/types/firefox-webext-browser/index.d.ts
index 3a0bbc6a4c..2497d3b53d 100644
--- a/types/firefox-webext-browser/index.d.ts
+++ b/types/firefox-webext-browser/index.d.ts
@@ -5890,7 +5890,7 @@ declare namespace browser.contextMenus {
         /** A list of all contexts that apply to the menu. */
         contexts: ContextType[];
         editable: boolean;
-        mediaType: string;
+        mediaType?: string;
         linkUrl?: string;
         linkText?: string;
         srcUrl?: string;
@@ -6131,7 +6131,7 @@ declare namespace browser.menus {
         /** A list of all contexts that apply to the menu. */
         contexts: ContextType[];
         editable: boolean;
-        mediaType: string;
+        mediaType?: string;
         linkUrl?: string;
         linkText?: string;
         srcUrl?: string;
diff --git a/types/gitlab/tslint.json b/types/gitlab/tslint.json
index 3db14f85ea..4d35d29327 100644
--- a/types/gitlab/tslint.json
+++ b/types/gitlab/tslint.json
@@ -1 +1,14 @@
-{ "extends": "dtslint/dt.json" }
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        // All are TODOs
+        "ban-types": false,
+        "interface-name": false,
+        "no-consecutive-blank-lines": false,
+        "no-padding": false,
+        "one-line": false,
+        "semicolon": false,
+        "strict-export-declare-modifiers": false,
+        "whitespace": false
+    }
+}
diff --git a/types/google-adwords-scripts/index.d.ts b/types/google-adwords-scripts/index.d.ts
index adf58cb4a4..5e71857a3a 100644
--- a/types/google-adwords-scripts/index.d.ts
+++ b/types/google-adwords-scripts/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/jafaircl/gaws
 // Definitions by: Jonathan Faircloth <https://github.com/jafaircl>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 /// <reference types="google-apps-script" />
 
diff --git a/types/google-apps-script/apis/slides/v1.d.ts b/types/google-apps-script/apis/slides/v1.d.ts
index 28f2f31a7d..078c510a68 100644
--- a/types/google-apps-script/apis/slides/v1.d.ts
+++ b/types/google-apps-script/apis/slides/v1.d.ts
@@ -3,8 +3,6 @@
 // Definitions by: grant <https://github.com/grant/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference path="../../google-apps-script.types.d.ts" />
-
 declare namespace GoogleAppsScript {
   export module Slides_v1 {
     //// FILE: color.proto ////
@@ -804,7 +802,7 @@ declare namespace GoogleAppsScript {
       // File Formats - Fundamentals and Markup Language Reference", part 1 of
       // [ECMA-376 4th
       // edition](http://www.ecma-international.org/publications/standards/Ecma-376.htm).
-      
+
       // The type of the shape.
       shape_type: ShapeType
       // The text content of the shape.
diff --git a/types/google-apps-script/index.d.ts b/types/google-apps-script/index.d.ts
index 4b4436fcf4..ae463c738b 100644
--- a/types/google-apps-script/index.d.ts
+++ b/types/google-apps-script/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://developers.google.com/apps-script/
 // Definitions by: motemen <https://github.com/motemen>, grant <https://github.com/grant>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 // Base Types
 /// <reference path="google-apps-script.base.d.ts"/>
diff --git a/types/googlemaps/index.d.ts b/types/googlemaps/index.d.ts
index 722a2ff819..322c29c8dc 100644
--- a/types/googlemaps/index.d.ts
+++ b/types/googlemaps/index.d.ts
@@ -2613,6 +2613,7 @@ declare namespace google.maps {
       strictBounds?: boolean;
       types?: string[];
       type?: string;
+      fields?: string[];
     }
 
     export interface AutocompletePrediction {
diff --git a/types/graphql-date/index.d.ts b/types/graphql-date/index.d.ts
index 4615d424a1..009adebff9 100644
--- a/types/graphql-date/index.d.ts
+++ b/types/graphql-date/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/tjmehta/graphql-date
 // Definitions by: Eric Naeseth <https://github.com/enaeseth>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.6
 
 import { GraphQLScalarType } from 'graphql';
 
diff --git a/types/graphql-date/tsconfig.json b/types/graphql-date/tsconfig.json
index c55674e246..1db1103639 100644
--- a/types/graphql-date/tsconfig.json
+++ b/types/graphql-date/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "esnext.asynciterable"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/graphql-depth-limit/tsconfig.json b/types/graphql-depth-limit/tsconfig.json
index 5c59137102..cde0c3a496 100644
--- a/types/graphql-depth-limit/tsconfig.json
+++ b/types/graphql-depth-limit/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "esnext.asynciterable"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/graphql-iso-date/index.d.ts b/types/graphql-iso-date/index.d.ts
index 7f0731478e..24283e3d2f 100644
--- a/types/graphql-iso-date/index.d.ts
+++ b/types/graphql-iso-date/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/excitement-engineer/graphql-iso-date
 // Definitions by: Jason Waldrip <https://github.com/jwaldrip>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.6
 
 import { GraphQLScalarType } from "graphql";
 
diff --git a/types/graphql-iso-date/tsconfig.json b/types/graphql-iso-date/tsconfig.json
index 1ea5d6fc91..09350f27bb 100644
--- a/types/graphql-iso-date/tsconfig.json
+++ b/types/graphql-iso-date/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "esnext.asynciterable"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/graphql-list-fields/index.d.ts b/types/graphql-list-fields/index.d.ts
index 362658deb9..b20bf869d6 100644
--- a/types/graphql-list-fields/index.d.ts
+++ b/types/graphql-list-fields/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/jakepusateri/graphql-list-fields#readme
 // Definitions by: Chris Filipowski <https://github.com/filipows>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.6
 
 import { GraphQLResolveInfo } from "graphql";
 
diff --git a/types/graphql-list-fields/tsconfig.json b/types/graphql-list-fields/tsconfig.json
index 6f53c2c900..2f79913620 100644
--- a/types/graphql-list-fields/tsconfig.json
+++ b/types/graphql-list-fields/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "esnext.asynciterable"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/graphql-query-complexity/index.d.ts b/types/graphql-query-complexity/index.d.ts
index 4c5954fb4f..ba34b4f4e2 100644
--- a/types/graphql-query-complexity/index.d.ts
+++ b/types/graphql-query-complexity/index.d.ts
@@ -2,6 +2,6 @@
 // Project: https://github.com/ivome/graphql-query-complexity
 // Definitions by: Abhik Mitra <https://github.com/abhikmitra>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.6
 import createQueryComplexityValidator from "./dist";
 export default createQueryComplexityValidator;
diff --git a/types/graphql-query-complexity/tsconfig.json b/types/graphql-query-complexity/tsconfig.json
index d706752c48..4dcc6586aa 100644
--- a/types/graphql-query-complexity/tsconfig.json
+++ b/types/graphql-query-complexity/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "esnext.asynciterable"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/graphql-relay/index.d.ts b/types/graphql-relay/index.d.ts
index 87634b98c9..d4bba06948 100644
--- a/types/graphql-relay/index.d.ts
+++ b/types/graphql-relay/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/graphql/graphql-relay-js
 // Definitions by: Arvitaly <https://github.com/arvitaly>, nitintutlani <https://github.com/nitintutlani>, Grelinfo <https://github.com/Grelinfo>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.6
 
 import {
     GraphQLBoolean,
diff --git a/types/graphql-relay/tsconfig.json b/types/graphql-relay/tsconfig.json
index bf5b3ba6b6..f10d183985 100644
--- a/types/graphql-relay/tsconfig.json
+++ b/types/graphql-relay/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "esnext.asynciterable"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/graphql-resolve-batch/index.d.ts b/types/graphql-resolve-batch/index.d.ts
index 9908b7082a..2baa60d248 100644
--- a/types/graphql-resolve-batch/index.d.ts
+++ b/types/graphql-resolve-batch/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/calebmer/graphql-resolve-batch#readme
 // Definitions by: Rutger Hendrickx <https://github.com/nayni>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.6
 
 import { GraphQLResolveInfo } from 'graphql';
 
diff --git a/types/graphql-resolve-batch/tsconfig.json b/types/graphql-resolve-batch/tsconfig.json
index aa4ad6661d..ef3f8a1dc8 100644
--- a/types/graphql-resolve-batch/tsconfig.json
+++ b/types/graphql-resolve-batch/tsconfig.json
@@ -1,7 +1,7 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": ["es6"],
+        "lib": ["es6", "esnext.asynciterable"],
         "strictFunctionTypes": true,
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/graphql-type-json/index.d.ts b/types/graphql-type-json/index.d.ts
index 2b10599e0e..a6a8ec87ee 100644
--- a/types/graphql-type-json/index.d.ts
+++ b/types/graphql-type-json/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/taion/graphql-type-json#readme
 // Definitions by: Pavel Ivanov <https://github.com/schfkt>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.6
 
 import { GraphQLScalarType } from "graphql";
 
diff --git a/types/graphql-type-json/tsconfig.json b/types/graphql-type-json/tsconfig.json
index 479196f574..e0bed0c4f7 100644
--- a/types/graphql-type-json/tsconfig.json
+++ b/types/graphql-type-json/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "esnext.asynciterable"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/graphql/index.d.ts b/types/graphql/index.d.ts
index 26c32e3f8a..0b87d35222 100644
--- a/types/graphql/index.d.ts
+++ b/types/graphql/index.d.ts
@@ -17,7 +17,7 @@
 //                 Curtis Layne <https://github.com/clayne11>
 //                 Jonathan Cardoso <https://github.com/JCMais>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.6
 
 // The primary entry point into fulfilling a GraphQL request.
 export { graphql, graphqlSync, GraphQLArgs } from "./graphql";
diff --git a/types/graphql/tslint.json b/types/graphql/tslint.json
index 2750cc0197..9e6ea4e366 100644
--- a/types/graphql/tslint.json
+++ b/types/graphql/tslint.json
@@ -1 +1,20 @@
-{ "extends": "dtslint/dt.json" }
\ No newline at end of file
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        // All are TODOs
+        "array-type": false,
+        "interface-over-type-literal": false,
+        "jsdoc-format": false,
+        "no-any-union": false,
+        "no-consecutive-blank-lines": false,
+        "no-duplicate-imports": false,
+        "no-empty-interface": false,
+        "no-redundant-undefined": false,
+        "no-unnecessary-generics": false,
+        "semicolon": false,
+        "strict-export-declare-modifiers": false,
+        "unified-signatures": false,
+        "use-default-type-parameter": false,
+        "void-return": false
+    }
+}
diff --git a/types/gsap/tslint.json b/types/gsap/tslint.json
index 6d192e7cef..9081f7897d 100644
--- a/types/gsap/tslint.json
+++ b/types/gsap/tslint.json
@@ -1,9 +1,16 @@
 {
     "extends": "dtslint/dt.json",
     "rules": {
-        // TODOs
+        // All are TODOs
         "dt-header": false,
+        "jsdoc-format": false,
+        "max-line-length": false,
+        "no-consecutive-blank-lines": false,
         "no-declare-current-package": false,
-        "no-single-declare-module": false
+        "no-padding": false,
+        "no-single-declare-module": false,
+        "no-unnecessary-class": false,
+        "no-var-keyword": false,
+        "strict-export-declare-modifiers": false
     }
 }
diff --git a/types/gulp-connect/index.d.ts b/types/gulp-connect/index.d.ts
index b8b1a467f9..03537e62e1 100644
--- a/types/gulp-connect/index.d.ts
+++ b/types/gulp-connect/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/avevlad/gulp-connect#readme
 // Definitions by: Andre Wiggins <https://github.com/andrewiggins>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.2
+// TypeScript Version: 2.3
 
 import * as http from "http";
 import * as https from "https";
diff --git a/types/gulp-filter/index.d.ts b/types/gulp-filter/index.d.ts
index ba95977024..ae59b2bdb4 100644
--- a/types/gulp-filter/index.d.ts
+++ b/types/gulp-filter/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/sindresorhus/gulp-filter
 // Definitions by: Tanguy Krotoff <https://github.com/tkrotoff>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 /// <reference types="node" />
 
diff --git a/types/gulp-filter/tsconfig.json b/types/gulp-filter/tsconfig.json
index 43ae1fe5c5..b009c4b2ad 100644
--- a/types/gulp-filter/tsconfig.json
+++ b/types/gulp-filter/tsconfig.json
@@ -14,10 +14,7 @@
         ],
         "types": [],
         "noEmit": true,
-        "forceConsistentCasingInFileNames": true,
-        "paths": {
-            "uglify-js": ["uglify-js/v2"]
-        }
+        "forceConsistentCasingInFileNames": true
     },
     "files": [
         "index.d.ts",
diff --git a/types/gulp-rev-replace/index.d.ts b/types/gulp-rev-replace/index.d.ts
index 322604bf1d..b385d579a9 100644
--- a/types/gulp-rev-replace/index.d.ts
+++ b/types/gulp-rev-replace/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/jamesknelson/gulp-rev-replace
 // Definitions by: Tanguy Krotoff <https://github.com/tkrotoff>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 /// <reference types="node" />
 
diff --git a/types/gulp-rev-replace/tsconfig.json b/types/gulp-rev-replace/tsconfig.json
index dfef77b20b..d6b9abe0ba 100644
--- a/types/gulp-rev-replace/tsconfig.json
+++ b/types/gulp-rev-replace/tsconfig.json
@@ -14,12 +14,7 @@
         ],
         "types": [],
         "noEmit": true,
-        "forceConsistentCasingInFileNames": true,
-        "paths": {
-            "uglify-js": [
-                "uglify-js/v2"
-            ]
-        }
+        "forceConsistentCasingInFileNames": true
     },
     "files": [
         "index.d.ts",
diff --git a/types/gulp-svg-sprite/index.d.ts b/types/gulp-svg-sprite/index.d.ts
index 61c7b03f31..28c9240375 100644
--- a/types/gulp-svg-sprite/index.d.ts
+++ b/types/gulp-svg-sprite/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/jkphl/gulp-svg-sprite
 // Definitions by: Qubo <https://github.com/tkqubo>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 /// <reference types="node" />
 
diff --git a/types/gulp-uglify/index.d.ts b/types/gulp-uglify/index.d.ts
index 823ce28e67..4dc340aa18 100644
--- a/types/gulp-uglify/index.d.ts
+++ b/types/gulp-uglify/index.d.ts
@@ -3,6 +3,7 @@
 // Definitions by: Christopher Haws <https://github.com/ChristopherHaws>
 //                 Leonard Thieu <https://github.com/leonard-thieu>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 /// <reference types="node"/>
 
@@ -13,17 +14,17 @@ declare namespace GulpUglify {
         /**
          * Pass false to skip mangling names.
          */
-        mangle?: boolean;
+        mangle?: UglifyJS.MangleOptions | boolean;
 
         /**
          * Pass if you wish to specify additional output options. The defaults are optimized for best compression.
          */
-        output?: UglifyJS.BeautifierOptions;
+        output?: UglifyJS.OutputOptions;
 
         /**
          * Pass an object to specify custom compressor options. Pass false to skip compression completely.
          */
-        compress?: UglifyJS.CompressorOptions | boolean;
+        compress?: UglifyJS.CompressOptions | boolean;
     }
 }
 
diff --git a/types/gulp-uglify/tsconfig.json b/types/gulp-uglify/tsconfig.json
index 70663fcc71..b759e9fc57 100644
--- a/types/gulp-uglify/tsconfig.json
+++ b/types/gulp-uglify/tsconfig.json
@@ -14,12 +14,7 @@
         ],
         "types": [],
         "noEmit": true,
-        "forceConsistentCasingInFileNames": true,
-        "paths": {
-            "uglify-js": [
-                "uglify-js/v2"
-            ]
-        }
+        "forceConsistentCasingInFileNames": true
     },
     "files": [
         "index.d.ts",
diff --git a/types/gulp-useref/index.d.ts b/types/gulp-useref/index.d.ts
index ba95c68308..36cd0ddc24 100644
--- a/types/gulp-useref/index.d.ts
+++ b/types/gulp-useref/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/jonkemp/gulp-useref
 // Definitions by: Tanguy Krotoff <https://github.com/tkrotoff>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 /// <reference types="node" />
 
diff --git a/types/gulp-useref/tsconfig.json b/types/gulp-useref/tsconfig.json
index f3867032fa..b8a3dc7bba 100644
--- a/types/gulp-useref/tsconfig.json
+++ b/types/gulp-useref/tsconfig.json
@@ -14,10 +14,7 @@
         ],
         "types": [],
         "noEmit": true,
-        "forceConsistentCasingInFileNames": true,
-        "paths": {
-            "uglify-js": ["uglify-js/v2"]
-        }
+        "forceConsistentCasingInFileNames": true
     },
     "files": [
         "index.d.ts",
diff --git a/types/history/DOMUtils.d.ts b/types/history/DOMUtils.d.ts
index 7ec86d00c9..180bbdcbeb 100644
--- a/types/history/DOMUtils.d.ts
+++ b/types/history/DOMUtils.d.ts
@@ -1,6 +1,13 @@
+declare global {
+    // Some users of this package are don't use "dom" libs
+    interface EventTarget {}
+    interface EventListener {}
+    interface EventListenerObject {}
+}
+
 export const isExtraneousPopstateEvent: boolean;
-export function addEventListener(node: EventTarget, event: string, listener: EventListenerOrEventListenerObject): void;
-export function removeEventListener(node: EventTarget, event: string, listener: EventListenerOrEventListenerObject): void;
+export function addEventListener(node: EventTarget, event: string, listener: EventListener | EventListenerObject): void;
+export function removeEventListener(node: EventTarget, event: string, listener: EventListener | EventListenerObject): void;
 export function getConfirmation(message: string, callback: (result: boolean) => void): void;
 export function supportsHistory(): boolean;
 export function supportsGoWithoutReloadUsingHash(): boolean;
diff --git a/types/host-validation/host-validation-tests.ts b/types/host-validation/host-validation-tests.ts
new file mode 100644
index 0000000000..a025432416
--- /dev/null
+++ b/types/host-validation/host-validation-tests.ts
@@ -0,0 +1,73 @@
+// Copyright (c) 2018 Brannon Dorsey <brannon@brannondorsey.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+import * as express from 'express';
+import * as hostValidation from 'host-validation';
+
+const app = express();
+
+// allow development hosts, a domain name, and a regex for all subdomains
+// host can accept strings or regular expressions
+app.use(hostValidation({ hosts: ['127.0.0.1:3000',
+        'localhost:3000',
+        'mydomain.com',
+		/.*\.mydomain\.com/] }));
+
+// referer headers can accept strings or regular expressions
+app.use(hostValidation({ referers: ['http://trusted-site.com/login.php',
+		/^http:\/\/othersite\.com\/login\/.*/] }));
+
+// only accept POSTs from HTTPS referrers
+app.use(hostValidation({ referers: [/^https:\/\//]}));
+
+// you can include both host and referer values in the config
+// by default, only requests that match BOTH Host and Referer values will be allowed
+app.use(hostValidation({ hosts: ['trusted-host.com'],
+		referers: ['https://trusted-host.com/login.php'] }));
+
+// you can use the { mode: 'either' } value in the config accept requests that match
+// either the hosts or the referers requirements. Accepted values for mode include
+// 'both' and 'either'. The default value is 'both' if none is specified.
+app.use(hostValidation({ hosts: ['trusted-host.com'],
+        referers: ['https://trusted-host.com/login.php'],
+		mode: 'either' }));
+
+// route-specific rules can be specified like any Express.js middleware
+app.use('/login', hostValidation({ hosts: ['trusted-host.com'] }));
+app.use('/from-twitter', hostValidation({ referers: [/^https:\/\/twitter.com\//] }));
+
+// Add a custom error handler that's run when host or referer validation fails.
+// This function overwrites the default behavior of responding to failed requests
+// with a 403 Forbidden error.
+app.use('/brew-tea', hostValidation({
+	hosts: ['office-teapot'],
+	fail: (req, res, next) => {
+        // send a 418 "I'm a Teapot" Error
+		res.status(418).send('I\'m the office teapot. Refer to me only as such.');
+	}
+}));
+
+app.get('/', (req, res) => {
+    res.send('Hello trusted client, thanks for including 127.0.0.1 in your Host header.');
+});
+
+app.listen(3000, () => {
+    console.log('server allowing HTTP requests from 127.0.0.1 on port 3000');
+});
diff --git a/types/host-validation/index.d.ts b/types/host-validation/index.d.ts
new file mode 100644
index 0000000000..7dfc66b559
--- /dev/null
+++ b/types/host-validation/index.d.ts
@@ -0,0 +1,21 @@
+// Type definitions for host-validation 2.0
+// Project: https://github.com/brannondorsey/host-validation
+// Definitions by: Rich Liu <https://github.com/dintopple>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+import { Request, Response, NextFunction } from 'express';
+
+declare namespace hostValidation {
+    interface config {
+        hosts?: Array<string|RegExp>;
+        referers?: Array<string|RegExp>;
+        mode?: 'both' | 'either';
+        fail?(req: Request, res: Response, next: NextFunction): void;
+    }
+}
+
+declare function hostValidation(opts: hostValidation.config):
+    (req: Request, res: Response, next: NextFunction) => void;
+
+export = hostValidation;
diff --git a/types/host-validation/tsconfig.json b/types/host-validation/tsconfig.json
new file mode 100644
index 0000000000..af2a26a4fb
--- /dev/null
+++ b/types/host-validation/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "host-validation-tests.ts"
+    ]
+}
diff --git a/types/host-validation/tslint.json b/types/host-validation/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/host-validation/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/html-minifier/v1/index.d.ts b/types/html-minifier/v1/index.d.ts
index 0bf9e2ae7f..c1ff944e7e 100644
--- a/types/html-minifier/v1/index.d.ts
+++ b/types/html-minifier/v1/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/kangax/html-minifier
 // Definitions by: Tanguy Krotoff <https://github.com/tkrotoff>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 /// <reference types="uglify-js" />
 
diff --git a/types/http-proxy-agent/http-proxy-agent-tests.ts b/types/http-proxy-agent/http-proxy-agent-tests.ts
index f730cd1bde..2158a9129f 100644
--- a/types/http-proxy-agent/http-proxy-agent-tests.ts
+++ b/types/http-proxy-agent/http-proxy-agent-tests.ts
@@ -5,6 +5,9 @@ new Agent('url');
 new Agent({});
 new Agent({ host: 'url' });
 
+new Agent({}).proxy;
+new Agent({}).secureProxy;
+
 // $ExpectError
 new Agent();
 
diff --git a/types/http-proxy-agent/index.d.ts b/types/http-proxy-agent/index.d.ts
index 015508b5d1..b518fddf0c 100644
--- a/types/http-proxy-agent/index.d.ts
+++ b/types/http-proxy-agent/index.d.ts
@@ -1,6 +1,7 @@
 // Type definitions for http-proxy-agent 2.0
 // Project: https://github.com/TooTallNate/node-http-proxy-agent
 // Definitions by: mrmlnc <https://github.com/mrmlnc>
+//                 steprescott <https://github.com/steprescott>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /// <reference types="node"/>
@@ -10,6 +11,9 @@ import { Url } from 'url';
 
 declare class HttpProxyAgent extends Agent {
     constructor(options: string | Url);
+
+    proxy: Url;
+    secureProxy: boolean;
 }
 
 export = HttpProxyAgent;
diff --git a/types/i18n-abide/i18n-abide-tests.ts b/types/i18n-abide/i18n-abide-tests.ts
new file mode 100644
index 0000000000..6e95f52475
--- /dev/null
+++ b/types/i18n-abide/i18n-abide-tests.ts
@@ -0,0 +1,38 @@
+import * as i18n from 'i18n-abide';
+
+const emptyAbideOptions: i18n.AbideOptions = {};
+const fullAbideOptions: i18n.AbideOptions = {
+    gettext_alias: 'gettext',
+    supported_languages: ['en-US'],
+    default_lang: 'en-US',
+    debug_lang: 'it-CH',
+    disable_locale_check: false,
+    translation_directory: 'l18n/',
+    logger: { warn(msg: string) {}, error(msg: string) {} },
+};
+
+i18n.abide(); // $ExpectType RequestHandler
+i18n.abide(emptyAbideOptions); // $ExpectType RequestHandler
+i18n.abide(fullAbideOptions); // $ExpectType RequestHandler
+
+i18n.parseAcceptLanguage(""); // $ExpectType { lang: string; quality: number; }[]
+
+i18n.bestLanguage([{lang: 'en-US', quality: 1.0}], ['en-US'], 'en-US'); // $ExpectType string
+
+i18n.localeFrom(); // $ExpectType string
+i18n.localeFrom(""); // $ExpectType string
+
+i18n.languageFrom(); // $ExpectType string
+i18n.languageFrom(""); // $ExpectType string
+
+i18n.normalizeLanguage(); // $ExpectType string
+i18n.normalizeLanguage(""); // $ExpectType string
+
+i18n.normalizeLocale(); // $ExpectType string
+i18n.normalizeLocale(""); // $ExpectType string
+
+i18n.format(""); // $ExpectType string
+i18n.format("", {}); // $ExpectType string
+i18n.format("", {}, false); // $ExpectType string
+
+i18n.getLocales(); // $ExpectType string[]
diff --git a/types/i18n-abide/index.d.ts b/types/i18n-abide/index.d.ts
new file mode 100644
index 0000000000..9f824b695b
--- /dev/null
+++ b/types/i18n-abide/index.d.ts
@@ -0,0 +1,27 @@
+// Type definitions for i18n-abide 0.0
+// Project: https://github.com/mozilla/i18n-abide
+// Definitions by: Steven Bell <https://github.com/smbell>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
+
+import { RequestHandler } from 'express';
+
+export function abide(options?: AbideOptions): RequestHandler;
+export function parseAcceptLanguage(header?: string): Array<{ lang: string, quality: number }>;
+export function bestLanguage(languages: Array<{ lang: string, quality: number}>, supported_languages: string[], defaultLanguage: string): string;
+export function localeFrom(language?: string): string;
+export function languageFrom(locale?: string): string;
+export function normalizeLanguage(language?: string): string;
+export function normalizeLocale(locale?: string): string;
+export function format(fmt: string, obj?: any, named?: boolean): string;
+export function getLocales(): string[];
+
+export interface AbideOptions {
+    gettext_alias?: string;
+    supported_languages?: string[];
+    default_lang?: string;
+    debug_lang?: string;
+    disable_locale_check?: boolean;
+    translation_directory?: string;
+    logger?: { warn(msg: string): void, error(msg: string): void };
+}
diff --git a/types/i18n-abide/tsconfig.json b/types/i18n-abide/tsconfig.json
new file mode 100644
index 0000000000..43310061aa
--- /dev/null
+++ b/types/i18n-abide/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "i18n-abide-tests.ts"
+    ]
+}
diff --git a/types/i18n-abide/tslint.json b/types/i18n-abide/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/i18n-abide/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/i18next-ko/tsconfig.json b/types/i18next-ko/tsconfig.json
index 9509fa509e..cded42ee92 100644
--- a/types/i18next-ko/tsconfig.json
+++ b/types/i18next-ko/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/i18next/index.d.ts b/types/i18next/index.d.ts
index 0f4e4abf60..84433c26ec 100644
--- a/types/i18next/index.d.ts
+++ b/types/i18next/index.d.ts
@@ -5,6 +5,7 @@
 //                 Giedrius Grabauskas <https://github.com/GiedriusGrabauskas>
 //                 Silas Rech <https://github.com/lenovouser>
 //                 Philipp Katz <https://github.com/qqilihq>
+//                 Milan Konir <https://github.com/butchyyyy>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
@@ -385,6 +386,12 @@ declare namespace i18next {
          * Compatibility JSON version
          */
         compatibilityJSON?: string;
+
+        /**
+         * options for i18n nessage format - check documentation of plugin
+         * @default undefined
+         */
+        i18nFormat?: object;
     }
 
     // Add an indexer to assure that interpolation arguments can be passed
diff --git a/types/i2c-bus/index.d.ts b/types/i2c-bus/index.d.ts
index ebb06e83ae..188210653a 100644
--- a/types/i2c-bus/index.d.ts
+++ b/types/i2c-bus/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/fivdi/i2c-bus
 // Definitions by: Jason Heard <https://github.com/101100>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
+// TypeScript Version: 2.3
 
 /// <reference types="node" />
 
diff --git a/types/iltorb/tsconfig.json b/types/iltorb/tsconfig.json
index 6c079ff3f7..afe875d6a2 100644
--- a/types/iltorb/tsconfig.json
+++ b/types/iltorb/tsconfig.json
@@ -2,7 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es5"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/image-type/image-type-tests.ts b/types/image-type/image-type-tests.ts
new file mode 100644
index 0000000000..ea9951d6f2
--- /dev/null
+++ b/types/image-type/image-type-tests.ts
@@ -0,0 +1,4 @@
+import imageType = require('file-type');
+
+imageType(new Buffer([0xFF, 0xD8, 0xFF]));
+imageType(new Uint8Array([0xFF, 0xD8, 0xFF]));
diff --git a/types/image-type/index.d.ts b/types/image-type/index.d.ts
new file mode 100644
index 0000000000..2c5abcfd87
--- /dev/null
+++ b/types/image-type/index.d.ts
@@ -0,0 +1,12 @@
+// Type definitions for image-type 3.0
+// Project: https://github.com/sindresorhus/image-type#readme
+// Definitions by: Florian Keller <https://github.com/ffflorian>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="node" />
+
+import FileType = require('file-type');
+
+declare function ImageType(buf: Buffer | Uint8Array): FileType.FileTypeResult | null;
+
+export = ImageType;
diff --git a/types/image-type/tsconfig.json b/types/image-type/tsconfig.json
new file mode 100644
index 0000000000..2c7c57ebba
--- /dev/null
+++ b/types/image-type/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "image-type-tests.ts"
+    ]
+}
diff --git a/types/image-type/tslint.json b/types/image-type/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/image-type/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/intercom-client/index.d.ts b/types/intercom-client/index.d.ts
index 25b166e10d..b776165c55 100644
--- a/types/intercom-client/index.d.ts
+++ b/types/intercom-client/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/intercom/intercom-node
 // Definitions by: Jinesh Shah <https://github.com/jineshshah36>, Josef Hornych <https://github.com/peping>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
+// TypeScript Version: 2.2
 /// <reference types="node" />
 
 import { List as UserList, User, UserIdentifier } from './User';
diff --git a/types/intercom-client/tslint.json b/types/intercom-client/tslint.json
index 3db14f85ea..3d2339d469 100644
--- a/types/intercom-client/tslint.json
+++ b/types/intercom-client/tslint.json
@@ -1 +1,15 @@
-{ "extends": "dtslint/dt.json" }
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        // All are TODOs
+        "array-type": false,
+        "comment-format": false,
+        "eofline": false,
+        "no-consecutive-blank-lines": false,
+        "no-padding": false,
+        "no-trailing-whitespace": false,
+        "semicolon": false,
+        "strict-export-declare-modifiers": false,
+        "trim-file": false
+    }
+}
diff --git a/types/intercom-web/index.d.ts b/types/intercom-web/index.d.ts
index 4348094541..3a40451a3a 100755
--- a/types/intercom-web/index.d.ts
+++ b/types/intercom-web/index.d.ts
@@ -56,6 +56,7 @@ declare namespace Intercom_ {
     (command: 'onUnreadCountChange', cb: (unreadCount: number) => void): void;
     (command: 'getVisitorId'): string;
     (command: IntercomCommand, param1?: any, param2?: any): void;
+    booted: boolean;
   }
 }
 
diff --git a/types/intercom-web/intercom-web-tests.ts b/types/intercom-web/intercom-web-tests.ts
index 325ecb7f4a..c6a8e948fe 100755
--- a/types/intercom-web/intercom-web-tests.ts
+++ b/types/intercom-web/intercom-web-tests.ts
@@ -28,6 +28,8 @@ Intercom('onActivatorClick', () => { /* Do stuff */ });
 Intercom('trackEvent', 'invited-friend');
 const visitorId = Intercom('getVisitorId');
 
+Intercom.booted;
+
 const metadata = {
   invitee_email: 'pi@example.org',
   invite_code: 'ADDAFRIEND'
diff --git a/types/is-docker/index.d.ts b/types/is-docker/index.d.ts
new file mode 100644
index 0000000000..12b3f6b797
--- /dev/null
+++ b/types/is-docker/index.d.ts
@@ -0,0 +1,8 @@
+// Type definitions for is-docker 1.1
+// Project: https://github.com/sindresorhus/is-docker#readme
+// Definitions by: Yash Kulshrestha <https://github.com/YashdalfTheGray>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.7
+
+declare function isDocker(): boolean;
+export = isDocker;
diff --git a/types/is-docker/is-docker-tests.ts b/types/is-docker/is-docker-tests.ts
new file mode 100644
index 0000000000..00274a35e0
--- /dev/null
+++ b/types/is-docker/is-docker-tests.ts
@@ -0,0 +1,3 @@
+import isDocker from "is-docker";
+
+isDocker(); // $ExpectType boolean
diff --git a/types/is-docker/tsconfig.json b/types/is-docker/tsconfig.json
new file mode 100644
index 0000000000..4c065b1b55
--- /dev/null
+++ b/types/is-docker/tsconfig.json
@@ -0,0 +1,17 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": ["es6"],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": ["../"],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true,
+        "strictFunctionTypes": true,
+        "esModuleInterop": true
+    },
+    "files": ["index.d.ts", "is-docker-tests.ts"]
+}
diff --git a/types/is-docker/tslint.json b/types/is-docker/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/is-docker/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/jasmine-data-provider/index.d.ts b/types/jasmine-data-provider/index.d.ts
new file mode 100644
index 0000000000..26f96be2d0
--- /dev/null
+++ b/types/jasmine-data-provider/index.d.ts
@@ -0,0 +1,16 @@
+// Type definitions for jasmine-data-provider 2.2
+// Project: https://github.com/MortalFlesh/jasmine-data-provider
+// Definitions by: Tomek Łaziuk <https://github.com/tlaziuk>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+declare function using<T extends any[]>(values: using.ValueType<T[]>, func: (...data: Array<using.ArrayFuncArgType<T>>) => void): void;
+declare function using<T>(values: using.ValueType<T[]>, func: (data: T) => void): void;
+declare function using<T>(values: using.ValueType<Record<string, T>>, func: (data: T, description: string) => void): void;
+
+declare namespace using {
+    type ValueType<T> = T | (() => T);
+    type ArrayFuncArgType<T> = T extends Array<infer U> ? U : never;
+}
+
+export = using;
diff --git a/types/jasmine-data-provider/jasmine-data-provider-tests.ts b/types/jasmine-data-provider/jasmine-data-provider-tests.ts
new file mode 100644
index 0000000000..361f1b49c0
--- /dev/null
+++ b/types/jasmine-data-provider/jasmine-data-provider-tests.ts
@@ -0,0 +1,85 @@
+import * as using from 'jasmine-data-provider';
+import 'jasmine';
+
+declare const calculator: any;
+
+describe('test subtraction with data provider - direct array', () => {
+    using([{ a: 5, b: 2, expected: 3 }, { a: 25, b: 26, expected: -1 }], (data) => {
+        it('should calc with operator -', () => {
+            const result = calculator.calc(data.a, data.b, '-');
+
+            expect(result).toEqual(data.expected);
+        });
+    });
+});
+
+describe('test addition with data provider - provider function', () => {
+    function plusProvider() {
+        return [
+            { a: 2, b: 3, expected: 5 },
+            { a: '14', b: 15, expected: 29 },
+            { a: 12, b: '13', expected: 25 },
+            { a: '22', b: '13', expected: 35 },
+        ];
+    }
+
+    using(plusProvider, (data) => {
+        it('should calc with operator +', () => {
+            const result = calculator.calc(data.a, data.b, '+');
+
+            expect(result).toEqual(data.expected);
+        });
+    });
+});
+
+describe('My fantastic test', () => {
+    const objectDataProvider = {
+        'First one is awesome!': { a: 6, b: 3, expected: 9 },
+        'Second test should fail': { a: 8, b: 1, expected: 10 }
+    };
+
+    using(objectDataProvider, (data, description) => {
+        it(description, () => {
+            const result = calculator.calc(data.a, data.b, '+');
+
+            expect(result).toEqual(data.expected);
+        });
+    });
+});
+
+// undocumented behaviour
+
+describe(`Ugh, I don't know if this one works`, () => {
+    using([[6, 3, 9], [8, 1, 10]], (a, b, expected) => {
+        it('should calc with operator +', () => {
+            const result = calculator.calc(a, b, '+');
+
+            expect(result).toEqual(expected);
+        });
+    });
+});
+
+// TypeScript-specific tests
+
+describe('My awesome test with declared types!', () => {
+    interface TestType {
+        value: number;
+        expected: number;
+    }
+
+    using<TestType>([{ value: 2, expected: 4 }], (data) => {
+        it('should calc with operator ^2', () => {
+            const result = calculator.calc(data.value, '^2');
+
+            expect(result).toEqual(data.expected);
+        });
+    });
+
+    using<TestType>({ desc: { value: 2, expected: 4 } }, (data, description) => {
+        it(description, () => {
+            const result = calculator.calc(data.value, '^2');
+
+            expect(result).toEqual(data.expected);
+        });
+    });
+});
diff --git a/types/jasmine-data-provider/tsconfig.json b/types/jasmine-data-provider/tsconfig.json
new file mode 100644
index 0000000000..4ad53680f8
--- /dev/null
+++ b/types/jasmine-data-provider/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "jasmine-data-provider-tests.ts"
+    ]
+}
diff --git a/types/jasmine-data-provider/tslint.json b/types/jasmine-data-provider/tslint.json
new file mode 100644
index 0000000000..f93cf8562a
--- /dev/null
+++ b/types/jasmine-data-provider/tslint.json
@@ -0,0 +1,3 @@
+{
+    "extends": "dtslint/dt.json"
+}
diff --git a/types/jest-axe/tsconfig.json b/types/jest-axe/tsconfig.json
index 887813c869..1889f0045d 100644
--- a/types/jest-axe/tsconfig.json
+++ b/types/jest-axe/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/jest-environment-puppeteer/tsconfig.json b/types/jest-environment-puppeteer/tsconfig.json
index ed53d60edd..0e9ded7993 100644
--- a/types/jest-environment-puppeteer/tsconfig.json
+++ b/types/jest-environment-puppeteer/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/jquery-awesome-cursor/tsconfig.json b/types/jquery-awesome-cursor/tsconfig.json
index cb81088d83..7fb68010e3 100644
--- a/types/jquery-awesome-cursor/tsconfig.json
+++ b/types/jquery-awesome-cursor/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/jquery-toast-plugin/tsconfig.json b/types/jquery-toast-plugin/tsconfig.json
index 95759d345b..81dae6d531 100644
--- a/types/jquery-toast-plugin/tsconfig.json
+++ b/types/jquery-toast-plugin/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/jquery.growl/tsconfig.json b/types/jquery.growl/tsconfig.json
index 8416f143a7..7b2e28e9d9 100644
--- a/types/jquery.growl/tsconfig.json
+++ b/types/jquery.growl/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/jquery/JQuery.d.ts b/types/jquery/JQuery.d.ts
new file mode 100644
index 0000000000..7453457953
--- /dev/null
+++ b/types/jquery/JQuery.d.ts
@@ -0,0 +1,12762 @@
+// tslint:disable:jsdoc-format
+// tslint:disable:max-line-length
+// tslint:disable:no-irregular-whitespace
+
+interface JQuery<TElement = HTMLElement> extends Iterable<TElement> {
+    /**
+     * A string containing the jQuery version number.
+     * @see \`{@link https://api.jquery.com/jquery-2/#jquery1 }\`
+     * @since 1.0
+     * @example ​ ````Determine if an object is a jQuery object
+```javascript
+var a = { what: "A regular JS object" },
+  b = $( "body" );
+​
+if ( a.jquery ) { // Falsy, since it's undefined
+  alert( "a is a jQuery object!" );
+}
+​
+if ( b.jquery ) { // Truthy, since it's a string
+    alert( "b is a jQuery object!" );
+}
+```
+     * @example ​ ````Get the current version of jQuery running on the page
+```javascript
+alert( "You are running jQuery version: " + $.fn.jquery );
+```
+     */
+    jquery: string;
+    /**
+     * The number of elements in the jQuery object.
+     * @see \`{@link https://api.jquery.com/length/ }\`
+     * @since 1.0
+     * @example ​ ````Count the divs.  Click to add more.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>length demo</title>
+  <style>
+  body {
+    cursor: pointer;
+  }
+  div {
+    width: 50px;
+    height: 30px;
+    margin: 5px;
+    float: left;
+    background: green;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​<span></span>
+  <div></div>​
+<script>
+$( document.body )
+  .click(function() {
+    $( document.body ).append( $( "<div>" ) );
+    var n = $( "div" ).length;
+    $( "span" ).text( "There are " + n + " divs." +
+      "Click to add more.");
+  })
+  // Trigger the click to start
+  .trigger( "click" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    length: number;
+    /**
+     * Create a new jQuery object with elements added to the set of matched elements.
+     * @param selector A string representing a selector expression to find additional elements to add to the set of matched elements.
+     * @param context The point in the document at which the selector should begin matching; similar to the context
+     *                argument of the $(selector, context) method.
+     * @see \`{@link https://api.jquery.com/add/ }\`
+     * @since 1.4
+     */
+    add(selector: JQuery.Selector, context: Element): this;
+    /**
+     * Create a new jQuery object with elements added to the set of matched elements.
+     * @param selector_elements_html_selection _&#x40;param_ `selector_elements_html_selection`
+     * <br>
+     * * `selector` — A string representing a selector expression to find additional elements to add to the set of matched elements. <br>
+     * * `elements` — One or more elements to add to the set of matched elements. <br>
+     * * `html` — An HTML fragment to add to the set of matched elements. <br>
+     * * `selection` — An existing jQuery object to add to the set of matched elements.
+     * @see \`{@link https://api.jquery.com/add/ }\`
+     * @since 1.0
+     * @since 1.3.2
+     * @example ​ ````Finds all divs and makes a border.  Then adds all paragraphs to the jQuery object to set their backgrounds yellow.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>add demo</title>
+  <style>
+  div {
+    width: 60px;
+    height: 60px;
+    margin: 10px;
+    float: left;
+  }
+  p {
+    clear: left;
+    font-weight: bold;
+    font-size: 16px;
+    color: blue;
+    margin: 0 10px;
+    padding: 2px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div></div>
+<div></div>
+<div></div>
+<div></div>
+<div></div>
+<div></div>
+​
+<p>Added this... (notice no border)</p>
+​
+<script>
+$( "div" ).css( "border", "2px solid red" )
+  .add( "p" )
+  .css( "background", "yellow" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Adds more elements, matched by the given expression, to the set of matched elements.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>add demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<span>Hello Again</span>
+​
+<script>
+$( "p" ).add( "span" ).css( "background", "yellow" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Adds more elements, created on the fly, to the set of matched elements.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>add demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+​
+<script>
+$( "p" ).clone().add( "<span>Again</span>" ).appendTo( document.body );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Adds one or more Elements to the set of matched elements.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>add demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<span id="a">Hello Again</span>
+​
+<script>
+$( "p" ).add( document.getElementById( "a" ) ).css( "background", "yellow" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Demonstrates how to add (or push) elements to an existing collection
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>add demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<span id="a">Hello Again</span>
+​
+<script>
+var collection = $( "p" );
+// Capture the new collection
+collection = collection.add( document.getElementById( "a" ) );
+collection.css( "background", "yellow" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    add(selector_elements_html_selection: JQuery.Selector | JQuery.TypeOrArray<Element> | JQuery.htmlString | JQuery): this;
+    /**
+     * Add the previous set of elements on the stack to the current set, optionally filtered by a selector.
+     * @param selector A string containing a selector expression to match the current set of elements against.
+     * @see \`{@link https://api.jquery.com/addBack/ }\`
+     * @since 1.8
+     * @example ​ ````The .addBack() method causes the previous set of DOM elements in the traversal stack to be added to the current set. In the first example, the top stack contains the set resulting from .find(&quot;p&quot;). In the second example, .addBack() adds the previous set of elements on the stack — in this case $(&quot;div.after-addback&quot;) — to the current set, selecting both the div and its enclosed paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>addBack demo</title>
+  <style>
+  p, div {
+    margin: 5px;
+    padding: 5px;
+  }
+  .border {
+    border: 2px solid red;
+  }
+  .background {
+    background: yellow;
+  }
+  .left, .right {
+    width: 45%;
+    float: left;
+  }
+  .right {
+    margin-left: 3%;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div class="left">
+  <p><strong>Before <code>addBack()</code></strong></p>
+  <div class="before-addback">
+    <p>First Paragraph</p>
+    <p>Second Paragraph</p>
+  </div>
+</div>
+<div class="right">
+  <p><strong>After <code>addBack()</code></strong></p>
+  <div class="after-addback">
+    <p>First Paragraph</p>
+    <p>Second Paragraph</p>
+  </div>
+</div>
+​
+<script>
+$( "div.left, div.right" ).find( "div, div > p" ).addClass( "border" );
+​
+// First Example
+$( "div.before-addback" ).find( "p" ).addClass( "background" );
+​
+// Second Example
+$( "div.after-addback" ).find( "p" ).addBack().addClass( "background" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    addBack(selector?: JQuery.Selector): this;
+    /**
+     * Adds the specified class(es) to each element in the set of matched elements.
+     * @param className_function _&#x40;param_ `className_function`
+     * <br>
+     * * `className` — One or more space-separated classes to be added to the class attribute of each matched element. <br>
+     * * `function` — A function returning one or more space-separated class names to be added to the existing class
+     *                name(s). Receives the index position of the element in the set and the existing class name(s) as
+     *                arguments. Within the function, `this` refers to the current element in the set.
+     * @see \`{@link https://api.jquery.com/addClass/ }\`
+     * @since 1.0
+     * @since 1.4
+     * @since 3.3
+     * @example ​ ````Add the class &quot;selected&quot; to the matched elements.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>addClass demo</title>
+  <style>
+  p {
+    margin: 8px;
+    font-size: 16px;
+  }
+  .selected {
+    color: blue;
+  }
+  .highlight {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<p>and</p>
+<p>Goodbye</p>
+​
+<script>
+$( "p" ).last().addClass( "selected" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Add the classes &quot;selected&quot; and &quot;highlight&quot; to the matched elements.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>addClass demo</title>
+  <style>
+  p {
+    margin: 8px;
+    font-size: 16px;
+  }
+  .selected {
+    color: red;
+  }
+  .highlight {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<p>and</p>
+<p>Goodbye</p>
+​
+<script>
+$( "p:last" ).addClass( "selected highlight" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Pass in a function to .addClass() to add the &quot;green&quot; class to a div that already has a &quot;red&quot; class.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>addClass demo</title>
+  <style>
+  div {
+    background: white;
+  }
+  .red {
+    background: red;
+  }
+  .red.green {
+    background: green;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+ <div>This div should be white</div>
+ <div class="red">This div will be green because it now has the "green" and "red" classes.
+   It would be red if the addClass function failed.</div>
+ <div>This div should be white</div>
+ <p>There are zero green divs</p>
+​
+<script>
+$( "div" ).addClass(function( index, currentClass ) {
+  var addedClass;
+​
+  if ( currentClass === "red" ) {
+    addedClass = "green";
+    $( "p" ).text( "There is one green div" );
+  }
+​
+  return addedClass;
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    addClass(className_function: JQuery.TypeOrArray<string> | ((this: TElement, index: number, currentClassName: string) => string)): this;
+    /**
+     * Insert content, specified by the parameter, after each element in the set of matched elements.
+     * @param contents One or more additional DOM elements, text nodes, arrays of elements and text nodes, HTML strings, or
+     *                 jQuery objects to insert after each element in the set of matched elements.
+     * @see \`{@link https://api.jquery.com/after/ }\`
+     * @since 1.0
+     * @example ​ ````Inserts some HTML after all paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>after demo</title>
+  <style>
+  p {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>I would like to say: </p>
+​
+<script>
+$( "p" ).after( "<b>Hello</b>" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Inserts a DOM element after all paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>after demo</title>
+  <style>
+  p {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>I would like to say: </p>
+​
+<script>
+$( "p" ).after( document.createTextNode( "Hello" ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Inserts a jQuery object (similar to an Array of DOM Elements) after all paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>after demo</title>
+  <style>
+  p {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<b>Hello</b>
+<p>I would like to say: </p>
+​
+<script>
+$( "p" ).after( $( "b" ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    after(...contents: Array<JQuery.htmlString | JQuery.TypeOrArray<JQuery.Node | JQuery<JQuery.Node>>>): this;
+    /**
+     * Insert content, specified by the parameter, after each element in the set of matched elements.
+     * @param function_functionｰhtml _&#x40;param_ `function_functionｰhtml`
+     * <br>
+     * * `function` — A function that returns an HTML string, DOM element(s), text node(s), or jQuery object to insert
+     *                after each element in the set of matched elements. Receives the index position of the element in the
+     *                set as an argument. Within the function, `this` refers to the current element in the set. <br>
+     * * `functionｰhtml` — A function that returns an HTML string, DOM element(s), text node(s), or jQuery object to insert
+     *                     after each element in the set of matched elements. Receives the index position of the element in the
+     *                     set and the old HTML value of the element as arguments. Within the function, `this` refers to the
+     *                     current element in the set.
+     * @see \`{@link https://api.jquery.com/after/ }\`
+     * @since 1.4
+     * @since 1.10
+     */
+    after(function_functionｰhtml: (this: TElement, index: number, html: string) => JQuery.htmlString | JQuery.TypeOrArray<JQuery.Node | JQuery<JQuery.Node>>): this;
+    /**
+     * Register a handler to be called when Ajax requests complete. This is an AjaxEvent.
+     * @param handler The function to be invoked.
+     * @see \`{@link https://api.jquery.com/ajaxComplete/ }\`
+     * @since 1.0
+     * @example ​ ````Show a message when an Ajax request completes.
+```javascript
+$( document ).ajaxComplete(function( event, request, settings ) {
+  $( "#msg" ).append( "<li>Request Complete.</li>" );
+});
+```
+     */
+    ajaxComplete(handler: (this: Document, event: JQuery.Event<Document>, jqXHR: JQuery.jqXHR, ajaxOptions: JQuery.AjaxSettings) => void | false): this;
+    /**
+     * Register a handler to be called when Ajax requests complete with an error. This is an Ajax Event.
+     * @param handler The function to be invoked.
+     * @see \`{@link https://api.jquery.com/ajaxError/ }\`
+     * @since 1.0
+     * @example ​ ````Show a message when an Ajax request fails.
+```javascript
+$( document ).ajaxError(function( event, request, settings ) {
+  $( "#msg" ).append( "<li>Error requesting page " + settings.url + "</li>" );
+});
+```
+     */
+    ajaxError(handler: (this: Document, event: JQuery.Event<Document>, jqXHR: JQuery.jqXHR, ajaxSettings: JQuery.AjaxSettings, thrownError: string) => void | false): this;
+    /**
+     * Attach a function to be executed before an Ajax request is sent. This is an Ajax Event.
+     * @param handler The function to be invoked.
+     * @see \`{@link https://api.jquery.com/ajaxSend/ }\`
+     * @since 1.0
+     * @example ​ ````Show a message before an Ajax request is sent.
+```javascript
+$( document ).ajaxSend(function( event, request, settings ) {
+  $( "#msg" ).append( "<li>Starting request at " + settings.url + "</li>" );
+});
+```
+     */
+    ajaxSend(handler: (this: Document, event: JQuery.Event<Document>, jqXHR: JQuery.jqXHR, ajaxOptions: JQuery.AjaxSettings) => void | false): this;
+    /**
+     * Register a handler to be called when the first Ajax request begins. This is an Ajax Event.
+     * @param handler The function to be invoked.
+     * @see \`{@link https://api.jquery.com/ajaxStart/ }\`
+     * @since 1.0
+     * @example ​ ````Show a loading message whenever an Ajax request starts (and none is already active).
+```javascript
+$( document ).ajaxStart(function() {
+  $( "#loading" ).show();
+});
+```
+     */
+    ajaxStart(handler: (this: Document) => void | false): this;
+    /**
+     * Register a handler to be called when all Ajax requests have completed. This is an Ajax Event.
+     * @param handler The function to be invoked.
+     * @see \`{@link https://api.jquery.com/ajaxStop/ }\`
+     * @since 1.0
+     * @example ​ ````Hide a loading message after all the Ajax requests have stopped.
+```javascript
+$( document ).ajaxStop(function() {
+  $( "#loading" ).hide();
+});
+```
+     */
+    ajaxStop(handler: (this: Document) => void | false): this;
+    /**
+     * Attach a function to be executed whenever an Ajax request completes successfully. This is an Ajax Event.
+     * @param handler The function to be invoked.
+     * @see \`{@link https://api.jquery.com/ajaxSuccess/ }\`
+     * @since 1.0
+     * @example ​ ````Show a message when an Ajax request completes successfully.
+```javascript
+$( document ).ajaxSuccess(function( event, request, settings ) {
+  $( "#msg" ).append( "<li>Successful Request!</li>" );
+});
+```
+     */
+    ajaxSuccess(handler: (this: Document, event: JQuery.Event<Document>, jqXHR: JQuery.jqXHR, ajaxOptions: JQuery.AjaxSettings, data: JQuery.PlainObject) => void | false): this;
+    /**
+     * Perform a custom animation of a set of CSS properties.
+     * @param properties An object of CSS properties and values that the animation will move toward.
+     * @param duration A string or number determining how long the animation will run.
+     * @param easing A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/animate/ }\`
+     * @since 1.0
+     * @example ​ ````An example of using an &#39;easing&#39; function to provide a different style of animation. This will only work if you have a plugin that provides this easing function.  Note, this code will do nothing unless the paragraph element is hidden.
+```javascript
+$( "p" ).animate({
+  opacity: "show"
+}, "slow", "easein" );
+```
+     * @example ​ ````Animate all paragraphs and execute a callback function when the animation is complete.  The first argument is an object of CSS properties, the second specifies that the animation should take 1000 milliseconds to complete, the third states the easing type, and the fourth argument is an anonymous callback function.
+```javascript
+$( "p" ).animate({
+  height: 200,
+  width: 400,
+  opacity: 0.5
+}, 1000, "linear", function() {
+  alert( "all done" );
+});
+```
+     */
+    animate(properties: JQuery.PlainObject,
+            duration: JQuery.Duration,
+            easing: string,
+            complete?: (this: TElement) => void): this;
+    /**
+     * Perform a custom animation of a set of CSS properties.
+     * @param properties An object of CSS properties and values that the animation will move toward.
+     * @param duration_easing _&#x40;param_ `duration_easing`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `easing` — A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/animate/ }\`
+     * @since 1.0
+     * @example ​ ````Click the button to animate the div with a number of different properties.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>animate demo</title>
+  <style>
+  div {
+    background-color: #bca;
+    width: 100px;
+    border: 1px solid green;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="go">&raquo; Run</button>
+<div id="block">Hello!</div>
+​
+<script>
+// Using multiple unit types within one animation.
+​
+$( "#go" ).click(function() {
+  $( "#block" ).animate({
+    width: "70%",
+    opacity: 0.4,
+    marginLeft: "0.6in",
+    fontSize: "3em",
+    borderWidth: "10px"
+  }, 1500 );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Animates a div&#39;s left property with a relative value. Click several times on the buttons to see the relative animations queued up.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>animate demo</title>
+  <style>
+  div {
+    position: absolute;
+    background-color: #abc;
+    left: 50px;
+    width: 90px;
+    height: 90px;
+    margin: 5px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="left">&laquo;</button>
+<button id="right">&raquo;</button>
+<div class="block"></div>
+​
+<script>
+$( "#right" ).click(function() {
+  $( ".block" ).animate({ "left": "+=50px" }, "slow" );
+});
+​
+$( "#left" ).click(function(){
+  $( ".block" ).animate({ "left": "-=50px" }, "slow" );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Animate all paragraphs to toggle both height and opacity, completing the animation within 600 milliseconds.
+```javascript
+$( "p" ).animate({
+  height: "toggle",
+  opacity: "toggle"
+}, "slow" );
+```
+     * @example ​ ````Animate all paragraphs to a left style of 50 and opacity of 1 (opaque, visible), completing the animation within 500 milliseconds.
+```javascript
+$( "p" ).animate({
+  left: 50,
+  opacity: 1
+}, 500 );
+```
+     */
+    animate(properties: JQuery.PlainObject,
+            duration_easing: JQuery.Duration | string,
+            complete?: (this: TElement) => void): this;
+    /**
+     * Perform a custom animation of a set of CSS properties.
+     * @param properties An object of CSS properties and values that the animation will move toward.
+     * @param options A map of additional options to pass to the method.
+     * @see \`{@link https://api.jquery.com/animate/ }\`
+     * @since 1.0
+     * @example ​ ````The first button shows how an unqueued animation works.  It expands the div out to 90% width while the font-size is increasing. Once the font-size change is complete, the border animation will begin.
+
+The second button starts a traditional chained animation, where each animation will start once the previous animation on the element has completed.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>animate demo</title>
+  <style>
+  div {
+    background-color: #bca;
+    width: 200px;
+    height: 1.1em;
+    text-align: center;
+    border: 2px solid green;
+    margin: 3px;
+    font-size: 14px;
+  }
+  button {
+    font-size: 14px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="go1">&raquo; Animate Block1</button>
+<button id="go2">&raquo; Animate Block2</button>
+<button id="go3">&raquo; Animate Both</button>
+<button id="go4">&raquo; Reset</button>
+<div id="block1">Block1</div>
+<div id="block2">Block2</div>
+​
+<script>
+$( "#go1" ).click(function() {
+  $( "#block1" )
+    .animate({
+      width: "90%"
+    }, {
+      queue: false,
+      duration: 3000
+    })
+    .animate({ fontSize: "24px" }, 1500 )
+    .animate({ borderRightWidth: "15px" }, 1500 );
+});
+​
+$( "#go2" ).click(function() {
+  $( "#block2" )
+    .animate({ width: "90%" }, 1000 )
+    .animate({ fontSize: "24px" }, 1000 )
+    .animate({ borderLeftWidth: "15px" }, 1000 );
+});
+​
+$( "#go3" ).click(function() {
+  $( "#go1" ).add( "#go2" ).click();
+});
+​
+$( "#go4" ).click(function() {
+  $( "div" ).css({
+    width: "",
+    fontSize: "",
+    borderWidth: ""
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Animates the first div&#39;s left property and synchronizes the remaining divs, using the step function to set their left properties at each stage of the animation.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>animate demo</title>
+  <style>
+  div {
+    position: relative;
+    background-color: #abc;
+    width: 40px;
+    height: 40px;
+    float: left;
+    margin: 5px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button id="go">Run »</button></p>
+<div class="block"></div>
+<div class="block"></div>
+<div class="block"></div>
+<div class="block"></div>
+<div class="block"></div>
+<div class="block"></div>
+​
+<script>
+$( "#go" ).click(function() {
+  $( ".block:first" ).animate({
+    left: 100
+  }, {
+    duration: 1000,
+    step: function( now, fx ){
+      $( ".block:gt(0)" ).css( "left", now );
+    }
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Animate the left and opacity style properties of all paragraphs; run the animation outside the queue, so that it will automatically start without waiting for its turn.
+```javascript
+$( "p" ).animate({
+  left: "50px",
+  opacity: 1
+}, {
+  duration: 500,
+  queue: false
+});
+```
+     * @example ​ ````Animates all paragraphs to toggle both height and opacity, completing the animation within 600 milliseconds.
+```javascript
+$( "p" ).animate({
+  height: "toggle",
+  opacity: "toggle"
+}, {
+  duration: "slow"
+});
+```
+     * @example ​ ````Use an easing function to provide a different style of animation. This will only work if you have a plugin that provides this easing function.
+```javascript
+$( "p" ).animate({
+  opacity: "show"
+}, {
+  duration: "slow",
+  easing: "easein"
+});
+```
+     */
+    animate(properties: JQuery.PlainObject,
+            options: JQuery.EffectsOptions<TElement>): this;
+    /**
+     * Perform a custom animation of a set of CSS properties.
+     * @param properties An object of CSS properties and values that the animation will move toward.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/animate/ }\`
+     * @since 1.0
+     */
+    animate(properties: JQuery.PlainObject,
+            complete?: (this: TElement) => void): this;
+    /**
+     * Insert content, specified by the parameter, to the end of each element in the set of matched elements.
+     * @param contents One or more additional DOM elements, text nodes, arrays of elements and text nodes, HTML strings, or
+     *                 jQuery objects to insert at the end of each element in the set of matched elements.
+     * @see \`{@link https://api.jquery.com/append/ }\`
+     * @since 1.0
+     * @example ​ ````Appends some HTML to all paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>append demo</title>
+  <style>
+  p {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>I would like to say: </p>
+​
+<script>
+$( "p" ).append( "<strong>Hello</strong>" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Appends an Element to all paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>append demo</title>
+  <style>
+  p {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>I would like to say: </p>
+​
+<script>
+$( "p" ).append( document.createTextNode( "Hello" ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Appends a jQuery object (similar to an Array of DOM Elements) to all paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>append demo</title>
+  <style>
+  p {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<strong>Hello world!!!</strong>
+<p>I would like to say: </p>
+​
+<script>
+$( "p" ).append( $( "strong" ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    append(...contents: Array<JQuery.htmlString | JQuery.TypeOrArray<JQuery.Node | JQuery<JQuery.Node>>>): this;
+    /**
+     * Insert content, specified by the parameter, to the end of each element in the set of matched elements.
+     * @param funсtion A function that returns an HTML string, DOM element(s), text node(s), or jQuery object to insert at
+     *                 the end of each element in the set of matched elements. Receives the index position of the element
+     *                 in the set and the old HTML value of the element as arguments. Within the function, `this` refers to
+     *                 the current element in the set.
+     * @see \`{@link https://api.jquery.com/append/ }\`
+     * @since 1.4
+     */
+    append(funсtion: (this: TElement, index: number, html: string) => JQuery.htmlString | JQuery.TypeOrArray<JQuery.Node | JQuery<JQuery.Node>>): this;
+    /**
+     * Insert every element in the set of matched elements to the end of the target.
+     * @param target A selector, element, HTML string, array of elements, or jQuery object; the matched set of elements
+     *               will be inserted at the end of the element(s) specified by this parameter.
+     * @see \`{@link https://api.jquery.com/appendTo/ }\`
+     * @since 1.0
+     * @example ​ ````Append all spans to the element with the ID &quot;foo&quot; (Check append() documentation for more examples)
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>appendTo demo</title>
+  <style>
+  #foo {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<span>I have nothing more to say... </span>
+​
+<div id="foo">FOO! </div>
+​
+<script>
+$( "span" ).appendTo( "#foo" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    appendTo(target: JQuery.Selector | JQuery.htmlString | JQuery.TypeOrArray<Element | DocumentFragment> | JQuery): this;
+    /**
+     * Set one or more attributes for the set of matched elements.
+     * @param attributeName The name of the attribute to set.
+     * @param value_function _&#x40;param_ `value_function`
+     * <br>
+     * * `value` — A value to set for the attribute. If `null`, the specified attribute will be removed (as in \`{@link removeAttr .removeAttr()}`). <br>
+     * * `function` — A function returning the value to set. `this` is the current element. Receives the index position of
+     *                the element in the set and the old attribute value as arguments.
+     * @see \`{@link https://api.jquery.com/attr/ }\`
+     * @since 1.0
+     * @since 1.1
+     * @example ​ ````Set the id for divs based on the position in the page.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>attr demo</title>
+  <style>
+  div {
+    color: blue;
+  }
+  span {
+    color: red;
+  }
+  b {
+    font-weight: bolder;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>Zero-th <span></span></div>
+<div>First <span></span></div>
+<div>Second <span></span></div>
+​
+<script>
+$( "div" )
+  .attr( "id", function( arr ) {
+    return "div-id" + arr;
+  })
+  .each(function() {
+    $( "span", this ).html( "(id = '<b>" + this.id + "</b>')" );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Set the src attribute from title attribute on the image.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>attr demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<img title="hat.gif">
+​
+<script>
+$( "img" ).attr( "src", function() {
+  return "/resources/" + this.title;
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    attr(attributeName: string,
+         value_function: string | number | null | ((this: TElement, index: number, attr: string) => string | number | void | undefined)): this;
+    /**
+     * Set one or more attributes for the set of matched elements.
+     * @param attributes An object of attribute-value pairs to set.
+     * @see \`{@link https://api.jquery.com/attr/ }\`
+     * @since 1.0
+     * @example ​ ````Set some attributes for all &lt;img&gt;s in the page.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>attr demo</title>
+  <style>
+  img {
+    padding: 10px;
+  }
+  div {
+    color: red;
+    font-size: 24px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<img>
+<img>
+<img>
+​
+<div><b>Attribute of Ajax</b></div>
+​
+<script>
+$( "img" ).attr({
+  src: "/resources/hat.gif",
+  title: "jQuery",
+  alt: "jQuery Logo"
+});
+$( "div" ).text( $( "img" ).attr( "alt" ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    attr(attributes: JQuery.PlainObject): this;
+    /**
+     * Get the value of an attribute for the first element in the set of matched elements.
+     * @param attributeName The name of the attribute to get.
+     * @see \`{@link https://api.jquery.com/attr/ }\`
+     * @since 1.0
+     * @example ​ ````Display the checked attribute and property of a checkbox as it changes.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>attr demo</title>
+  <style>
+  p {
+    margin: 20px 0 0;
+  }
+  b {
+    color: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<input id="check1" type="checkbox" checked="checked">
+<label for="check1">Check me</label>
+<p></p>
+​
+<script>
+$( "input" )
+  .change(function() {
+    var $input = $( this );
+    $( "p" ).html( ".attr( 'checked' ): <b>" + $input.attr( "checked" ) + "</b><br>" +
+      ".prop( 'checked' ): <b>" + $input.prop( "checked" ) + "</b><br>" +
+      ".is( ':checked' ): <b>" + $input.is( ":checked" ) + "</b>" );
+  })
+  .change();
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Find the title attribute of the first &lt;em&gt; in the page.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>attr demo</title>
+  <style>
+  em {
+    color: blue;
+    font-weight: bold;
+  }
+  div {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Once there was a <em title="huge, gigantic">large</em> dinosaur...</p>
+​
+The title of the emphasis is:<div></div>
+​
+<script>
+var title = $( "em" ).attr( "title" );
+$( "div" ).text( title );
+</script>
+​
+</body>
+</html>
+```
+     */
+    attr(attributeName: string): string | undefined;
+    /**
+     * Insert content, specified by the parameter, before each element in the set of matched elements.
+     * @param contents One or more additional DOM elements, text nodes, arrays of elements and text nodes, HTML strings, or
+     *                 jQuery objects to insert before each element in the set of matched elements.
+     * @see \`{@link https://api.jquery.com/before/ }\`
+     * @since 1.0
+     * @example ​ ````Inserts some HTML before all paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>before demo</title>
+  <style>
+  p {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p> is what I said...</p>
+​
+<script>
+$( "p" ).before( "<b>Hello</b>" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Inserts a DOM element before all paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>before demo</title>
+  <style>
+  p {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p> is what I said...</p>
+​
+<script>
+$( "p" ).before( document.createTextNode( "Hello" ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Inserts a jQuery object (similar to an Array of DOM Elements) before all paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>before demo</title>
+  <style>
+  p {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p> is what I said...</p><b>Hello</b>
+​
+<script>
+$( "p" ).before( $( "b" ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    before(...contents: Array<JQuery.htmlString | JQuery.TypeOrArray<JQuery.Node | JQuery<JQuery.Node>>>): this;
+    /**
+     * Insert content, specified by the parameter, before each element in the set of matched elements.
+     * @param function_functionｰhtml _&#x40;param_ `function_functionｰhtml`
+     * <br>
+     * * `function` — A function that returns an HTML string, DOM element(s), text node(s), or jQuery object to insert
+     *                before each element in the set of matched elements. Receives the index position of the element in
+     *                the set as an argument. Within the function, `this` refers to the current element in the set. <br>
+     * * `functionｰhtml` — A function that returns an HTML string, DOM element(s), text node(s), or jQuery object to insert
+     *                     before each element in the set of matched elements. Receives the index position of the element in
+     *                     the set and the old HTML value of the element as arguments. Within the function, `this` refers to the
+     *                     current element in the set.
+     * @see \`{@link https://api.jquery.com/before/ }\`
+     * @since 1.4
+     * @since 1.10
+     */
+    before(function_functionｰhtml: (this: TElement, index: number, html: string) => JQuery.htmlString | JQuery.TypeOrArray<JQuery.Node | JQuery<JQuery.Node>>): this;
+    // [bind() overloads] https://github.com/jquery/api.jquery.com/issues/1048
+    /**
+     * Attach a handler to an event for the elements.
+     * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/bind/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.0. Use \`{@link on }\`.
+     *
+     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
+     *
+     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
+     */
+    bind<TData>(eventType: string,
+                eventData: TData,
+                handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Attach a handler to an event for the elements.
+     * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
+     * @param handler_preventBubble _&#x40;param_ `handler_preventBubble`
+     * <br>
+     * * `handler` — A function to execute each time the event is triggered. <br>
+     * * `preventBubble` — Setting the third argument to false will attach a function that prevents the default action from
+     *                     occurring and stops the event from bubbling. The default is `true`.
+     * @see \`{@link https://api.jquery.com/bind/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.0. Use \`{@link on }\`.
+     *
+     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
+     *
+     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
+     * @example ​ ````Handle click and double-click for the paragraph.  Note: the coordinates are window relative, so in this case relative to the demo iframe.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>bind demo</title>
+  <style>
+  p {
+    background: yellow;
+    font-weight: bold;
+    cursor: pointer;
+    padding: 5px;
+  }
+  p.over {
+     background: #ccc;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Click or double click here.</p>
+<span></span>
+​
+<script>
+$( "p" ).bind( "click", function( event ) {
+  var str = "( " + event.pageX + ", " + event.pageY + " )";
+  $( "span" ).text( "Click happened! " + str );
+});
+$( "p" ).bind( "dblclick", function() {
+  $( "span" ).text( "Double-click happened in " + this.nodeName );
+});
+$( "p" ).bind( "mouseenter mouseleave", function( event ) {
+  $( this ).toggleClass( "over" );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````To display each paragraph&#39;s text in an alert box whenever it is clicked:
+```javascript
+$( "p" ).bind( "click", function() {
+  alert( $( this ).text() );
+});
+```
+     * @example ​ ````Cancel a default action and prevent it from bubbling up by returning false:
+```javascript
+$( "form" ).bind( "submit", function() {
+  return false;
+})
+```
+     * @example ​ ````Cancel only the default action by using the .preventDefault() method.
+```javascript
+$( "form" ).bind( "submit", function( event ) {
+  event.preventDefault();
+});
+```
+     * @example ​ ````Stop an event from bubbling without preventing the default action by using the .stopPropagation() method.
+```javascript
+$( "form" ).bind( "submit", function( event ) {
+  event.stopPropagation();
+});
+```
+     * @example ​ ````Bind custom events.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>bind demo</title>
+  <style>
+  p {
+    color: red;
+  }
+  span {
+    color: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Has an attached custom event.</p>
+<button>Trigger custom event</button>
+<span style="display: none;"></span>
+​
+<script>
+$( "p" ).bind( "myCustomEvent", function( e, myName, myValue ) {
+  $( this ).text( myName + ", hi there!" );
+  $( "span" )
+    .stop()
+    .css( "opacity", 1 )
+    .text( "myName = " + myName )
+    .fadeIn( 30 )
+    .fadeOut( 1000 );
+  });
+$( "button" ).click(function() {
+  $( "p" ).trigger( "myCustomEvent", [ "John" ] );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    bind(eventType: string,
+         handler_preventBubble: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false | null | undefined): this;
+    /**
+     * Attach a handler to an event for the elements.
+     * @param events An object containing one or more DOM event types and functions to execute for them.
+     * @see \`{@link https://api.jquery.com/bind/ }\`
+     * @since 1.4
+     * @deprecated ​ Deprecated since 3.0. Use \`{@link on }\`.
+     *
+     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
+     *
+     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
+     * @example ​ ````Bind multiple events simultaneously.
+```javascript
+$( "div.test" ).bind({
+  click: function() {
+    $( this ).addClass( "active" );
+  },
+  mouseenter: function() {
+    $( this ).addClass( "inside" );
+  },
+  mouseleave: function() {
+    $( this ).removeClass( "inside" );
+  }
+});
+```
+     */
+    bind(events: JQuery.PlainObject<JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false>): this;
+    /**
+     * Bind an event handler to the "blur" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/blur/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    blur<TData>(eventData: TData,
+                handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "blur" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/blur/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````To trigger the blur event on all paragraphs:
+```javascript
+$( "p" ).blur();
+```
+     */
+    blur(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Bind an event handler to the "change" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/change/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    change<TData>(eventData: TData,
+                  handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "change" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/change/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````Attaches a change event to the select that gets the text for each selected option and writes them in the div.  It then triggers the event for the initial text draw.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>change demo</title>
+  <style>
+  div {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<select name="sweets" multiple="multiple">
+  <option>Chocolate</option>
+  <option selected="selected">Candy</option>
+  <option>Taffy</option>
+  <option selected="selected">Caramel</option>
+  <option>Fudge</option>
+  <option>Cookie</option>
+</select>
+<div></div>
+​
+<script>
+$( "select" )
+  .change(function () {
+    var str = "";
+    $( "select option:selected" ).each(function() {
+      str += $( this ).text() + " ";
+    });
+    $( "div" ).text( str );
+  })
+  .change();
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````To add a validity test to all text input elements:
+```javascript
+$( "input[type='text']" ).change(function() {
+  // Check input( $( this ).val() ) for validity here
+});
+```
+     */
+    change(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Get the children of each element in the set of matched elements, optionally filtered by a selector.
+     * @param selector A string containing a selector expression to match elements against.
+     * @see \`{@link https://api.jquery.com/children/ }\`
+     * @since 1.0
+     * @example ​ ````Find all children of the clicked element.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>children demo</title>
+  <style>
+  body {
+    font-size: 16px;
+    font-weight: bolder;
+  }
+  div {
+    width: 130px;
+    height: 82px;
+    margin: 10px;
+    float: left;
+    border: 1px solid blue;
+    padding: 4px;
+  }
+  #container {
+    width: auto;
+    height: 105px;
+    margin: 0;
+    float: none;
+    border: none;
+  }
+  .hilite {
+    border-color: red;
+  }
+  #results {
+    display: block;
+    color: red;
+  }
+  p, span, em, a, b, button {
+    border: 1px solid transparent;
+  }
+  p {
+    margin: 10px;
+  }
+  span {
+    color: blue;
+  }
+  input {
+    width: 100px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="container">
+  <div>
+    <p>This <span>is the <em>way</em> we</span>
+      write <em>the</em> demo,</p>
+  </div>
+​
+  <div>
+    <a href="#"><b>w</b>rit<b>e</b></a> the <span>demo,</span> <button>write
+    the</button> demo,
+  </div>
+​
+  <div>
+    This <span>the way we <em>write</em> the <em>demo</em> so</span>
+    <input type="text" value="early"> in
+  </div>
+​
+  <p>
+    <span>t</span>he <span>m</span>orning.
+    <span id="results">Found <span>0</span> children in <span>TAG</span>.</span>
+  </p>
+</div>
+​
+<script>
+$( "#container" ).click(function ( event ) {
+  $( "*" ).removeClass( "hilite" );
+  var kids = $( event.target ).children();
+  var len = kids.addClass( "hilite" ).length;
+​
+  $( "#results span:first" ).text( len );
+  $( "#results span:last" ).text( event.target.tagName );
+​
+  event.preventDefault();
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Find all children of each div.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>children demo</title>
+  <style>
+  body {
+    font-size: 16px;
+    font-weight: bolder;
+  }
+  span {
+    color: blue;
+  }
+  p {
+    margin: 5px 0;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello (this is a paragraph)</p>
+​
+<div><span>Hello Again (this span is a child of the a div)</span></div>
+<p>And <span>Again</span> (in another paragraph)</p>
+​
+<div>And One Last <span>Time</span> (most text directly in a div)</div>
+​
+<script>
+$( "div" ).children().css( "border-bottom", "3px double red" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Find all children with a class &quot;selected&quot; of each div.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>children demo</title>
+  <style>
+  body {
+    font-size: 16px;
+    font-weight: bolder;
+  }
+  p {
+    margin: 5px 0;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>
+  <span>Hello</span>
+  <p class="selected">Hello Again</p>
+  <div class="selected">And Again</div>
+  <p>And One Last Time</p>
+</div>
+​
+<script>
+$( "div" ).children( ".selected" ).css( "color", "blue" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    children(selector?: JQuery.Selector): this;
+    /**
+     * Remove from the queue all items that have not yet been run.
+     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
+     * @see \`{@link https://api.jquery.com/clearQueue/ }\`
+     * @since 1.4
+     * @example ​ ````Empty the queue.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>clearQueue demo</title>
+  <style>
+  div {
+    margin: 3px;
+    width: 40px;
+    height: 40px;
+    position: absolute;
+    left: 0px;
+    top: 30px;
+    background: green;
+    display: none;
+  }
+  div.newcolor {
+    background: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="start">Start</button>
+<button id="stop">Stop</button>
+<div></div>
+​
+<script>
+$( "#start" ).click(function() {
+  var myDiv = $( "div" );
+  myDiv.show( "slow" );
+  myDiv.animate({
+    left:"+=200"
+  }, 5000 );
+​
+  myDiv.queue(function() {
+    var that = $( this );
+    that.addClass( "newcolor" );
+    that.dequeue();
+  });
+​
+  myDiv.animate({
+    left:"-=200"
+  }, 1500 );
+  myDiv.queue(function() {
+    var that = $( this );
+    that.removeClass( "newcolor" );
+    that.dequeue();
+  });
+  myDiv.slideUp();
+});
+​
+$( "#stop" ).click(function() {
+  var myDiv = $( "div" );
+  myDiv.clearQueue();
+  myDiv.stop();
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    clearQueue(queueName?: string): this;
+    /**
+     * Bind an event handler to the "click" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/click/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    click<TData>(eventData: TData,
+                 handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "click" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/click/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````Hide paragraphs on a page when they are clicked:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>click demo</title>
+  <style>
+  p {
+    color: red;
+    margin: 5px;
+    cursor: pointer;
+  }
+  p:hover {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>First Paragraph</p>
+<p>Second Paragraph</p>
+<p>Yet one more Paragraph</p>
+​
+<script>
+$( "p" ).click(function() {
+  $( this ).slideUp();
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Trigger the click event on all of the paragraphs on the page:
+```javascript
+$( "p" ).click();
+```
+     */
+    click(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Create a deep copy of the set of matched elements.
+     * @param withDataAndEvents A Boolean indicating whether event handlers and data should be copied along with the elements. The
+     *                          default value is false. *In jQuery 1.5.0 the default value was incorrectly true; it was changed back
+     *                          to false in 1.5.1 and up.
+     * @param deepWithDataAndEvents A Boolean indicating whether event handlers and data for all children of the cloned element should
+     *                              be copied. By default its value matches the first argument's value (which defaults to false).
+     * @see \`{@link https://api.jquery.com/clone/ }\`
+     * @since 1.0
+     * @since 1.5
+     * @example ​ ````Clones all b elements (and selects the clones) and prepends them to all paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>clone demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<b>Hello</b><p>, how are you?</p>
+​
+<script>
+$( "b" ).clone().prependTo( "p" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    clone(withDataAndEvents?: boolean, deepWithDataAndEvents?: boolean): this;
+    /**
+     * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
+     * @param selector A string containing a selector expression to match elements against.
+     * @param context A DOM element within which a matching element may be found.
+     * @see \`{@link https://api.jquery.com/closest/ }\`
+     * @since 1.4
+     */
+    closest(selector: JQuery.Selector, context: Element): this;
+    /**
+     * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
+     * @param selector_selection_element _&#x40;param_ `selector_selection_element`
+     * <br>
+     * * `selector` — A string containing a selector expression to match elements against. <br>
+     * * `selection` — A jQuery object to match elements against. <br>
+     * * `element` — An element to match elements against.
+     * @see \`{@link https://api.jquery.com/closest/ }\`
+     * @since 1.3
+     * @since 1.6
+     * @example ​ ````Show how event delegation can be done with closest. The closest list element toggles a yellow background when it or its descendent is clicked.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>closest demo</title>
+  <style>
+  li {
+    margin: 3px;
+    padding: 3px;
+    background: #EEEEEE;
+  }
+  li.highlight {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul>
+  <li><b>Click me!</b></li>
+  <li>You can also <b>Click me!</b></li>
+</ul>
+​
+<script>
+$( document ).on( "click", function( event ) {
+  $( event.target ).closest( "li" ).toggleClass( "highlight" );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Pass a jQuery object to closest. The closest list element toggles a yellow background when it or its descendent is clicked.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>closest demo</title>
+  <style>
+  li {
+    margin: 3px;
+    padding: 3px;
+    background: #EEEEEE;
+  }
+  li.highlight {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul>
+  <li><b>Click me!</b></li>
+  <li>You can also <b>Click me!</b></li>
+</ul>
+​
+<script>
+var listElements = $( "li" ).css( "color", "blue" );
+$( document ).on( "click", function( event ) {
+  $( event.target ).closest( listElements ).toggleClass( "highlight" );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    closest(selector_selection_element: JQuery.Selector | Element | JQuery): this;
+    /**
+     * Get the children of each element in the set of matched elements, including text and comment nodes.
+     * @see \`{@link https://api.jquery.com/contents/ }\`
+     * @since 1.2
+     * @example ​ ````Find all the text nodes inside a paragraph and wrap them with a bold tag.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>contents demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello <a href="https://johnresig.com/">John</a>, how are you doing?</p>
+​
+<script>
+$( "p" )
+  .contents()
+  .filter(function(){
+    return this.nodeType !== 1;
+  })
+  .wrap( "<b></b>" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the background color of links inside of an iframe.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>contents demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<iframe src="https://api.jquery.com/" width="80%" height="600" id="frameDemo"></iframe>
+​
+<script>
+$( "#frameDemo" ).contents().find( "a" ).css( "background-color", "#BADA55" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    contents(): JQuery<TElement | Text | Comment>;
+    /**
+     * Bind an event handler to the "contextmenu" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/contextmenu/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    contextmenu<TData>(eventData: TData,
+                       handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "contextmenu" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/contextmenu/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````To show a &quot;Hello World!&quot; alert box when the contextmenu event is triggered on a paragraph on the page:
+```javascript
+$( "p" ).contextmenu(function() {
+  alert( "Hello World!" );
+});
+```
+     * @example ​ ````Right click to toggle background color.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>contextmenu demo</title>
+  <style>
+  div {
+    background: blue;
+    color: white;
+    height: 100px;
+    width: 150px;
+ }
+  div.contextmenu {
+    background: yellow;
+    color: black;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div></div>
+<span>Right click the block</span>
+​
+<script>
+var div = $( "div:first" );
+div.contextmenu(function() {
+  div.toggleClass( "contextmenu" );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    contextmenu(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Set one or more CSS properties for the set of matched elements.
+     * @param propertyName A CSS property name.
+     * @param value_function _&#x40;param_ `value_function`
+     * <br>
+     * * `value` — A value to set for the property. <br>
+     * * `function` — A function returning the value to set. `this` is the current element. Receives the index position of
+     *                the element in the set and the old value as arguments.
+     * @see \`{@link https://api.jquery.com/css/ }\`
+     * @since 1.0
+     * @since 1.4
+     * @example ​ ````Change the color of any paragraph to red on mouseover event.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>css demo</title>
+  <style>
+  p {
+    color: blue;
+    width: 200px;
+    font-size: 14px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+  <p>Just roll the mouse over me.</p>
+​
+  <p>Or me to see a color change.</p>
+​
+<script>
+$( "p" ).on( "mouseover", function() {
+  $( this ).css( "color", "red" );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Increase the width of #box by 200 pixels the first time it is clicked.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>css demo</title>
+  <style>
+  #box {
+    background: black;
+    color: snow;
+    width: 100px;
+    padding: 10px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="box">Click me to grow</div>
+​
+<script>
+$( "#box" ).one( "click", function() {
+  $( this ).css( "width", "+=200" );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Highlight a clicked word in the paragraph.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>css demo</title>
+  <style>
+  p {
+    color: blue;
+    font-weight: bold;
+    cursor: pointer;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>
+  Once upon a time there was a man
+  who lived in a pizza parlor. This
+  man just loved pizza and ate it all
+  the time.  He went on to be the
+  happiest man in the world.  The end.
+</p>
+​
+<script>
+var words = $( "p" ).first().text().split( /\s+/ );
+var text = words.join( "</span> <span>" );
+$( "p" ).first().html( "<span>" + text + "</span>" );
+$( "span" ).on( "click", function() {
+  $( this ).css( "background-color", "yellow" );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    css(propertyName: string,
+        value_function: string | number | ((this: TElement, index: number, value: string) => string | number | void | undefined)): this;
+    /**
+     * Set one or more CSS properties for the set of matched elements.
+     * @param properties An object of property-value pairs to set.
+     * @see \`{@link https://api.jquery.com/css/ }\`
+     * @since 1.0
+     * @example ​ ````Change the font weight and background color on mouseenter and mouseleave.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>css demo</title>
+  <style>
+  p {
+    color: green;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Move the mouse over a paragraph.</p>
+<p>Like this one or the one above.</p>
+​
+<script>
+$( "p" )
+  .on( "mouseenter", function() {
+    $( this ).css({
+      "background-color": "yellow",
+      "font-weight": "bolder"
+    });
+  })
+  .on( "mouseleave", function() {
+    var styles = {
+      backgroundColor : "#ddd",
+      fontWeight: ""
+    };
+    $( this ).css( styles );
+  });
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Increase the size of a div when you click it.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>css demo</title>
+  <style>
+  div {
+    width: 20px;
+    height: 15px;
+    background-color: #f33;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>click</div>
+<div>click</div>
+​
+<script>
+$( "div" ).on( "click", function() {
+  $( this ).css({
+    width: function( index, value ) {
+      return parseFloat( value ) * 1.2;
+    },
+    height: function( index, value ) {
+      return parseFloat( value ) * 1.2;
+    }
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    css(properties: JQuery.PlainObject<string | number | ((this: TElement, index: number, value: string) => string | number | void | undefined)>): this;
+    /**
+     * Get the computed style properties for the first element in the set of matched elements.
+     * @param propertyName A CSS property.
+     * @see \`{@link https://api.jquery.com/css/ }\`
+     * @since 1.0
+     * @example ​ ````Get the background color of a clicked div.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>css demo</title>
+  <style>
+  div {
+    width: 60px;
+    height: 60px;
+    margin: 5px;
+    float: left;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<span id="result">&nbsp;</span>
+<div style="background-color:blue;"></div>
+<div style="background-color:rgb(15,99,30);"></div>
+<div style="background-color:#123456;"></div>
+<div style="background-color:#f11;"></div>
+​
+<script>
+$( "div" ).click(function() {
+  var color = $( this ).css( "background-color" );
+  $( "#result" ).html( "That div is <span style='color:" +
+    color + ";'>" + color + "</span>." );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    css(propertyName: string): string;
+    /**
+     * Get the computed style properties for the first element in the set of matched elements.
+     * @param propertyNames An array of one or more CSS properties.
+     * @see \`{@link https://api.jquery.com/css/ }\`
+     * @since 1.9
+     * @example ​ ````Get the width, height, text color, and background color of a clicked div.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>css demo</title>
+  <style>
+  div {
+    height: 50px;
+    margin: 5px;
+    padding: 5px;
+    float: left;
+  }
+  #box1 {
+    width: 50px;
+    color: yellow;
+    background-color: blue;
+  }
+  #box2 {
+    width: 80px;
+    color: rgb(255, 255, 255);
+    background-color: rgb(15, 99, 30);
+  }
+  #box3 {
+    width: 40px;
+    color: #fcc;
+    background-color: #123456;
+  }
+  #box4 {
+    width: 70px;
+    background-color: #f11;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p id="result">&nbsp;</p>
+<div id="box1">1</div>
+<div id="box2">2</div>
+<div id="box3">3</div>
+<div id="box4">4</div>
+​
+<script>
+$( "div" ).click(function() {
+  var html = [ "The clicked div has the following styles:" ];
+​
+  var styleProps = $( this ).css([
+    "width", "height", "color", "background-color"
+  ]);
+  $.each( styleProps, function( prop, value ) {
+    html.push( prop + ": " + value );
+  });
+​
+  $( "#result" ).html( html.join( "<br>" ) );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    css(propertyNames: string[]): JQuery.PlainObject<string>;
+    /**
+     * Store arbitrary data associated with the matched elements.
+     * @param key A string naming the piece of data to set.
+     * @param value The new data value; this can be any Javascript type except `undefined`.
+     * @see \`{@link https://api.jquery.com/data/ }\`
+     * @since 1.2.3
+     * @example ​ ````Store then retrieve a value from the div element.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>data demo</title>
+  <style>
+  div {
+    color: blue;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>
+  The values stored were
+  <span></span>
+  and
+  <span></span>
+</div>
+​
+<script>
+$( "div" ).data( "test", { first: 16, last: "pizza!" } );
+$( "span:first" ).text( $( "div" ).data( "test" ).first );
+$( "span:last" ).text( $( "div" ).data( "test" ).last );
+</script>
+​
+</body>
+</html>
+```
+     */
+    data(key: string, value: string | number | boolean | symbol | object | null): this;
+    /**
+     * Store arbitrary data associated with the matched elements.
+     * @param obj An object of key-value pairs of data to update.
+     * @see \`{@link https://api.jquery.com/data/ }\`
+     * @since 1.4.3
+     */
+    data(obj: JQuery.PlainObject): this;
+    /**
+     * Return the value at the named data store for the first element in the jQuery collection, as set by data(name, value) or by an HTML5 data-* attribute.
+     * @param key Name of the data stored.
+     * @param value `undefined` is not recognized as a data value. Calls such as `.data( "name", undefined )`
+     *              will return the jQuery object that it was called on, allowing for chaining.
+     * @see \`{@link https://api.jquery.com/data/ }\`
+     * @since 1.2.3
+     */
+    // `unified-signatures` is disabled so that behavior when passing `undefined` to `value` can be documented. Unifying the signatures
+    // results in potential confusion for users from an unexpected parameter.
+    // tslint:disable-next-line:unified-signatures
+    data(key: string, value: undefined): any;
+    /**
+     * Return the value at the named data store for the first element in the jQuery collection, as set by data(name, value) or by an HTML5 data-* attribute.
+     * @param key Name of the data stored.
+     * @see \`{@link https://api.jquery.com/data/ }\`
+     * @since 1.2.3
+     * @example ​ ````Get the data named &quot;blah&quot; stored at for an element.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>data demo</title>
+  <style>
+  div {
+    margin: 5px;
+    background: yellow;
+  }
+  button {
+    margin: 5px;
+    font-size: 14px;
+  }
+  p {
+    margin: 5px;
+    color: blue;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>A div</div>
+<button>Get "blah" from the div</button>
+<button>Set "blah" to "hello"</button>
+<button>Set "blah" to 86</button>
+<button>Remove "blah" from the div</button>
+<p>The "blah" value of this div is <span>?</span></p>
+​
+<script>
+$( "button" ).click(function() {
+  var value;
+​
+  switch ( $( "button" ).index( this ) ) {
+    case 0 :
+      value = $( "div" ).data( "blah" );
+      break;
+    case 1 :
+      $( "div" ).data( "blah", "hello" );
+      value = "Stored!";
+      break;
+    case 2 :
+      $( "div" ).data( "blah", 86 );
+      value = "Stored!";
+      break;
+    case 3 :
+      $( "div" ).removeData( "blah" );
+      value = "Removed!";
+      break;
+  }
+​
+  $( "span" ).text( "" + value );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    data(key: string): any;
+    /**
+     * Return the value at the named data store for the first element in the jQuery collection, as set by data(name, value) or by an HTML5 data-* attribute.
+     * @see \`{@link https://api.jquery.com/data/ }\`
+     * @since 1.4
+     */
+    data(): JQuery.PlainObject;
+    /**
+     * Bind an event handler to the "dblclick" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/dblclick/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    dblclick<TData>(eventData: TData,
+                    handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "dblclick" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/dblclick/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````To bind a &quot;Hello World!&quot; alert box to the dblclick event on every paragraph on the page:
+```javascript
+$( "p" ).dblclick(function() {
+  alert( "Hello World!" );
+});
+```
+     * @example ​ ````Double click to toggle background color.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>dblclick demo</title>
+  <style>
+  div {
+    background: blue;
+    color: white;
+    height: 100px;
+    width: 150px;
+ }
+  div.dbl {
+    background: yellow;
+    color: black;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div></div>
+<span>Double click the block</span>
+​
+<script>
+var divdbl = $( "div:first" );
+divdbl.dblclick(function() {
+  divdbl.toggleClass( "dbl" );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    dblclick(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Set a timer to delay execution of subsequent items in the queue.
+     * @param duration An integer indicating the number of milliseconds to delay execution of the next item in the queue.
+     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
+     * @see \`{@link https://api.jquery.com/delay/ }\`
+     * @since 1.4
+     * @example ​ ````Animate the hiding and showing of two divs, delaying the first before showing it.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>delay demo</title>
+  <style>
+  div {
+    position: absolute;
+    width: 60px;
+    height: 60px;
+    float: left;
+  }
+  .first {
+    background-color: #3f3;
+    left: 0;
+  }
+  .second {
+    background-color: #33f;
+    left: 80px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button>Run</button></p>
+<div class="first"></div>
+<div class="second"></div>
+​
+<script>
+$( "button" ).click(function() {
+  $( "div.first" ).slideUp( 300 ).delay( 800 ).fadeIn( 400 );
+  $( "div.second" ).slideUp( 300 ).fadeIn( 400 );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    delay(duration: JQuery.Duration, queueName?: string): this;
+    /**
+     * Attach a handler to one or more events for all elements that match the selector, now or in the future, based on a specific set of root elements.
+     * @param selector A selector to filter the elements that trigger the event.
+     * @param eventType A string containing one or more space-separated JavaScript event types, such as "click" or
+     *                  "keydown," or custom event names.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/delegate/ }\`
+     * @since 1.4.2
+     * @deprecated ​ Deprecated since 3.0. Use \`{@link on }\`.
+     *
+     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
+     *
+     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
+     */
+    delegate<TData>(selector: JQuery.Selector,
+                    eventType: string,
+                    eventData: TData,
+                    handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Attach a handler to one or more events for all elements that match the selector, now or in the future, based on a specific set of root elements.
+     * @param selector A selector to filter the elements that trigger the event.
+     * @param eventType A string containing one or more space-separated JavaScript event types, such as "click" or
+     *                  "keydown," or custom event names.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/delegate/ }\`
+     * @since 1.4.2
+     * @deprecated ​ Deprecated since 3.0. Use \`{@link on }\`.
+     *
+     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
+     *
+     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
+     * @example ​ ````Click a paragraph to add another. Note that .delegate() attaches a click event handler to all paragraphs - even new ones.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>delegate demo</title>
+  <style>
+  p {
+    background: yellow;
+    font-weight: bold;
+    cursor: pointer;
+    padding: 5px;
+  }
+  p.over {
+    background: #ccc;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Click me!</p>
+​
+<span></span>
+​
+<script>
+$( "body" ).delegate( "p", "click", function() {
+  $( this ).after( "<p>Another paragraph!</p>" );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````To display each paragraph&#39;s text in an alert box whenever it is clicked:
+```javascript
+$( "body" ).delegate( "p", "click", function() {
+  alert( $( this ).text() );
+});
+```
+     * @example ​ ````To cancel a default action and prevent it from bubbling up, return false:
+```javascript
+$( "body" ).delegate( "a", "click", function() {
+  return false;
+});
+```
+     * @example ​ ````To cancel only the default action by using the preventDefault method.
+```javascript
+$( "body" ).delegate( "a", "click", function( event ) {
+  event.preventDefault();
+});
+```
+     * @example ​ ````Can bind custom events too.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>delegate demo</title>
+  <style>
+  p {
+    color: red;
+  }
+  span {
+    color: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Has an attached custom event.</p>
+<button>Trigger custom event</button>
+<span style="display:none;"></span>
+​
+<script>
+$( "body" ).delegate( "p", "myCustomEvent", function( e, myName, myValue ) {
+  $( this ).text( "Hi there!" );
+  $( "span" )
+    .stop()
+    .css( "opacity", 1 )
+    .text( "myName = " + myName )
+    .fadeIn( 30 )
+    .fadeOut( 1000 );
+});
+$( "button" ).click(function() {
+  $( "p" ).trigger( "myCustomEvent" );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    delegate(selector: JQuery.Selector,
+             eventType: string,
+             handler: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Attach a handler to one or more events for all elements that match the selector, now or in the future, based on a specific set of root elements.
+     * @param selector A selector to filter the elements that trigger the event.
+     * @param events A plain object of one or more event types and functions to execute for them.
+     * @see \`{@link https://api.jquery.com/delegate/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.0. Use \`{@link on }\`.
+     *
+     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
+     *
+     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
+     */
+    delegate(selector: JQuery.Selector,
+             events: JQuery.PlainObject<JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false>): this;
+    /**
+     * Execute the next function on the queue for the matched elements.
+     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
+     * @see \`{@link https://api.jquery.com/dequeue/ }\`
+     * @since 1.2
+     * @example ​ ````Use dequeue to end a custom queue function which allows the queue to keep going.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>dequeue demo</title>
+  <style>
+  div {
+    margin: 3px;
+    width: 50px;
+    position: absolute;
+    height: 50px;
+    left: 10px;
+    top: 30px;
+    background-color: yellow;
+  }
+  div.red {
+    background-color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Start</button>
+<div></div>
+​
+<script>
+$( "button" ).click(function() {
+  $( "div" )
+    .animate({ left:"+=200px" }, 2000 )
+    .animate({ top:"0px" }, 600 )
+    .queue(function() {
+      $( this ).toggleClass( "red" ).dequeue();
+    })
+    .animate({ left:"10px", top:"30px" }, 700 );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    dequeue(queueName?: string): this;
+    /**
+     * Remove the set of matched elements from the DOM.
+     * @param selector A selector expression that filters the set of matched elements to be removed.
+     * @see \`{@link https://api.jquery.com/detach/ }\`
+     * @since 1.4
+     * @example ​ ````Detach all paragraphs from the DOM
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>detach demo</title>
+  <style>
+  p {
+    background: yellow;
+    margin: 6px 0;
+  }
+  p.off {
+    background: black;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+how are
+<p>you?</p>
+<button>Attach/detach paragraphs</button>
+​
+<script>
+$( "p" ).click(function() {
+  $( this ).toggleClass( "off" );
+});
+var p;
+$( "button" ).click(function() {
+  if ( p ) {
+    p.appendTo( "body" );
+    p = null;
+  } else {
+    p = $( "p" ).detach();
+  }
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    detach(selector?: JQuery.Selector): this;
+    /**
+     * Iterate over a jQuery object, executing a function for each matched element.
+     * @param funсtion A function to execute for each matched element.
+     * @see \`{@link https://api.jquery.com/each/ }\`
+     * @since 1.0
+     * @example ​ ````Iterate over three divs and sets their color property.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>each demo</title>
+  <style>
+  div {
+    color: red;
+    text-align: center;
+    cursor: pointer;
+    font-weight: bolder;
+    width: 300px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>Click here</div>
+<div>to iterate through</div>
+<div>these divs.</div>
+​
+<script>
+$( document.body ).click(function() {
+  $( "div" ).each(function( i ) {
+    if ( this.style.color !== "blue" ) {
+      this.style.color = "blue";
+    } else {
+      this.style.color = "";
+    }
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````To access a jQuery object instead of the regular DOM element, use $( this ). For example:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>each demo</title>
+  <style>
+  ul {
+    font-size: 18px;
+    margin: 0;
+  }
+  span {
+    color: blue;
+    text-decoration: underline;
+    cursor: pointer;
+  }
+  .example {
+    font-style: italic;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+To do list: <span>(click here to change)</span>
+<ul>
+  <li>Eat</li>
+  <li>Sleep</li>
+  <li>Be merry</li>
+</ul>
+​
+<script>
+$( "span" ).click(function() {
+  $( "li" ).each(function() {
+    $( this ).toggleClass( "example" );
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Use return false to break out of each() loops early.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>each demo</title>
+  <style>
+  div {
+    width: 40px;
+    height: 40px;
+    margin: 5px;
+    float: left;
+    border: 2px blue solid;
+    text-align: center;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Change colors</button>
+<span></span>
+<div></div>
+<div></div>
+<div></div>
+<div></div>
+<div id="stop">Stop here</div>
+<div></div>
+<div></div>
+<div></div>
+​
+<script>
+$( "button" ).click(function() {
+  $( "div" ).each(function( index, element ) {
+    // element == this
+    $( element ).css( "backgroundColor", "yellow" );
+    if ( $( this ).is( "#stop" ) ) {
+      $( "span" ).text( "Stopped at div index #" + index );
+      return false;
+    }
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    each(funсtion: (this: TElement, index: number, element: TElement) => void | false): this;
+    /**
+     * Remove all child nodes of the set of matched elements from the DOM.
+     * @see \`{@link https://api.jquery.com/empty/ }\`
+     * @since 1.0
+     * @example ​ ````Removes all child nodes (including text nodes) from all paragraphs
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>empty demo</title>
+  <style>
+  p {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>
+  Hello, <span>Person</span> <em>and person</em>.
+</p>
+​
+<button>Call empty() on above paragraph</button>
+​
+<script>
+$( "button" ).click(function() {
+  $( "p" ).empty();
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    empty(): this;
+    /**
+     * End the most recent filtering operation in the current chain and return the set of matched elements to its previous state.
+     * @see \`{@link https://api.jquery.com/end/ }\`
+     * @since 1.0
+     * @example ​ ````Selects all paragraphs, finds span elements inside these, and reverts the selection back to the paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>end demo</title>
+  <style>
+  p, div {
+    margin: 1px;
+    padding: 1px;
+    font-weight: bold;
+    font-size: 16px;
+  }
+  div {
+    color: blue;
+  }
+  b {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>
+  Hi there <span>how</span> are you <span>doing</span>?
+</p>
+​
+<p>
+  This <span>span</span> is one of
+  several <span>spans</span> in this
+  <span>sentence</span>.
+</p>
+​
+<div>
+  Tags in jQuery object initially: <b></b>
+</div>
+​
+<div>
+  Tags in jQuery object after find: <b></b>
+</div>
+​
+<div>
+  Tags in jQuery object after end: <b></b>
+</div>
+​
+<script>
+jQuery.fn.showTags = function( n ) {
+  var tags = this.map(function() {
+    return this.tagName;
+  })
+  .get()
+  .join( ", " );
+  $( "b:eq( " + n + " )" ).text( tags );
+  return this;
+};
+​
+$( "p" )
+  .showTags( 0 )
+  .find( "span" )
+    .showTags( 1 )
+    .css( "background", "yellow" )
+  .end()
+  .showTags( 2 )
+  .css( "font-style", "italic" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Selects all paragraphs, finds span elements inside these, and reverts the selection back to the paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>end demo</title>
+  <style>
+  p {
+    margin: 10px;
+    padding: 10px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><span>Hello</span>, how are you?</p>
+​
+<script>
+$( "p" )
+  .find( "span" )
+  .end()
+  .css( "border", "2px red solid" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    end(): this;
+    /**
+     * Reduce the set of matched elements to the one at the specified index.
+     * @param index An integer indicating the 0-based position of the element.
+     *              An integer indicating the position of the element, counting backwards from the last element in the set.
+     * @see \`{@link https://api.jquery.com/eq/ }\`
+     * @since 1.1.2
+     * @since 1.4
+     * @example ​ ````Turn the div with index 2 blue by adding an appropriate class.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>eq demo</title>
+  <style>
+  div {
+    width: 60px;
+    height: 60px;
+    margin: 10px;
+    float: left;
+    border: 2px solid blue;
+  }
+  .blue {
+    background: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div></div>
+<div></div>
+<div></div>
+<div></div>
+<div></div>
+<div></div>
+​
+<script>
+$( "body" ).find( "div" ).eq( 2 ).addClass( "blue" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    eq(index: number): this;
+    /**
+     * Merge the contents of an object onto the jQuery prototype to provide new jQuery instance methods.
+     * @param obj An object to merge onto the jQuery prototype.
+     * @see \`{@link https://api.jquery.com/jQuery.fn.extend/ }\`
+     * @since 1.0
+     * @example ​ ````Add two methods to the jQuery prototype ($.fn) object and then use one of them.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.fn.extend demo</title>
+  <style>
+  label {
+    display: block;
+    margin: .5em;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<label><input type="checkbox" name="foo"> Foo</label>
+<label><input type="checkbox" name="bar"> Bar</label>
+​
+<script>
+jQuery.fn.extend({
+  check: function() {
+    return this.each(function() {
+      this.checked = true;
+    });
+  },
+  uncheck: function() {
+    return this.each(function() {
+      this.checked = false;
+    });
+  }
+});
+​
+// Use the newly created .check() method
+$( "input[type='checkbox']" ).check();
+</script>
+​
+</body>
+</html>
+```
+     */
+    extend(obj: object): this;
+    /**
+     * Display the matched elements by fading them to opaque.
+     * @param duration A string or number determining how long the animation will run.
+     * @param easing A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/fadeIn/ }\`
+     * @since 1.4.3
+     */
+    fadeIn(duration: JQuery.Duration, easing: string, complete?: (this: TElement) => void): this;
+    /**
+     * Display the matched elements by fading them to opaque.
+     * @param duration_easing _&#x40;param_ `duration_easing`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `easing` — A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/fadeIn/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     * @example ​ ````Fades a red block in over the text. Once the animation is done, it quickly fades in more text on top.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>fadeIn demo</title>
+  <style>
+  p {
+    position: relative;
+    width: 400px;
+    height: 90px;
+  }
+  div {
+    position: absolute;
+    width: 400px;
+    height: 65px;
+    font-size: 36px;
+    text-align: center;
+    color: yellow;
+    background: red;
+    padding-top: 25px;
+    top: 0;
+    left: 0;
+    display: none;
+  }
+  span {
+    display: none;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>
+  Let it be known that the party of the first part
+  and the party of the second part are henceforth
+  and hereto directed to assess the allegations
+  for factual correctness... (<a href="#">click!</a>)
+  <div><span>CENSORED!</span></div>
+</p>
+​
+<script>
+$( "a" ).click(function() {
+  $( "div" ).fadeIn( 3000, function() {
+    $( "span" ).fadeIn( 100 );
+  });
+  return false;
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    fadeIn(duration_easing: JQuery.Duration | string, complete: (this: TElement) => void): this;
+    /**
+     * Display the matched elements by fading them to opaque.
+     * @param duration_easing_complete_options _&#x40;param_ `duration_easing_complete_options`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `easing` — A string indicating which easing function to use for the transition. <br>
+     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
+     * * `options` — A map of additional options to pass to the method.
+     * @see \`{@link https://api.jquery.com/fadeIn/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     * @example ​ ````Animates hidden divs to fade in one by one, completing each animation within 600 milliseconds.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>fadeIn demo</title>
+  <style>
+  span {
+    color: red;
+    cursor: pointer;
+  }
+  div {
+    margin: 3px;
+    width: 80px;
+    display: none;
+    height: 80px;
+    float: left;
+  }
+  #one {
+    background: #f00;
+  }
+  #two {
+    background: #0f0;
+  }
+  #three {
+    background: #00f;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<span>Click here...</span>
+<div id="one"></div>
+<div id="two"></div>
+<div id="three"></div>
+​
+<script>
+$( document.body ).click(function() {
+  $( "div:hidden:first" ).fadeIn( "slow" );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    fadeIn(duration_easing_complete_options?: JQuery.Duration | string | ((this: TElement) => void) | JQuery.EffectsOptions<TElement>): this;
+    /**
+     * Hide the matched elements by fading them to transparent.
+     * @param duration A string or number determining how long the animation will run.
+     * @param easing A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/fadeOut/ }\`
+     * @since 1.4.3
+     * @example ​ ````Fades out two divs, one with a &quot;linear&quot; easing and one with the default, &quot;swing,&quot; easing.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>fadeOut demo</title>
+  <style>
+  .box,
+  button {
+    float: left;
+    margin: 5px 10px 5px 0;
+  }
+  .box {
+    height: 80px;
+    width: 80px;
+    background: #090;
+  }
+  #log {
+    clear: left;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="btn1">fade out</button>
+<button id="btn2">show</button>
+​
+<div id="log"></div>
+​
+<div id="box1" class="box">linear</div>
+<div id="box2" class="box">swing</div>
+​
+<script>
+$( "#btn1" ).click(function() {
+  function complete() {
+    $( "<div>" ).text( this.id ).appendTo( "#log" );
+  }
+  $( "#box1" ).fadeOut( 1600, "linear", complete );
+  $( "#box2" ).fadeOut( 1600, complete );
+});
+​
+$( "#btn2" ).click(function() {
+  $( "div" ).show();
+  $( "#log" ).empty();
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    fadeOut(duration: JQuery.Duration, easing: string, complete?: (this: TElement) => void): this;
+    /**
+     * Hide the matched elements by fading them to transparent.
+     * @param duration_easing _&#x40;param_ `duration_easing`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `easing` — A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/fadeOut/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     * @example ​ ````Fades out spans in one section that you click on.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>fadeOut demo</title>
+  <style>
+  span {
+    cursor: pointer;
+  }
+  span.hilite {
+    background: yellow;
+  }
+  div {
+    display: inline;
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<h3>Find the modifiers - <div></div></h3>
+<p>
+  If you <span>really</span> want to go outside
+  <span>in the cold</span> then make sure to wear
+  your <span>warm</span> jacket given to you by
+  your <span>favorite</span> teacher.
+</p>
+​
+<script>
+$( "span" ).click(function() {
+  $( this ).fadeOut( 1000, function() {
+    $( "div" ).text( "'" + $( this ).text() + "' has faded!" );
+    $( this ).remove();
+  });
+});
+$( "span" ).hover(function() {
+  $( this ).addClass( "hilite" );
+}, function() {
+  $( this ).removeClass( "hilite" );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    fadeOut(duration_easing: JQuery.Duration | string, complete: (this: TElement) => void): this;
+    /**
+     * Hide the matched elements by fading them to transparent.
+     * @param duration_easing_complete_options _&#x40;param_ `duration_easing_complete_options`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `easing` — A string indicating which easing function to use for the transition. <br>
+     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
+     * * `options` — A map of additional options to pass to the method.
+     * @see \`{@link https://api.jquery.com/fadeOut/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     * @example ​ ````Animates all paragraphs to fade out, completing the animation within 600 milliseconds.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>fadeOut demo</title>
+  <style>
+  p {
+    font-size: 150%;
+    cursor: pointer;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>
+  If you click on this paragraph
+  you'll see it just fade away.
+</p>
+​
+<script>
+$( "p" ).click(function() {
+  $( "p" ).fadeOut( "slow" );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    fadeOut(duration_easing_complete_options?: JQuery.Duration | string | ((this: TElement) => void) | JQuery.EffectsOptions<TElement>): this;
+    /**
+     * Adjust the opacity of the matched elements.
+     * @param duration A string or number determining how long the animation will run.
+     * @param opacity A number between 0 and 1 denoting the target opacity.
+     * @param easing A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/fadeTo/ }\`
+     * @since 1.4.3
+     */
+    fadeTo(duration: JQuery.Duration, opacity: number, easing: string, complete?: (this: TElement) => void): this;
+    /**
+     * Adjust the opacity of the matched elements.
+     * @param duration A string or number determining how long the animation will run.
+     * @param opacity A number between 0 and 1 denoting the target opacity.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/fadeTo/ }\`
+     * @since 1.0
+     * @example ​ ````Animates first paragraph to fade to an opacity of 0.33 (33%, about one third visible), completing the animation within 600 milliseconds.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>fadeTo demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>
+Click this paragraph to see it fade.
+</p>
+​
+<p>
+Compare to this one that won't fade.
+</p>
+​
+<script>
+$( "p:first" ).click(function() {
+  $( this ).fadeTo( "slow", 0.33 );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Fade div to a random opacity on each click, completing the animation within 200 milliseconds.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>fadeTo demo</title>
+  <style>
+  p {
+    width: 80px;
+    margin: 0;
+    padding: 5px;
+  }
+  div {
+    width: 40px;
+    height: 40px;
+    position: absolute;
+  }
+  #one {
+    top: 0;
+    left: 0;
+    background: #f00;
+  }
+  #two {
+    top: 20px;
+    left: 20px;
+    background: #0f0;
+  }
+  #three {
+    top: 40px;
+    left:40px;
+    background:#00f;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>And this is the library that John built...</p>
+​
+<div id="one"></div>
+<div id="two"></div>
+<div id="three"></div>
+​
+<script>
+$( "div" ).click(function() {
+  $( this ).fadeTo( "fast", Math.random() );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Find the right answer! The fade will take 250 milliseconds and change various styles when it completes.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>fadeTo demo</title>
+  <style>
+  div, p {
+    width: 80px;
+    height: 40px;
+    top: 0;
+    margin: 0;
+    position: absolute;
+    padding-top: 8px;
+  }
+  p {
+    background: #fcc;
+    text-align: center;
+  }
+  div {
+    background: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Wrong</p>
+<div></div>
+<p>Wrong</p>
+<div></div>
+<p>Right!</p>
+<div></div>
+​
+<script>
+var getPos = function( n ) {
+  return (Math.floor( n ) * 90) + "px";
+};
+$( "p" ).each(function( n ) {
+  var r = Math.floor( Math.random() * 3 );
+  var tmp = $( this ).text();
+  $( this ).text( $( "p:eq(" + r + ")" ).text() );
+  $( "p:eq(" + r + ")" ).text( tmp );
+  $( this ).css( "left", getPos( n ) );
+});
+$( "div" )
+  .each(function( n ) {
+    $( this ).css( "left", getPos( n ) );
+  })
+  .css( "cursor", "pointer" )
+  .click( function() {
+    $( this ).fadeTo( 250, 0.25, function() {
+      $( this )
+        .css( "cursor", "" )
+        .prev()
+          .css({
+            "font-weight": "bolder",
+            "font-style": "italic"
+          });
+    });
+  });
+</script>
+​
+</body>
+</html>
+```
+     */
+    fadeTo(duration: JQuery.Duration, opacity: number, complete?: (this: TElement) => void): this;
+    /**
+     * Display or hide the matched elements by animating their opacity.
+     * @param duration A string or number determining how long the animation will run.
+     * @param easing A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/fadeToggle/ }\`
+     * @since 1.4.4
+     * @example ​ ````Fades first paragraph in or out, completing the animation within 600 milliseconds and using a linear easing. Fades last paragraph in or out for 200 milliseconds, inserting a &quot;finished&quot; message upon completion.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>fadeToggle demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>fadeToggle p1</button>
+<button>fadeToggle p2</button>
+<p>This paragraph has a slow, linear fade.</p>
+<p>This paragraph has a fast animation.</p>
+<div id="log"></div>
+​
+<script>
+$( "button:first" ).click(function() {
+  $( "p:first" ).fadeToggle( "slow", "linear" );
+});
+$( "button:last" ).click(function() {
+  $( "p:last" ).fadeToggle( "fast", function() {
+    $( "#log" ).append( "<div>finished</div>" );
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    fadeToggle(duration: JQuery.Duration, easing: string, complete?: (this: TElement) => void): this;
+    /**
+     * Display or hide the matched elements by animating their opacity.
+     * @param duration_easing _&#x40;param_ `duration_easing`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `easing` — A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/fadeToggle/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     * @example ​ ````Fades first paragraph in or out, completing the animation within 600 milliseconds and using a linear easing. Fades last paragraph in or out for 200 milliseconds, inserting a &quot;finished&quot; message upon completion.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>fadeToggle demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>fadeToggle p1</button>
+<button>fadeToggle p2</button>
+<p>This paragraph has a slow, linear fade.</p>
+<p>This paragraph has a fast animation.</p>
+<div id="log"></div>
+​
+<script>
+$( "button:first" ).click(function() {
+  $( "p:first" ).fadeToggle( "slow", "linear" );
+});
+$( "button:last" ).click(function() {
+  $( "p:last" ).fadeToggle( "fast", function() {
+    $( "#log" ).append( "<div>finished</div>" );
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    fadeToggle(duration_easing: JQuery.Duration | string, complete: (this: TElement) => void): this;
+    /**
+     * Display or hide the matched elements by animating their opacity.
+     * @param duration_easing_complete_options _&#x40;param_ `duration_easing_complete_options`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `easing` — A string indicating which easing function to use for the transition. <br>
+     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
+     * * `options` — A map of additional options to pass to the method.
+     * @see \`{@link https://api.jquery.com/fadeToggle/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     */
+    fadeToggle(duration_easing_complete_options?: JQuery.Duration | string | ((this: TElement) => void) | JQuery.EffectsOptions<TElement>): this;
+    /**
+     * Reduce the set of matched elements to those that match the selector or pass the function's test.
+     * @param selector_elements_selection_function _&#x40;param_ `selector_elements_selection_function`
+     * <br>
+     * * `selector` — A string containing a selector expression to match the current set of elements against. <br>
+     * * `elements` — One or more DOM elements to match the current set of elements against. <br>
+     * * `selection` — An existing jQuery object to match the current set of elements against. <br>
+     * * `function` — A function used as a test for each element in the set. this is the current DOM element.
+     * @see \`{@link https://api.jquery.com/filter/ }\`
+     * @since 1.0
+     * @since 1.4
+     * @example ​ ````Change the color of all divs; then add a border to those with a &quot;middle&quot; class.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>filter demo</title>
+  <style>
+  div {
+    width: 60px;
+    height: 60px;
+    margin: 5px;
+    float: left;
+    border: 2px white solid;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div></div>
+<div class="middle"></div>
+<div class="middle"></div>
+<div class="middle"></div>
+<div class="middle"></div>
+<div></div>
+​
+<script>
+$( "div" )
+  .css( "background", "#c8ebcc" )
+  .filter( ".middle" )
+    .css( "border-color", "red" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the color of all divs; then add a border to the second one (index == 1) and the div with an id of &quot;fourth.&quot;
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>filter demo</title>
+  <style>
+  div {
+    width: 60px;
+    height: 60px;
+    margin: 5px;
+    float: left;
+    border: 3px white solid;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="first"></div>
+<div id="second"></div>
+<div id="third"></div>
+<div id="fourth"></div>
+<div id="fifth"></div>
+<div id="sixth"></div>
+​
+<script>
+$( "div" )
+  .css( "background", "#b4b0da" )
+  .filter(function( index ) {
+    return index === 1 || $( this ).attr( "id" ) === "fourth";
+  })
+    .css( "border", "3px double red" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Select all divs and filter the selection with a DOM element, keeping only the one with an id of &quot;unique&quot;.
+```javascript
+$( "div" ).filter( document.getElementById( "unique" ) );
+```
+     * @example ​ ````Select all divs and filter the selection with a jQuery object, keeping only the one with an id of &quot;unique&quot;.
+```javascript
+$( "div" ).filter( $( "#unique" ) );
+```
+     */
+    filter(selector_elements_selection_function:
+        JQuery.Selector |
+        JQuery.TypeOrArray<Element> |
+        JQuery |
+        ((this: TElement, index: number, element: TElement) => boolean)
+    ): this;
+    /**
+     * Get the descendants of each element in the current set of matched elements, filtered by a selector, jQuery object, or element.
+     * @param selector_element _&#x40;param_ `selector_element`
+     * <br>
+     * * `selector` — A string containing a selector expression to match elements against. <br>
+     * * `element` — An element or a jQuery object to match elements against.
+     * @see \`{@link https://api.jquery.com/find/ }\`
+     * @since 1.0
+     * @since 1.6
+     * @example ​ ````Starts with all paragraphs and searches for descendant span elements, same as $( &quot;p span&quot; )
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>find demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><span>Hello</span>, how are you?</p>
+<p>Me? I'm <span>good</span>.</p>
+​
+<script>
+$( "p" ).find( "span" ).css( "color", "red" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````A selection using a jQuery collection of all span tags. Only spans within p tags are changed to red while others are left blue.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>find demo</title>
+  <style>
+  span {
+    color: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><span>Hello</span>, how are you?</p>
+<p>Me? I'm <span>good</span>.</p>
+<div>Did you <span>eat</span> yet?</div>
+​
+<script>
+var spans = $( "span" );
+$( "p" ).find( spans ).css( "color", "red" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Add spans around each word then add a hover and italicize words with the letter t.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>find demo</title>
+  <style>
+  p {
+    font-size: 20px;
+    width: 200px;
+    color: blue;
+    font-weight: bold;
+    margin: 0 10px;
+  }
+  .hilite {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>
+  When the day is short
+  find that which matters to you
+  or stop believing
+</p>
+​
+<script>
+var newText = $( "p" ).text().split( " " ).join( "</span> <span>" );
+newText = "<span>" + newText + "</span>";
+​
+$( "p" )
+  .html( newText )
+  .find( "span" )
+    .hover(function() {
+      $( this ).addClass( "hilite" );
+    }, function() {
+      $( this ).removeClass( "hilite" );
+    })
+  .end()
+  .find( ":contains('t')" )
+    .css({
+      "font-style": "italic",
+      "font-weight": "bolder"
+    });
+</script>
+​
+</body>
+</html>
+```
+     */
+    find(selector_element: JQuery.Selector | Element | JQuery): this;
+    /**
+     * Stop the currently-running animation, remove all queued animations, and complete all animations for the matched elements.
+     * @param queue The name of the queue in which to stop animations.
+     * @see \`{@link https://api.jquery.com/finish/ }\`
+     * @since 1.9
+     * @example ​ ````Click the Go button once to start the animation, and then click the other buttons to see how they affect the current and queued animations.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>finish demo</title>
+  <style>
+  .box {
+    position: absolute;
+    top: 10px;
+    left: 10px;
+    width: 15px;
+    height: 15px;
+    background: black;
+  }
+  #path {
+    height: 244px;
+    font-size: 70%;
+    border-left: 2px dashed red;
+    border-bottom: 2px dashed green;
+    border-right: 2px dashed blue;
+  }
+  button {
+    width: 12em;
+    display: block;
+    text-align: left;
+    margin: 0 auto;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div class="box"></div>
+<div id="path">
+  <button id="go">Go</button>
+  <br>
+  <button id="bstt" class="b">.stop( true,true )</button>
+  <button id="bcf" class="b">.clearQueue().finish()</button>
+  <br>
+  <button id="bstf" class="b">.stop( true, false )</button>
+  <button id="bcs" class="b">.clearQueue().stop()</button>
+  <br>
+  <button id="bsff" class="b">.stop( false, false )</button>
+  <button id="bs" class="b">.stop()</button>
+  <br>
+  <button id="bsft" class="b">.stop( false, true )</button>
+  <br>
+  <button id="bf" class="b">.finish()</button>
+</div>
+​
+<script>
+var horiz = $( "#path" ).width() - 20,
+  vert = $( "#path" ).height() - 20;
+​
+var btns = {
+  bstt: function() {
+    $( "div.box" ).stop( true, true );
+  },
+  bs: function() {
+    $( "div.box" ).stop();
+  },
+  bsft: function() {
+    $( "div.box" ).stop( false, true );
+  },
+  bf: function() {
+    $( "div.box" ).finish();
+  },
+  bcf: function() {
+    $( "div.box" ).clearQueue().finish();
+  },
+  bsff: function() {
+    $( "div.box" ).stop( false, false );
+  },
+  bstf: function() {
+    $( "div.box" ).stop( true, false );
+  },
+  bcs: function() {
+    $( "div.box" ).clearQueue().stop();
+  }
+};
+​
+$( "button.b" ).on( "click", function() {
+  btns[ this.id ]();
+});
+​
+$( "#go" ).on( "click", function() {
+  $( ".box" )
+    .clearQueue()
+    .stop()
+    .css({
+      left: 10,
+      top: 10
+    })
+    .animate({
+      top: vert
+    }, 3000 )
+    .animate({
+      left: horiz
+    }, 3000 )
+    .animate({
+      top: 10
+    }, 3000 );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    finish(queue?: string): this;
+    /**
+     * Reduce the set of matched elements to the first in the set.
+     * @see \`{@link https://api.jquery.com/first/ }\`
+     * @since 1.4
+     * @example ​ ````Highlight the first span in a paragraph.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>first demo</title>
+  <style>
+  .highlight{
+    background-color: yellow
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>
+  <span>Look:</span>
+  <span>This is some text in a paragraph.</span>
+  <span>This is a note about it.</span>
+</p>
+​
+<script>
+$( "p span" ).first().addClass( "highlight" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    first(): this;
+    /**
+     * Bind an event handler to the "focus" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/focus/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    focus<TData>(eventData: TData,
+                 handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "focus" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/focus/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````Fire focus.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>focus demo</title>
+  <style>
+  span {
+    display: none;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><input type="text"> <span>focus fire</span></p>
+<p><input type="password"> <span>focus fire</span></p>
+​
+<script>
+$( "input" ).focus(function() {
+  $( this ).next( "span" ).css( "display", "inline" ).fadeOut( 1000 );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````To stop people from writing in text input boxes, try:
+```javascript
+$( "input[type=text]" ).focus(function() {
+  $( this ).blur();
+});
+```
+     * @example ​ ````To focus on a login input box with id &#39;login&#39; on page startup, try:
+```javascript
+$( document ).ready(function() {
+  $( "#login" ).focus();
+});
+```
+     */
+    focus(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Bind an event handler to the "focusin" event.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/focusin/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    focusin<TData>(eventData: TData,
+                   handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "focusin" event.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/focusin/ }\`
+     * @since 1.4
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````Watch for a focus to occur within the paragraphs on the page.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>focusin demo</title>
+  <style>
+  span {
+    display: none;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><input type="text"> <span>focusin fire</span></p>
+<p><input type="password"> <span>focusin fire</span></p>
+​
+<script>
+$( "p" ).focusin(function() {
+  $( this ).find( "span" ).css( "display", "inline" ).fadeOut( 1000 );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    focusin(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Bind an event handler to the "focusout" JavaScript event.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/focusout/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    focusout<TData>(eventData: TData,
+                    handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "focusout" JavaScript event.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/focusout/ }\`
+     * @since 1.4
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````Watch for a loss of focus to occur inside paragraphs and note the difference between the focusout count and the blur count. (The blur count does not change because those events do not bubble.)
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>focusout demo</title>
+  <style>
+  .inputs {
+    float: left;
+    margin-right: 1em;
+  }
+  .inputs p {
+    margin-top: 0;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div class="inputs">
+  <p>
+    <input type="text"><br>
+    <input type="text">
+  </p>
+  <p>
+    <input type="password">
+  </p>
+</div>
+<div id="focus-count">focusout fire</div>
+<div id="blur-count">blur fire</div>
+​
+<script>
+var focus = 0,
+  blur = 0;
+$( "p" )
+  .focusout(function() {
+    focus++;
+    $( "#focus-count" ).text( "focusout fired: " + focus + "x" );
+  })
+  .blur(function() {
+    blur++;
+    $( "#blur-count" ).text( "blur fired: " + blur + "x" );
+  });
+</script>
+​
+</body>
+</html>
+```
+     */
+    focusout(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Retrieve one of the elements matched by the jQuery object.
+     * @param index A zero-based integer indicating which element to retrieve.
+     * @see \`{@link https://api.jquery.com/get/ }\`
+     * @since 1.0
+     * @example ​ ````Display the tag name of the click element.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>get demo</title>
+  <style>
+  span {
+    color: red;
+  }
+  div {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<span>&nbsp;</span>
+<p>In this paragraph is an <span>important</span> section</p>
+<div><input type="text"></div>
+​
+<script>
+$( "*", document.body ).click(function( event ) {
+  event.stopPropagation();
+  var domElement = $( this ).get( 0 );
+  $( "span:first" ).text( "Clicked on - " + domElement.nodeName );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    get(index: number): TElement;
+    /**
+     * Retrieve the elements matched by the jQuery object.
+     * @see \`{@link https://api.jquery.com/get/ }\`
+     * @since 1.0
+     * @example ​ ````Select all divs in the document and return the DOM Elements as an Array; then use the built-in reverse() method to reverse that array.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>get demo</title>
+  <style>
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+Reversed - <span></span>
+​
+<div>One</div>
+<div>Two</div>
+<div>Three</div>
+​
+<script>
+function display( divs ) {
+  var a = [];
+  for ( var i = 0; i < divs.length; i++ ) {
+    a.push( divs[ i ].innerHTML );
+  }
+  $( "span" ).text( a.join(" ") );
+}
+display( $( "div" ).get().reverse() );
+</script>
+​
+</body>
+</html>
+```
+     */
+    get(): TElement[];
+    /**
+     * Reduce the set of matched elements to those that have a descendant that matches the selector or DOM element.
+     * @param selector_contained _&#x40;param_ `selector_contained`
+     * <br>
+     * * `selector` — A string containing a selector expression to match elements against. <br>
+     * * `contained` — A DOM element to match elements against.
+     * @see \`{@link https://api.jquery.com/has/ }\`
+     * @since 1.4
+     * @example ​ ````Check if an element is inside another.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>has demo</title>
+  <style>
+  .full {
+    border: 1px solid red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul><li>Does the UL contain an LI?</li></ul>
+​
+<script>
+$( "ul" ).append( "<li>" +
+  ( $( "ul" ).has( "li" ).length ? "Yes" : "No" ) +
+  "</li>" );
+$( "ul" ).has( "li" ).addClass( "full" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    has(selector_contained: string | Element): this;
+    /**
+     * Determine whether any of the matched elements are assigned the given class.
+     * @param className The class name to search for.
+     * @see \`{@link https://api.jquery.com/hasClass/ }\`
+     * @since 1.2
+     * @example ​ ````Looks for the paragraph that contains &#39;selected&#39; as a class.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>hasClass demo</title>
+  <style>
+  p {
+    margin: 8px;
+    font-size: 16px;
+  }
+  .selected {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>This paragraph is black and is the first paragraph.</p>
+<p class="selected">This paragraph is red and is the second paragraph.</p>
+<div id="result1">First paragraph has selected class: </div>
+<div id="result2">Second paragraph has selected class: </div>
+<div id="result3">At least one paragraph has selected class: </div>
+​
+<script>
+$( "#result1" ).append( $( "p:first" ).hasClass( "selected" ).toString() );
+$( "#result2" ).append( $( "p:last" ).hasClass( "selected" ).toString() );
+$( "#result3" ).append( $( "p" ).hasClass( "selected" ).toString() ) ;
+</script>
+​
+</body>
+</html>
+```
+     */
+    hasClass(className: string): boolean;
+    /**
+     * Set the CSS height of every matched element.
+     * @param value_function _&#x40;param_ `value_function`
+     * <br>
+     * * `value` — An integer representing the number of pixels, or an integer with an optional unit of measure
+     *             appended (as a string). <br>
+     * * `function` — A function returning the height to set. Receives the index position of the element in the set and
+     *                the old height as arguments. Within the function, `this` refers to the current element in the set.
+     * @see \`{@link https://api.jquery.com/height/ }\`
+     * @since 1.0
+     * @since 1.4.1
+     * @example ​ ````To set the height of each div on click to 30px plus a color change.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>height demo</title>
+  <style>
+  div {
+    width: 50px;
+    height: 70px;
+    float: left;
+    margin: 5px;
+    background: rgb(255,140,0);
+    cursor: pointer;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div></div>
+<div></div>
+<div></div>
+<div></div>
+<div></div>
+​
+<script>
+$( "div" ).one( "click", function() {
+  $( this ).height( 30 ).css({
+    cursor: "auto",
+    backgroundColor: "green"
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    height(value_function: string | number | ((this: TElement, index: number, height: number) => string | number)): this;
+    /**
+     * Get the current computed height for the first element in the set of matched elements.
+     * @see \`{@link https://api.jquery.com/height/ }\`
+     * @since 1.0
+     * @example ​ ````Show various heights.  Note the values are from the iframe so might be smaller than you expected.  The yellow highlight shows the iframe body.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>height demo</title>
+  <style>
+  body {
+    background: yellow;
+  }
+  button {
+    font-size: 12px;
+    margin: 2px;
+  }
+  p {
+    width: 150px;
+    border: 1px red solid;
+  }
+  div {
+    color: red;
+    font-weight: bold;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="getp">Get Paragraph Height</button>
+<button id="getd">Get Document Height</button>
+<button id="getw">Get Window Height</button>
+​
+<div>&nbsp;</div>
+<p>
+  Sample paragraph to test height
+</p>
+​
+<script>
+function showHeight( element, height ) {
+  $( "div" ).text( "The height for the " + element + " is " + height + "px." );
+}
+$( "#getp" ).click(function() {
+  showHeight( "paragraph", $( "p" ).height() );
+});
+$( "#getd" ).click(function() {
+  showHeight( "document", $( document ).height() );
+});
+$( "#getw" ).click(function() {
+  showHeight( "window", $( window ).height() );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    height(): number | undefined;
+    /**
+     * Hide the matched elements.
+     * @param duration A string or number determining how long the animation will run.
+     * @param easing A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/hide/ }\`
+     * @since 1.4.3
+     */
+    hide(duration: JQuery.Duration, easing: string, complete: (this: TElement) => void): this;
+    /**
+     * Hide the matched elements.
+     * @param duration A string or number determining how long the animation will run.
+     * @param easing_complete _&#x40;param_ `easing_complete`
+     * <br>
+     * * `easing` — A string indicating which easing function to use for the transition. <br>
+     * * `complete` — A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/hide/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     * @example ​ ````Animates all spans (words in this case) to hide fastly, completing each animation within 200 milliseconds. Once each animation is done, it starts the next one.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>hide demo</title>
+  <style>
+  span {
+    background: #def3ca;
+    padding: 3px;
+    float: left;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="hider">Hide</button>
+<button id="shower">Show</button>
+<div>
+  <span>Once</span> <span>upon</span> <span>a</span>
+  <span>time</span> <span>there</span> <span>were</span>
+  <span>three</span> <span>programmers...</span>
+</div>
+​
+<script>
+$( "#hider" ).click(function() {
+  $( "span:last-child" ).hide( "fast", function() {
+    // Use arguments.callee so we don't need a named function
+    $( this ).prev().hide( "fast", arguments.callee );
+  });
+});
+$( "#shower" ).click(function() {
+  $( "span" ).show( 2000 );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Hides the divs when clicked over 2 seconds, then removes the div element when its hidden.  Try clicking on more than one box at a time.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>hide demo</title>
+  <style>
+  div {
+    background: #ece023;
+    width: 30px;
+    height: 40px;
+    margin: 2px;
+    float: left;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div></div>
+​
+<script>
+for ( var i = 0; i < 5; i++ ) {
+  $( "<div>" ).appendTo( document.body );
+}
+$( "div" ).click(function() {
+  $( this ).hide( 2000, function() {
+    $( this ).remove();
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    hide(duration: JQuery.Duration, easing_complete: string | ((this: TElement) => void)): this;
+    /**
+     * Hide the matched elements.
+     * @param duration_complete_options _&#x40;param_ `duration_complete_options`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
+     * * `options` — A map of additional options to pass to the method.
+     * @see \`{@link https://api.jquery.com/hide/ }\`
+     * @since 1.0
+     * @example ​ ````Hides all paragraphs then the link on click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>hide demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<a href="#">Click to hide me too</a>
+<p>Here is another paragraph</p>
+​
+<script>
+$( "p" ).hide();
+$( "a" ).click(function( event ) {
+  event.preventDefault();
+  $( this ).hide();
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Animates all shown paragraphs to hide slowly, completing the animation within 600 milliseconds.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>hide demo</title>
+  <style>
+  p {
+    background: #dad;
+    font-weight: bold;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Hide 'em</button>
+<p>Hiya</p>
+<p>Such interesting text, eh?</p>
+​
+<script>
+$( "button" ).click(function() {
+  $( "p" ).hide( "slow" );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    hide(duration_complete_options?: JQuery.Duration | ((this: TElement) => void) | JQuery.EffectsOptions<TElement>): this;
+    /**
+     * Bind one or two handlers to the matched elements, to be executed when the mouse pointer enters and leaves the elements.
+     * @param handlerInOut A function to execute when the mouse pointer enters or leaves the element.
+     * @param handlerOut A function to execute when the mouse pointer leaves the element.
+     * @see \`{@link https://api.jquery.com/hover/ }\`
+     * @since 1.0
+     * @since 1.4
+     * @deprecated ​ Deprecated.
+     *
+     * **Cause**: The `.hover()` method is a shorthand for the use of the `mouseover`/`mouseout` events. It is often a poor user interface choice because it does not allow for any small amounts of delay between when the mouse enters or exits an area and when the event fires. This can make it quite difficult to use with UI widgets such as drop-down menus. For more information on the problems of hovering, see the \`{@link http://cherne.net/brian/resources/jquery.hoverIntent.html hoverIntent plugin}\`.
+     *
+     * **Solution**: Review uses of `.hover()` to determine if they are appropriate, and consider use of plugins such as `hoverIntent` as an alternative. The direct replacement for `.hover(fn1, fn2)`, is `.on("mouseenter", fn1).on("mouseleave", fn2)`.
+     * @example ​ ````To add a special style to list items that are being hovered over, try:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>hover demo</title>
+  <style>
+  ul {
+    margin-left: 20px;
+    color: blue;
+  }
+  li {
+    cursor: default;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul>
+  <li>Milk</li>
+  <li>Bread</li>
+  <li class="fade">Chips</li>
+  <li class="fade">Socks</li>
+</ul>
+​
+<script>
+$( "li" ).hover(
+  function() {
+    $( this ).append( $( "<span> ***</span>" ) );
+  }, function() {
+    $( this ).find( "span:last" ).remove();
+  }
+);
+​
+$( "li.fade" ).hover(function() {
+  $( this ).fadeOut( 100 );
+  $( this ).fadeIn( 500 );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````To add a special style to table cells that are being hovered over, try:
+```javascript
+$( "td" ).hover(
+  function() {
+    $( this ).addClass( "hover" );
+  }, function() {
+    $( this ).removeClass( "hover" );
+  }
+);
+```
+     * @example ​ ````To unbind the above example use:
+```javascript
+$( "td" ).off( "mouseenter mouseleave" );
+```
+     * @example ​ ````Slide the next sibling LI up or down on hover, and toggle a class.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>hover demo</title>
+  <style>
+  ul {
+    margin-left: 20px;
+    color: blue;
+  }
+  li {
+    cursor: default;
+  }
+  li.active {
+    background: black;
+    color: white;
+  }
+  span {
+    color:red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul>
+  <li>Milk</li>
+  <li>White</li>
+  <li>Carrots</li>
+  <li>Orange</li>
+  <li>Broccoli</li>
+  <li>Green</li>
+</ul>
+​
+<script>
+$( "li" )
+  .filter( ":odd" )
+    .hide()
+  .end()
+  .filter( ":even" )
+    .hover(function() {
+      $( this )
+        .toggleClass( "active" )
+        .next()
+          .stop( true, true )
+          .slideToggle();
+    });
+</script>
+​
+</body>
+</html>
+```
+     */
+    // HACK: The type parameter T is not used but ensures the 'event' callback parameter is typed correctly.
+    // tslint:disable-next-line:no-unnecessary-generics
+    hover<T>(handlerInOut: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false,
+             handlerOut?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Set the HTML contents of each element in the set of matched elements.
+     * @param htmlString_function _&#x40;param_ `htmlString_function`
+     * <br>
+     * * `htmlString` — A string of HTML to set as the content of each matched element. <br>
+     * * `function` — A function returning the HTML content to set. Receives the index position of the element in the set
+     *                and the old HTML value as arguments. jQuery empties the element before calling the function; use the
+     *                oldhtml argument to reference the previous content. Within the function, `this` refers to the current
+     *                element in the set.
+     * @see \`{@link https://api.jquery.com/html/ }\`
+     * @since 1.0
+     * @since 1.4
+     * @example ​ ````Add some html to each div.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>html demo</title>
+  <style>
+  .red {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<span>Hello</span>
+<div></div>
+<div></div>
+<div></div>
+​
+<script>
+$( "div" ).html( "<span class='red'>Hello <b>Again</b></span>" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Add some html to each div then immediately do further manipulations to the inserted html.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>html demo</title>
+  <style>
+  div {
+    color: blue;
+    font-size: 18px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div></div>
+<div></div>
+<div></div>
+​
+<script>
+$( "div" ).html( "<b>Wow!</b> Such excitement..." );
+$( "div b" )
+  .append( document.createTextNode( "!!!" ) )
+  .css( "color", "red" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    html(htmlString_function: JQuery.htmlString | ((this: TElement, index: number, oldhtml: JQuery.htmlString) => JQuery.htmlString)): this;
+    /**
+     * Get the HTML contents of the first element in the set of matched elements.
+     * @see \`{@link https://api.jquery.com/html/ }\`
+     * @since 1.0
+     * @example ​ ````Click a paragraph to convert it from html to text.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>html demo</title>
+  <style>
+  p {
+    margin: 8px;
+    font-size: 20px;
+    color: blue;
+    cursor: pointer;
+  }
+  b {
+    text-decoration: underline;
+  }
+  button {
+    cursor: pointer;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>
+  <b>Click</b> to change the <span id="tag">html</span>
+</p>
+<p>
+  to a <span id="text">text</span> node.
+</p>
+<p>
+  This <button name="nada">button</button> does nothing.
+</p>
+​
+<script>
+$( "p" ).click(function() {
+  var htmlString = $( this ).html();
+  $( this ).text( htmlString );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    html(): string;
+    /**
+     * Search for a given element from among the matched elements.
+     * @param selector_element _&#x40;param_ `selector_element`
+     * <br>
+     * * `selector` — A selector representing a jQuery collection in which to look for an element. <br>
+     * * `element` — The DOM element or first element within the jQuery object to look for.
+     * @see \`{@link https://api.jquery.com/index/ }\`
+     * @since 1.0
+     * @since 1.4
+     * @example ​ ````On click, returns the index (zero-based) of that div in the page.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>index demo</title>
+  <style>
+  div {
+    background: yellow;
+    margin: 5px;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<span>Click a div!</span>
+<div>First div</div>
+<div>Second div</div>
+<div>Third div</div>
+​
+<script>
+$( "div" ).click(function() {
+  // `this` is the DOM element that was clicked
+  var index = $( "div" ).index( this );
+  $( "span" ).text( "That was div index #" + index );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Returns the index for the element with ID bar.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>index demo</title>
+  <style>
+  div {
+    font-weight: bold;
+    color: #090;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul>
+  <li id="foo">foo</li>
+  <li id="bar">bar</li>
+  <li id="baz">baz</li>
+</ul>
+<div></div>
+​
+<script>
+var listItem = $( "#bar" );
+$( "div" ).html( "Index: " + $( "li" ).index( listItem ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Returns the index for the first item in the jQuery collection.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>index demo</title>
+  <style>
+  div {
+    font-weight: bold;
+    color: #090;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul>
+  <li id="foo">foo</li>
+  <li id="bar">bar</li>
+  <li id="baz">baz</li>
+</ul>
+<div></div>
+​
+<script>
+var listItems = $( "li:gt(0)" );
+$( "div" ).html( "Index: " + $( "li" ).index( listItems ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Returns the index for the element with ID bar in relation to all &lt;li&gt; elements.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>index demo</title>
+  <style>
+  div {
+    font-weight: bold;
+    color: #090;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul>
+  <li id="foo">foo</li>
+  <li id="bar">bar</li>
+  <li id="baz">baz</li>
+</ul>
+<div></div>
+​
+<script>
+$( "div" ).html( "Index: " +  $( "#bar" ).index( "li" ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Returns the index for the element with ID bar in relation to its siblings.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>index demo</title>
+  <style>
+  div {
+    font-weight: bold;
+    color: #090;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul>
+  <li id="foo">foo</li>
+  <li id="bar">bar</li>
+  <li id="baz">baz</li>
+</ul>
+<div></div>
+​
+<script>
+var barIndex = $( "#bar" ).index();
+$( "div" ).html( "Index: " +  barIndex );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Returns -1, as there is no element with ID foobar.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>index demo</title>
+  <style>
+  div {
+    font-weight: bold;
+    color: #090;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul>
+  <li id="foo">foo</li>
+  <li id="bar">bar</li>
+  <li id="baz">baz</li>
+</ul>
+<div></div>
+​
+<script>
+var foobar = $( "li" ).index( $( "#foobar" ) );
+$( "div" ).html( "Index: " + foobar );
+</script>
+​
+</body>
+</html>
+```
+     */
+    index(selector_element?: JQuery.Selector | Element | JQuery): number;
+    /**
+     * Set the CSS inner height of each element in the set of matched elements.
+     * @param value_function _&#x40;param_ `value_function`
+     * <br>
+     * * `value` — A number representing the number of pixels, or a number along with an optional unit of measure
+     *             appended (as a string). <br>
+     * * `function` — A function returning the inner height (including padding but not border) to set. Receives the index
+     *                position of the element in the set and the old inner height as arguments. Within the function, `this`
+     *                refers to the current element in the set.
+     * @see \`{@link https://api.jquery.com/innerHeight/ }\`
+     * @since 1.8.0
+     * @example ​ ````Change the inner height of each div the first time it is clicked (and change its color).
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>innerHeight demo</title>
+  <style>
+div {
+  width: 60px;
+  padding: 10px;
+  height: 70px;
+  float: left;
+  margin: 5px;
+  background: red;
+  cursor: pointer;
+}
+.mod {
+  background: blue;
+  cursor: default;
+}
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>d</div>
+<div>d</div>
+<div>d</div>
+<div>d</div>
+<div>d</div>
+​
+<script>
+var modHeight = 70;
+$( "div" ).one( "click", function() {
+  $( this ).innerHeight( modHeight ).addClass( "mod" );
+  modHeight -= 8;
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    innerHeight(value_function: string | number | ((this: TElement, index: number, height: number) => string | number)): this;
+    /**
+     * Get the current computed height for the first element in the set of matched elements, including padding but not border.
+     * @see \`{@link https://api.jquery.com/innerHeight/ }\`
+     * @since 1.2.6
+     * @example ​ ````Get the innerHeight of a paragraph.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>innerHeight demo</title>
+  <style>
+  p {
+    margin: 10px;
+    padding: 5px;
+    border: 2px solid #666;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<p></p>
+​
+<script>
+var p = $( "p:first" );
+$( "p:last" ).text( "innerHeight:" + p.innerHeight() );
+</script>
+​
+</body>
+</html>
+```
+     */
+    innerHeight(): number | undefined;
+    /**
+     * Set the CSS inner width of each element in the set of matched elements.
+     * @param value_function _&#x40;param_ `value_function`
+     * <br>
+     * * `value` — A number representing the number of pixels, or a number along with an optional unit of measure
+     *             appended (as a string). <br>
+     * * `function` — A function returning the inner width (including padding but not border) to set. Receives the index
+     *                position of the element in the set and the old inner width as arguments. Within the function, `this`
+     *                refers to the current element in the set.
+     * @see \`{@link https://api.jquery.com/innerWidth/ }\`
+     * @since 1.8.0
+     * @example ​ ````Change the inner width of each div the first time it is clicked (and change its color).
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>innerWidth demo</title>
+  <style>
+div {
+width: 60px;
+padding: 10px;
+height: 50px;
+float: left;
+margin: 5px;
+background: red;
+cursor: pointer;
+}
+.mod {
+background: blue;
+cursor: default;
+}
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>d</div>
+<div>d</div>
+<div>d</div>
+<div>d</div>
+<div>d</div>
+​
+<script>
+var modWidth = 60;
+$( "div" ).one( "click", function() {
+$( this ).innerWidth( modWidth ).addClass( "mod" );
+modWidth -= 8;
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    innerWidth(value_function: string | number | ((this: TElement, index: number, width: number) => string | number)): this;
+    /**
+     * Get the current computed inner width for the first element in the set of matched elements, including padding but not border.
+     * @see \`{@link https://api.jquery.com/innerWidth/ }\`
+     * @since 1.2.6
+     * @example ​ ````Get the innerWidth of a paragraph.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>innerWidth demo</title>
+  <style>
+  p {
+    margin: 10px;
+    padding: 5px;
+    border: 2px solid #666;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<p></p>
+​
+<script>
+var p = $( "p:first" );
+$( "p:last" ).text( "innerWidth:" + p.innerWidth() );
+</script>
+​
+</body>
+</html>
+```
+     */
+    innerWidth(): number | undefined;
+    /**
+     * Insert every element in the set of matched elements after the target.
+     * @param target A selector, element, array of elements, HTML string, or jQuery object; the matched set of elements
+     *               will be inserted after the element(s) specified by this parameter.
+     * @see \`{@link https://api.jquery.com/insertAfter/ }\`
+     * @since 1.0
+     * @example ​ ````Insert all paragraphs after an element with id of &quot;foo&quot;. Same as $( &quot;#foo&quot; ).after( &quot;p&quot; )
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>insertAfter demo</title>
+  <style>
+  #foo {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p> is what I said... </p>
+<div id="foo">FOO!</div>
+​
+<script>
+$( "p" ).insertAfter( "#foo" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    insertAfter(target: JQuery.Selector | JQuery.htmlString | JQuery.TypeOrArray<Node> | JQuery<Node>): this;
+    /**
+     * Insert every element in the set of matched elements before the target.
+     * @param target A selector, element, array of elements, HTML string, or jQuery object; the matched set of elements
+     *               will be inserted before the element(s) specified by this parameter.
+     * @see \`{@link https://api.jquery.com/insertBefore/ }\`
+     * @since 1.0
+     * @example ​ ````Insert all paragraphs before an element with id of &quot;foo&quot;. Same as $( &quot;#foo&quot; ).before( &quot;p&quot; )
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>insertBefore demo</title>
+  <style>
+  #foo {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="foo">FOO!</div>
+<p>I would like to say: </p>
+​
+<script>
+$( "p" ).insertBefore( "#foo" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    insertBefore(target: JQuery.Selector | JQuery.htmlString | JQuery.TypeOrArray<Node> | JQuery<Node>): this;
+    /**
+     * Check the current matched set of elements against a selector, element, or jQuery object and return true if at least one of these elements matches the given arguments.
+     * @param selector_function_selection_elements _&#x40;param_ `selector_function_selection_elements`
+     * <br>
+     * * `selector` — A string containing a selector expression to match elements against. <br>
+     * * `function` — A function used as a test for every element in the set. It accepts two arguments, `index`, which is
+     *                the element's index in the jQuery collection, and `element`, which is the DOM element. Within the
+     *                function, `this` refers to the current DOM element. <br>
+     * * `selection` — An existing jQuery object to match the current set of elements against. <br>
+     * * `elements` — One or more elements to match the current set of elements against.
+     * @see \`{@link https://api.jquery.com/is/ }\`
+     * @since 1.0
+     * @since 1.6
+     * @example ​ ````Shows a few ways is() can be used inside an event handler.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>is demo</title>
+  <style>
+  div {
+    width: 60px;
+    height: 60px;
+    margin: 5px;
+    float: left;
+    border: 4px outset;
+    background: green;
+    text-align: center;
+    font-weight: bolder;
+    cursor: pointer;
+  }
+  .blue {
+    background: blue;
+  }
+  .red {
+    background: red;
+  }
+  span {
+    color: white;
+    font-size: 16px;
+  }
+  p {
+    color: red;
+    font-weight: bolder;
+    background: yellow;
+    margin: 3px;
+    clear: left;
+    display: none;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div></div>
+<div class="blue"></div>
+<div></div>
+<div class="red"></div>
+<div><br/><span>Peter</span></div>
+<div class="blue"></div>
+<p>&nbsp;</p>
+​
+<script>
+$( "div" ).one( "click", function() {
+  if ( $( this ).is( ":first-child" ) ) {
+    $( "p" ).text( "It's the first div." );
+  } else if ( $( this ).is( ".blue,.red" ) ) {
+    $( "p" ).text( "It's a blue or red div." );
+  } else if ( $( this ).is( ":contains('Peter')" ) ) {
+    $( "p" ).text( "It's Peter!" );
+  } else {
+    $( "p" ).html( "It's nothing <em>special</em>." );
+  }
+  $( "p" ).hide().slideDown( "slow" );
+  $( this ).css({
+    "border-style": "inset",
+    cursor: "default"
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Returns true, because the parent of the input is a form element.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>is demo</title>
+  <style>
+  div {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<form>
+  <input type="checkbox">
+</form>
+<div></div>
+​
+<script>
+var isFormParent = $( "input[type='checkbox']" ).parent().is( "form" );
+$( "div" ).text( "isFormParent = " + isFormParent );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Returns false, because the parent of the input is a p element.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>is demo</title>
+  <style>
+  div {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<form>
+  <p><input type="checkbox"></p>
+</form>
+<div></div>
+​
+<script>
+var isFormParent = $( "input[type='checkbox']" ).parent().is( "form" );
+$( "div" ).text( "isFormParent = " + isFormParent );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Checks against an existing collection of alternating list elements. Blue, alternating list elements slide up while others turn red.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>is demo</title>
+  <style>
+  li {
+    cursor: pointer;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul id="browsers">
+  <li>Chrome</li>
+  <li>Safari</li>
+  <li>Firefox</li>
+  <li>Opera</li>
+</ul>
+​
+<script>
+var alt = $( "#browsers li:nth-child(2n)" ).css( "background", "#0ff" );
+$( "li" ).click(function() {
+  var li = $( this );
+  if ( li.is( alt ) ) {
+    li.slideUp();
+  } else {
+    li.css( "background", "red" );
+  }
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````An alternate way to achieve the above example using an element rather than a jQuery object. Checks against an existing collection of alternating list elements. Blue, alternating list elements slide up while others turn red.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>is demo</title>
+  <style>
+  li {
+    cursor: pointer;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul id="browsers">
+  <li>Chrome</li>
+  <li>Safari</li>
+  <li>Firefox</li>
+  <li>Opera</li>
+</ul>
+​
+<script>
+var alt = $( "#browsers li:nth-child(2n)" ).css( "background", "#0ff" );
+$( "li" ).click(function() {
+  if ( alt.is( this ) ) {
+    $( this ).slideUp();
+  } else {
+    $( this ).css( "background", "red" );
+  }
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    is(selector_function_selection_elements: JQuery.Selector | JQuery.TypeOrArray<Element> | JQuery | ((this: TElement, index: number, element: TElement) => boolean)): boolean;
+    /**
+     * Bind an event handler to the "keydown" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/keydown/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    keydown<TData>(eventData: TData,
+                   handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "keydown" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/keydown/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````Show the event object for the keydown handler when a key is pressed in the input.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>keydown demo</title>
+  <style>
+  fieldset {
+    margin-bottom: 1em;
+  }
+  input {
+    display: block;
+    margin-bottom: .25em;
+  }
+  #print-output {
+    width: 100%;
+  }
+  .print-output-line {
+    white-space: pre;
+    padding: 5px;
+    font-family: monaco, monospace;
+    font-size: .7em;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<form>
+  <fieldset>
+    <label for="target">Type Something:</label>
+    <input id="target" type="text">
+  </fieldset>
+</form>
+<button id="other">
+  Trigger the handler
+</button>
+<script type="text/javascript" src="/resources/events.js"></script>
+​
+<script>
+var xTriggered = 0;
+$( "#target" ).keydown(function( event ) {
+  if ( event.which == 13 ) {
+   event.preventDefault();
+  }
+  xTriggered++;
+  var msg = "Handler for .keydown() called " + xTriggered + " time(s).";
+  $.print( msg, "html" );
+  $.print( event );
+});
+​
+$( "#other" ).click(function() {
+  $( "#target" ).keydown();
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    keydown(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Bind an event handler to the "keypress" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/keypress/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    keypress<TData>(eventData: TData,
+                    handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "keypress" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/keypress/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````Show the event object when a key is pressed in the input. Note: This demo relies on a simple $.print() plugin (https://api.jquery.com/resources/events.js) for the event object&#39;s output.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>keypress demo</title>
+  <style>
+  fieldset {
+    margin-bottom: 1em;
+  }
+  input {
+    display: block;
+    margin-bottom: .25em;
+  }
+  #print-output {
+    width: 100%;
+  }
+  .print-output-line {
+    white-space: pre;
+    padding: 5px;
+    font-family: monaco, monospace;
+    font-size: .7em;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<form>
+  <fieldset>
+    <label for="target">Type Something:</label>
+    <input id="target" type="text">
+  </fieldset>
+</form>
+<button id="other">
+  Trigger the handler
+</button>
+<script src="/resources/events.js"></script>
+​
+<script>
+var xTriggered = 0;
+$( "#target" ).keypress(function( event ) {
+  if ( event.which == 13 ) {
+     event.preventDefault();
+  }
+  xTriggered++;
+  var msg = "Handler for .keypress() called " + xTriggered + " time(s).";
+  $.print( msg, "html" );
+  $.print( event );
+});
+​
+$( "#other" ).click(function() {
+  $( "#target" ).keypress();
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    keypress(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Bind an event handler to the "keyup" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/keyup/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    keyup<TData>(eventData: TData,
+                 handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "keyup" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/keyup/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````Show the event object for the keyup handler (using a simple $.print plugin) when a key is released in the input.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>keyup demo</title>
+  <style>
+  fieldset {
+    margin-bottom: 1em;
+  }
+  input {
+    display: block;
+    margin-bottom: .25em;
+  }
+  #print-output {
+    width: 100%;
+  }
+  .print-output-line {
+    white-space: pre;
+    padding: 5px;
+    font-family: monaco, monospace;
+    font-size: .7em;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<form>
+  <fieldset>
+    <label for="target">Type Something:</label>
+    <input id="target" type="text">
+  </fieldset>
+</form>
+<button id="other">
+  Trigger the handler
+</button>
+<script type="text/javascript" src="/resources/events.js"></script>
+​
+<script>
+var xTriggered = 0;
+$( "#target" ).keyup(function( event ) {
+  xTriggered++;
+  var msg = "Handler for .keyup() called " + xTriggered + " time(s).";
+  $.print( msg, "html" );
+  $.print( event );
+}).keydown(function( event ) {
+  if ( event.which == 13 ) {
+    event.preventDefault();
+  }
+});
+​
+$( "#other").click(function() {
+  $( "#target" ).keyup();
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    keyup(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Reduce the set of matched elements to the final one in the set.
+     * @see \`{@link https://api.jquery.com/last/ }\`
+     * @since 1.4
+     * @example ​ ````Highlight the last span in a paragraph.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>last demo</title>
+  <style>
+  .highlight {
+    background-color: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><span>Look:</span> <span>This is some text in a paragraph.</span> <span>This is a note about it.</span></p>
+​
+<script>
+$( "p span" ).last().addClass( "highlight" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    last(): this;
+    /**
+     * Load data from the server and place the returned HTML into the matched element.
+     * @param url A string containing the URL to which the request is sent.
+     * @param data A plain object or string that is sent to the server with the request.
+     * @param complete A callback function that is executed when the request completes.
+     * @see \`{@link https://api.jquery.com/load/ }\`
+     * @since 1.0
+     * @example ​ ````Same as above, but will POST the additional parameters to the server and a callback that is executed when the server is finished responding.
+```javascript
+$( "#feeds" ).load( "feeds.php", { limit: 25 }, function() {
+  alert( "The last 25 entries in the feed have been loaded" );
+});
+```
+     */
+    load(url: string,
+         data: string | JQuery.PlainObject,
+         complete: (this: TElement, responseText: string, textStatus: JQuery.Ajax.TextStatus, jqXHR: JQuery.jqXHR) => void): this;
+    /**
+     * Load data from the server and place the returned HTML into the matched element.
+     * @param url A string containing the URL to which the request is sent.
+     * @param complete_data _&#x40;param_ `complete_data`
+     * <br>
+     * * `complete` — A callback function that is executed when the request completes. <br>
+     * * `data` — A plain object or string that is sent to the server with the request.
+     * @see \`{@link https://api.jquery.com/load/ }\`
+     * @since 1.0
+     * @example ​ ````Load another page&#39;s list items into an ordered list.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>load demo</title>
+  <style>
+  body {
+    font-size: 12px;
+    font-family: Arial;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<b>Projects:</b>
+<ol id="new-projects"></ol>
+​
+<script>
+$( "#new-projects" ).load( "/resources/load.html #projects li" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Display a notice if the Ajax request encounters an error.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>load demo</title>
+  <style>
+  body {
+    font-size: 12px;
+    font-family: Arial;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<b>Successful Response (should be blank):</b>
+<div id="success"></div>
+<b>Error Response:</b>
+<div id="error"></div>
+​
+<script>
+$( "#success" ).load( "/not-here.php", function( response, status, xhr ) {
+  if ( status == "error" ) {
+    var msg = "Sorry but there was an error: ";
+    $( "#error" ).html( msg + xhr.status + " " + xhr.statusText );
+  }
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Load the feeds.html file into the div with the ID of feeds.
+```javascript
+$( "#feeds" ).load( "feeds.html" );
+```
+     * @example ​ ````pass arrays of data to the server.
+```javascript
+$( "#objectID" ).load( "test.php", { "choices[]": [ "Jon", "Susan" ] } );
+```
+     */
+    load(url: string,
+         complete_data?: ((this: TElement, responseText: string, textStatus: JQuery.Ajax.TextStatus, jqXHR: JQuery.jqXHR) => void) | string | JQuery.PlainObject): this;
+    /**
+     * Pass each element in the current matched set through a function, producing a new jQuery object containing the return values.
+     * @param callback A function object that will be invoked for each element in the current set.
+     * @see \`{@link https://api.jquery.com/map/ }\`
+     * @since 1.2
+     * @example ​ ````Build a list of all the values within a form.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>map demo</title>
+  <style>
+  p {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><b>Values: </b></p>
+<form>
+  <input type="text" name="name" value="John">
+  <input type="text" name="password" value="password">
+  <input type="text" name="url" value="https://johnresig.com/">
+</form>
+​
+<script>
+$( "p" )
+  .append( $( "input" ).map(function() {
+    return $( this ).val();
+  })
+  .get()
+  .join( ", " ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````A contrived example to show some functionality.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>map demo</title>
+  <style>
+  body {
+    font-size: 16px;
+  }
+  ul {
+    float: left;
+    margin: 0 30px;
+    color: blue;
+  }
+  #results {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul>
+  <li>First</li>
+  <li>Second</li>
+  <li>Third</li>
+  <li>Fourth</li>
+  <li>Fifth</li>
+</ul>
+<ul id="results">
+</ul>
+​
+<script>
+var mappedItems = $( "li" ).map(function( index ) {
+  var replacement = $( "<li>" ).text( $( this ).text() ).get( 0 );
+  if ( index === 0 ) {
+​
+    // Make the first item all caps
+    $( replacement ).text( $( replacement ).text().toUpperCase() );
+  } else if ( index === 1 || index === 3 ) {
+​
+    // Delete the second and fourth items
+    replacement = null;
+  } else if ( index === 2 ) {
+​
+    // Make two of the third item and add some text
+    replacement = [ replacement, $( "<li>" ).get( 0 ) ];
+    $( replacement[ 0 ] ).append( "<b> - A</b>" );
+    $( replacement[ 1 ] ).append( "Extra <b> - B</b>" );
+  }
+​
+  // Replacement will be a dom element, null,
+  // or an array of dom elements
+  return replacement;
+});
+$( "#results" ).append( mappedItems );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Equalize the heights of the divs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>map demo</title>
+  <style>
+  div {
+    width: 40px;
+    float: left;
+  }
+  input {
+    clear: left;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<input type="button" value="equalize div heights">
+<div style="background: red; height: 40px; "></div>
+<div style="background: green; height: 70px;"></div>
+<div style="background: blue; height: 50px; "></div>
+​
+<script>
+$.fn.equalizeHeights = function() {
+  var maxHeight = this.map(function( i, e ) {
+    return $( e ).height();
+  }).get();
+  return this.height( Math.max.apply( this, maxHeight ) );
+};
+​
+$( "input" ).click(function() {
+  $( "div" ).equalizeHeights();
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    map<TReturn>(callback: (this: TElement, index: number, domElement: TElement) => JQuery.TypeOrArray<TReturn> | null | undefined): JQuery<TReturn>;
+    /**
+     * Bind an event handler to the "mousedown" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/mousedown/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    mousedown<TData>(eventData: TData,
+                     handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "mousedown" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/mousedown/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````Show texts when mouseup and mousedown event triggering.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>mousedown demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Press mouse and release here.</p>
+​
+<script>
+$( "p" )
+  .mouseup(function() {
+    $( this ).append( "<span style='color:#f00;'>Mouse up.</span>" );
+  })
+  .mousedown(function() {
+    $( this ).append( "<span style='color:#00f;'>Mouse down.</span>" );
+  });
+</script>
+​
+</body>
+</html>
+```
+     */
+    mousedown(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Bind an event handler to be fired when the mouse enters an element, or trigger that handler on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/mouseenter/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    mouseenter<TData>(eventData: TData,
+                      handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to be fired when the mouse enters an element, or trigger that handler on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/mouseenter/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````Show texts when mouseenter and mouseout event triggering.
+    mouseover fires when the pointer moves into the child element as well, while mouseenter fires only when the pointer moves into the bound element.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>mouseenter demo</title>
+  <style>
+  div.out {
+    width: 40%;
+    height: 120px;
+    margin: 0 15px;
+    background-color: #d6edfc;
+    float: left;
+  }
+  div.in {
+    width: 60%;
+    height: 60%;
+    background-color: #fc0;
+    margin: 10px auto;
+  }
+  p {
+    line-height: 1em;
+    margin: 0;
+    padding: 0;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div class="out overout">
+  <p>move your mouse</p>
+  <div class="in overout"><p>move your mouse</p><p>0</p></div>
+  <p>0</p>
+</div>
+​
+<div class="out enterleave">
+  <p>move your mouse</p>
+  <div class="in enterleave"><p>move your mouse</p><p>0</p></div>
+  <p>0</p>
+</div>
+​
+<script>
+var i = 0;
+$( "div.overout" )
+  .mouseover(function() {
+    $( "p:first", this ).text( "mouse over" );
+    $( "p:last", this ).text( ++i );
+  })
+  .mouseout(function() {
+    $( "p:first", this ).text( "mouse out" );
+  });
+​
+var n = 0;
+$( "div.enterleave" )
+  .mouseenter(function() {
+    $( "p:first", this ).text( "mouse enter" );
+    $( "p:last", this ).text( ++n );
+  })
+  .mouseleave(function() {
+    $( "p:first", this ).text( "mouse leave" );
+  });
+</script>
+​
+</body>
+</html>
+```
+     */
+    mouseenter(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Bind an event handler to be fired when the mouse leaves an element, or trigger that handler on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/mouseleave/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    mouseleave<TData>(eventData: TData,
+                      handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to be fired when the mouse leaves an element, or trigger that handler on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/mouseleave/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````Show number of times mouseout and mouseleave events are triggered. mouseout fires when the pointer moves out of child element as well, while mouseleave fires only when the pointer moves out of the bound element.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>mouseleave demo</title>
+  <style>
+  div.out {
+    width: 40%;
+    height: 120px;
+    margin: 0 15px;
+    background-color: #d6edfc;
+    float: left;
+  }
+  div.in {
+    width: 60%;
+    height: 60%;
+    background-color: #fc0;
+    margin: 10px auto;
+  }
+  p {
+    line-height: 1em;
+    margin: 0;
+    padding: 0;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div class="out overout">
+  <p>move your mouse</p>
+  <div class="in overout"><p>move your mouse</p><p>0</p></div>
+  <p>0</p>
+</div>
+<div class="out enterleave">
+  <p>move your mouse</p>
+  <div class="in enterleave"><p>move your mouse</p><p>0</p></div>
+  <p>0</p>
+</div>
+​
+<script>
+var i = 0;
+$( "div.overout" )
+  .mouseover(function() {
+    $( "p:first", this ).text( "mouse over" );
+  })
+  .mouseout(function() {
+    $( "p:first", this ).text( "mouse out" );
+    $( "p:last", this ).text( ++i );
+  });
+​
+var n = 0;
+$( "div.enterleave" )
+  .mouseenter(function() {
+    $( "p:first", this ).text( "mouse enter" );
+  })
+  .mouseleave(function() {
+    $( "p:first", this ).text( "mouse leave" );
+    $( "p:last", this ).text( ++n );
+  });
+</script>
+​
+</body>
+</html>
+```
+     */
+    mouseleave(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Bind an event handler to the "mousemove" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/mousemove/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    mousemove<TData>(eventData: TData,
+                     handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "mousemove" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/mousemove/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````Show the mouse coordinates when the mouse is moved over the yellow div.  Coordinates are relative to the window, which in this case is the iframe.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>mousemove demo</title>
+  <style>
+  div {
+    width: 220px;
+    height: 170px;
+    margin: 10px 50px 10px 10px;
+    background: yellow;
+    border: 2px groove;
+    float: right;
+  }
+  p {
+    margin: 0;
+    margin-left: 10px;
+    color: red;
+    width: 220px;
+    height: 120px;
+    padding-top: 70px;
+    float: left;
+    font-size: 14px;
+  }
+  span {
+    display: block;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>
+  <span>Move the mouse over the div.</span>
+  <span>&nbsp;</span>
+</p>
+<div></div>
+​
+<script>
+$( "div" ).mousemove(function( event ) {
+  var pageCoords = "( " + event.pageX + ", " + event.pageY + " )";
+  var clientCoords = "( " + event.clientX + ", " + event.clientY + " )";
+  $( "span:first" ).text( "( event.pageX, event.pageY ) : " + pageCoords );
+  $( "span:last" ).text( "( event.clientX, event.clientY ) : " + clientCoords );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    mousemove(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Bind an event handler to the "mouseout" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/mouseout/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    mouseout<TData>(eventData: TData,
+                    handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "mouseout" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/mouseout/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````Show the number of times mouseout and mouseleave events are triggered.
+  mouseout fires when the pointer moves out of the child element as well, while mouseleave fires only when the pointer moves out of the bound element.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>mouseout demo</title>
+  <style>
+  div.out {
+    width: 40%;
+    height: 120px;
+    margin: 0 15px;
+    background-color: #d6edfc;
+    float: left;
+  }
+  div.in {
+    width: 60%;
+    height: 60%;
+    background-color: #fc0;
+    margin: 10px auto;
+  }
+  p {
+    line-height: 1em;
+    margin: 0;
+    padding: 0;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div class="out overout">
+  <p>move your mouse</p>
+  <div class="in overout"><p>move your mouse</p><p>0</p></div>
+  <p>0</p>
+</div>
+​
+<div class="out enterleave">
+  <p>move your mouse</p>
+  <div class="in enterleave"><p>move your mouse</p><p>0</p></div>
+  <p>0</p>
+</div>
+​
+<script>
+var i = 0;
+$( "div.overout" )
+  .mouseout(function() {
+    $( "p:first", this ).text( "mouse out" );
+    $( "p:last", this ).text( ++i );
+  })
+  .mouseover(function() {
+    $( "p:first", this ).text( "mouse over" );
+  });
+​
+var n = 0;
+$( "div.enterleave" )
+  .on( "mouseenter", function() {
+    $( "p:first", this ).text( "mouse enter" );
+  })
+  .on( "mouseleave", function() {
+    $( "p:first", this ).text( "mouse leave" );
+    $( "p:last", this ).text( ++n );
+  });
+</script>
+​
+</body>
+</html>
+```
+     */
+    mouseout(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Bind an event handler to the "mouseover" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/mouseover/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    mouseover<TData>(eventData: TData,
+                     handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "mouseover" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/mouseover/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````Show the number of times mouseover and mouseenter events are triggered.
+mouseover fires when the pointer moves into the child element as well, while mouseenter fires only when the pointer moves into the bound element.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>mouseover demo</title>
+  <style>
+  div.out {
+    width: 40%;
+    height: 120px;
+    margin: 0 15px;
+    background-color: #d6edfc;
+    float: left;
+  }
+  div.in {
+    width: 60%;
+    height: 60%;
+    background-color: #fc0;
+    margin: 10px auto;
+  }
+  p {
+    line-height: 1em;
+    margin: 0;
+    padding: 0;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div class="out overout">
+  <span>move your mouse</span>
+  <div class="in">
+  </div>
+</div>
+​
+<div class="out enterleave">
+  <span>move your mouse</span>
+  <div class="in">
+  </div>
+</div>
+​
+<script>
+var i = 0;
+$( "div.overout" )
+  .mouseover(function() {
+    i += 1;
+    $( this ).find( "span" ).text( "mouse over x " + i );
+  })
+  .mouseout(function() {
+    $( this ).find( "span" ).text( "mouse out " );
+  });
+​
+var n = 0;
+$( "div.enterleave" )
+  .mouseenter(function() {
+    n += 1;
+    $( this ).find( "span" ).text( "mouse enter x " + n );
+  })
+  .mouseleave(function() {
+    $( this ).find( "span" ).text( "mouse leave" );
+  });
+</script>
+​
+</body>
+</html>
+```
+     */
+    mouseover(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Bind an event handler to the "mouseup" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/mouseup/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    mouseup<TData>(eventData: TData,
+                   handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "mouseup" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/mouseup/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````Show texts when mouseup and mousedown event triggering.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>mouseup demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Press mouse and release here.</p>
+​
+<script>
+$( "p" )
+  .mouseup(function() {
+    $( this ).append( "<span style='color:#f00;'>Mouse up.</span>" );
+  })
+  .mousedown(function() {
+    $( this ).append( "<span style='color:#00f;'>Mouse down.</span>" );
+  });
+</script>
+​
+</body>
+</html>
+```
+     */
+    mouseup(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Get the immediately following sibling of each element in the set of matched elements. If a selector is provided, it retrieves the next sibling only if it matches that selector.
+     * @param selector A string containing a selector expression to match elements against.
+     * @see \`{@link https://api.jquery.com/next/ }\`
+     * @since 1.0
+     * @example ​ ````Find the very next sibling of each disabled button and change its text &quot;this button is disabled&quot;.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>next demo</title>
+  <style>
+  span {
+    color: blue;
+    font-weight: bold;
+  }
+  button {
+    width: 100px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div><button disabled="disabled">First</button> - <span></span></div>
+<div><button>Second</button> - <span></span></div>
+<div><button disabled="disabled">Third</button> - <span></span></div>
+​
+<script>
+$( "button[disabled]" ).next().text( "this button is disabled" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Find the very next sibling of each paragraph. Keep only the ones with a class &quot;selected&quot;.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>next demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<p class="selected">Hello Again</p>
+<div><span>And Again</span></div>
+​
+<script>
+$( "p" ).next( ".selected" ).css( "background", "yellow" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    next(selector?: JQuery.Selector): this;
+    /**
+     * Get all following siblings of each element in the set of matched elements, optionally filtered by a selector.
+     * @param selector A string containing a selector expression to match elements against.
+     * @see \`{@link https://api.jquery.com/nextAll/ }\`
+     * @since 1.2
+     * @example ​ ````Locate all the divs after the first and give them a class.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>nextAll demo</title>
+  <style>
+  div {
+    width: 80px;
+    height: 80px;
+    background: #abc;
+    border: 2px solid black;
+    margin: 10px;
+    float: left;
+  }
+  div.after {
+    border-color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>first</div>
+<div>sibling<div>child</div></div>
+<div>sibling</div>
+<div>sibling</div>​
+<script>
+$( "div:first" ).nextAll().addClass( "after" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Locate all the paragraphs after the second child in the body and give them a class.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>nextAll demo</title>
+  <style>
+  div, p {
+    width: 60px;
+    height: 60px;
+    background: #abc;
+    border: 2px solid black;
+    margin: 10px;
+    float: left;
+  }
+  .after {
+    border-color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>p</p>
+<div>div</div>
+<p>p</p>
+<p>p</p>
+<div>div</div>
+<p>p</p>
+<div>div</div>
+​
+<script>
+$( ":nth-child(1)" ).nextAll( "p" ).addClass( "after" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    nextAll(selector?: string): this;
+    /**
+     * Get all following siblings of each element up to but not including the element matched by the selector, DOM node, or jQuery object passed.
+     * @param selector_element _&#x40;param_ `selector_element`
+     * <br>
+     * * `selector` — A string containing a selector expression to indicate where to stop matching following sibling elements. <br>
+     * * `element` — A DOM node or jQuery object indicating where to stop matching following sibling elements.
+     * @param filter A string containing a selector expression to match elements against.
+     * @see \`{@link https://api.jquery.com/nextUntil/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @example ​ ````Find the siblings that follow &lt;dt id=&quot;term-2&quot;&gt; up to the next &lt;dt&gt; and give them a red background color. Also, find &lt;dd&gt; siblings that follow &lt;dt id=&quot;term-1&quot;&gt; up to &lt;dt id=&quot;term-3&quot;&gt; and give them a green text color.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>nextUntil demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<dl>
+  <dt id="term-1">term 1</dt>
+  <dd>definition 1-a</dd>
+  <dd>definition 1-b</dd>
+  <dd>definition 1-c</dd>
+  <dd>definition 1-d</dd>
+  <dt id="term-2">term 2</dt>
+  <dd>definition 2-a</dd>
+  <dd>definition 2-b</dd>
+  <dd>definition 2-c</dd>
+  <dt id="term-3">term 3</dt>
+  <dd>definition 3-a</dd>
+  <dd>definition 3-b</dd>
+</dl>
+​
+<script>
+$( "#term-2" )
+  .nextUntil( "dt" )
+    .css( "background-color", "red" );
+var term3 = document.getElementById( "term-3" );
+$( "#term-1" )
+  .nextUntil( term3, "dd" )
+    .css( "color", "green" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    nextUntil(selector_element?: JQuery.Selector | Element | JQuery, filter?: JQuery.Selector): this;
+    /**
+     * Remove elements from the set of matched elements.
+     * @param selector_function_selection _&#x40;param_ `selector_function_selection`
+     * <br>
+     * * `selector` — A string containing a selector expression, a DOM element, or an array of elements to match against the set. <br>
+     * * `function` — A function used as a test for each element in the set. It accepts two arguments, `index`, which is
+     *                the element's index in the jQuery collection, and `element`, which is the DOM element. Within the
+     *                function, `this` refers to the current DOM element. <br>
+     * * `selection` — An existing jQuery object to match the current set of elements against.
+     * @see \`{@link https://api.jquery.com/not/ }\`
+     * @since 1.0
+     * @since 1.4
+     * @example ​ ````Adds a border to divs that are not green or blue.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>not demo</title>
+  <style>
+  div {
+    width: 50px;
+    height: 50px;
+    margin: 10px;
+    float: left;
+    background: yellow;
+    border: 2px solid white;
+  }
+  .green {
+    background: #8f8;
+  }
+  .gray {
+    background: #ccc;
+  }
+  #blueone {
+    background: #99f;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div></div>
+<div id="blueone"></div>
+<div></div>
+<div class="green"></div>
+<div class="green"></div>
+<div class="gray"></div>
+<div></div>
+​
+<script>
+$( "div" ).not( ".green, #blueone" )
+  .css( "border-color", "red" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Removes the element with the ID &quot;selected&quot; from the set of all paragraphs.
+```javascript
+$( "p" ).not( $( "#selected" )[ 0 ] );
+```
+     * @example ​ ````Removes the element with the ID &quot;selected&quot; from the set of all paragraphs.
+```javascript
+$( "p" ).not( "#selected" );
+```
+     * @example ​ ````Removes all elements that match &quot;div p.selected&quot; from the total set of all paragraphs.
+```javascript
+$( "p" ).not( $( "div p.selected" ) );
+```
+     */
+    not(selector_function_selection: JQuery.Selector | JQuery.TypeOrArray<Element> | JQuery | ((this: TElement, index: number, element: TElement) => boolean)): this;
+    /**
+     * Remove an event handler.
+     * @param events One or more space-separated event types and optional namespaces, or just namespaces, such as
+     *               "click", "keydown.myPlugin", or ".myPlugin".
+     * @param selector A selector which should match the one originally passed to .on() when attaching event handlers.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/off/ }\`
+     * @since 1.7
+     * @example ​ ````Add and remove event handlers on the colored button.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>off demo</title>
+  <style>
+  button {
+    margin: 5px;
+  }
+  button#theone {
+    color: red;
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="theone">Does nothing...</button>
+<button id="bind">Add Click</button>
+<button id="unbind">Remove Click</button>
+<div style="display:none;">Click!</div>
+​
+<script>
+function flash() {
+  $( "div" ).show().fadeOut( "slow" );
+}
+$( "#bind" ).click(function() {
+  $( "body" )
+    .on( "click", "#theone", flash )
+    .find( "#theone" )
+      .text( "Can Click!" );
+});
+$( "#unbind" ).click(function() {
+  $( "body" )
+    .off( "click", "#theone", flash )
+    .find( "#theone" )
+      .text( "Does nothing..." );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Remove just one previously bound handler by passing it as the third argument:
+```javascript
+var foo = function() {
+  // Code to handle some kind of event
+};
+​
+// ... Now foo will be called when paragraphs are clicked ...
+$( "body" ).on( "click", "p", foo );
+​
+// ... Foo will no longer be called.
+$( "body" ).off( "click", "p", foo );
+```
+     */
+    off(events: string, selector: JQuery.Selector, handler: JQuery.EventHandlerBase<any, JQuery.Event<TElement, any>> | false): this;
+    /**
+     * Remove an event handler.
+     * @param events One or more space-separated event types and optional namespaces, or just namespaces, such as
+     *               "click", "keydown.myPlugin", or ".myPlugin".
+     * @param selector_handler _&#x40;param_ `selector_handler`
+     * <br>
+     * * `selector` — A selector which should match the one originally passed to `.on()` when attaching event handlers. <br>
+     * * `handler` — A handler function previously attached for the event(s), or the special value `false`.
+     * @see \`{@link https://api.jquery.com/off/ }\`
+     * @since 1.7
+     * @example ​ ````Remove all delegated click handlers from all paragraphs:
+```javascript
+$( "p" ).off( "click", "**" );
+```
+     * @example ​ ````Unbind all delegated event handlers by their namespace:
+```javascript
+var validate = function() {
+  // Code to validate form entries
+};
+​
+// Delegate events under the ".validator" namespace
+$( "form" ).on( "click.validator", "button", validate );
+​
+$( "form" ).on( "keypress.validator", "input[type='text']", validate );
+​
+// Remove event handlers in the ".validator" namespace
+$( "form" ).off( ".validator" );
+```
+     */
+    off(events: string, selector_handler?: JQuery.Selector | JQuery.EventHandlerBase<any, JQuery.Event<TElement, any>> | false): this;
+    /**
+     * Remove an event handler.
+     * @param events An object where the string keys represent one or more space-separated event types and optional
+     *               namespaces, and the values represent handler functions previously attached for the event(s).
+     * @param selector A selector which should match the one originally passed to .on() when attaching event handlers.
+     * @see \`{@link https://api.jquery.com/off/ }\`
+     * @since 1.7
+     */
+    off(events: JQuery.PlainObject<JQuery.EventHandlerBase<any, JQuery.Event<TElement, any>> | false>, selector?: JQuery.Selector): this;
+    /**
+     * Remove an event handler.
+     * @param event A jQuery.Event object.
+     * @see \`{@link https://api.jquery.com/off/ }\`
+     * @since 1.7
+     * @example ​ ````Remove all event handlers from all paragraphs:
+```javascript
+$( "p" ).off();
+```
+     */
+    off(event?: JQuery.Event<TElement>): this;
+    /**
+     * Set the current coordinates of every element in the set of matched elements, relative to the document.
+     * @param coordinates_function _&#x40;param_ `coordinates_function`
+     * <br>
+     * * `coordinates` — An object containing the properties `top` and `left`, which are numbers indicating the new top and
+     *                   left coordinates for the elements. <br>
+     * * `function` — A function to return the coordinates to set. Receives the index of the element in the collection as
+     *                the first argument and the current coordinates as the second argument. The function should return an
+     *                object with the new `top` and `left` properties.
+     * @see \`{@link https://api.jquery.com/offset/ }\`
+     * @since 1.4
+     * @example ​ ````Set the offset of the second paragraph:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>offset demo</title>
+  <style>
+  p {
+    margin-left: 10px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p><p>2nd Paragraph</p>
+​
+<script>
+$( "p:last" ).offset({ top: 10, left: 30 });
+</script>
+​
+</body>
+</html>
+```
+     */
+    offset(coordinates_function: JQuery.CoordinatesPartial | ((this: TElement, index: number, coords: JQuery.Coordinates) => JQuery.CoordinatesPartial)): this;
+    /**
+     * Get the current coordinates of the first element in the set of matched elements, relative to the document.
+     * @see \`{@link https://api.jquery.com/offset/ }\`
+     * @since 1.2
+     * @example ​ ````Access the offset of the second paragraph:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>offset demo</title>
+  <style>
+  p {
+    margin-left: 10px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p><p>2nd Paragraph</p>
+​
+<script>
+var p = $( "p:last" );
+var offset = p.offset();
+p.html( "left: " + offset.left + ", top: " + offset.top );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Click to see the offset.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>offset demo</title>
+  <style>
+  p {
+    margin-left: 10px;
+    color: blue;
+    width: 200px;
+    cursor: pointer;
+  }
+  span {
+    color: red;
+    cursor: pointer;
+  }
+  div.abs {
+    width: 50px;
+    height: 50px;
+    position: absolute;
+    left: 220px;
+    top: 35px;
+    background-color: green;
+    cursor: pointer;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="result">Click an element.</div>
+<p>
+  This is the best way to <span>find</span> an offset.
+</p>
+<div class="abs">
+</div>
+​
+<script>
+$( "*", document.body ).click(function( event ) {
+  var offset = $( this ).offset();
+  event.stopPropagation();
+  $( "#result" ).text( this.tagName +
+    " coords ( " + offset.left + ", " + offset.top + " )" );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    offset(): JQuery.Coordinates | undefined;
+    /**
+     * Get the closest ancestor element that is positioned.
+     * @see \`{@link https://api.jquery.com/offsetParent/ }\`
+     * @since 1.2.6
+     * @example ​ ````Find the offsetParent of item &quot;A.&quot;
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>offsetParent demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul class="level-1">
+  <li class="item-i">I</li>
+  <li class="item-ii" style="position: relative;">II
+    <ul class="level-2">
+      <li class="item-a">A</li>
+      <li class="item-b">B
+        <ul class="level-3">
+          <li class="item-1">1</li>
+          <li class="item-2">2</li>
+          <li class="item-3">3</li>
+        </ul>
+      </li>
+      <li class="item-c">C</li>
+    </ul>
+  </li>
+  <li class="item-iii">III</li>
+</ul>
+​
+<script>$( "li.item-a" ).offsetParent().css( "background-color", "red" );</script>
+​
+</body>
+</html>
+```
+     */
+    offsetParent(): this;
+    /**
+     * Attach an event handler function for one or more events to the selected elements.
+     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
+     * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the
+     *                 selector is null or omitted, the event is always triggered when it reaches the selected element.
+     * @param data Data to be passed to the handler in event.data when an event is triggered.
+     * @param handler A function to execute when the event is triggered.
+     * @see \`{@link https://api.jquery.com/on/ }\`
+     * @since 1.7
+     */
+    on<TData>(events: string,
+              selector: JQuery.Selector | null,
+              data: TData,
+              handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Attach an event handler function for one or more events to the selected elements.
+     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
+     * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the
+     *                 selector is null or omitted, the event is always triggered when it reaches the selected element.
+     * @param data Data to be passed to the handler in event.data when an event is triggered.
+     * @param handler A function to execute when the event is triggered.
+     * @see \`{@link https://api.jquery.com/on/ }\`
+     * @since 1.7
+     * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\` in place of \`{@link JQueryEventObject }\`.
+     */
+    on(events: string,
+       selector: JQuery.Selector | null,
+       data: any,
+       handler: ((event: JQueryEventObject) => void)): this;
+    /**
+     * Attach an event handler function for one or more events to the selected elements.
+     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
+     * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the
+     *                 selector is null or omitted, the event is always triggered when it reaches the selected element.
+     * @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand
+     *                for a function that simply does return false.
+     * @see \`{@link https://api.jquery.com/on/ }\`
+     * @since 1.7
+     * @example ​ ````Click any paragraph to add another after it. Note that .on() allows a click event on any paragraph--even new ones--since the event is handled by the ever-present body element after it bubbles to there.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>on demo</title>
+  <style>
+  p {
+    background: yellow;
+    font-weight: bold;
+    cursor: pointer;
+    padding: 5px;
+  }
+  p.over {
+    background: #ccc;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Click me!</p>
+<span></span>
+​
+<script>
+var count = 0;
+$( "body" ).on( "click", "p", function() {
+  $( this ).after( "<p>Another paragraph! " + (++count) + "</p>" );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Display each paragraph&#39;s text in an alert box whenever it is clicked:
+```javascript
+$( "body" ).on( "click", "p", function() {
+  alert( $( this ).text() );
+});
+```
+     * @example ​ ````Cancel a link&#39;s default action using the .preventDefault() method:
+```javascript
+$( "body" ).on( "click", "a", function( event ) {
+  event.preventDefault();
+});
+```
+     */
+    on(events: string,
+       selector: JQuery.Selector,
+       handler: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Attach an event handler function for one or more events to the selected elements.
+     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
+     * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the
+     *                 selector is null or omitted, the event is always triggered when it reaches the selected element.
+     * @param handler A function to execute when the event is triggered.
+     * @see \`{@link https://api.jquery.com/on/ }\`
+     * @since 1.7
+     * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\` in place of \`{@link JQueryEventObject }\`.
+     * @example ​ ````Click any paragraph to add another after it. Note that .on() allows a click event on any paragraph--even new ones--since the event is handled by the ever-present body element after it bubbles to there.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>on demo</title>
+  <style>
+  p {
+    background: yellow;
+    font-weight: bold;
+    cursor: pointer;
+    padding: 5px;
+  }
+  p.over {
+    background: #ccc;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Click me!</p>
+<span></span>
+​
+<script>
+var count = 0;
+$( "body" ).on( "click", "p", function() {
+  $( this ).after( "<p>Another paragraph! " + (++count) + "</p>" );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Display each paragraph&#39;s text in an alert box whenever it is clicked:
+```javascript
+$( "body" ).on( "click", "p", function() {
+  alert( $( this ).text() );
+});
+```
+     * @example ​ ````Cancel a link&#39;s default action using the .preventDefault() method:
+```javascript
+$( "body" ).on( "click", "a", function( event ) {
+  event.preventDefault();
+});
+```
+     */
+    on(events: string,
+       selector: JQuery.Selector,
+       // tslint:disable-next-line:unified-signatures
+       handler: ((event: JQueryEventObject) => void)): this;
+    /**
+     * Attach an event handler function for one or more events to the selected elements.
+     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
+     * @param data Data to be passed to the handler in event.data when an event is triggered.
+     * @param handler A function to execute when the event is triggered.
+     * @see \`{@link https://api.jquery.com/on/ }\`
+     * @since 1.7
+     * @example ​ ````Pass data to the event handler, which is specified here by name:
+```javascript
+function myHandler( event ) {
+  alert( event.data.foo );
+}
+$( "p" ).on( "click", { foo: "bar" }, myHandler );
+```
+     */
+    on<TData>(events: string,
+              data: TData,
+              handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Attach an event handler function for one or more events to the selected elements.
+     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
+     * @param data Data to be passed to the handler in event.data when an event is triggered.
+     * @param handler A function to execute when the event is triggered.
+     * @see \`{@link https://api.jquery.com/on/ }\`
+     * @since 1.7
+     * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\` in place of \`{@link JQueryEventObject }\`.
+     * @example ​ ````Pass data to the event handler, which is specified here by name:
+```javascript
+function myHandler( event ) {
+  alert( event.data.foo );
+}
+$( "p" ).on( "click", { foo: "bar" }, myHandler );
+```
+     */
+    on(events: string,
+       // tslint:disable-next-line:unified-signatures
+       data: any,
+       handler: ((event: JQueryEventObject) => void)): this;
+    /**
+     * Attach an event handler function for one or more events to the selected elements.
+     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
+     * @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand
+     *                for a function that simply does return false.
+     * @see \`{@link https://api.jquery.com/on/ }\`
+     * @since 1.7
+     * @example ​ ````Display a paragraph&#39;s text in an alert when it is clicked:
+```javascript
+$( "p" ).on( "click", function() {
+  alert( $( this ).text() );
+});
+```
+     * @example ​ ````Cancel a form submit action and prevent the event from bubbling up by returning false:
+```javascript
+$( "form" ).on( "submit", false );
+```
+     * @example ​ ````Cancel only the default action by using .preventDefault().
+```javascript
+$( "form" ).on( "submit", function( event ) {
+  event.preventDefault();
+});
+```
+     * @example ​ ````Stop submit events from bubbling without preventing form submit, using .stopPropagation().
+```javascript
+$( "form" ).on( "submit", function( event ) {
+  event.stopPropagation();
+});
+```
+     * @example ​ ````Pass data to the event handler using the second argument to .trigger()
+```javascript
+$( "div" ).on( "click", function( event, person ) {
+  alert( "Hello, " + person.name );
+});
+$( "div" ).trigger( "click", { name: "Jim" } );
+```
+     * @example ​ ````Use the the second argument of .trigger() to pass an array of data to the event handler
+```javascript
+$( "div" ).on( "click", function( event, salutation, name ) {
+  alert( salutation + ", " + name );
+});
+$( "div" ).trigger( "click", [ "Goodbye", "Jim" ] );
+```
+     * @example ​ ````Attach and trigger custom (non-browser) events.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>on demo</title>
+  <style>
+  p {
+    color: red;
+  }
+  span {
+    color: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Has an attached custom event.</p>
+<button>Trigger custom event</button>
+<span style="display:none;"></span>
+​
+<script>
+$( "p" ).on( "myCustomEvent", function( event, myName ) {
+  $( this ).text( myName + ", hi there!" );
+  $( "span" )
+    .stop()
+    .css( "opacity", 1 )
+    .text( "myName = " + myName )
+    .fadeIn( 30 )
+    .fadeOut( 1000 );
+});
+$( "button" ).click(function () {
+  $( "p" ).trigger( "myCustomEvent", [ "John" ] );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Attach multiple events—one on mouseenter and one on mouseleave to the same element:
+```javascript
+$( "#cart" ).on( "mouseenter mouseleave", function( event ) {
+  $( this ).toggleClass( "active" );
+});
+```
+     */
+    on(events: string,
+       handler: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Attach an event handler function for one or more events to the selected elements.
+     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
+     * @param handler A function to execute when the event is triggered.
+     * @see \`{@link https://api.jquery.com/on/ }\`
+     * @since 1.7
+     * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\` in place of \`{@link JQueryEventObject }\`.
+     * @example ​ ````Display a paragraph&#39;s text in an alert when it is clicked:
+```javascript
+$( "p" ).on( "click", function() {
+  alert( $( this ).text() );
+});
+```
+     * @example ​ ````Cancel a form submit action and prevent the event from bubbling up by returning false:
+```javascript
+$( "form" ).on( "submit", false );
+```
+     * @example ​ ````Cancel only the default action by using .preventDefault().
+```javascript
+$( "form" ).on( "submit", function( event ) {
+  event.preventDefault();
+});
+```
+     * @example ​ ````Stop submit events from bubbling without preventing form submit, using .stopPropagation().
+```javascript
+$( "form" ).on( "submit", function( event ) {
+  event.stopPropagation();
+});
+```
+     * @example ​ ````Pass data to the event handler using the second argument to .trigger()
+```javascript
+$( "div" ).on( "click", function( event, person ) {
+  alert( "Hello, " + person.name );
+});
+$( "div" ).trigger( "click", { name: "Jim" } );
+```
+     * @example ​ ````Use the the second argument of .trigger() to pass an array of data to the event handler
+```javascript
+$( "div" ).on( "click", function( event, salutation, name ) {
+  alert( salutation + ", " + name );
+});
+$( "div" ).trigger( "click", [ "Goodbye", "Jim" ] );
+```
+     * @example ​ ````Attach and trigger custom (non-browser) events.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>on demo</title>
+  <style>
+  p {
+    color: red;
+  }
+  span {
+    color: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Has an attached custom event.</p>
+<button>Trigger custom event</button>
+<span style="display:none;"></span>
+​
+<script>
+$( "p" ).on( "myCustomEvent", function( event, myName ) {
+  $( this ).text( myName + ", hi there!" );
+  $( "span" )
+    .stop()
+    .css( "opacity", 1 )
+    .text( "myName = " + myName )
+    .fadeIn( 30 )
+    .fadeOut( 1000 );
+});
+$( "button" ).click(function () {
+  $( "p" ).trigger( "myCustomEvent", [ "John" ] );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Attach multiple events—one on mouseenter and one on mouseleave to the same element:
+```javascript
+$( "#cart" ).on( "mouseenter mouseleave", function( event ) {
+  $( this ).toggleClass( "active" );
+});
+```
+     */
+    on(events: string,
+       // tslint:disable-next-line:unified-signatures
+       handler: ((event: JQueryEventObject) => void)): this;
+    /**
+     * Attach an event handler function for one or more events to the selected elements.
+     * @param events An object in which the string keys represent one or more space-separated event types and optional
+     *               namespaces, and the values represent a handler function to be called for the event(s).
+     * @param selector A selector string to filter the descendants of the selected elements that will call the handler. If
+     *                 the selector is null or omitted, the handler is always called when it reaches the selected element.
+     * @param data Data to be passed to the handler in event.data when an event occurs.
+     * @see \`{@link https://api.jquery.com/on/ }\`
+     * @since 1.7
+     */
+    on<TData>(events: JQuery.PlainObject<JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>> | false>,
+              selector: JQuery.Selector | null,
+              data: TData): this;
+    /**
+     * Attach an event handler function for one or more events to the selected elements.
+     * @param events An object in which the string keys represent one or more space-separated event types and optional
+     *               namespaces, and the values represent a handler function to be called for the event(s).
+     * @param selector A selector string to filter the descendants of the selected elements that will call the handler. If
+     *                 the selector is null or omitted, the handler is always called when it reaches the selected element.
+     * @see \`{@link https://api.jquery.com/on/ }\`
+     * @since 1.7
+     */
+    on(events: JQuery.PlainObject<JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false>,
+       // tslint:disable-next-line:unified-signatures
+       selector: JQuery.Selector): this;
+    /**
+     * Attach an event handler function for one or more events to the selected elements.
+     * @param events An object in which the string keys represent one or more space-separated event types and optional
+     *               namespaces, and the values represent a handler function to be called for the event(s).
+     * @param data Data to be passed to the handler in event.data when an event occurs.
+     * @see \`{@link https://api.jquery.com/on/ }\`
+     * @since 1.7
+     */
+    on<TData>(events: JQuery.PlainObject<JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>> | false>,
+              data: TData): this;
+    /**
+     * Attach an event handler function for one or more events to the selected elements.
+     * @param events An object in which the string keys represent one or more space-separated event types and optional
+     *               namespaces, and the values represent a handler function to be called for the event(s).
+     * @see \`{@link https://api.jquery.com/on/ }\`
+     * @since 1.7
+     * @example ​ ````Attach multiple event handlers simultaneously using a plain object.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>on demo</title>
+  <style>
+  .test {
+    color: #000;
+    padding: .5em;
+    border: 1px solid #444;
+  }
+  .active {
+    color: #900;
+  }
+  .inside {
+    background-color: aqua;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div class="test">test div</div>
+​
+<script>
+$( "div.test" ).on({
+  click: function() {
+    $( this ).toggleClass( "active" );
+  }, mouseenter: function() {
+    $( this ).addClass( "inside" );
+  }, mouseleave: function() {
+    $( this ).removeClass( "inside" );
+  }
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    on(events: JQuery.PlainObject<JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false>): this;
+    /**
+     * Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
+     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
+     * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the
+     *                 selector is null or omitted, the event is always triggered when it reaches the selected element.
+     * @param data Data to be passed to the handler in event.data when an event is triggered.
+     * @param handler A function to execute when the event is triggered.
+     * @see \`{@link https://api.jquery.com/one/ }\`
+     * @since 1.7
+     */
+    one<TData>(events: string,
+               selector: JQuery.Selector | null,
+               data: TData,
+               handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
+     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
+     * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the
+     *                 selector is null or omitted, the event is always triggered when it reaches the selected element.
+     * @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand
+     *                for a function that simply does return false.
+     * @see \`{@link https://api.jquery.com/one/ }\`
+     * @since 1.7
+     */
+    one(events: string,
+        selector: JQuery.Selector,
+        handler: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
+     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
+     * @param data Data to be passed to the handler in event.data when an event is triggered.
+     * @param handler A function to execute when the event is triggered.
+     * @see \`{@link https://api.jquery.com/one/ }\`
+     * @since 1.7
+     */
+    one<TData>(events: string,
+               data: TData,
+               handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
+     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
+     * @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand
+     *                for a function that simply does return false.
+     * @see \`{@link https://api.jquery.com/one/ }\`
+     * @since 1.7
+     * @example ​ ````Tie a one-time click to each div.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>one demo</title>
+  <style>
+  div {
+    width: 60px;
+    height: 60px;
+    margin: 5px;
+    float: left;
+    background: green;
+    border: 10px outset;
+    cursor:pointer;
+  }
+  p {
+    color: red;
+    margin: 0;
+    clear: left;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div></div>
+<div></div>
+<div></div>
+<div></div>
+<div></div>
+<p>Click a green square...</p>
+​
+<script>
+var n = 0;
+$( "div" ).one( "click", function() {
+  var index = $( "div" ).index( this );
+  $( this ).css({
+    borderStyle: "inset",
+    cursor: "auto"
+  });
+  $( "p" ).text( "Div at index #" + index + " clicked." +
+    " That's " + (++n) + " total clicks." );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````To display the text of all paragraphs in an alert box the first time each of them is clicked:
+```javascript
+$( "p" ).one( "click", function() {
+  alert( $( this ).text() );
+});
+```
+     * @example ​ ````Event handlers will trigger once per element per event type
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>one demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div class="count">0</div>
+<div class="target">Hover/click me</div>
+​
+<script>
+var n = 0;
+$(".target").one("click mouseenter", function() {
+  $(".count").html(++n);
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    one(events: string,
+        handler: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
+     * @param events An object in which the string keys represent one or more space-separated event types and optional
+     *               namespaces, and the values represent a handler function to be called for the event(s).
+     * @param selector A selector string to filter the descendants of the selected elements that will call the handler. If
+     *                 the selector is null or omitted, the handler is always called when it reaches the selected element.
+     * @param data Data to be passed to the handler in event.data when an event occurs.
+     * @see \`{@link https://api.jquery.com/one/ }\`
+     * @since 1.7
+     */
+    one<TData>(events: JQuery.PlainObject<JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>> | false>,
+               selector: JQuery.Selector | null,
+               data: TData): this;
+    /**
+     * Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
+     * @param events An object in which the string keys represent one or more space-separated event types and optional
+     *               namespaces, and the values represent a handler function to be called for the event(s).
+     * @param selector A selector string to filter the descendants of the selected elements that will call the handler. If
+     *                 the selector is null or omitted, the handler is always called when it reaches the selected element.
+     * @see \`{@link https://api.jquery.com/one/ }\`
+     * @since 1.7
+     */
+    one(events: JQuery.PlainObject<JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false>,
+        // tslint:disable-next-line:unified-signatures
+        selector: JQuery.Selector): this;
+    /**
+     * Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
+     * @param events An object in which the string keys represent one or more space-separated event types and optional
+     *               namespaces, and the values represent a handler function to be called for the event(s).
+     * @param data Data to be passed to the handler in event.data when an event occurs.
+     * @see \`{@link https://api.jquery.com/one/ }\`
+     * @since 1.7
+     */
+    one<TData>(events: JQuery.PlainObject<JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>> | false>,
+               data: TData): this;
+    /**
+     * Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
+     * @param events An object in which the string keys represent one or more space-separated event types and optional
+     *               namespaces, and the values represent a handler function to be called for the event(s).
+     * @see \`{@link https://api.jquery.com/one/ }\`
+     * @since 1.7
+     */
+    one(events: JQuery.PlainObject<JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false>): this;
+    /**
+     * Set the CSS outer height of each element in the set of matched elements.
+     * @param value_function _&#x40;param_ `value_function`
+     * <br>
+     * * `value` — A number representing the number of pixels, or a number along with an optional unit of measure
+     *             appended (as a string). <br>
+     * * `function` — A function returning the outer height to set. Receives the index position of the element in the set
+     *                and the old outer height as arguments. Within the function, `this` refers to the current element in
+     *                the set.
+     * @see \`{@link https://api.jquery.com/outerHeight/ }\`
+     * @since 1.8.0
+     * @example ​ ````Change the outer height of each div the first time it is clicked (and change its color).
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>outerHeight demo</title>
+  <style>
+  div {
+    width: 50px;
+    padding: 10px;
+    height: 60px;
+    float: left;
+    margin: 5px;
+    background: red;
+    cursor: pointer;
+  }
+  .mod {
+    background: blue;
+    cursor: default;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>d</div>
+<div>d</div>
+<div>d</div>
+<div>d</div>
+<div>d</div>
+​
+<script>
+var modHeight = 60;
+$( "div" ).one( "click", function() {
+  $( this ).outerHeight( modHeight ).addClass( "mod" );
+  modHeight -= 8;
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    outerHeight(value_function: string | number | ((this: TElement, index: number, height: number) => string | number),
+                includeMargin?: boolean): this;
+    /**
+     * Get the current computed outer height (including padding, border, and optionally margin) for the first element in the set of matched elements.
+     * @param includeMargin A Boolean indicating whether to include the element's margin in the calculation.
+     * @see \`{@link https://api.jquery.com/outerHeight/ }\`
+     * @since 1.2.6
+     * @example ​ ````Get the outerHeight of a paragraph.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>outerHeight demo</title>
+  <style>
+  p {
+    margin: 10px;
+    padding: 5px;
+    border: 2px solid #666;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p><p></p>
+​
+<script>
+var p = $( "p:first" );
+$( "p:last" ).text(
+  "outerHeight:" + p.outerHeight() +
+  " , outerHeight( true ):" + p.outerHeight( true ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    outerHeight(includeMargin?: boolean): number | undefined;
+    /**
+     * Set the CSS outer width of each element in the set of matched elements.
+     * @param value_function _&#x40;param_ `value_function`
+     * <br>
+     * * `value` — A number representing the number of pixels, or a number along with an optional unit of measure
+     *             appended (as a string). <br>
+     * * `function` — A function returning the outer width to set. Receives the index position of the element in the set
+     *                and the old outer width as arguments. Within the function, `this` refers to the current element in
+     *                the set.
+     * @see \`{@link https://api.jquery.com/outerWidth/ }\`
+     * @since 1.8.0
+     * @example ​ ````Change the outer width of each div the first time it is clicked (and change its color).
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>outerWidth demo</title>
+  <style>
+  div {
+    width: 60px;
+    padding: 10px;
+    height: 50px;
+    float: left;
+    margin: 5px;
+    background: red;
+    cursor: pointer;
+  }
+  .mod {
+    background: blue;
+    cursor: default;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>d</div>
+<div>d</div>
+<div>d</div>
+<div>d</div>
+<div>d</div>
+​
+<script>
+var modWidth = 60;
+$( "div" ).one( "click", function() {
+  $( this ).outerWidth( modWidth ).addClass( "mod" );
+  modWidth -= 8;
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    outerWidth(value_function: string | number | ((this: TElement, index: number, width: number) => string | number),
+               includeMargin?: boolean): this;
+    /**
+     * Get the current computed outer width (including padding, border, and optionally margin) for the first element in the set of matched elements.
+     * @param includeMargin A Boolean indicating whether to include the element's margin in the calculation.
+     * @see \`{@link https://api.jquery.com/outerWidth/ }\`
+     * @since 1.2.6
+     * @example ​ ````Get the outerWidth of a paragraph.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>outerWidth demo</title>
+  <style>
+  p {
+    margin: 10px;
+    padding: 5px;
+    border: 2px solid #666;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p><p></p>
+​
+<script>
+var p = $( "p:first" );
+$( "p:last" ).text(
+  "outerWidth:" + p.outerWidth() +
+  " , outerWidth( true ):" + p.outerWidth( true ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    outerWidth(includeMargin?: boolean): number | undefined;
+    /**
+     * Get the parent of each element in the current set of matched elements, optionally filtered by a selector.
+     * @param selector A string containing a selector expression to match elements against.
+     * @see \`{@link https://api.jquery.com/parent/ }\`
+     * @since 1.0
+     * @example ​ ````Shows the parent of each element as (parent &gt; child).  Check the View Source to see the raw html.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>parent demo</title>
+  <style>
+  div, p {
+    margin: 10px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>div,
+  <span>span, </span>
+  <b>b </b>
+</div>
+​
+<p>p,
+  <span>span,
+    <em>em </em>
+  </span>
+</p>
+​
+<div>div,
+  <strong>strong,
+    <span>span, </span>
+    <em>em,
+      <b>b, </b>
+    </em>
+  </strong>
+  <b>b </b>
+</div>
+​
+<script>
+$( "*", document.body ).each(function() {
+  var parentTag = $( this ).parent().get( 0 ).tagName;
+  $( this ).prepend( document.createTextNode( parentTag + " > " ) );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Find the parent element of each paragraph with a class &quot;selected&quot;.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>parent demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div><p>Hello</p></div>
+<div class="selected"><p>Hello Again</p></div>
+​
+<script>
+$( "p" ).parent( ".selected" ).css( "background", "yellow" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    parent(selector?: JQuery.Selector): this;
+    /**
+     * Get the ancestors of each element in the current set of matched elements, optionally filtered by a selector.
+     * @param selector A string containing a selector expression to match elements against.
+     * @see \`{@link https://api.jquery.com/parents/ }\`
+     * @since 1.0
+     * @example ​ ````Find all parent elements of each b.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>parents demo</title>
+  <style>
+  b, span, p, html body {
+    padding: .5em;
+    border: 1px solid;
+  }
+  b {
+    color: blue;
+  }
+  strong {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>
+  <p>
+    <span>
+      <b>My parents are: </b>
+    </span>
+  </p>
+</div>
+​
+<script>
+var parentEls = $( "b" ).parents()
+  .map(function() {
+    return this.tagName;
+  })
+  .get()
+  .join( ", " );
+$( "b" ).append( "<strong>" + parentEls + "</strong>" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Click to find all unique div parent elements of each span.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>parents demo</title>
+  <style>
+  p, div, span {
+    margin: 2px;
+    padding: 1px;
+  }
+  div {
+    border: 2px white solid;
+  }
+  span {
+    cursor: pointer;
+    font-size: 12px;
+  }
+  .selected {
+    color: blue;
+  }
+  b {
+    color: red;
+    display: block;
+    font-size: 14px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>
+  <div>
+    <div><span>Hello</span></div>
+      <span>Hello Again</span>
+    </div>
+    <div>
+      <span>And Hello Again</span>
+    </div>
+  </p>
+  <b>Click Hellos to toggle their parents.</b>
+​
+<script>
+function showParents() {
+  $( "div" ).css( "border-color", "white" );
+  var len = $( "span.selected" )
+    .parents( "div" )
+      .css( "border", "2px red solid" )
+      .length;
+  $( "b" ).text( "Unique div parents: " + len );
+}
+$( "span" ).click(function() {
+  $( this ).toggleClass( "selected" );
+  showParents();
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    parents(selector?: JQuery.Selector): this;
+    /**
+     * Get the ancestors of each element in the current set of matched elements, up to but not including the element matched by the selector, DOM node, or jQuery object.
+     * @param selector_element _&#x40;param_ `selector_element`
+     * <br>
+     * * `selector` — A string containing a selector expression to indicate where to stop matching ancestor elements. <br>
+     * * `element` — A DOM node or jQuery object indicating where to stop matching ancestor elements.
+     * @param filter A string containing a selector expression to match elements against.
+     * @see \`{@link https://api.jquery.com/parentsUntil/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @example ​ ````Find the ancestors of &lt;li class=&quot;item-a&quot;&gt; up to &lt;ul class=&quot;level-1&quot;&gt; and give them a red background color. Also, find ancestors of &lt;li class=&quot;item-2&quot;&gt; that have a class of &quot;yes&quot; up to &lt;ul class=&quot;level-1&quot;&gt; and give them a green border.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>parentsUntil demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul class="level-1 yes">
+  <li class="item-i">I</li>
+  <li class="item-ii">II
+    <ul class="level-2 yes">
+      <li class="item-a">A</li>
+      <li class="item-b">B
+        <ul class="level-3">
+          <li class="item-1">1</li>
+          <li class="item-2">2</li>
+          <li class="item-3">3</li>
+        </ul>
+      </li>
+      <li class="item-c">C</li>
+    </ul>
+  </li>
+  <li class="item-iii">III</li>
+</ul>
+​
+<script>
+$( "li.item-a" )
+  .parentsUntil( ".level-1" )
+    .css( "background-color", "red" );
+​
+$( "li.item-2" )
+  .parentsUntil( $( "ul.level-1" ), ".yes" )
+    .css( "border", "3px solid green" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    parentsUntil(selector_element?: JQuery.Selector | Element | JQuery, filter?: JQuery.Selector): this;
+    /**
+     * Get the current coordinates of the first element in the set of matched elements, relative to the offset parent.
+     * @see \`{@link https://api.jquery.com/position/ }\`
+     * @since 1.2
+     * @example ​ ````Access the position of the second paragraph:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>position demo</title>
+  <style>
+  div {
+    padding: 15px;
+  }
+  p {
+    margin-left: 10px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>
+  <p>Hello</p>
+</div>
+<p></p>
+​
+<script>
+var p = $( "p:first" );
+var position = p.position();
+$( "p:last" ).text( "left: " + position.left + ", top: " + position.top );
+</script>
+​
+</body>
+</html>
+```
+     */
+    position(): JQuery.Coordinates;
+    /**
+     * Insert content, specified by the parameter, to the beginning of each element in the set of matched elements.
+     * @param contents One or more additional DOM elements, text nodes, arrays of elements and text nodes, HTML strings, or
+     *                 jQuery objects to insert at the beginning of each element in the set of matched elements.
+     * @see \`{@link https://api.jquery.com/prepend/ }\`
+     * @since 1.0
+     * @example ​ ````Prepends some HTML to all paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>prepend demo</title>
+  <style>
+  p {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>there, friend!</p>
+<p>amigo!</p>
+​
+<script>
+$( "p" ).prepend( "<b>Hello </b>" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Prepends a DOM Element to all paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>prepend demo</title>
+  <style>
+  p {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>is what I'd say</p>
+<p>is what I said</p>
+​
+<script>
+$( "p" ).prepend( document.createTextNode( "Hello " ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Prepends a jQuery object (similar to an Array of DOM Elements) to all paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>prepend demo</title>
+  <style>
+  p {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p> is what was said.</p><b>Hello</b>
+​
+<script>
+$( "p" ).prepend( $( "b" ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    prepend(...contents: Array<JQuery.htmlString | JQuery.TypeOrArray<JQuery.Node | JQuery<JQuery.Node>>>): this;
+    /**
+     * Insert content, specified by the parameter, to the beginning of each element in the set of matched elements.
+     * @param funсtion A function that returns an HTML string, DOM element(s), text node(s), or jQuery object to insert at
+     *                 the beginning of each element in the set of matched elements. Receives the index position of the
+     *                 element in the set and the old HTML value of the element as arguments. Within the function, `this`
+     *                 refers to the current element in the set.
+     * @see \`{@link https://api.jquery.com/prepend/ }\`
+     * @since 1.4
+     */
+    prepend(funсtion: (this: TElement, index: number, html: string) => JQuery.htmlString | JQuery.TypeOrArray<JQuery.Node | JQuery<JQuery.Node>>): this;
+    /**
+     * Insert every element in the set of matched elements to the beginning of the target.
+     * @param target A selector, element, HTML string, array of elements, or jQuery object; the matched set of elements
+     *               will be inserted at the beginning of the element(s) specified by this parameter.
+     * @see \`{@link https://api.jquery.com/prependTo/ }\`
+     * @since 1.0
+     * @example ​ ````Prepend all spans to the element with the ID &quot;foo&quot; (Check .prepend() documentation for more examples)
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>prependTo demo</title>
+  <style>
+  div {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="foo">FOO!</div>
+<span>I have something to say... </span>
+​
+<script>
+$( "span" ).prependTo( "#foo" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    prependTo(target: JQuery.Selector | JQuery.htmlString | JQuery.TypeOrArray<Element | DocumentFragment> | JQuery): this;
+    /**
+     * Get the immediately preceding sibling of each element in the set of matched elements. If a selector is provided, it retrieves the previous sibling only if it matches that selector.
+     * @param selector A string containing a selector expression to match elements against.
+     * @see \`{@link https://api.jquery.com/prev/ }\`
+     * @since 1.0
+     * @example ​ ````Find the very previous sibling of each div.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>prev demo</title>
+  <style>
+  div {
+    width: 40px;
+    height: 40px;
+    margin: 10px;
+    float: left;
+    border: 2px blue solid;
+    padding: 2px;
+  }
+  span {
+    font-size: 14px;
+  }
+  p {
+    clear: left;
+    margin: 10px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div></div>
+<div></div>
+<div><span>has child</span></div>
+<div></div>
+<div></div>
+<div></div>
+<div id="start"></div>
+<div></div>
+<p><button>Go to Prev</button></p>
+​
+<script>
+var $curr = $( "#start" );
+$curr.css( "background", "#f99" );
+$( "button" ).click(function() {
+  $curr = $curr.prev();
+  $( "div" ).css( "background", "" );
+  $curr.css( "background", "#f99" );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````For each paragraph, find the very previous sibling that has a class &quot;selected&quot;.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>prev demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div><span>Hello</span></div>
+<p class="selected">Hello Again</p>
+<p>And Again</p>
+​
+<script>
+$( "p" ).prev( ".selected" ).css( "background", "yellow" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    prev(selector?: JQuery.Selector): this;
+    /**
+     * Get all preceding siblings of each element in the set of matched elements, optionally filtered by a selector.
+     * @param selector A string containing a selector expression to match elements against.
+     * @see \`{@link https://api.jquery.com/prevAll/ }\`
+     * @since 1.2
+     * @example ​ ````Locate all the divs preceding the last div and give them a class.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>prevAll demo</title>
+  <style>
+  div {
+    width: 70px;
+    height: 70px;
+    background: #abc;
+    border: 2px solid black;
+    margin: 10px;
+    float: left;
+  }
+  div.before {
+    border-color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div></div>
+<div></div>
+<div></div>
+<div></div>
+​
+<script>
+$( "div:last" ).prevAll().addClass( "before" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    prevAll(selector?: JQuery.Selector): this;
+    /**
+     * Get all preceding siblings of each element up to but not including the element matched by the selector, DOM node, or jQuery object.
+     * @param selector_element _&#x40;param_ `selector_element`
+     * <br>
+     * * `selector` — A string containing a selector expression to indicate where to stop matching preceding sibling elements. <br>
+     * * `element` — A DOM node or jQuery object indicating where to stop matching preceding sibling elements.
+     * @param filter A string containing a selector expression to match elements against.
+     * @see \`{@link https://api.jquery.com/prevUntil/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @example ​ ````Find the siblings that precede &lt;dt id=&quot;term-2&quot;&gt; up to the preceding &lt;dt&gt; and give them a red background color. Also, find previous &lt;dd&gt; siblings of &lt;dt id=&quot;term-3&quot;&gt; up to &lt;dt id=&quot;term-1&quot;&gt; and give them a green text color.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>prevUntil demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<dl>
+  <dt id="term-1">term 1</dt>
+  <dd>definition 1-a</dd>
+  <dd>definition 1-b</dd>
+  <dd>definition 1-c</dd>
+  <dd>definition 1-d</dd>
+​
+  <dt id="term-2">term 2</dt>
+  <dd>definition 2-a</dd>
+  <dd>definition 2-b</dd>
+  <dd>definition 2-c</dd>
+​
+  <dt id="term-3">term 3</dt>
+  <dd>definition 3-a</dd>
+  <dd>definition 3-b</dd>
+</dl>
+​
+<script>
+$( "#term-2" ).prevUntil( "dt" )
+  .css( "background-color", "red" );
+​
+var term1 = document.getElementById( "term-1" );
+$( "#term-3" ).prevUntil( term1, "dd" )
+  .css( "color", "green" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    prevUntil(selector_element?: JQuery.Selector | Element | JQuery, filter?: JQuery.Selector): this;
+    /**
+     * Return a Promise object to observe when all actions of a certain type bound to the collection, queued or not, have finished.
+     * @param type The type of queue that needs to be observed.
+     * @param target Object onto which the promise methods have to be attached
+     * @see \`{@link https://api.jquery.com/promise/ }\`
+     * @since 1.6
+     */
+    promise<T extends object>(type: string, target: T): T & JQuery.Promise<this>;
+    /**
+     * Return a Promise object to observe when all actions of a certain type bound to the collection, queued or not, have finished.
+     * @param target Object onto which the promise methods have to be attached
+     * @see \`{@link https://api.jquery.com/promise/ }\`
+     * @since 1.6
+     */
+    promise<T extends object>(target: T): T & JQuery.Promise<this>;
+    /**
+     * Return a Promise object to observe when all actions of a certain type bound to the collection, queued or not, have finished.
+     * @param type The type of queue that needs to be observed.
+     * @see \`{@link https://api.jquery.com/promise/ }\`
+     * @since 1.6
+     * @example ​ ````Using .promise() on a collection with no active animation returns a resolved Promise:
+```javascript
+var div = $( "<div>" );
+​
+div.promise().done(function( arg1 ) {
+  // Will fire right away and alert "true"
+  alert( this === div && arg1 === div );
+});
+```
+     * @example ​ ````Resolve the returned Promise when all animations have ended (including those initiated in the animation callback or added later on):
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>promise demo</title>
+  <style>
+  div {
+    height: 50px;
+    width: 50px;
+    float: left;
+    margin-right: 10px;
+    display: none;
+    background-color: #090;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Go</button>
+<p>Ready...</p>
+<div></div>
+<div></div>
+<div></div>
+<div></div>
+​
+<script>
+$( "button" ).on( "click", function() {
+  $( "p" ).append( "Started..." );
+​
+  $( "div" ).each(function( i ) {
+    $( this ).fadeIn().fadeOut( 1000 * ( i + 1 ) );
+  });
+​
+  $( "div" ).promise().done(function() {
+    $( "p" ).append( " Finished! " );
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Resolve the returned Promise using a $.when() statement (the .promise() method makes it possible to do this with jQuery collections):
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>promise demo</title>
+  <style>
+  div {
+    height: 50px;
+    width: 50px;
+    float: left;
+    margin-right: 10px;
+    display: none;
+    background-color: #090;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Go</button>
+<p>Ready...</p>
+<div></div>
+<div></div>
+<div></div>
+<div></div>
+​
+<script>
+var effect = function() {
+  return $( "div" ).fadeIn( 800 ).delay( 1200 ).fadeOut();
+};
+​
+$( "button" ).on( "click", function() {
+  $( "p" ).append( " Started... " );
+​
+  $.when( effect() ).done(function() {
+    $( "p" ).append( " Finished! " );
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    promise(type?: string): JQuery.Promise<this>;
+    /**
+     * Set one or more properties for the set of matched elements.
+     * @param propertyName The name of the property to set.
+     * @param value_function _&#x40;param_ `value_function`
+     * <br>
+     * * `value` — A value to set for the property. <br>
+     * * `function` — A function returning the value to set. Receives the index position of the element in the set and the
+     *                old property value as arguments. Within the function, the keyword `this` refers to the current element.
+     * @see \`{@link https://api.jquery.com/prop/ }\`
+     * @since 1.6
+     */
+    prop(propertyName: string,
+         value_function: string | number | boolean | symbol | object | null | undefined | ((this: TElement, index: number, oldPropertyValue: any) => any)): this;
+    /**
+     * Set one or more properties for the set of matched elements.
+     * @param properties An object of property-value pairs to set.
+     * @see \`{@link https://api.jquery.com/prop/ }\`
+     * @since 1.6
+     * @example ​ ````Disable all checkboxes on the page.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>prop demo</title>
+  <style>
+  img {
+    padding: 10px;
+  }
+  div {
+    color: red;
+    font-size: 24px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+  <input type="checkbox" checked="checked">
+  <input type="checkbox">
+  <input type="checkbox">
+  <input type="checkbox" checked="checked">
+​
+<script>
+$( "input[type='checkbox']" ).prop({
+  disabled: true
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    prop(properties: JQuery.PlainObject): this;
+    /**
+     * Get the value of a property for the first element in the set of matched elements.
+     * @param propertyName The name of the property to get.
+     * @see \`{@link https://api.jquery.com/prop/ }\`
+     * @since 1.6
+     * @example ​ ````Display the checked property and attribute of a checkbox as it changes.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>prop demo</title>
+  <style>
+  p {
+    margin: 20px 0 0;
+  }
+  b {
+    color: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<input id="check1" type="checkbox" checked="checked">
+<label for="check1">Check me</label>
+<p></p>
+​
+<script>
+$( "input" ).change(function() {
+  var $input = $( this );
+  $( "p" ).html(
+    ".attr( \"checked\" ): <b>" + $input.attr( "checked" ) + "</b><br>" +
+    ".prop( \"checked\" ): <b>" + $input.prop( "checked" ) + "</b><br>" +
+    ".is( \":checked\" ): <b>" + $input.is( ":checked" ) + "</b>" );
+}).change();
+</script>
+​
+</body>
+</html>
+```
+     */
+    prop(propertyName: string): any;
+    /**
+     * Add a collection of DOM elements onto the jQuery stack.
+     * @param elements An array of elements to push onto the stack and make into a new jQuery object.
+     * @param name The name of a jQuery method that generated the array of elements.
+     * @param args The arguments that were passed in to the jQuery method (for serialization).
+     * @see \`{@link https://api.jquery.com/pushStack/ }\`
+     * @since 1.3
+     */
+    pushStack(elements: ArrayLike<Element>, name: string, args: any[]): this;
+    /**
+     * Add a collection of DOM elements onto the jQuery stack.
+     * @param elements An array of elements to push onto the stack and make into a new jQuery object.
+     * @see \`{@link https://api.jquery.com/pushStack/ }\`
+     * @since 1.0
+     * @example ​ ````Add some elements onto the jQuery stack, then pop back off again.
+```javascript
+jQuery([])
+  .pushStack( document.getElementsByTagName( "div" ) )
+  .remove()
+  .end();
+```
+     */
+    pushStack(elements: ArrayLike<Element>): this;
+    /**
+     * Manipulate the queue of functions to be executed, once for each matched element.
+     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
+     * @param newQueue The new function to add to the queue, with a function to call that will dequeue the next item.
+     *                 An array of functions to replace the current queue contents.
+     * @see \`{@link https://api.jquery.com/queue/ }\`
+     * @since 1.2
+     * @example ​ ````Set a queue array to delete the queue.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>queue demo</title>
+  <style>
+  div {
+    margin: 3px;
+    width: 40px;
+    height: 40px;
+    position: absolute;
+    left: 0px;
+    top: 30px;
+    background: green;
+    display: none;
+  }
+  div.newcolor {
+    background: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="start">Start</button>
+<button id="stop">Stop</button>
+<div></div>
+​
+<script>
+$( "#start" ).click(function() {
+  $( "div" )
+    .show( "slow" )
+    .animate({ left: "+=200" }, 5000 )
+    .queue(function() {
+      $( this ).addClass( "newcolor" ).dequeue();
+    })
+    .animate({ left: '-=200' }, 1500 )
+    .queue(function() {
+      $( this ).removeClass( "newcolor" ).dequeue();
+    })
+    .slideUp();
+});
+$( "#stop" ).click(function() {
+  $( "div" )
+    .queue( "fx", [] )
+    .stop();
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    queue(queueName: string, newQueue: JQuery.TypeOrArray<JQuery.QueueFunction<TElement>>): this;
+    /**
+     * Manipulate the queue of functions to be executed, once for each matched element.
+     * @param newQueue The new function to add to the queue, with a function to call that will dequeue the next item.
+     *                 An array of functions to replace the current queue contents.
+     * @see \`{@link https://api.jquery.com/queue/ }\`
+     * @since 1.2
+     * @example ​ ````Queue a custom function.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>queue demo</title>
+  <style>
+  div {
+    margin: 3px;
+    width: 40px;
+    height: 40px;
+    position: absolute;
+    left: 0px;
+    top: 30px;
+    background: green;
+    display: none;
+  }
+  div.newcolor {
+    background: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+Click here...
+<div></div>
+​
+<script>
+$( document.body ).click(function() {
+  $( "div" )
+    .show( "slow" )
+    .animate({ left: "+=200" }, 2000 )
+    .queue(function() {
+      $( this ).addClass( "newcolor" ).dequeue();
+    })
+    .animate({ left: "-=200" }, 500 )
+    .queue(function() {
+      $( this ).removeClass( "newcolor" ).dequeue();
+    })
+    .slideUp();
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    queue(newQueue: JQuery.TypeOrArray<JQuery.QueueFunction<TElement>>): this;
+    /**
+     * Show the queue of functions to be executed on the matched elements.
+     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
+     * @see \`{@link https://api.jquery.com/queue/ }\`
+     * @since 1.2
+     * @example ​ ````Show the length of the queue.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>queue demo</title>
+  <style>
+  div {
+    margin: 3px;
+    width: 40px;
+    height: 40px;
+    position: absolute;
+    left: 0px;
+    top: 60px;
+    background: green;
+    display: none;
+  }
+  div.newcolor {
+    background: blue;
+  }
+  p {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>The queue length is: <span></span></p>
+<div></div>
+​
+<script>
+var div = $( "div" );
+​
+function runIt() {
+  div
+    .show( "slow" )
+    .animate({ left: "+=200" }, 2000 )
+    .slideToggle( 1000 )
+    .slideToggle( "fast" )
+    .animate({ left: "-=200" }, 1500 )
+    .hide( "slow" )
+    .show( 1200 )
+    .slideUp( "normal", runIt );
+}
+​
+function showIt() {
+  var n = div.queue( "fx" );
+  $( "span" ).text( n.length );
+  setTimeout( showIt, 100 );
+}
+​
+runIt();
+showIt();
+</script>
+​
+</body>
+</html>
+```
+     */
+    queue(queueName?: string): JQuery.Queue<Node>;
+    /**
+     * Specify a function to execute when the DOM is fully loaded.
+     * @param handler A function to execute after the DOM is ready.
+     * @see \`{@link https://api.jquery.com/ready/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.0. Use `jQuery(function() { })`.
+     * @example ​ ````Display a message when the DOM is loaded.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>ready demo</title>
+  <style>
+  p {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+  <script>
+​
+  $(function() {
+    $( "p" ).text( "The DOM is now loaded and can be manipulated." );
+  });
+​
+  </script>
+</head>
+<body>
+​
+<p>Not loaded yet.</p>
+​
+</body>
+</html>
+```
+     */
+    ready(handler: ($: JQueryStatic) => void): this;
+    /**
+     * Remove the set of matched elements from the DOM.
+     * @param selector A selector expression that filters the set of matched elements to be removed.
+     * @see \`{@link https://api.jquery.com/remove/ }\`
+     * @since 1.0
+     * @example ​ ````Removes all paragraphs from the DOM
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>remove demo</title>
+  <style>
+  p {
+    background: yellow;
+    margin: 6px 0;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+how are
+<p>you?</p>
+<button>Call remove() on paragraphs</button>
+​
+<script>
+$( "button" ).click(function() {
+  $( "p" ).remove();
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Removes all paragraphs that contain &quot;Hello&quot; from the DOM.  Analogous to doing $(&quot;p&quot;).filter(&quot;:contains(&#39;Hello&#39;)&quot;).remove().
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>remove demo</title>
+  <style>
+  p {
+    background: yellow;
+    margin: 6px 0;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p class="hello">Hello</p>
+how are
+<p>you?</p>
+<button>Call remove( ":contains('Hello')" ) on paragraphs</button>
+​
+<script>
+$( "button" ).click(function() {
+  $( "p" ).remove( ":contains('Hello')" );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    remove(selector?: string): this;
+    /**
+     * Remove an attribute from each element in the set of matched elements.
+     * @param attributeName An attribute to remove; as of version 1.7, it can be a space-separated list of attributes.
+     * @see \`{@link https://api.jquery.com/removeAttr/ }\`
+     * @since 1.0
+     * @example ​ ````Clicking the button changes the title of the input next to it. Move the mouse pointer over the text input to see the effect of adding and removing the title attribute.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>removeAttr demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Change title</button>
+<input type="text" title="hello there">
+<div id="log"></div>
+​
+<script>
+(function() {
+  var inputTitle = $( "input" ).attr( "title" );
+  $( "button" ).click(function() {
+    var input = $( this ).next();
+​
+    if ( input.attr( "title" ) === inputTitle ) {
+      input.removeAttr( "title" )
+    } else {
+      input.attr( "title", inputTitle );
+    }
+​
+    $( "#log" ).html( "input title is now " + input.attr( "title" ) );
+  });
+})();
+</script>
+​
+</body>
+</html>
+```
+     */
+    removeAttr(attributeName: string): this;
+    /**
+     * Remove a single class, multiple classes, or all classes from each element in the set of matched elements.
+     * @param className_function _&#x40;param_ `className_function`
+     * <br>
+     * * `className` — One or more space-separated classes to be removed from the class attribute of each matched element. <br>
+     * * `function` — A function returning one or more space-separated class names to be removed. Receives the index
+     *                position of the element in the set and the old class value as arguments.
+     * @see \`{@link https://api.jquery.com/removeClass/ }\`
+     * @since 1.0
+     * @since 1.4
+     * @since 3.3
+     * @example ​ ````Remove the class &#39;blue&#39; from the matched elements.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>removeClass demo</title>
+  <style>
+  p {
+    margin: 4px;
+    font-size: 16px;
+    font-weight: bolder;
+  }
+  .blue {
+    color: blue;
+  }
+  .under {
+    text-decoration: underline;
+  }
+  .highlight {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p class="blue under">Hello</p>
+<p class="blue under highlight">and</p>
+<p class="blue under">then</p>
+<p class="blue under">Goodbye</p>
+​
+<script>
+$( "p:even" ).removeClass( "blue" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Remove the class &#39;blue&#39; and &#39;under&#39; from the matched elements.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>removeClass demo</title>
+  <style>
+  p {
+    margin: 4px;
+    font-size: 16px;
+    font-weight: bolder;
+  }
+  .blue {
+    color: blue;
+  }
+  .under {
+    text-decoration: underline;
+  }
+  .highlight {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p class="blue under">Hello</p>
+<p class="blue under highlight">and</p>
+<p class="blue under">then</p>
+<p class="blue under">Goodbye</p>
+​
+<script>
+$( "p:odd" ).removeClass( "blue under" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Remove all the classes from the matched elements.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>removeClass demo</title>
+  <style>
+  p {
+    margin: 4px;
+    font-size: 16px;
+    font-weight: bolder;
+  }
+  .blue {
+    color: blue;
+  }
+  .under {
+    text-decoration: underline;
+  }
+  .highlight {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p class="blue under">Hello</p>
+<p class="blue under highlight">and</p>
+<p class="blue under">then</p>
+<p class="blue under">Goodbye</p>
+​
+<script>
+$( "p:eq(1)" ).removeClass();
+</script>
+​
+</body>
+</html>
+```
+     */
+    removeClass(className_function?: JQuery.TypeOrArray<string> | ((this: TElement, index: number, className: string) => string)): this;
+    /**
+     * Remove a previously-stored piece of data.
+     * @param name A string naming the piece of data to delete.
+     *             An array or space-separated string naming the pieces of data to delete.
+     * @see \`{@link https://api.jquery.com/removeData/ }\`
+     * @since 1.2.3
+     * @since 1.7
+     * @example ​ ````Set a data store for 2 names then remove one of them.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>removeData demo</title>
+  <style>
+  div {
+    margin: 2px;
+    color: blue;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>value1 before creation: <span></span></div>
+<div>value1 after creation: <span></span></div>
+<div>value1 after removal: <span></span></div>
+<div>value2 after removal: <span></span></div>
+​
+<script>
+$( "span:eq(0)" ).text( "" + $( "div" ).data( "test1" ) );
+$( "div" ).data( "test1", "VALUE-1" );
+$( "div" ).data( "test2", "VALUE-2" );
+$( "span:eq(1)" ).text( "" + $( "div").data( "test1" ) );
+$( "div" ).removeData( "test1" );
+$( "span:eq(2)" ).text( "" + $( "div" ).data( "test1" ) );
+$( "span:eq(3)" ).text( "" + $( "div" ).data( "test2" ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    removeData(name?: JQuery.TypeOrArray<string>): this;
+    /**
+     * Remove a property for the set of matched elements.
+     * @param propertyName The name of the property to remove.
+     * @see \`{@link https://api.jquery.com/removeProp/ }\`
+     * @since 1.6
+     * @example ​ ````Set a numeric property on a paragraph and then remove it.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>removeProp demo</title>
+  <style>
+  img {
+    padding: 10px;
+  }
+  div {
+    color: red;
+    font-size: 24px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+  <p></p>
+​
+<script>
+para = $( "p" );
+para
+  .prop( "luggageCode", 1234 )
+  .append( "The secret luggage code is: ", String( para.prop( "luggageCode" ) ), ". " )
+  .removeProp( "luggageCode" )
+  .append( "Now the secret luggage code is: ", String( para.prop( "luggageCode" ) ), ". " );
+</script>
+​
+</body>
+</html>
+```
+     */
+    removeProp(propertyName: string): this;
+    /**
+     * Replace each target element with the set of matched elements.
+     * @param target A selector string, jQuery object, DOM element, or array of elements indicating which element(s) to replace.
+     * @see \`{@link https://api.jquery.com/replaceAll/ }\`
+     * @since 1.2
+     * @example ​ ````Replace all the paragraphs with bold words.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>replaceAll demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<p>cruel</p>
+<p>World</p>
+​
+<script>
+$( "<b>Paragraph. </b>" ).replaceAll( "p" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    replaceAll(target: JQuery.Selector | JQuery | JQuery.TypeOrArray<Element>): this;
+    /**
+     * Replace each element in the set of matched elements with the provided new content and return the set of elements that was removed.
+     * @param newContent_function _&#x40;param_ `newContent_function`
+     * <br>
+     * * `newContent` — The content to insert. May be an HTML string, DOM element, array of DOM elements, or jQuery object. <br>
+     * * `function` — A function that returns content with which to replace the set of matched elements.
+     * @see \`{@link https://api.jquery.com/replaceWith/ }\`
+     * @since 1.2
+     * @since 1.4
+     * @example ​ ````On click, replace the button with a div containing the same word.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>replaceWith demo</title>
+  <style>
+  button {
+    display: block;
+    margin: 3px;
+    color: red;
+    width: 200px;
+  }
+  div {
+    color: red;
+    border: 2px solid blue;
+    width: 200px;
+    margin: 3px;
+    text-align: center;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>First</button>
+<button>Second</button>
+<button>Third</button>
+​
+<script>
+$( "button" ).click(function() {
+  $( this ).replaceWith( "<div>" + $( this ).text() + "</div>" );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Replace all paragraphs with bold words.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>replaceWith demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<p>cruel</p>
+<p>World</p>
+​
+<script>
+$( "p" ).replaceWith( "<b>Paragraph. </b>" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````On click, replace each paragraph with a div that is already in the DOM and selected with the $() function. Notice it doesn&#39;t clone the object but rather moves it to replace the paragraph.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>replaceWith demo</title>
+  <style>
+  div {
+    border: 2px solid blue;
+    color: red;
+    margin: 3px;
+  }
+  p {
+    border: 2px solid red;
+    color: blue;
+    margin: 3px;
+    cursor: pointer;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+  <p>Hello</p>
+  <p>cruel</p>
+  <p>World</p>
+  <div>Replaced!</div>
+​
+<script>
+$( "p" ).click(function() {
+  $( this ).replaceWith( $( "div" ) );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````On button click, replace the containing div with its child divs and append the class name of the selected element to the paragraph.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>replaceWith demo</title>
+  <style>
+  .container {
+    background-color: #991;
+  }
+  .inner {
+    color: #911;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>
+  <button>Replace!</button>
+</p>
+<div class="container">
+  <div class="inner">Scooby</div>
+  <div class="inner">Dooby</div>
+  <div class="inner">Doo</div>
+</div>
+​
+<script>
+$( "button" ).on( "click", function() {
+  var $container = $( "div.container" ).replaceWith(function() {
+    return $( this ).contents();
+  });
+​
+  $( "p" ).append( $container.attr( "class" ) );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    replaceWith(newContent_function: JQuery.htmlString | JQuery | JQuery.TypeOrArray<Element> | ((this: TElement) => any)): this;
+    /**
+     * Bind an event handler to the "resize" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/resize/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    resize<TData>(eventData: TData,
+                  handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "resize" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/resize/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````To see the window width while (or after) it is resized, try:
+```javascript
+$( window ).resize(function() {
+  $( "body" ).prepend( "<div>" + $( window ).width() + "</div>" );
+});
+```
+     */
+    resize(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Bind an event handler to the "scroll" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/scroll/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    scroll<TData>(eventData: TData,
+                  handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "scroll" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/scroll/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````To do something when your page is scrolled:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>scroll demo</title>
+  <style>
+  div {
+    color: blue;
+  }
+  p {
+    color: green;
+  }
+  span {
+    color: red;
+    display: none;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>Try scrolling the iframe.</div>
+<p>Paragraph - <span>Scroll happened!</span></p>
+​
+<script>
+$( "p" ).clone().appendTo( document.body );
+$( "p" ).clone().appendTo( document.body );
+$( "p" ).clone().appendTo( document.body );
+$( window ).scroll(function() {
+  $( "span" ).css( "display", "inline" ).fadeOut( "slow" );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    scroll(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Set the current horizontal position of the scroll bar for each of the set of matched elements.
+     * @param value An integer indicating the new position to set the scroll bar to.
+     * @see \`{@link https://api.jquery.com/scrollLeft/ }\`
+     * @since 1.2.6
+     * @example ​ ````Set the scrollLeft of a div.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>scrollLeft demo</title>
+  <style>
+  div.demo {
+    background: #ccc none repeat scroll 0 0;
+    border: 3px solid #666;
+    margin: 5px;
+    padding: 5px;
+    position: relative;
+    width: 200px;
+    height: 100px;
+    overflow: auto;
+  }
+  p {
+    margin: 10px;
+    padding: 5px;
+    border: 2px solid #666;
+    width: 1000px;
+    height: 1000px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div class="demo"><h1>lalala</h1><p>Hello</p></div>
+​
+<script>
+$( "div.demo" ).scrollLeft( 300 );
+</script>
+​
+</body>
+</html>
+```
+     */
+    scrollLeft(value: number): this;
+    /**
+     * Get the current horizontal position of the scroll bar for the first element in the set of matched elements.
+     * @see \`{@link https://api.jquery.com/scrollLeft/ }\`
+     * @since 1.2.6
+     * @example ​ ````Get the scrollLeft of a paragraph.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>scrollLeft demo</title>
+  <style>
+  p {
+    margin: 10px;
+    padding: 5px;
+    border: 2px solid #666;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p><p></p>
+​
+<script>
+var p = $( "p:first" );
+$( "p:last" ).text( "scrollLeft:" + p.scrollLeft() );
+</script>
+​
+</body>
+</html>
+```
+     */
+    scrollLeft(): number | undefined;
+    /**
+     * Set the current vertical position of the scroll bar for each of the set of matched elements.
+     * @param value A number indicating the new position to set the scroll bar to.
+     * @see \`{@link https://api.jquery.com/scrollTop/ }\`
+     * @since 1.2.6
+     * @example ​ ````Set the scrollTop of a div.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>scrollTop demo</title>
+  <style>
+  div.demo {
+    background: #ccc none repeat scroll 0 0;
+    border: 3px solid #666;
+    margin: 5px;
+    padding: 5px;
+    position: relative;
+    width: 200px;
+    height: 100px;
+    overflow: auto;
+  }
+  p {
+    margin: 10px;
+    padding: 5px;
+    border: 2px solid #666;
+    width: 1000px;
+    height: 1000px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div class="demo"><h1>lalala</h1><p>Hello</p></div>
+​
+<script>
+$( "div.demo" ).scrollTop( 300 );
+</script>
+​
+</body>
+</html>
+```
+     */
+    scrollTop(value: number): this;
+    /**
+     * Get the current vertical position of the scroll bar for the first element in the set of matched elements or set the vertical position of the scroll bar for every matched element.
+     * @see \`{@link https://api.jquery.com/scrollTop/ }\`
+     * @since 1.2.6
+     * @example ​ ````Get the scrollTop of a paragraph.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>scrollTop demo</title>
+  <style>
+  p {
+    margin: 10px;
+    padding: 5px;
+    border: 2px solid #666;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p><p></p>
+​
+<script>
+var p = $( "p:first" );
+$( "p:last" ).text( "scrollTop:" + p.scrollTop() );
+</script>
+​
+</body>
+</html>
+```
+     */
+    scrollTop(): number | undefined;
+    /**
+     * Bind an event handler to the "select" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/select/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    select<TData>(eventData: TData,
+                  handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "select" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/select/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````To do something when text in input boxes is selected:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>select demo</title>
+  <style>
+  p {
+    color: blue;
+  }
+  div {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+  <p>Click and drag the mouse to select text in the inputs.</p>
+  <input type="text" value="Some text">
+  <input type="text" value="to test on">
+  <div></div>
+  ​
+<script>
+$( ":input" ).select(function() {
+  $( "div" ).text( "Something was selected" ).show().fadeOut( 1000 );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````To trigger the select event on all input elements, try:
+```javascript
+$( "input" ).select();
+```
+     */
+    select(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Encode a set of form elements as a string for submission.
+     * @see \`{@link https://api.jquery.com/serialize/ }\`
+     * @since 1.0
+     * @example ​ ````Serialize a form to a query string that could be sent to a server in an Ajax request.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>serialize demo</title>
+  <style>
+  body, select {
+    font-size: 12px;
+  }
+  form {
+    margin: 5px;
+  }
+  p {
+    color: red;
+    margin: 5px;
+    font-size: 14px;
+  }
+  b {
+    color: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<form>
+  <select name="single">
+    <option>Single</option>
+    <option>Single2</option>
+  </select>
+​
+  <br>
+  <select name="multiple" multiple="multiple">
+    <option selected="selected">Multiple</option>
+    <option>Multiple2</option>
+    <option selected="selected">Multiple3</option>
+  </select>
+​
+  <br>
+  <input type="checkbox" name="check" value="check1" id="ch1">
+  <label for="ch1">check1</label>
+  <input type="checkbox" name="check" value="check2" checked="checked" id="ch2">
+  <label for="ch2">check2</label>
+​
+  <br>
+  <input type="radio" name="radio" value="radio1" checked="checked" id="r1">
+  <label for="r1">radio1</label>
+  <input type="radio" name="radio" value="radio2" id="r2">
+  <label for="r2">radio2</label>
+</form>
+​
+<p><tt id="results"></tt></p>
+​
+<script>
+  function showValues() {
+    var str = $( "form" ).serialize();
+    $( "#results" ).text( str );
+  }
+  $( "input[type='checkbox'], input[type='radio']" ).on( "click", showValues );
+  $( "select" ).on( "change", showValues );
+  showValues();
+</script>
+​
+</body>
+</html>
+```
+     */
+    serialize(): string;
+    /**
+     * Encode a set of form elements as an array of names and values.
+     * @see \`{@link https://api.jquery.com/serializeArray/ }\`
+     * @since 1.2
+     * @example ​ ````Get the values from a form, iterate through them, and append them to a results display.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>serializeArray demo</title>
+  <style>
+  body, select {
+    font-size: 14px;
+  }
+  form {
+    margin: 5px;
+  }
+  p {
+    color: red;
+    margin: 5px;
+  }
+  b {
+    color: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><b>Results:</b> <span id="results"></span></p>
+<form>
+  <select name="single">
+    <option>Single</option>
+    <option>Single2</option>
+  </select>
+  <select name="multiple" multiple="multiple">
+    <option selected="selected">Multiple</option>
+    <option>Multiple2</option>
+    <option selected="selected">Multiple3</option>
+  </select>
+  <br>
+  <input type="checkbox" name="check" value="check1" id="ch1">
+  <label for="ch1">check1</label>
+  <input type="checkbox" name="check" value="check2" checked="checked" id="ch2">
+  <label for="ch2">check2</label>
+  <input type="radio" name="radio" value="radio1" checked="checked" id="r1">
+  <label for="r1">radio1</label>
+  <input type="radio" name="radio" value="radio2" id="r2">
+  <label for="r2">radio2</label>
+</form>
+​
+<script>
+  function showValues() {
+    var fields = $( ":input" ).serializeArray();
+    $( "#results" ).empty();
+    jQuery.each( fields, function( i, field ) {
+      $( "#results" ).append( field.value + " " );
+    });
+  }
+​
+  $( ":checkbox, :radio" ).click( showValues );
+  $( "select" ).change( showValues );
+  showValues();
+</script>
+​
+</body>
+</html>
+```
+     */
+    serializeArray(): JQuery.NameValuePair[];
+    /**
+     * Display the matched elements.
+     * @param duration A string or number determining how long the animation will run.
+     * @param easing A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/show/ }\`
+     * @since 1.4.3
+     */
+    show(duration: JQuery.Duration, easing: string, complete: (this: TElement) => void): this;
+    /**
+     * Display the matched elements.
+     * @param duration A string or number determining how long the animation will run.
+     * @param easing_complete _&#x40;param_ `easing_complete`
+     * <br>
+     * * `easing` — A string indicating which easing function to use for the transition. <br>
+     * * `complete` — A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/show/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     * @example ​ ````Show the first div, followed by each next adjacent sibling div in order, with a 200ms animation. Each animation starts when the previous sibling div&#39;s animation ends.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>show demo</title>
+  <style>
+  div {
+    background: #def3ca;
+    margin: 3px;
+    width: 80px;
+    display: none;
+    float: left;
+    text-align: center;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="showr">Show</button>
+<button id="hidr">Hide</button>
+<div>Hello 3,</div>
+<div>how</div>
+<div>are</div>
+<div>you?</div>
+​
+<script>
+$( "#showr" ).click(function() {
+  $( "div" ).first().show( "fast", function showNext() {
+    $( this ).next( "div" ).show( "fast", showNext );
+  });
+});
+​
+$( "#hidr" ).click(function() {
+  $( "div" ).hide( 1000 );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Show all span and input elements with an animation. Change the text once the animation is done.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>show demo</title>
+  <style>
+  span {
+    display: none;
+  }
+  div {
+    display: none;
+  }
+  p {
+    font-weight: bold;
+    background-color: #fcd;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Do it!</button>
+<span>Are you sure? (type 'yes' if you are) </span>
+<div>
+  <form>
+    <input type="text"  value="as;ldkfjalsdf">
+  </form>
+</div>
+<p style="display:none;">I'm hidden...</p>
+​
+<script>
+function doIt() {
+  $( "span,div" ).show( "slow" );
+}
+// Can pass in function name
+$( "button" ).click( doIt );
+​
+$( "form" ).submit(function( event ) {
+  if ( $( "input" ).val() === "yes" ) {
+    $( "p" ).show( 4000, function() {
+      $( this ).text( "Ok, DONE! (now showing)" );
+    });
+  }
+  $( "span,div" ).hide( "fast" );
+​
+  // Prevent form submission
+  event.preventDefault();
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    show(duration: JQuery.Duration, easing_complete: string | ((this: TElement) => void)): this;
+    /**
+     * Display the matched elements.
+     * @param duration_complete_options _&#x40;param_ `duration_complete_options`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
+     * * `options` — A map of additional options to pass to the method.
+     * @see \`{@link https://api.jquery.com/show/ }\`
+     * @since 1.0
+     * @example ​ ````Animates all hidden paragraphs to show slowly, completing the animation within 600 milliseconds.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>show demo</title>
+  <style>
+  p {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Show it</button>
+<p style="display: none">Hello  2</p>
+​
+<script>
+$( "button" ).click(function() {
+  $( "p" ).show( "slow" );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    show(duration_complete_options?: JQuery.Duration | ((this: TElement) => void) | JQuery.EffectsOptions<TElement>): this;
+    /**
+     * Get the siblings of each element in the set of matched elements, optionally filtered by a selector.
+     * @param selector A string containing a selector expression to match elements against.
+     * @see \`{@link https://api.jquery.com/siblings/ }\`
+     * @since 1.0
+     * @example ​ ````Find the unique siblings of all yellow li elements in the 3 lists (including other yellow li elements if appropriate).
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>siblings demo</title>
+  <style>
+  ul {
+    float: left;
+    margin: 5px;
+    font-size: 16px;
+    font-weight: bold;
+  }
+  p {
+    color: blue;
+    margin: 10px 20px;
+    font-size: 16px;
+    padding: 5px;
+    font-weight: bolder;
+  }
+  .hilite {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul>
+  <li>One</li>
+  <li>Two</li>
+  <li class="hilite">Three</li>
+  <li>Four</li>
+</ul>
+​
+<ul>
+  <li>Five</li>
+  <li>Six</li>
+  <li>Seven</li>
+</ul>
+​
+<ul>
+  <li>Eight</li>
+  <li class="hilite">Nine</li>
+  <li>Ten</li>
+  <li class="hilite">Eleven</li>
+</ul>
+​
+<p>Unique siblings: <b></b></p>
+​
+<script>
+var len = $( ".hilite" ).siblings()
+  .css( "color", "red" )
+  .length;
+$( "b" ).text( len );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Find all siblings with a class &quot;selected&quot; of each div.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>siblings demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div><span>Hello</span></div>
+<p class="selected">Hello Again</p>
+<p>And Again</p>
+​
+<script>
+$( "p" ).siblings( ".selected" ).css( "background", "yellow" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    siblings(selector?: JQuery.Selector): this;
+    /**
+     * Reduce the set of matched elements to a subset specified by a range of indices.
+     * @param start An integer indicating the 0-based position at which the elements begin to be selected. If negative,
+     *              it indicates an offset from the end of the set.
+     * @param end An integer indicating the 0-based position at which the elements stop being selected. If negative,
+     *            it indicates an offset from the end of the set. If omitted, the range continues until the end of the set.
+     * @see \`{@link https://api.jquery.com/slice/ }\`
+     * @since 1.1.4
+     * @example ​ ````Turns divs yellow based on a random slice.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>slice demo</title>
+  <style>
+  div {
+    width: 40px;
+    height: 40px;
+    margin: 10px;
+    float: left;
+    border: 2px solid blue;
+  }
+  span {
+    color: red;
+    font-weight: bold;
+  }
+  button {
+    margin: 5px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button>Turn slice yellow</button>
+  <span>Click the button!</span></p>
+  <div></div>
+  <div></div>
+  <div></div>
+  <div></div>
+  <div></div>
+  <div></div>
+  <div></div>
+  <div></div>
+  <div></div>
+  ​
+<script>
+function colorEm() {
+  var $div = $( "div" );
+  var start = Math.floor( Math.random() * $div.length );
+  var end = Math.floor( Math.random() * ( $div.length - start ) ) +
+    start + 1;
+  if ( end === $div.length ) {
+    end = undefined;
+  }
+  $div.css( "background", "" );
+  if ( end ) {
+    $div.slice( start, end ).css( "background", "yellow" );
+  } else {
+    $div.slice( start ).css( "background", "yellow" );
+  }
+  $( "span" ).text( "$( 'div' ).slice( " + start +
+    (end ? ", " + end : "") +
+    ").css( 'background', 'yellow' );" );
+}
+​
+$( "button" ).click( colorEm );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Selects all paragraphs, then slices the selection to include only the first element.
+```javascript
+$( "p" ).slice( 0, 1 ).wrapInner( "<b></b>" );
+```
+     * @example ​ ````Selects all paragraphs, then slices the selection to include only the first and second element.
+```javascript
+$( "p" ).slice( 0, 2 ).wrapInner( "<b></b>" );
+```
+     * @example ​ ````Selects all paragraphs, then slices the selection to include only the second element.
+```javascript
+$( "p" ).slice( 1, 2 ).wrapInner( "<b></b>" );
+```
+     * @example ​ ````Selects all paragraphs, then slices the selection to include only the second and third element.
+```javascript
+$( "p" ).slice( 1 ).wrapInner( "<b></b>" );
+```
+     * @example ​ ````Selects all paragraphs, then slices the selection to include only the third element.
+```javascript
+$( "p" ).slice( -1 ).wrapInner( "<b></b>" );
+```
+     */
+    slice(start: number, end?: number): this;
+    /**
+     * Display the matched elements with a sliding motion.
+     * @param duration A string or number determining how long the animation will run.
+     * @param easing A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/slideDown/ }\`
+     * @since 1.4.3
+     */
+    slideDown(duration: JQuery.Duration, easing: string, complete?: (this: TElement) => void): this;
+    /**
+     * Display the matched elements with a sliding motion.
+     * @param duration_easing _&#x40;param_ `duration_easing`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `easing` — A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/slideDown/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     * @example ​ ````Animates all inputs to slide down, completing the animation within 1000 milliseconds. Once the animation is done, the input look is changed especially if it is the middle input which gets the focus.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>slideDown demo</title>
+  <style>
+  div {
+    background: #cfd;
+    margin: 3px;
+    width: 50px;
+    text-align: center;
+    float: left;
+    cursor: pointer;
+    border: 2px outset black;
+    font-weight: bolder;
+  }
+  input {
+    display: none;
+    width: 120px;
+    float: left;
+    margin: 10px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>Push!</div>
+<input type="text">
+<input type="text" class="middle">
+<input type="text">
+  ​
+<script>
+$( "div" ).click(function() {
+  $( this ).css({
+    borderStyle: "inset",
+    cursor: "wait"
+  });
+  $( "input" ).slideDown( 1000, function() {
+    $( this )
+      .css( "border", "2px red inset" )
+      .filter( ".middle" )
+        .css( "background", "yellow" )
+        .focus();
+    $( "div" ).css( "visibility", "hidden" );
+  });
+});
+​
+</script>
+​
+</body>
+</html>
+```
+     */
+    slideDown(duration_easing: JQuery.Duration | string, complete: (this: TElement) => void): this;
+    /**
+     * Display the matched elements with a sliding motion.
+     * @param duration_easing_complete_options _&#x40;param_ `duration_easing_complete_options`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `easing` — A string indicating which easing function to use for the transition. <br>
+     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
+     * * `options` — A map of additional options to pass to the method.
+     * @see \`{@link https://api.jquery.com/slideDown/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     * @example ​ ````Animates all divs to slide down and show themselves over 600 milliseconds.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>slideDown demo</title>
+  <style>
+  div {
+    background: #de9a44;
+    margin: 3px;
+    width: 80px;
+    height: 40px;
+    display: none;
+    float: left;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+Click me!
+<div></div>
+<div></div>
+<div></div>
+​
+<script>
+$( document.body ).click(function () {
+  if ( $( "div:first" ).is( ":hidden" ) ) {
+    $( "div" ).slideDown( "slow" );
+  } else {
+    $( "div" ).hide();
+  }
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    slideDown(duration_easing_complete_options?: JQuery.Duration | string | ((this: TElement) => void) | JQuery.EffectsOptions<TElement>): this;
+    /**
+     * Display or hide the matched elements with a sliding motion.
+     * @param duration A string or number determining how long the animation will run.
+     * @param easing A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/slideToggle/ }\`
+     * @since 1.4.3
+     */
+    slideToggle(duration: JQuery.Duration, easing: string, complete?: (this: TElement) => void): this;
+    /**
+     * Display or hide the matched elements with a sliding motion.
+     * @param duration_easing _&#x40;param_ `duration_easing`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `easing` — A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/slideToggle/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     * @example ​ ````Animates divs between dividers with a toggle that makes some appear and some disappear.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>slideToggle demo</title>
+  <style>
+  div {
+    background: #b977d1;
+    margin: 3px;
+    width: 60px;
+    height: 60px;
+    float: left;
+  }
+  div.still {
+    background: #345;
+    width: 5px;
+  }
+  div.hider {
+    display: none;
+  }
+  span {
+    color: red;
+  }
+  p {
+    clear: left;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div></div>
+<div class="still"></div>
+<div style="display:none;">
+</div><div class="still"></div>
+<div></div>
+<div class="still"></div>
+<div class="hider"></div>
+<div class="still"></div>
+<div class="hider"></div>
+<div class="still"></div>
+<div></div>
+<p><button id="aa">Toggle</button> There have been <span>0</span> toggled divs.</p>
+​
+<script>
+$( "#aa" ).click(function() {
+  $( "div:not(.still)" ).slideToggle( "slow", function() {
+    var n = parseInt( $( "span" ).text(), 10 );
+    $( "span" ).text( n + 1 );
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    slideToggle(duration_easing: JQuery.Duration | string, complete: (this: TElement) => void): this;
+    /**
+     * Display or hide the matched elements with a sliding motion.
+     * @param duration_easing_complete_options _&#x40;param_ `duration_easing_complete_options`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `easing` — A string indicating which easing function to use for the transition. <br>
+     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
+     * * `options` — A map of additional options to pass to the method.
+     * @see \`{@link https://api.jquery.com/slideToggle/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     * @example ​ ````Animates all paragraphs to slide up or down, completing the animation within 600 milliseconds.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>slideToggle demo</title>
+  <style>
+  p {
+    width: 400px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Toggle</button>
+<p>
+  This is the paragraph to end all paragraphs.  You
+  should feel <em>lucky</em> to have seen such a paragraph in
+  your life.  Congratulations!
+</p>
+​
+<script>
+$( "button" ).click(function() {
+  $( "p" ).slideToggle( "slow" );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    slideToggle(duration_easing_complete_options?: JQuery.Duration | string | ((this: TElement) => void) | JQuery.EffectsOptions<TElement>): this;
+    /**
+     * Hide the matched elements with a sliding motion.
+     * @param duration A string or number determining how long the animation will run.
+     * @param easing A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/slideUp/ }\`
+     * @since 1.4.3
+     */
+    slideUp(duration: JQuery.Duration, easing: string, complete?: (this: TElement) => void): this;
+    /**
+     * Hide the matched elements with a sliding motion.
+     * @param duration_easing _&#x40;param_ `duration_easing`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `easing` — A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/slideUp/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     * @example ​ ````Animates the parent paragraph to slide up, completing the animation within 200 milliseconds. Once the animation is done, it displays an alert.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>slideUp demo</title>
+  <style>
+ div {
+   margin: 2px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>
+  <button>Hide One</button>
+  <input type="text" value="One">
+</div>
+​
+<div>
+  <button>Hide Two</button>
+  <input type="text" value="Two">
+</div>
+​
+<div>
+  <button>Hide Three</button>
+  <input type="text" value="Three">
+</div>
+​
+<div id="msg"></div>
+​
+<script>
+$( "button" ).click(function() {
+  $( this ).parent().slideUp( "slow", function() {
+    $( "#msg" ).text( $( "button", this ).text() + " has completed." );
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    slideUp(duration_easing: JQuery.Duration | string, complete: (this: TElement) => void): this;
+    /**
+     * Hide the matched elements with a sliding motion.
+     * @param duration_easing_complete_options _&#x40;param_ `duration_easing_complete_options`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `easing` — A string indicating which easing function to use for the transition. <br>
+     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
+     * * `options` — A map of additional options to pass to the method.
+     * @see \`{@link https://api.jquery.com/slideUp/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     * @example ​ ````Animates all divs to slide up, completing the animation within 400 milliseconds.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>slideUp demo</title>
+  <style>
+  div {
+    background: #3d9a44;
+    margin: 3px;
+    width: 80px;
+    height: 40px;
+    float: left;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+Click me!
+<div></div>
+<div></div>
+<div></div>
+<div></div>
+<div></div>
+​
+<script>
+$( document.body ).click(function() {
+  if ( $( "div:first" ).is( ":hidden" ) ) {
+    $( "div" ).show( "slow" );
+  } else {
+    $( "div" ).slideUp();
+  }
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    slideUp(duration_easing_complete_options?: JQuery.Duration | string | ((this: TElement) => void) | JQuery.EffectsOptions<TElement>): this;
+    /**
+     * Stop the currently-running animation on the matched elements.
+     * @param queue The name of the queue in which to stop animations.
+     * @param clearQueue A Boolean indicating whether to remove queued animation as well. Defaults to false.
+     * @param jumpToEnd A Boolean indicating whether to complete the current animation immediately. Defaults to false.
+     * @see \`{@link https://api.jquery.com/stop/ }\`
+     * @since 1.7
+     */
+    stop(queue: string, clearQueue?: boolean, jumpToEnd?: boolean): this;
+    /**
+     * Stop the currently-running animation on the matched elements.
+     * @param clearQueue A Boolean indicating whether to remove queued animation as well. Defaults to false.
+     * @param jumpToEnd A Boolean indicating whether to complete the current animation immediately. Defaults to false.
+     * @see \`{@link https://api.jquery.com/stop/ }\`
+     * @since 1.2
+     * @example ​ ````Click the Go button once to start the animation, then click the STOP button to stop it where it&#39;s currently positioned.  Another option is to click several buttons to queue them up and see that stop just kills the currently playing one.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>stop demo</title>
+  <style>
+  div {
+    position: absolute;
+    background-color: #abc;
+    left: 0px;
+    top: 30px;
+    width: 60px;
+    height: 60px;
+    margin: 5px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="go">Go</button>
+<button id="stop">STOP!</button>
+<button id="back">Back</button>
+<div class="block"></div>
+​
+<script>
+// Start animation
+$( "#go" ).click(function() {
+  $( ".block" ).animate({ left: "+=100px" }, 2000 );
+});
+​
+// Stop animation when button is clicked
+$( "#stop" ).click(function() {
+  $( ".block" ).stop();
+});
+​
+// Start animation in the opposite direction
+$( "#back" ).click(function() {
+  $( ".block" ).animate({ left: "-=100px" }, 2000 );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Click the slideToggle button to start the animation, then click again before the animation is completed. The animation will toggle the other direction from the saved starting point.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>stop demo</title>
+  <style>
+  .block {
+    background-color: #abc;
+    border: 2px solid black;
+    width: 200px;
+    height: 80px;
+    margin: 10px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="toggle">slideToggle</button>
+<div class="block"></div>
+​
+<script>
+var $block = $( ".block" );
+​
+// Toggle a sliding animation animation
+$( "#toggle" ).on( "click", function() {
+  $block.stop().slideToggle( 1000 );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    stop(clearQueue?: boolean, jumpToEnd?: boolean): this;
+    /**
+     * Bind an event handler to the "submit" JavaScript event, or trigger that event on an element.
+     * @param eventData An object containing data that will be passed to the event handler.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/submit/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     */
+    submit<TData>(eventData: TData,
+                  handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
+    /**
+     * Bind an event handler to the "submit" JavaScript event, or trigger that event on an element.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/submit/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
+     *
+     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
+     *
+     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
+     * @example ​ ````If you&#39;d like to prevent forms from being submitted unless a flag variable is set, try:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>submit demo</title>
+  <style>
+  p {
+    margin: 0;
+    color: blue;
+  }
+  div,p {
+    margin-left: 10px;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Type 'correct' to validate.</p>
+<form action="javascript:alert( 'success!' );">
+  <div>
+    <input type="text">
+    <input type="submit">
+  </div>
+</form>
+<span></span>
+​
+<script>
+$( "form" ).submit(function( event ) {
+  if ( $( "input:first" ).val() === "correct" ) {
+    $( "span" ).text( "Validated..." ).show();
+    return;
+  }
+​
+  $( "span" ).text( "Not valid!" ).show().fadeOut( 1000 );
+  event.preventDefault();
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````If you&#39;d like to prevent forms from being submitted unless a flag variable is set, try:
+```javascript
+$( "form" ).submit(function() {
+  return this.some_flag_variable;
+});
+```
+     * @example ​ ````To trigger the submit event on the first form on the page, try:
+```javascript
+$( "form:first" ).submit();
+```
+     */
+    submit(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
+    /**
+     * Set the content of each element in the set of matched elements to the specified text.
+     * @param text_function _&#x40;param_ `text_function`
+     * <br>
+     * * `text` — The text to set as the content of each matched element. When Number or Boolean is supplied, it will
+     *            be converted to a String representation. <br>
+     * * `function` — A function returning the text content to set. Receives the index position of the element in the set
+     *                and the old text value as arguments.
+     * @see \`{@link https://api.jquery.com/text/ }\`
+     * @since 1.0
+     * @since 1.4
+     * @example ​ ````Add text to the paragraph (notice the bold tag is escaped).
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>text demo</title>
+  <style>
+  p {
+    color: blue;
+    margin: 8px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Test Paragraph.</p>
+​
+<script>
+$( "p" ).text( "<b>Some</b> new text." );
+</script>
+​
+</body>
+</html>
+```
+     */
+    text(text_function: string | number | boolean | ((this: TElement, index: number, text: string) => string | number | boolean)): this;
+    /**
+     * Get the combined text contents of each element in the set of matched elements, including their descendants.
+     * @see \`{@link https://api.jquery.com/text/ }\`
+     * @since 1.0
+     * @example ​ ````Find the text in the first paragraph (stripping out the html), then set the html of the last paragraph to show it is just text (the red bold is gone).
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>text demo</title>
+  <style>
+  p {
+    color: blue;
+    margin: 8px;
+  }
+  b {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><b>Test</b> Paragraph.</p>
+<p></p>
+​
+<script>
+var str = $( "p:first" ).text();
+$( "p:last" ).html( str );
+</script>
+​
+</body>
+</html>
+```
+     */
+    text(): string;
+    /**
+     * Retrieve all the elements contained in the jQuery set, as an array.
+     * @see \`{@link https://api.jquery.com/toArray/ }\`
+     * @since 1.4
+     * @example ​ ````Select all divs in the document and return the DOM Elements as an Array; then use the built-in reverse() method to reverse that array.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>toArray demo</title>
+  <style>
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+Reversed - <span></span>
+​
+<div>One</div>
+<div>Two</div>
+<div>Three</div>​
+<script>
+function disp( divs ) {
+  var a = [];
+  for ( var i = 0; i < divs.length; i++ ) {
+    a.push( divs[ i ].innerHTML );
+  }
+  $( "span" ).text( a.join( " " ) );
+}
+​
+disp( $( "div" ).toArray().reverse() );
+</script>
+​
+</body>
+</html>
+```
+     */
+    toArray(): TElement[];
+    /**
+     * Display or hide the matched elements.
+     * @param duration A string or number determining how long the animation will run.
+     * @param easing A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/toggle/ }\`
+     * @since 1.4.3
+     */
+    toggle(duration: JQuery.Duration, easing: string, complete?: (this: TElement) => void): this;
+    /**
+     * Display or hide the matched elements.
+     * @param duration A string or number determining how long the animation will run.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/toggle/ }\`
+     * @since 1.0
+     */
+    toggle(duration: JQuery.Duration, complete: (this: TElement) => void): this;
+    /**
+     * Display or hide the matched elements.
+     * @param duration_complete_options_display _&#x40;param_ `duration_complete_options_display`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
+     * * `options` — A map of additional options to pass to the method. <br>
+     * * `display` — Use true to show the element or false to hide it.
+     * @see \`{@link https://api.jquery.com/toggle/ }\`
+     * @since 1.0
+     * @since 1.3
+     * @example ​ ````Toggles all paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>toggle demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Toggle</button>
+<p>Hello</p>
+<p style="display: none">Good Bye</p>
+​
+<script>
+$( "button" ).click(function() {
+  $( "p" ).toggle();
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Animates all paragraphs to be shown if they are hidden and hidden if they are visible, completing the animation within 600 milliseconds.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>toggle demo</title>
+  <style>
+  p {
+    background: #dad;
+    font-weight: bold;
+    font-size: 16px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Toggle 'em</button>
+<p>Hiya</p>
+<p>Such interesting text, eh?</p>
+​
+<script>
+$( "button" ).click(function() {
+  $( "p" ).toggle( "slow" );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Shows all paragraphs, then hides them all, back and forth.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>toggle demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Toggle</button>
+<p>Hello</p>
+<p style="display: none">Good Bye</p>
+​
+<script>
+var flip = 0;
+$( "button" ).click(function() {
+  $( "p" ).toggle( flip++ % 2 === 0 );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    toggle(duration_complete_options_display?: JQuery.Duration | ((this: TElement) => void) | JQuery.EffectsOptions<TElement> | boolean): this;
+    /**
+     * Add or remove one or more classes from each element in the set of matched elements, depending on either the class's presence or the value of the state argument.
+     * @param className_function _&#x40;param_ `className_function`
+     * <br>
+     * * `className` — One or more class names (separated by spaces) to be toggled for each element in the matched set. <br>
+     * * `function` — A function that returns class names to be toggled in the class attribute of each element in the
+     *                matched set. Receives the index position of the element in the set, the old class value, and the state as arguments.
+     * @param state A Boolean (not just truthy/falsy) value to determine whether the class should be added or removed.
+     * @see \`{@link https://api.jquery.com/toggleClass/ }\`
+     * @since 1.0
+     * @since 1.3
+     * @since 1.4
+     * @since 3.3
+     * @example ​ ````Toggle the class &#39;highlight&#39; when a paragraph is clicked.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>toggleClass demo</title>
+  <style>
+  p {
+    margin: 4px;
+    font-size: 16px;
+    font-weight: bolder;
+    cursor: pointer;
+  }
+  .blue {
+    color: blue;
+  }
+  .highlight {
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p class="blue">Click to toggle</p>
+<p class="blue highlight">highlight</p>
+<p class="blue">on these</p>
+<p class="blue">paragraphs</p>
+​
+<script>
+$( "p" ).click(function() {
+  $( this ).toggleClass( "highlight" );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Add the &quot;highlight&quot; class to the clicked paragraph on every third click of that paragraph, remove it every first and second click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>toggleClass demo</title>
+  <style>
+  p {
+    margin: 4px;
+    font-size: 16px;
+    font-weight: bolder;
+    cursor: pointer;
+  }
+  .blue {
+    color: blue;
+  }
+  .highlight {
+    background: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p class="blue">Click to toggle (<span>clicks: 0</span>)</p>
+<p class="blue highlight">highlight (<span>clicks: 0</span>)</p>
+<p class="blue">on these (<span>clicks: 0</span>)</p>
+<p class="blue">paragraphs (<span>clicks: 0</span>)</p>
+​
+<script>
+var count = 0;
+$( "p" ).each(function() {
+  var $thisParagraph = $( this );
+  var count = 0;
+  $thisParagraph.click(function() {
+    count++;
+    $thisParagraph.find( "span" ).text( "clicks: " + count );
+    $thisParagraph.toggleClass( "highlight", count % 3 === 0 );
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Toggle the class name(s) indicated on the buttons for each div.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>toggleClass demo</title>
+  <style>
+  .wrap > div {
+    float: left;
+    width: 100px;
+    margin: 1em 1em 0 0;
+    padding-left: 3px;
+    border: 1px solid #abc;
+  }
+  div.a {
+    background-color: aqua;
+  }
+  div.b {
+    background-color: burlywood;
+  }
+  div.c {
+    background-color: cornsilk;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div class="buttons">
+  <button>toggle</button>
+  <button class="a">toggle a</button>
+  <button class="a b">toggle a b</button>
+  <button class="a b c">toggle a b c</button>
+  <a href="#">reset</a>
+</div>
+<div class="wrap">
+  <div></div>
+  <div class="b"></div>
+  <div class="a b"></div>
+  <div class="a c"></div>
+</div>
+​
+<script>
+var cls = [ "", "a", "a b", "a b c" ];
+var divs = $( "div.wrap" ).children();
+var appendClass = function() {
+  divs.append(function() {
+    return "<div>" + ( this.className || "none" ) + "</div>";
+  });
+};
+​
+appendClass();
+​
+$( "button" ).on( "click", function() {
+  var tc = this.className || undefined;
+  divs.toggleClass( tc );
+  appendClass();
+});
+​
+$( "a" ).on( "click", function( event ) {
+  event.preventDefault();
+  divs.empty().each(function( i ) {
+    this.className = cls[ i ];
+  });
+  appendClass();
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    toggleClass<TState extends boolean>(className_function: JQuery.TypeOrArray<string> | ((this: TElement, index: number, className: string, state: TState) => string),
+                                        state?: TState): this;
+    /**
+     * Add or remove one or more classes from each element in the set of matched elements, depending on either the class's presence or the value of the state argument.
+     * @param state A boolean value to determine whether the class should be added or removed.
+     * @see \`{@link https://api.jquery.com/toggleClass/ }\`
+     * @since 1.4
+     * @deprecated ​ Deprecated since 3.0. See \`{@link https://github.com/jquery/jquery/pull/2618 }\`.
+     *
+     * **Cause**: Calling `.toggleClass()` with no arguments, or with a single Boolean `true` or `false` argument, has been deprecated. Its behavior was poorly documented, but essentially the method saved away the current class value in a data item when the class was removed and restored the saved value when it was toggled back. If you do not believe you are specificially trying to use this form of the method, it is possible you are accidentally doing so via an inadvertent undefined value, as `.toggleClass( undefined )` toggles all classes.
+     *
+     * **Solution**: If this functionality is still needed, save the current full `.attr( "class" )` value in a data item and restore it when required.
+     */
+    toggleClass(state?: boolean): this;
+    /**
+     * Execute all handlers and behaviors attached to the matched elements for the given event type.
+     * @param eventType_event _&#x40;param_ `eventType_event`
+     * <br>
+     * * `eventType` — A string containing a JavaScript event type, such as `click` or `submit`. <br>
+     * * `event` — A \`{@link https://api.jquery.com/category/events/event-object/ jQuery.Event}\` object.
+     * @param extraParameters Additional parameters to pass along to the event handler.
+     * @see \`{@link https://api.jquery.com/trigger/ }\`
+     * @since 1.0
+     * @since 1.3
+     * @example ​ ````Clicks to button #2 also trigger a click for button #1.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>trigger demo</title>
+  <style>
+  button {
+    margin: 10px;
+  }
+  div {
+    color: blue;
+    font-weight: bold;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Button #1</button>
+<button>Button #2</button>
+<div><span>0</span> button #1 clicks.</div>
+<div><span>0</span> button #2 clicks.</div>
+​
+<script>
+$( "button:first" ).click(function() {
+  update( $( "span:first" ) );
+});
+​
+$( "button:last" ).click(function() {
+  $( "button:first" ).trigger( "click" );
+  update( $( "span:last" ) );
+});
+​
+function update( j ) {
+  var n = parseInt( j.text(), 10 );
+  j.text( n + 1 );
+}
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````To submit the first form without using the submit() function, try:
+```javascript
+$( "form:first" ).trigger( "submit" );
+```
+     * @example ​ ````To submit the first form without using the submit() function, try:
+```javascript
+var event = jQuery.Event( "submit" );
+$( "form:first" ).trigger( event );
+if ( event.isDefaultPrevented() ) {
+  // Perform an action...
+}
+```
+     * @example ​ ````To pass arbitrary data to an event:
+```javascript
+$( "p" )
+  .click(function( event, a, b ) {
+    // When a normal click fires, a and b are undefined
+    // for a trigger like below a refers to "foo" and b refers to "bar"
+  })
+  .trigger( "click", [ "foo", "bar" ] );
+```
+     * @example ​ ````To pass arbitrary data through an event object:
+```javascript
+var event = jQuery.Event( "logged" );
+event.user = "foo";
+event.pass = "bar";
+$( "body" ).trigger( event );
+```
+     * @example ​ ````Alternative way to pass data through an event object:
+```javascript
+$( "body" ).trigger({
+  type:"logged",
+  user:"foo",
+  pass:"bar"
+});
+```
+     */
+    trigger(eventType_event: string | JQuery.Event<TElement>, extraParameters?: any[] | JQuery.PlainObject | string | number | boolean): this;
+    /**
+     * Execute all handlers attached to an element for an event.
+     * @param eventType_event _&#x40;param_ `eventType_event`
+     * <br>
+     * * `eventType` — A string containing a JavaScript event type, such as `click` or `submit`. <br>
+     * * `event` — A \`{@link https://api.jquery.com/category/events/event-object/ jQuery.Event}\` object.
+     * @param extraParameters Additional parameters to pass along to the event handler.
+     * @see \`{@link https://api.jquery.com/triggerHandler/ }\`
+     * @since 1.2
+     * @since 1.3
+     * @example ​ ````If you called .triggerHandler() on a focus event - the browser&#39;s default focus action would not be triggered, only the event handlers bound to the focus event.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>triggerHandler demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="old">.trigger( "focus" )</button>
+<button id="new">.triggerHandler( "focus" )</button><br><br>
+​
+<input type="text" value="To Be Focused">
+​
+<script>
+$( "#old" ).click(function() {
+  $( "input" ).trigger( "focus" );
+});
+$( "#new" ).click(function() {
+  $( "input" ).triggerHandler( "focus" );
+});
+$( "input" ).focus(function() {
+  $( "<span>Focused!</span>" ).appendTo( "body" ).fadeOut( 1000 );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    triggerHandler(eventType_event: string | JQuery.Event<TElement>, extraParameters?: any[] | JQuery.PlainObject | string | number | boolean): any;
+    /**
+     * Remove a previously-attached event handler from the elements.
+     * @param event A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/unbind/ }\`
+     * @since 1.0
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.0. Use \`{@link off }\`.
+     *
+     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
+     *
+     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
+     * @example ​ ````Can bind and unbind events to the colored button.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>unbind demo</title>
+  <style>
+  button {
+    margin: 5px;
+  }
+  button#theone {
+    color: red;
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="theone">Does nothing...</button>
+<button id="bind">Bind Click</button>
+<button id="unbind">Unbind Click</button>
+<div style="display:none;">Click!</div>
+​
+<script>
+function aClick() {
+  $( "div" ).show().fadeOut( "slow" );
+}
+$( "#bind" ).click(function() {
+  $( "#theone" )
+    .bind( "click", aClick )
+    .text( "Can Click!" );
+});
+$( "#unbind" ).click(function() {
+  $( "#theone" )
+    .unbind( "click", aClick )
+    .text( "Does nothing..." );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````To unbind just one previously bound handler, pass the function in as the second argument:
+```javascript
+var foo = function() {
+  // Code to handle some kind of event
+};
+​
+$( "p" ).bind( "click", foo ); // ... Now foo will be called when paragraphs are clicked ...
+​
+$( "p" ).unbind( "click", foo ); // ... foo will no longer be called.
+```
+     */
+    unbind(event: string, handler: JQuery.EventHandlerBase<any, JQuery.Event<TElement, any>> | false): this;
+    /**
+     * Remove a previously-attached event handler from the elements.
+     * @param event A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
+     *              A jQuery.Event object.
+     * @see \`{@link https://api.jquery.com/unbind/ }\`
+     * @since 1.0
+     * @deprecated ​ Deprecated since 3.0. Use \`{@link off }\`.
+     *
+     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
+     *
+     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
+     * @example ​ ````To unbind all events from all paragraphs, write:
+```javascript
+$( "p" ).unbind();
+```
+     * @example ​ ````To unbind all click events from all paragraphs, write:
+```javascript
+$( "p" ).unbind( "click" );
+```
+     */
+    unbind(event?: string | JQuery.Event<TElement>): this;
+    /**
+     * Remove a handler from the event for all elements which match the current selector, based upon a specific set of root elements.
+     * @param selector A selector which will be used to filter the event results.
+     * @param eventType A string containing a JavaScript event type, such as "click" or "keydown"
+     * @param handler A function to execute each time the event is triggered.
+     * @see \`{@link https://api.jquery.com/undelegate/ }\`
+     * @since 1.4.2
+     * @deprecated ​ Deprecated since 3.0. Use \`{@link off }\`.
+     *
+     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
+     *
+     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
+     * @example ​ ````Can bind and unbind events to the colored button.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>undelegate demo</title>
+  <style>
+  button {
+    margin: 5px;
+  }
+  button#theone {
+    color: red;
+    background: yellow;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="theone">Does nothing...</button>
+<button id="bind">Bind Click</button>
+<button id="unbind">Unbind Click</button>
+<div style="display:none;">Click!</div>
+​
+<script>
+function aClick() {
+  $( "div" ).show().fadeOut( "slow" );
+}
+$( "#bind" ).click(function() {
+  $( "body" )
+    .delegate( "#theone", "click", aClick )
+    .find( "#theone" ).text( "Can Click!" );
+});
+$( "#unbind" ).click(function() {
+  $( "body" )
+    .undelegate( "#theone", "click", aClick )
+    .find( "#theone" ).text( "Does nothing..." );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````To undelegate just one previously bound handler, pass the function in as the third argument:
+```javascript
+var foo = function () {
+  // Code to handle some kind of event
+};
+​
+// ... Now foo will be called when paragraphs are clicked ...
+$( "body" ).delegate( "p", "click", foo );
+​
+// ... foo will no longer be called.
+$( "body" ).undelegate( "p", "click", foo );
+```
+     */
+    undelegate(selector: JQuery.Selector, eventType: string, handler: JQuery.EventHandlerBase<any, JQuery.Event<TElement, any>> | false): this;
+    /**
+     * Remove a handler from the event for all elements which match the current selector, based upon a specific set of root elements.
+     * @param selector A selector which will be used to filter the event results.
+     * @param eventTypes A string containing a JavaScript event type, such as "click" or "keydown"
+     *                   An object of one or more event types and previously bound functions to unbind from them.
+     * @see \`{@link https://api.jquery.com/undelegate/ }\`
+     * @since 1.4.2
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.0. Use \`{@link off }\`.
+     *
+     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
+     *
+     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
+     */
+    undelegate(selector: JQuery.Selector, eventTypes: string | JQuery.PlainObject<JQuery.EventHandlerBase<any, JQuery.Event<TElement, any>> | false>): this;
+    /**
+     * Remove a handler from the event for all elements which match the current selector, based upon a specific set of root elements.
+     * @param namespace A selector which will be used to filter the event results.
+     * @see \`{@link https://api.jquery.com/undelegate/ }\`
+     * @since 1.4.2
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.0. Use \`{@link off }\`.
+     *
+     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
+     *
+     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
+     * @example ​ ````To unbind all delegated events from all paragraphs, write:
+```javascript
+$( "p" ).undelegate();
+```
+     * @example ​ ````To unbind all delegated click events from all paragraphs, write:
+```javascript
+$( "p" ).undelegate( "click" );
+```
+     * @example ​ ````To unbind all delegated events by their namespace:
+```javascript
+var foo = function() {
+  // Code to handle some kind of event
+};
+​
+// Delegate events under the ".whatever" namespace
+$( "form" ).delegate( ":button", "click.whatever", foo );
+​
+$( "form" ).delegate( "input[type='text'] ", "keypress.whatever", foo );
+​
+// Unbind all events delegated under the ".whatever" namespace
+$( "form" ).undelegate( ".whatever" );
+```
+     */
+    undelegate(namespace?: string): this;
+    /**
+     * Remove the parents of the set of matched elements from the DOM, leaving the matched elements in their place.
+     * @param selector A selector to check the parent element against. If an element's parent does not match the selector,
+     *                 the element won't be unwrapped.
+     * @see \`{@link https://api.jquery.com/unwrap/ }\`
+     * @since 1.4
+     * @since 3.0
+     * @example ​ ````Wrap/unwrap a div around each of the paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>unwrap demo</title>
+  <style>
+  div {
+    border: 2px solid blue;
+  }
+  p {
+    background: yellow;
+    margin: 4px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​<button>wrap/unwrap</button>
+<p>Hello</p>
+<p>cruel</p>
+<p>World</p>​
+<script>
+var pTags = $( "p" );
+$( "button" ).click(function() {
+  if ( pTags.parent().is( "div" ) ) {
+    pTags.unwrap();
+  } else {
+    pTags.wrap( "<div></div>" );
+  }
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    unwrap(selector?: string): this;
+    /**
+     * Set the value of each element in the set of matched elements.
+     * @param value_function _&#x40;param_ `value_function`
+     * <br>
+     * * `value` — A string of text, a number, or an array of strings corresponding to the value of each matched
+     *             element to set as selected/checked. <br>
+     * * `function` — A function returning the value to set. `this` is the current element. Receives the index position of
+     *                the element in the set and the old value as arguments.
+     * @see \`{@link https://api.jquery.com/val/ }\`
+     * @since 1.0
+     * @since 1.4
+     * @example ​ ````Set the value of an input box.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>val demo</title>
+  <style>
+  button {
+    margin: 4px;
+    cursor: pointer;
+  }
+  input {
+    margin: 4px;
+    color: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>
+  <button>Feed</button>
+  <button>the</button>
+  <button>Input</button>
+</div>
+<input type="text" value="click a button">
+​
+<script>
+$( "button" ).click(function() {
+  var text = $( this ).text();
+  $( "input" ).val( text );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Use the function argument to modify the value of an input box.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>val demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Type something and then click or tab out of the input.</p>
+<input type="text" value="type something">
+​
+<script>
+$( "input" ).on( "blur", function() {
+  $( this ).val(function( i, val ) {
+    return val.toUpperCase();
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Set a single select, a multiple select, checkboxes and a radio button .
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>val demo</title>
+  <style>
+  body {
+    color: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<select id="single">
+  <option>Single</option>
+  <option>Single2</option>
+</select>
+​
+<select id="multiple" multiple="multiple">
+  <option selected="selected">Multiple</option>
+  <option>Multiple2</option>
+  <option selected="selected">Multiple3</option>
+</select>
+​
+<br>
+<input type="checkbox" name="checkboxname" value="check1"> check1
+<input type="checkbox" name="checkboxname" value="check2"> check2
+<input type="radio" name="r" value="radio1"> radio1
+<input type="radio" name="r" value="radio2"> radio2
+​
+<script>
+$( "#single" ).val( "Single2" );
+$( "#multiple" ).val([ "Multiple2", "Multiple3" ]);
+$( "input").val([ "check1", "check2", "radio1" ]);
+</script>
+​
+</body>
+</html>
+```
+     */
+    val(value_function: string | number | string[] | ((this: TElement, index: number, value: string) => string)): this;
+    /**
+     * Get the current value of the first element in the set of matched elements.
+     * @see \`{@link https://api.jquery.com/val/ }\`
+     * @since 1.0
+     * @example ​ ````Get the single value from a single select and an array of values from a multiple select and display their values.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>val demo</title>
+  <style>
+  p {
+    color: red;
+    margin: 4px;
+  }
+  b {
+    color: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p></p>
+​
+<select id="single">
+  <option>Single</option>
+  <option>Single2</option>
+</select>
+​
+<select id="multiple" multiple="multiple">
+  <option selected="selected">Multiple</option>
+  <option>Multiple2</option>
+  <option selected="selected">Multiple3</option>
+</select>
+​
+<script>
+function displayVals() {
+  var singleValues = $( "#single" ).val();
+  var multipleValues = $( "#multiple" ).val() || [];
+  // When using jQuery 3:
+  // var multipleValues = $( "#multiple" ).val();
+  $( "p" ).html( "<b>Single:</b> " + singleValues +
+    " <b>Multiple:</b> " + multipleValues.join( ", " ) );
+}
+​
+$( "select" ).change( displayVals );
+displayVals();
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Find the value of an input box.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>val demo</title>
+  <style>
+  p {
+    color: blue;
+    margin: 8px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<input type="text" value="some text">
+<p></p>
+​
+<script>
+$( "input" )
+  .keyup(function() {
+    var value = $( this ).val();
+    $( "p" ).text( value );
+  })
+  .keyup();
+</script>
+​
+</body>
+</html>
+```
+     */
+    val(): string | number | string[] | undefined;
+    /**
+     * Set the CSS width of each element in the set of matched elements.
+     * @param value_function _&#x40;param_ `value_function`
+     * <br>
+     * * `value` — An integer representing the number of pixels, or an integer along with an optional unit of measure
+     *             appended (as a string). <br>
+     * * `function` — A function returning the width to set. Receives the index position of the element in the set and the
+     *                old width as arguments. Within the function, `this` refers to the current element in the set.
+     * @see \`{@link https://api.jquery.com/width/ }\`
+     * @since 1.0
+     * @since 1.4.1
+     * @example ​ ````Change the width of each div the first time it is clicked (and change its color).
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>width demo</title>
+  <style>
+  div {
+    width: 70px;
+    height: 50px;
+    float: left;
+    margin: 5px;
+    background: red;
+    cursor: pointer;
+  }
+  .mod {
+    background: blue;
+    cursor: default;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>d</div>
+<div>d</div>
+<div>d</div>
+<div>d</div>
+<div>d</div>
+​
+<script>
+var modWidth = 50;
+$( "div" ).one( "click", function() {
+  $( this ).width( modWidth ).addClass( "mod" );
+  modWidth -= 8;
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    width(value_function: string | number | ((this: TElement, index: number, value: number) => string | number)): this;
+    /**
+     * Get the current computed width for the first element in the set of matched elements.
+     * @see \`{@link https://api.jquery.com/width/ }\`
+     * @since 1.0
+     * @example ​ ````Show various widths.  Note the values are from the iframe so might be smaller than you expected.  The yellow highlight shows the iframe body.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>width demo</title>
+  <style>
+  body {
+    background: yellow;
+  }
+  button {
+    font-size: 12px;
+    margin: 2px;
+  }
+  p {
+    width: 150px;
+    border: 1px red solid;
+  }
+  div {
+    color: red;
+    font-weight: bold;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="getp">Get Paragraph Width</button>
+<button id="getd">Get Document Width</button>
+<button id="getw">Get Window Width</button>
+<div>&nbsp;</div>
+<p>
+  Sample paragraph to test width
+</p>
+​
+<script>
+function showWidth( ele, w ) {
+  $( "div" ).text( "The width for the " + ele + " is " + w + "px." );
+}
+$( "#getp" ).click(function() {
+  showWidth( "paragraph", $( "p" ).width() );
+});
+$( "#getd" ).click(function() {
+  showWidth( "document", $( document ).width() );
+});
+$("#getw").click(function() {
+  showWidth( "window", $( window ).width() );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    width(): number | undefined;
+    /**
+     * Wrap an HTML structure around each element in the set of matched elements.
+     * @param wrappingElement_function _&#x40;param_ `wrappingElement_function`
+     * <br>
+     * * `wrappingElement` — A selector, element, HTML string, or jQuery object specifying the structure to wrap around the
+     *                       matched elements. When you pass a jQuery collection containing more than one element, or a selector
+     *                       matching more than one element, the first element will be used. <br>
+     * * `function` — A callback function returning the HTML content or jQuery object to wrap around the matched elements.
+     *                Receives the index position of the element in the set as an argument. Within the function, `this`
+     *                refers to the current element in the set.
+     * @see \`{@link https://api.jquery.com/wrap/ }\`
+     * @since 1.0
+     * @since 1.4
+     * @example ​ ````Wrap a new div around all of the paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>wrap demo</title>
+  <style>
+  div {
+    border: 2px solid blue;
+  }
+  p {
+    background: yellow;
+    margin: 4px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<p>cruel</p>
+<p>World</p>
+​
+<script>
+$( "p" ).wrap( "<div></div>" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Wraps a newly created tree of objects around the spans.  Notice anything in between the spans gets left out like the &lt;strong&gt; (red text) in this example.  Even the white space between spans is left out.  Click View Source to see the original html.&gt;
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>wrap demo</title>
+  <style>
+  div {
+    border: 2px blue solid;
+    margin: 2px;
+    padding: 2px;
+  }
+  p {
+    background: yellow;
+    margin: 2px;
+    padding: 2px;
+  }
+  strong {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<span>Span Text</span>
+<strong>What about me?</strong>
+<span>Another One</span>
+​
+<script>
+$( "span" ).wrap( "<div><div><p><em><b></b></em></p></div></div>" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Wrap a new div around all of the paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>wrap demo</title>
+  <style>
+  div {
+    border: 2px solid blue;
+  }
+  p {
+    background: yellow;
+    margin: 4px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<p>cruel</p>
+<p>World</p>
+​
+<script>
+$( "p" ).wrap( document.createElement( "div" ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Wrap a jQuery object double depth div around all of the paragraphs.  Notice it doesn&#39;t move the object but just clones it to wrap around its target.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>wrap demo</title>
+  <style>
+  div {
+    border: 2px solid blue;
+    margin: 2px;
+    padding: 2px;
+  }
+  .doublediv {
+    border-color: red;
+  }
+  p {
+    background: yellow;
+    margin: 4px;
+    font-size: 14px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<p>cruel</p>
+<p>World</p>
+<div class="doublediv"><div></div></div>
+​
+<script>
+$( "p" ).wrap( $( ".doublediv" ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    wrap(wrappingElement_function: JQuery.Selector | JQuery.htmlString | Element | JQuery | ((this: TElement, index: number) => string | JQuery)): this;
+    /**
+     * Wrap an HTML structure around all elements in the set of matched elements.
+     * @param wrappingElement_function _&#x40;param_ `wrappingElement_function`
+     * <br>
+     * * `wrappingElement` — A selector, element, HTML string, or jQuery object specifying the structure to wrap around the matched elements. <br>
+     * * `function` — A callback function returning the HTML content or jQuery object to wrap around all the matched
+     *                elements. Within the function, `this` refers to the first element in the set. **Prior to jQuery
+     *                3.0**, the callback was incorrectly called for every element in the set and received the index
+     *                position of the element in the set as an argument.
+     * @see \`{@link https://api.jquery.com/wrapAll/ }\`
+     * @since 1.2
+     * @since 1.4
+     * @example ​ ````Wrap a new div around all of the paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>wrapAll demo</title>
+  <style>
+  div {
+    border: 2px solid blue;
+  }
+  p {
+    background: yellow;
+    margin: 4px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<p>cruel</p>
+<p>World</p>
+​
+<script>
+$( "p" ).wrapAll( "<div></div>" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Wraps a newly created tree of objects around the spans.  Notice anything in between the spans gets left out like the &lt;strong&gt; (red text) in this example.  Even the white space between spans is left out.  Click View Source to see the original html.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>wrapAll demo</title>
+  <style>
+  div {
+    border: 2px blue solid;
+    margin: 2px;
+    padding: 2px;
+  }
+  p {
+    background: yellow;
+    margin: 2px;
+    padding: 2px;
+  }
+  strong {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<span>Span Text</span>
+<strong>What about me?</strong>
+<span>Another One</span>
+​
+<script>
+$( "span").wrapAll( "<div><div><p><em><b></b></em></p></div></div>" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Wrap a new div around all of the paragraphs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>wrapAll demo</title>
+  <style>
+  div {
+    border: 2px solid blue;
+  }
+  p {
+    background: yellow;
+    margin: 4px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<p>cruel</p>
+<p>World</p>
+​
+<script>
+$( "p" ).wrapAll( document.createElement( "div" ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Wrap a jQuery object double depth div around all of the paragraphs.  Notice it doesn&#39;t move the object but just clones it to wrap around its target.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>wrapAll demo</title>
+  <style>
+  div {
+    border: 2px solid blue;
+    margin: 2px;
+    padding: 2px;
+  }
+  .doublediv {
+    border-color: red;
+  }
+  p {
+    background: yellow;
+    margin: 4px;
+    font-size: 14px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<p>cruel</p>
+<p>World</p>
+<div class="doublediv"><div></div></div>
+​
+<script>
+$( "p" ).wrapAll( $( ".doublediv" ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    wrapAll(wrappingElement_function: JQuery.Selector | JQuery.htmlString | Element | JQuery | ((this: TElement) => string | JQuery)): this;
+    /**
+     * Wrap an HTML structure around the content of each element in the set of matched elements.
+     * @param wrappingElement_function _&#x40;param_ `wrappingElement_function`
+     * <br>
+     * * `wrappingElement` — An HTML snippet, selector expression, jQuery object, or DOM element specifying the structure to wrap
+     *                       around the content of the matched elements. <br>
+     * * `function` — A callback function which generates a structure to wrap around the content of the matched elements.
+     *                Receives the index position of the element in the set as an argument. Within the function, `this`
+     *                refers to the current element in the set.
+     * @see \`{@link https://api.jquery.com/wrapInner/ }\`
+     * @since 1.2
+     * @since 1.4
+     * @example ​ ````Selects all paragraphs and wraps a bold tag around each of its contents.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>wrapInner demo</title>
+  <style>
+  p {
+    background: #bbf;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<p>cruel</p>
+<p>World</p>
+​
+<script>
+$( "p" ).wrapInner( "<b></b>" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Wraps a newly created tree of objects around the inside of the body.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>wrapInner demo</title>
+  <style>
+  div {
+    border: 2px green solid;
+    margin: 2px;
+    padding: 2px;
+  }
+  p {
+    background: yellow;
+    margin: 2px;
+    padding: 2px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+Plain old text, or is it?
+​
+<script>
+$( "body" ).wrapInner( "<div><div><p><em><b></b></em></p></div></div>" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Selects all paragraphs and wraps a bold tag around each of its contents.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>wrapInner demo</title>
+  <style>
+  p {
+    background: #9f9;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<p>cruel</p>
+<p>World</p>
+​
+<script>
+$( "p" ).wrapInner( document.createElement( "b" ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Selects all paragraphs and wraps a jQuery object around each of its contents.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>wrapInner demo</title>
+  <style>
+  p {
+    background: #9f9;
+  }
+  .red {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Hello</p>
+<p>cruel</p>
+<p>World</p>
+​
+<script>
+$( "p" ).wrapInner( $( "<span class='red'></span>" ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    wrapInner(wrappingElement_function: JQuery.Selector | JQuery.htmlString | Element | JQuery | ((this: TElement, index: number) => string | JQuery | Element)): this;
+
+    [n: number]: TElement;
+}
diff --git a/types/jquery/JQueryStatic.d.ts b/types/jquery/JQueryStatic.d.ts
new file mode 100644
index 0000000000..8e753d1739
--- /dev/null
+++ b/types/jquery/JQueryStatic.d.ts
@@ -0,0 +1,13051 @@
+// tslint:disable:jsdoc-format
+// tslint:disable:max-line-length
+// tslint:disable:no-irregular-whitespace
+
+interface JQueryStatic {
+    /**
+     * @see \`{@link https://api.jquery.com/jquery.ajax/#jQuery-ajax1 }\`
+     * @deprecated ​ Deprecated. Use \`{@link ajaxSetup }\`.
+     */
+    ajaxSettings: JQuery.AjaxSettings;
+    Animation: JQuery.AnimationStatic;
+    Callbacks: JQuery.CallbacksStatic;
+    /**
+     * Hook directly into jQuery to override how particular CSS properties are retrieved or set, normalize CSS property naming, or create custom properties.
+     * @see \`{@link https://api.jquery.com/jQuery.cssHooks/ }\`
+     * @since 1.4.3
+     */
+    cssHooks: JQuery.CSSHooks;
+    /**
+     * An object containing all CSS properties that may be used without a unit. The .css() method uses this object to see if it may append px to unitless values.
+     * @see \`{@link https://api.jquery.com/jQuery.cssNumber/ }\`
+     * @since 1.4.3
+     */
+    cssNumber: JQuery.PlainObject<boolean>;
+    Deferred: JQuery.DeferredStatic;
+    easing: JQuery.Easings;
+    Event: JQuery.EventStatic;
+    /**
+     * @see \`{@link https://learn.jquery.com/events/event-extensions/ }\`
+     */
+    event: JQuery.EventExtensions;
+    expr: JQuery.Selectors;
+    // Set to HTMLElement to minimize breaks but should probably be Element.
+    readonly fn: JQuery;
+    fx: JQuery.Effects;
+    /**
+     * A Promise-like object (or "thenable") that resolves when the document is ready.
+     * @see \`{@link https://api.jquery.com/jQuery.ready/ }\`
+     * @since 1.8
+     * @example ​ ````Listen for document ready using jQuery.when.
+```javascript
+$.when( $.ready ).then(function() {
+  // Document is ready.
+});
+```
+     * @example ​ ````Typical usage involving another promise, using jQuery.when.
+```javascript
+$.when(
+  $.getJSON( "ajax/test.json" ),
+  $.ready
+).done(function( data ) {
+  // Document is ready.
+  // Value of test.json is passed as `data`.
+});
+```
+     */
+    ready: JQuery.Thenable<JQueryStatic>;
+    /**
+     * A collection of properties that represent the presence of different browser features or bugs. Intended for jQuery's internal use; specific properties may be removed when they are no longer needed internally to improve page startup performance. For your own project's feature-detection needs, we strongly recommend the use of an external library such as Modernizr instead of dependency on properties in jQuery.support.
+     * @see \`{@link https://api.jquery.com/jQuery.support/ }\`
+     * @since 1.3
+     * @deprecated ​ Deprecated since 1.9. See \`{@link https://api.jquery.com/jQuery.support/ }\`.
+     */
+    support: JQuery.PlainObject;
+    timers: Array<JQuery.TickFunction<any>>;
+    Tween: JQuery.TweenStatic;
+    valHooks: JQuery.ValHooks;
+    // HACK: This is the factory function returned when importing jQuery without a DOM. Declaring it separately breaks using the type parameter on JQueryStatic.
+    // HACK: The discriminator parameter handles the edge case of passing a Window object to JQueryStatic. It doesn't actually exist on the factory function.
+    (window: Window, discriminator: boolean): JQueryStatic;
+    /**
+     * Creates DOM elements on the fly from the provided string of raw HTML.
+     * @param html _&#x40;param_ `html`
+     * <br>
+     * * `html (ownerDocument)` — A string of HTML to create on the fly. Note that this parses HTML, not XML. <br>
+     * * `html (attributes)` — A string defining a single, standalone, HTML element (e.g. &lt;div/&gt; or &lt;div&gt;&lt;/div&gt;).
+     * @param ownerDocument_attributes _&#x40;param_ `ownerDocument_attributes`
+     * <br>
+     * * `ownerDocument` — A document in which the new elements will be created. <br>
+     * * `attributes` — An object of attributes, events, and methods to call on the newly-created element.
+     * @see \`{@link https://api.jquery.com/jQuery/ }\`
+     * @since 1.0
+     * @since 1.4
+     * @example ​ ````Create a div element (and all of its contents) dynamically and append it to the body element. Internally, an element is created and its innerHTML property set to the given markup.
+```javascript
+$( "<div><p>Hello</p></div>" ).appendTo( "body" )
+```
+     * @example ​ ````Create some DOM elements.
+```javascript
+$( "<div/>", {
+  "class": "test",
+  text: "Click me!",
+  click: function() {
+    $( this ).toggleClass( "test" );
+  }
+})
+  .appendTo( "body" );
+```
+     */
+    // tslint:disable-next-line:no-unnecessary-generics
+    <TElement extends HTMLElement = HTMLElement>(html: JQuery.htmlString, ownerDocument_attributes?: Document | JQuery.PlainObject): JQuery<TElement>;
+    /**
+     * Accepts a string containing a CSS selector which is then used to match a set of elements.
+     * @param selector A string containing a selector expression
+     * @param context A DOM Element, Document, or jQuery to use as context
+     * @see \`{@link https://api.jquery.com/jQuery/ }\`
+     * @since 1.0
+     * @example ​ ````Find all p elements that are children of a div element and apply a border to them.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>one</p>
+<div><p>two</p></div>
+<p>three</p>
+​
+<script>
+$( "div > p" ).css( "border", "1px solid gray" );
+</script>
+</body>
+</html>
+```
+     * @example ​ ````Find all inputs of type radio within the first form in the document.
+```javascript
+$( "input:radio", document.forms[ 0 ] );
+```
+     * @example ​ ````Find all div elements within an XML document from an Ajax response.
+```javascript
+$( "div", xml.responseXML );
+```
+​
+     */
+    // tslint:disable-next-line:no-unnecessary-generics
+    <TElement extends Element = HTMLElement>(selector: JQuery.Selector, context?: Element | Document | JQuery): JQuery<TElement>;
+    /**
+     * Return a collection of matched elements either found in the DOM based on passed argument(s) or created by passing an HTML string.
+     * @param element A DOM element to wrap in a jQuery object.
+     * @see \`{@link https://api.jquery.com/jQuery/ }\`
+     * @since 1.0
+     * @example ​ ````Set the background color of the page to black.
+```javascript
+$( document.body ).css( "background", "black" );
+```
+     */
+    // Using a unified signature is not possible due to a TypeScript 2.4 bug (DefinitelyTyped#27810)
+    <T extends Element>(element: T): JQuery<T>;
+    /**
+     * Return a collection of matched elements either found in the DOM based on passed argument(s) or created by passing an HTML string.
+     * @param elementArray An array containing a set of DOM elements to wrap in a jQuery object.
+     * @see \`{@link https://api.jquery.com/jQuery/ }\`
+     * @since 1.0
+     * @example ​ ````Hide all the input elements within a form.
+```javascript
+$( myForm.elements ).hide();
+```
+     */
+    // Using a unified signature is not possible due to a TypeScript 2.4 bug (DefinitelyTyped#27810)
+    // tslint:disable-next-line:unified-signatures
+    <T extends Element>(elementArray: T[]): JQuery<T>;
+    /**
+     * Return a collection of matched elements either found in the DOM based on passed argument(s) or created by passing an HTML string.
+     * @param selection An existing jQuery object to clone.
+     * @see \`{@link https://api.jquery.com/jQuery/ }\`
+     * @since 1.0
+     */
+    <T>(selection: JQuery<T>): JQuery<T>;
+    /**
+     * Binds a function to be executed when the DOM has finished loading.
+     * @param callback The function to execute when the DOM is ready.
+     * @see \`{@link https://api.jquery.com/jQuery/ }\`
+     * @since 1.0
+     * @example ​ ````Execute the function when the DOM is ready to be used.
+```javascript
+$(function() {
+  // Document is ready
+});
+```
+     * @example ​ ````Use both the shortcut for $(document).ready() and the argument to write failsafe jQuery code using the $ alias, without relying on the global alias.
+```javascript
+jQuery(function( $ ) {
+  // Your code using failsafe $ alias here...
+});
+```
+     */
+    // tslint:disable-next-line:no-unnecessary-generics unified-signatures
+    <TElement = HTMLElement>(callback: ((this: Document, $: JQueryStatic) => void)): JQuery<TElement>;
+    /**
+     * Return a collection of matched elements either found in the DOM based on passed argument(s) or created by passing an HTML string.
+     * @param object A plain object to wrap in a jQuery object.
+     * @see \`{@link https://api.jquery.com/jQuery/ }\`
+     * @since 1.0
+     */
+    <T extends JQuery.PlainObject>(object: T): JQuery<T>;
+    /**
+     * Returns an empty jQuery set.
+     * @see \`{@link https://api.jquery.com/jQuery/ }\`
+     * @since 1.4
+     */
+    // tslint:disable-next-line:no-unnecessary-generics
+    <TElement = HTMLElement>(): JQuery<TElement>;
+    /**
+     * Perform an asynchronous HTTP (Ajax) request.
+     * @param url A string containing the URL to which the request is sent.
+     * @param settings A set of key/value pairs that configure the Ajax request. All settings are optional. A default can
+     *                 be set for any option with $.ajaxSetup(). See jQuery.ajax( settings ) below for a complete list of all settings.
+     * @see \`{@link https://api.jquery.com/jQuery.ajax/ }\`
+     * @since 1.5
+     */
+    ajax(url: string, settings?: JQuery.AjaxSettings): JQuery.jqXHR;
+    /**
+     * Perform an asynchronous HTTP (Ajax) request.
+     * @param settings A set of key/value pairs that configure the Ajax request. All settings are optional. A default can
+     *                 be set for any option with $.ajaxSetup().
+     * @see \`{@link https://api.jquery.com/jQuery.ajax/ }\`
+     * @since 1.0
+     * @example ​ ````Save some data to the server and notify the user once it&#39;s complete.
+```javascript
+$.ajax({
+  method: "POST",
+  url: "some.php",
+  data: { name: "John", location: "Boston" }
+})
+  .done(function( msg ) {
+    alert( "Data Saved: " + msg );
+  });
+```
+     * @example ​ ````Retrieve the latest version of an HTML page.
+```javascript
+$.ajax({
+  url: "test.html",
+  cache: false
+})
+  .done(function( html ) {
+    $( "#results" ).append( html );
+  });
+```
+     * @example ​ ````Send an xml document as data to the server. By setting the processData
+    option to false, the automatic conversion of data to strings is prevented.
+```javascript
+var xmlDocument = [create xml document];
+var xmlRequest = $.ajax({
+  url: "page.php",
+  processData: false,
+  data: xmlDocument
+});
+​
+xmlRequest.done( handleResponse );
+```
+     * @example ​ ````Send an id as data to the server, save some data to the server, and notify the user once it&#39;s complete. If the request fails, alert the user.
+```javascript
+var menuId = $( "ul.nav" ).first().attr( "id" );
+var request = $.ajax({
+  url: "script.php",
+  method: "POST",
+  data: { id : menuId },
+  dataType: "html"
+});
+​
+request.done(function( msg ) {
+  $( "#log" ).html( msg );
+});
+​
+request.fail(function( jqXHR, textStatus ) {
+  alert( "Request failed: " + textStatus );
+});
+```
+     * @example ​ ````Load and execute a JavaScript file.
+```javascript
+$.ajax({
+  method: "GET",
+  url: "test.js",
+  dataType: "script"
+});
+```
+     */
+    ajax(settings?: JQuery.AjaxSettings): JQuery.jqXHR;
+    /**
+     * Handle custom Ajax options or modify existing options before each request is sent and before they are processed by $.ajax().
+     * @param dataTypes An optional string containing one or more space-separated dataTypes
+     * @param handler A handler to set default values for future Ajax requests.
+     * @see \`{@link https://api.jquery.com/jQuery.ajaxPrefilter/ }\`
+     * @since 1.5
+     */
+    ajaxPrefilter(dataTypes: string,
+                  handler: (options: JQuery.AjaxSettings, originalOptions: JQuery.AjaxSettings, jqXHR: JQuery.jqXHR) => string | void): void;
+    /**
+     * Handle custom Ajax options or modify existing options before each request is sent and before they are processed by $.ajax().
+     * @param handler A handler to set default values for future Ajax requests.
+     * @see \`{@link https://api.jquery.com/jQuery.ajaxPrefilter/ }\`
+     * @since 1.5
+     */
+    ajaxPrefilter(handler: (options: JQuery.AjaxSettings, originalOptions: JQuery.AjaxSettings, jqXHR: JQuery.jqXHR) => string | void): void;
+    /**
+     * Set default values for future Ajax requests. Its use is not recommended.
+     * @param options A set of key/value pairs that configure the default Ajax request. All options are optional.
+     * @see \`{@link https://api.jquery.com/jQuery.ajaxSetup/ }\`
+     * @since 1.1
+     * @example ​ ````Sets the defaults for Ajax requests to the url &quot;/xmlhttp/&quot;, disables global handlers and uses POST instead of GET. The following Ajax requests then sends some data without having to set anything else.
+```javascript
+$.ajaxSetup({
+  url: "/xmlhttp/",
+  global: false,
+  type: "POST"
+});
+$.ajax({ data: myData });
+```
+     */
+    ajaxSetup(options: JQuery.AjaxSettings): JQuery.AjaxSettings;
+    /**
+     * 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/ }\`
+     * @since 1.5
+     */
+    ajaxTransport(dataType: string,
+                  handler: (options: JQuery.AjaxSettings, originalOptions: JQuery.AjaxSettings, jqXHR: JQuery.jqXHR) => JQuery.Transport | void): void;
+    /**
+     * @deprecated ​ Deprecated since 3.3. Internal. See \`{@link https://github.com/jquery/jquery/issues/3384 }\`.
+     */
+    camelCase(value: string): string;
+    cleanData(elems: ArrayLike<Element | Document | Window | JQuery.PlainObject>): void;
+    /**
+     * Check to see if a DOM element is a descendant of another DOM element.
+     * @param container The DOM element that may contain the other element.
+     * @param contained The DOM element that may be contained by (a descendant of) the other element.
+     * @see \`{@link https://api.jquery.com/jQuery.contains/ }\`
+     * @since 1.4
+     * @example ​ ````Check if an element is a descendant of another.
+```javascript
+$.contains( document.documentElement, document.body ); // true
+$.contains( document.body, document.documentElement ); // false
+```
+     */
+    contains(container: Element, contained: Element): boolean;
+    css(elem: Element, name: string): any;
+    /**
+     * Store arbitrary data associated with the specified element. Returns the value that was set.
+     * @param element The DOM element to associate with the data.
+     * @param key A string naming the piece of data to set.
+     * @param value The new data value; this can be any Javascript type except `undefined`.
+     * @see \`{@link https://api.jquery.com/jQuery.data/ }\`
+     * @since 1.2.3
+     * @example ​ ````Get the data named &quot;blah&quot; stored at for an element.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.data demo</title>
+  <style>
+  div {
+    margin: 5px;
+    background: yellow;
+  }
+  button {
+    margin: 5px;
+    font-size: 14px;
+  }
+  p {
+    margin: 5px;
+    color: blue;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>A div</div>
+<button>Get "blah" from the div</button>
+<button>Set "blah" to "hello"</button>
+<button>Set "blah" to 86</button>
+<button>Remove "blah" from the div</button>
+<p>The "blah" value of this div is <span>?</span></p>
+​
+<script>
+$( "button" ).click( function() {
+  var value,
+    div = $( "div" )[ 0 ];
+  switch ( $( "button" ).index( this ) ) {
+  case 0 :
+    value = jQuery.data( div, "blah" );
+    break;
+  case 1 :
+    jQuery.data( div, "blah", "hello" );
+    value = "Stored!";
+    break;
+  case 2 :
+    jQuery.data( div, "blah", 86 );
+    value = "Stored!";
+    break;
+  case 3 :
+    jQuery.removeData( div, "blah" );
+    value = "Removed!";
+    break;
+  }
+  $( "span" ).text( "" + value );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    data<T extends string | number | boolean | symbol | object | null>(element: Element | Document | Window | JQuery.PlainObject, key: string, value: T): T;
+    /**
+     * Returns value at named data store for the element, as set by `jQuery.data(element, name, value)`, or the full data store for the element.
+     * @param element The DOM element to query for the data.
+     * @param key Name of the data stored.
+     * @param value `undefined` is not recognized as a data value. Calls such as `jQuery.data( el, "name", undefined )`
+     *              will return the corresponding data for "name", and is therefore the same as `jQuery.data( el, "name" )`
+     * @see \`{@link https://api.jquery.com/jQuery.data/ }\`
+     * @since 1.2.3
+     */
+    // `unified-signatures` is disabled so that behavior when passing `undefined` to `value` can be documented. Unifying the signatures
+    // results in potential confusion for users from an unexpected parameter.
+    // tslint:disable-next-line:unified-signatures
+    data(element: Element | Document | Window | JQuery.PlainObject, key: string, value: undefined): any;
+    /**
+     * Returns value at named data store for the element, as set by `jQuery.data(element, name, value)`, or the full data store for the element.
+     * @param element The DOM element to query for the data.
+     * @param key Name of the data stored.
+     * @see \`{@link https://api.jquery.com/jQuery.data/ }\`
+     * @since 1.2.3
+     * @since 1.4
+     * @example ​ ````Store then retrieve a value from the div element.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.data demo</title>
+  <style>
+  div {
+    color: blue;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>
+  The values stored were
+  <span></span>
+  and
+  <span></span>
+</div>
+​
+<script>
+var div = $( "div" )[ 0 ];
+jQuery.data( div, "test", {
+  first: 16,
+  last: "pizza!"
+});
+$( "span:first" ).text( jQuery.data( div, "test" ).first );
+$( "span:last" ).text( jQuery.data( div, "test" ).last );
+</script>
+​
+</body>
+</html>
+```
+     */
+    data(element: Element | Document | Window | JQuery.PlainObject, key?: string): any;
+    /**
+     * Execute the next function on the queue for the matched element.
+     * @param element A DOM element from which to remove and execute a queued function.
+     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
+     * @see \`{@link https://api.jquery.com/jQuery.dequeue/ }\`
+     * @since 1.3
+     * @example ​ ````Use jQuery.dequeue() to end a custom queue function which allows the queue to keep going.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.dequeue demo</title>
+  <style>
+  div {
+    margin: 3px;
+    width: 50px;
+    position: absolute;
+    height: 50px;
+    left: 10px;
+    top: 30px;
+    background-color: yellow;
+  }
+  div.red {
+    background-color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Start</button>
+<div></div>
+​
+<script>
+$( "button" ).click(function() {
+  $( "div" )
+    .animate({ left: '+=200px' }, 2000 )
+    .animate({ top: '0px' }, 600 )
+    .queue(function() {
+      $( this ).toggleClass( "red" );
+      $.dequeue( this );
+    })
+    .animate({ left:'10px', top:'30px' }, 700 );
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    dequeue(element: Element, queueName?: string): void;
+    /**
+     * A generic iterator function, which can be used to seamlessly iterate over both objects and arrays. Arrays and array-like objects with a length property (such as a function's arguments object) are iterated by numeric index, from 0 to length-1. Other objects are iterated via their named properties.
+     * @param array The array to iterate over.
+     * @param callback The function that will be executed on every object.
+     * @see \`{@link https://api.jquery.com/jQuery.each/ }\`
+     * @since 1.0
+     * @example ​ ````Iterates through the array displaying each number as both a word and numeral
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.each demo</title>
+  <style>
+  div {
+    color: blue;
+  }
+  div#five {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="one"></div>
+<div id="two"></div>
+<div id="three"></div>
+<div id="four"></div>
+<div id="five"></div>
+​
+<script>
+var arr = [ "one", "two", "three", "four", "five" ];
+var obj = { one: 1, two: 2, three: 3, four: 4, five: 5 };
+​
+jQuery.each( arr, function( i, val ) {
+  $( "#" + val ).text( "Mine is " + val + "." );
+​
+  // Will stop running after "three"
+  return ( val !== "three" );
+});
+​
+jQuery.each( obj, function( i, val ) {
+  $( "#" + i ).append( document.createTextNode( " - " + val ) );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Iterates over items in an array, accessing both the current item and its index.
+```javascript
+$.each( [ "a", "b", "c" ], function( i, l ){
+  alert( "Index #" + i + ": " + l );
+});
+```
+     */
+    each<T>(array: ArrayLike<T>, callback: (this: T, indexInArray: number, value: T) => any): ArrayLike<T>;
+    /**
+     * A generic iterator function, which can be used to seamlessly iterate over both objects and arrays. Arrays and array-like objects with a length property (such as a function's arguments object) are iterated by numeric index, from 0 to length-1. Other objects are iterated via their named properties.
+     * @param obj The object to iterate over.
+     * @param callback The function that will be executed on every object.
+     * @see \`{@link https://api.jquery.com/jQuery.each/ }\`
+     * @since 1.0
+     * @example ​ ````Iterates through the array displaying each number as both a word and numeral
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.each demo</title>
+  <style>
+  div {
+    color: blue;
+  }
+  div#five {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="one"></div>
+<div id="two"></div>
+<div id="three"></div>
+<div id="four"></div>
+<div id="five"></div>
+​
+<script>
+var arr = [ "one", "two", "three", "four", "five" ];
+var obj = { one: 1, two: 2, three: 3, four: 4, five: 5 };
+​
+jQuery.each( arr, function( i, val ) {
+  $( "#" + val ).text( "Mine is " + val + "." );
+​
+  // Will stop running after "three"
+  return ( val !== "three" );
+});
+​
+jQuery.each( obj, function( i, val ) {
+  $( "#" + i ).append( document.createTextNode( " - " + val ) );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Iterates over the properties in an object, accessing both the current item and its key.
+```javascript
+$.each({ name: "John", lang: "JS" }, function( k, v ) {
+  alert( "Key: " + k + ", Value: " + v );
+});
+```
+     */
+    each<T, K extends keyof T>(obj: T, callback: (this: T[K], propertyName: K, valueOfProperty: T[K]) => any): T;
+    /**
+     * Takes a string and throws an exception containing it.
+     * @param message The message to send out.
+     * @see \`{@link https://api.jquery.com/jQuery.error/ }\`
+     * @since 1.4.1
+     * @example ​ ````Override jQuery.error for display in Firebug.
+```javascript
+jQuery.error = console.error;
+```
+     */
+    error(message: string): any;
+    /**
+     * Escapes any character that has a special meaning in a CSS selector.
+     * @param selector A string containing a selector expression to escape.
+     * @see \`{@link https://api.jquery.com/jQuery.escapeSelector/ }\`
+     * @since 3.0
+     * @example ​ ````Escape an ID containing a hash.
+```javascript
+$.escapeSelector( "#target" ); // "\#target"
+```
+     * @example ​ ````Select all the elements having a class name of .box inside a div.
+```javascript
+$( "div" ).find( "." + $.escapeSelector( ".box" ) );
+```
+     */
+    escapeSelector(selector: JQuery.Selector): JQuery.Selector;
+    /**
+     * Merge the contents of two or more objects together into the first object.
+     * @param deep If true, the merge becomes recursive (aka. deep copy). Passing false for this argument is not supported.
+     * @param target The object to extend. It will receive the new properties.
+     * @param object1 An object containing additional properties to merge in.
+     * @param object2 An object containing additional properties to merge in.
+     * @param object3 An object containing additional properties to merge in.
+     * @param object4 An object containing additional properties to merge in.
+     * @param object5 An object containing additional properties to merge in.
+     * @param object6 An object containing additional properties to merge in.
+     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
+     * @since 1.1.4
+     * @example ​ ````Merge two objects recursively, modifying the first.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var object1 = {
+  apple: 0,
+  banana: { weight: 52, price: 100 },
+  cherry: 97
+};
+var object2 = {
+  banana: { price: 200 },
+  durian: 100
+};
+​
+// Merge object2 into object1, recursively
+$.extend( true, object1, object2 );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( JSON.stringify( object1 ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    extend<T, U, V, W, X, Y, Z>(deep: true, target: T, object1: U, object2: V, object3: W, object4: X, object5: Y, object6: Z): T & U & V & W & X & Y & Z;
+    /**
+     * Merge the contents of two or more objects together into the first object.
+     * @param deep If true, the merge becomes recursive (aka. deep copy). Passing false for this argument is not supported.
+     * @param target The object to extend. It will receive the new properties.
+     * @param object1 An object containing additional properties to merge in.
+     * @param object2 An object containing additional properties to merge in.
+     * @param object3 An object containing additional properties to merge in.
+     * @param object4 An object containing additional properties to merge in.
+     * @param object5 An object containing additional properties to merge in.
+     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
+     * @since 1.1.4
+     * @example ​ ````Merge two objects recursively, modifying the first.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var object1 = {
+  apple: 0,
+  banana: { weight: 52, price: 100 },
+  cherry: 97
+};
+var object2 = {
+  banana: { price: 200 },
+  durian: 100
+};
+​
+// Merge object2 into object1, recursively
+$.extend( true, object1, object2 );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( JSON.stringify( object1 ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    extend<T, U, V, W, X, Y>(deep: true, target: T, object1: U, object2: V, object3: W, object4: X, object5: Y): T & U & V & W & X & Y;
+    /**
+     * Merge the contents of two or more objects together into the first object.
+     * @param deep If true, the merge becomes recursive (aka. deep copy). Passing false for this argument is not supported.
+     * @param target The object to extend. It will receive the new properties.
+     * @param object1 An object containing additional properties to merge in.
+     * @param object2 An object containing additional properties to merge in.
+     * @param object3 An object containing additional properties to merge in.
+     * @param object4 An object containing additional properties to merge in.
+     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
+     * @since 1.1.4
+     * @example ​ ````Merge two objects recursively, modifying the first.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var object1 = {
+  apple: 0,
+  banana: { weight: 52, price: 100 },
+  cherry: 97
+};
+var object2 = {
+  banana: { price: 200 },
+  durian: 100
+};
+​
+// Merge object2 into object1, recursively
+$.extend( true, object1, object2 );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( JSON.stringify( object1 ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    extend<T, U, V, W, X>(deep: true, target: T, object1: U, object2: V, object3: W, object4: X): T & U & V & W & X;
+    /**
+     * Merge the contents of two or more objects together into the first object.
+     * @param deep If true, the merge becomes recursive (aka. deep copy). Passing false for this argument is not supported.
+     * @param target The object to extend. It will receive the new properties.
+     * @param object1 An object containing additional properties to merge in.
+     * @param object2 An object containing additional properties to merge in.
+     * @param object3 An object containing additional properties to merge in.
+     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
+     * @since 1.1.4
+     * @example ​ ````Merge two objects recursively, modifying the first.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var object1 = {
+  apple: 0,
+  banana: { weight: 52, price: 100 },
+  cherry: 97
+};
+var object2 = {
+  banana: { price: 200 },
+  durian: 100
+};
+​
+// Merge object2 into object1, recursively
+$.extend( true, object1, object2 );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( JSON.stringify( object1 ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    extend<T, U, V, W>(deep: true, target: T, object1: U, object2: V, object3: W): T & U & V & W;
+    /**
+     * Merge the contents of two or more objects together into the first object.
+     * @param deep If true, the merge becomes recursive (aka. deep copy). Passing false for this argument is not supported.
+     * @param target The object to extend. It will receive the new properties.
+     * @param object1 An object containing additional properties to merge in.
+     * @param object2 An object containing additional properties to merge in.
+     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
+     * @since 1.1.4
+     * @example ​ ````Merge two objects recursively, modifying the first.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var object1 = {
+  apple: 0,
+  banana: { weight: 52, price: 100 },
+  cherry: 97
+};
+var object2 = {
+  banana: { price: 200 },
+  durian: 100
+};
+​
+// Merge object2 into object1, recursively
+$.extend( true, object1, object2 );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( JSON.stringify( object1 ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    extend<T, U, V>(deep: true, target: T, object1: U, object2: V): T & U & V;
+    /**
+     * Merge the contents of two or more objects together into the first object.
+     * @param deep If true, the merge becomes recursive (aka. deep copy). Passing false for this argument is not supported.
+     * @param target The object to extend. It will receive the new properties.
+     * @param object1 An object containing additional properties to merge in.
+     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
+     * @since 1.1.4
+     * @example ​ ````Merge two objects recursively, modifying the first.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var object1 = {
+  apple: 0,
+  banana: { weight: 52, price: 100 },
+  cherry: 97
+};
+var object2 = {
+  banana: { price: 200 },
+  durian: 100
+};
+​
+// Merge object2 into object1, recursively
+$.extend( true, object1, object2 );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( JSON.stringify( object1 ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    extend<T, U>(deep: true, target: T, object1: U): T & U;
+    /**
+     * Merge the contents of two or more objects together into the first object.
+     * @param deep If true, the merge becomes recursive (aka. deep copy). Passing false for this argument is not supported.
+     * @param target The object to extend. It will receive the new properties.
+     * @param object1 An object containing additional properties to merge in.
+     * @param objectN Additional objects containing properties to merge in.
+     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
+     * @since 1.1.4
+     * @example ​ ````Merge two objects recursively, modifying the first.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var object1 = {
+  apple: 0,
+  banana: { weight: 52, price: 100 },
+  cherry: 97
+};
+var object2 = {
+  banana: { price: 200 },
+  durian: 100
+};
+​
+// Merge object2 into object1, recursively
+$.extend( true, object1, object2 );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( JSON.stringify( object1 ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    extend(deep: true, target: any, object1: any, ...objectN: any[]): any;
+    /**
+     * Merge the contents of two or more objects together into the first object.
+     * @param target An object that will receive the new properties if additional objects are passed in or that will
+     *               extend the jQuery namespace if it is the sole argument.
+     * @param object1 An object containing additional properties to merge in.
+     * @param object2 An object containing additional properties to merge in.
+     * @param object3 An object containing additional properties to merge in.
+     * @param object4 An object containing additional properties to merge in.
+     * @param object5 An object containing additional properties to merge in.
+     * @param object6 An object containing additional properties to merge in.
+     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
+     * @since 1.0
+     * @example ​ ````Merge two objects, modifying the first.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var object1 = {
+  apple: 0,
+  banana: { weight: 52, price: 100 },
+  cherry: 97
+};
+var object2 = {
+  banana: { price: 200 },
+  durian: 100
+};
+​
+// Merge object2 into object1
+$.extend( object1, object2 );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( JSON.stringify( object1 ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Merge defaults and options, without modifying the defaults. This is a common plugin development pattern.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var defaults = { validate: false, limit: 5, name: "foo" };
+var options = { validate: true, name: "bar" };
+​
+// Merge defaults and options, without modifying defaults
+var settings = $.extend( {}, defaults, options );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( "<div><b>defaults -- </b>" + JSON.stringify( defaults ) + "</div>" );
+$( "#log" ).append( "<div><b>options -- </b>" + JSON.stringify( options ) + "</div>" );
+$( "#log" ).append( "<div><b>settings -- </b>" + JSON.stringify( settings ) + "</div>" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    extend<T, U, V, W, X, Y, Z>(target: T, object1: U, object2: V, object3: W, object4: X, object5: Y, object6: Z): T & U & V & W & X & Y & Z;
+    /**
+     * Merge the contents of two or more objects together into the first object.
+     * @param target An object that will receive the new properties if additional objects are passed in or that will
+     *               extend the jQuery namespace if it is the sole argument.
+     * @param object1 An object containing additional properties to merge in.
+     * @param object2 An object containing additional properties to merge in.
+     * @param object3 An object containing additional properties to merge in.
+     * @param object4 An object containing additional properties to merge in.
+     * @param object5 An object containing additional properties to merge in.
+     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
+     * @since 1.0
+     * @example ​ ````Merge two objects, modifying the first.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var object1 = {
+  apple: 0,
+  banana: { weight: 52, price: 100 },
+  cherry: 97
+};
+var object2 = {
+  banana: { price: 200 },
+  durian: 100
+};
+​
+// Merge object2 into object1
+$.extend( object1, object2 );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( JSON.stringify( object1 ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Merge defaults and options, without modifying the defaults. This is a common plugin development pattern.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var defaults = { validate: false, limit: 5, name: "foo" };
+var options = { validate: true, name: "bar" };
+​
+// Merge defaults and options, without modifying defaults
+var settings = $.extend( {}, defaults, options );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( "<div><b>defaults -- </b>" + JSON.stringify( defaults ) + "</div>" );
+$( "#log" ).append( "<div><b>options -- </b>" + JSON.stringify( options ) + "</div>" );
+$( "#log" ).append( "<div><b>settings -- </b>" + JSON.stringify( settings ) + "</div>" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    extend<T, U, V, W, X, Y>(target: T, object1: U, object2: V, object3: W, object4: X, object5: Y): T & U & V & W & X & Y;
+    /**
+     * Merge the contents of two or more objects together into the first object.
+     * @param target An object that will receive the new properties if additional objects are passed in or that will
+     *               extend the jQuery namespace if it is the sole argument.
+     * @param object1 An object containing additional properties to merge in.
+     * @param object2 An object containing additional properties to merge in.
+     * @param object3 An object containing additional properties to merge in.
+     * @param object4 An object containing additional properties to merge in.
+     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
+     * @since 1.0
+     * @example ​ ````Merge two objects, modifying the first.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var object1 = {
+  apple: 0,
+  banana: { weight: 52, price: 100 },
+  cherry: 97
+};
+var object2 = {
+  banana: { price: 200 },
+  durian: 100
+};
+​
+// Merge object2 into object1
+$.extend( object1, object2 );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( JSON.stringify( object1 ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Merge defaults and options, without modifying the defaults. This is a common plugin development pattern.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var defaults = { validate: false, limit: 5, name: "foo" };
+var options = { validate: true, name: "bar" };
+​
+// Merge defaults and options, without modifying defaults
+var settings = $.extend( {}, defaults, options );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( "<div><b>defaults -- </b>" + JSON.stringify( defaults ) + "</div>" );
+$( "#log" ).append( "<div><b>options -- </b>" + JSON.stringify( options ) + "</div>" );
+$( "#log" ).append( "<div><b>settings -- </b>" + JSON.stringify( settings ) + "</div>" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    extend<T, U, V, W, X>(target: T, object1: U, object2: V, object3: W, object4: X): T & U & V & W & X;
+    /**
+     * Merge the contents of two or more objects together into the first object.
+     * @param target An object that will receive the new properties if additional objects are passed in or that will
+     *               extend the jQuery namespace if it is the sole argument.
+     * @param object1 An object containing additional properties to merge in.
+     * @param object2 An object containing additional properties to merge in.
+     * @param object3 An object containing additional properties to merge in.
+     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
+     * @since 1.0
+     * @example ​ ````Merge two objects, modifying the first.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var object1 = {
+  apple: 0,
+  banana: { weight: 52, price: 100 },
+  cherry: 97
+};
+var object2 = {
+  banana: { price: 200 },
+  durian: 100
+};
+​
+// Merge object2 into object1
+$.extend( object1, object2 );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( JSON.stringify( object1 ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Merge defaults and options, without modifying the defaults. This is a common plugin development pattern.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var defaults = { validate: false, limit: 5, name: "foo" };
+var options = { validate: true, name: "bar" };
+​
+// Merge defaults and options, without modifying defaults
+var settings = $.extend( {}, defaults, options );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( "<div><b>defaults -- </b>" + JSON.stringify( defaults ) + "</div>" );
+$( "#log" ).append( "<div><b>options -- </b>" + JSON.stringify( options ) + "</div>" );
+$( "#log" ).append( "<div><b>settings -- </b>" + JSON.stringify( settings ) + "</div>" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    extend<T, U, V, W>(target: T, object1: U, object2: V, object3: W): T & U & V & W;
+    /**
+     * Merge the contents of two or more objects together into the first object.
+     * @param target An object that will receive the new properties if additional objects are passed in or that will
+     *               extend the jQuery namespace if it is the sole argument.
+     * @param object1 An object containing additional properties to merge in.
+     * @param object2 An object containing additional properties to merge in.
+     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
+     * @since 1.0
+     * @example ​ ````Merge two objects, modifying the first.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var object1 = {
+  apple: 0,
+  banana: { weight: 52, price: 100 },
+  cherry: 97
+};
+var object2 = {
+  banana: { price: 200 },
+  durian: 100
+};
+​
+// Merge object2 into object1
+$.extend( object1, object2 );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( JSON.stringify( object1 ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Merge defaults and options, without modifying the defaults. This is a common plugin development pattern.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var defaults = { validate: false, limit: 5, name: "foo" };
+var options = { validate: true, name: "bar" };
+​
+// Merge defaults and options, without modifying defaults
+var settings = $.extend( {}, defaults, options );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( "<div><b>defaults -- </b>" + JSON.stringify( defaults ) + "</div>" );
+$( "#log" ).append( "<div><b>options -- </b>" + JSON.stringify( options ) + "</div>" );
+$( "#log" ).append( "<div><b>settings -- </b>" + JSON.stringify( settings ) + "</div>" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    extend<T, U, V>(target: T, object1: U, object2: V): T & U & V;
+    /**
+     * Merge the contents of two or more objects together into the first object.
+     * @param target An object that will receive the new properties if additional objects are passed in or that will
+     *               extend the jQuery namespace if it is the sole argument.
+     * @param object1 An object containing additional properties to merge in.
+     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
+     * @since 1.0
+     * @example ​ ````Merge two objects, modifying the first.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var object1 = {
+  apple: 0,
+  banana: { weight: 52, price: 100 },
+  cherry: 97
+};
+var object2 = {
+  banana: { price: 200 },
+  durian: 100
+};
+​
+// Merge object2 into object1
+$.extend( object1, object2 );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( JSON.stringify( object1 ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Merge defaults and options, without modifying the defaults. This is a common plugin development pattern.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var defaults = { validate: false, limit: 5, name: "foo" };
+var options = { validate: true, name: "bar" };
+​
+// Merge defaults and options, without modifying defaults
+var settings = $.extend( {}, defaults, options );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( "<div><b>defaults -- </b>" + JSON.stringify( defaults ) + "</div>" );
+$( "#log" ).append( "<div><b>options -- </b>" + JSON.stringify( options ) + "</div>" );
+$( "#log" ).append( "<div><b>settings -- </b>" + JSON.stringify( settings ) + "</div>" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    extend<T, U>(target: T, object1: U): T & U;
+    /**
+     * Merge the contents of two or more objects together into the first object.
+     * @param target An object that will receive the new properties if additional objects are passed in or that will
+     *               extend the jQuery namespace if it is the sole argument.
+     * @param object1 An object containing additional properties to merge in.
+     * @param objectN Additional objects containing properties to merge in.
+     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
+     * @since 1.0
+     * @example ​ ````Merge two objects, modifying the first.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var object1 = {
+  apple: 0,
+  banana: { weight: 52, price: 100 },
+  cherry: 97
+};
+var object2 = {
+  banana: { price: 200 },
+  durian: 100
+};
+​
+// Merge object2 into object1
+$.extend( object1, object2 );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( JSON.stringify( object1 ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Merge defaults and options, without modifying the defaults. This is a common plugin development pattern.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.extend demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+var defaults = { validate: false, limit: 5, name: "foo" };
+var options = { validate: true, name: "bar" };
+​
+// Merge defaults and options, without modifying defaults
+var settings = $.extend( {}, defaults, options );
+​
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( "<div><b>defaults -- </b>" + JSON.stringify( defaults ) + "</div>" );
+$( "#log" ).append( "<div><b>options -- </b>" + JSON.stringify( options ) + "</div>" );
+$( "#log" ).append( "<div><b>settings -- </b>" + JSON.stringify( settings ) + "</div>" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    extend(target: any, object1: any, ...objectN: any[]): any;
+    /**
+     * Load data from the server using a HTTP GET request.
+     * @param url A string containing the URL to which the request is sent.
+     * @param data A plain object or string that is sent to the server with the request.
+     * @param success A callback function that is executed if the request succeeds. Required if `dataType` is provided,
+     *                but you can use `null` or \`{@link noop jQuery.noop}\` as a placeholder.
+     * @param dataType The type of data expected from the server. Default: Intelligent Guess (xml, json, script, text, html).
+     * @see \`{@link https://api.jquery.com/jQuery.get/ }\`
+     * @since 1.0
+     */
+    get(url: string,
+        data: JQuery.PlainObject | string,
+        success: JQuery.jqXHR.DoneCallback | null,
+        dataType?: string): JQuery.jqXHR;
+    /**
+     * Load data from the server using a HTTP GET request.
+     * @param url A string containing the URL to which the request is sent.
+     * @param success A callback function that is executed if the request succeeds. Required if `dataType` is provided,
+     *                but you can use `null` or \`{@link noop jQuery.noop}\` as a placeholder.
+     * @param dataType The type of data expected from the server. Default: Intelligent Guess (xml, json, script, text, html).
+     * @see \`{@link https://api.jquery.com/jQuery.get/ }\`
+     * @since 1.0
+     * @example ​ ````Get the test.php page contents, which has been returned in json format (&lt;?php echo json_encode( array( &quot;name&quot;=&gt;&quot;John&quot;,&quot;time&quot;=&gt;&quot;2pm&quot; ) ); ?&gt;), and add it to the page.
+```javascript
+$.get( "test.php", function( data ) {
+  $( "body" )
+    .append( "Name: " + data.name ) // John
+    .append( "Time: " + data.time ); //  2pm
+}, "json" );
+```
+     */
+    get(url: string,
+        success: JQuery.jqXHR.DoneCallback | null,
+        dataType: string): JQuery.jqXHR;
+    /**
+     * Load data from the server using a HTTP GET request.
+     * @param url A string containing the URL to which the request is sent.
+     * @param success_data _&#x40;param_ `success_data`
+     * <br>
+     * * `success` — A callback function that is executed if the request succeeds. Required if `dataType` is provided,
+     *               but you can use `null` or \`{@link noop jQuery.noop}\` as a placeholder. <br>
+     * * `data` — A plain object or string that is sent to the server with the request.
+     * @see \`{@link https://api.jquery.com/jQuery.get/ }\`
+     * @since 1.0
+     * @example ​ ````Request the test.php page and send some additional data along (while still ignoring the return results).
+```javascript
+$.get( "test.php", { name: "John", time: "2pm" } );
+```
+     * @example ​ ````Pass arrays of data to the server (while still ignoring the return results).
+```javascript
+$.get( "test.php", { "choices[]": ["Jon", "Susan"] } );
+```
+     * @example ​ ````Alert the results from requesting test.php (HTML or XML, depending on what was returned).
+```javascript
+$.get( "test.php", function( data ) {
+  alert( "Data Loaded: " + data );
+});
+```
+     * @example ​ ````Alert the results from requesting test.cgi with an additional payload of data (HTML or XML, depending on what was returned).
+```javascript
+$.get( "test.cgi", { name: "John", time: "2pm" } )
+  .done(function( data ) {
+    alert( "Data Loaded: " + data );
+  });
+```
+     */
+    get(url: string,
+        success_data: JQuery.jqXHR.DoneCallback | JQuery.PlainObject | string): JQuery.jqXHR;
+    /**
+     * Load data from the server using a HTTP GET request.
+     * @param url_settings _&#x40;param_ `url_settings`
+     * <br>
+     * * `url` — A string containing the URL to which the request is sent. <br>
+     * * `settings` — A set of key/value pairs that configure the Ajax request. All properties except for `url` are
+     *                optional. A default can be set for any option with \`{@link ajaxSetup $.ajaxSetup()}\`. See \`{@link https://api.jquery.com/jquery.ajax/#jQuery-ajax-settings jQuery.ajax( settings )}\`
+     *                for a complete list of all settings. The type option will automatically be set to `GET`.
+     * @see \`{@link https://api.jquery.com/jQuery.get/ }\`
+     * @since 1.0
+     * @since 1.12
+     * @since 2.2
+     * @example ​ ````Request the test.php page, but ignore the return results.
+```javascript
+$.get( "test.php" );
+```
+     */
+    get(url_settings?: string | JQuery.UrlAjaxSettings): JQuery.jqXHR;
+    /**
+     * Load JSON-encoded data from the server using a GET HTTP request.
+     * @param url A string containing the URL to which the request is sent.
+     * @param data A plain object or string that is sent to the server with the request.
+     * @param success A callback function that is executed if the request succeeds.
+     * @see \`{@link https://api.jquery.com/jQuery.getJSON/ }\`
+     * @since 1.0
+     */
+    getJSON(url: string,
+            data: JQuery.PlainObject | string,
+            success: JQuery.jqXHR.DoneCallback): JQuery.jqXHR;
+    /**
+     * Load JSON-encoded data from the server using a GET HTTP request.
+     * @param url A string containing the URL to which the request is sent.
+     * @param success_data _&#x40;param_ `url_settings`
+     * <br>
+     * * `success` — A callback function that is executed if the request succeeds. <br>
+     * * `data` — A plain object or string that is sent to the server with the request.
+     * @see \`{@link https://api.jquery.com/jQuery.getJSON/ }\`
+     * @since 1.0
+     * @example ​ ````Loads the four most recent pictures of Mount Rainier from the Flickr JSONP API.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.getJSON demo</title>
+  <style>
+  img {
+    height: 100px;
+    float: left;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="images"></div>
+​
+<script>
+(function() {
+  var flickerAPI = "https://api.flickr.com/services/feeds/photos_public.gne?jsoncallback=?";
+  $.getJSON( flickerAPI, {
+    tags: "mount rainier",
+    tagmode: "any",
+    format: "json"
+  })
+    .done(function( data ) {
+      $.each( data.items, function( i, item ) {
+        $( "<img>" ).attr( "src", item.media.m ).appendTo( "#images" );
+        if ( i === 3 ) {
+          return false;
+        }
+      });
+    });
+})();
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Load the JSON data from test.js and access a name from the returned JSON data.
+```javascript
+$.getJSON( "test.js", function( json ) {
+  console.log( "JSON Data: " + json.users[ 3 ].name );
+ });
+ ```
+     * @example ​ ````Load the JSON data from test.js, passing along additional data, and access a name from the returned JSON data.
+      If an error occurs, log an error message instead.
+```javascript
+$.getJSON( "test.js", { name: "John", time: "2pm" } )
+  .done(function( json ) {
+    console.log( "JSON Data: " + json.users[ 3 ].name );
+  })
+  .fail(function( jqxhr, textStatus, error ) {
+    var err = textStatus + ", " + error;
+    console.log( "Request Failed: " + err );
+});
+```
+     */
+    getJSON(url: string,
+            success_data?: JQuery.jqXHR.DoneCallback | JQuery.PlainObject | string): JQuery.jqXHR;
+    /**
+     * Load a JavaScript file from the server using a GET HTTP request, then execute it.
+     * @param url A string containing the URL to which the request is sent.
+     * @param success A callback function that is executed if the request succeeds.
+     * @see \`{@link https://api.jquery.com/jQuery.getScript/ }\`
+     * @since 1.0
+     * @example ​ ````Define a $.cachedScript() method that allows fetching a cached script:
+```javascript
+jQuery.cachedScript = function( url, options ) {
+​
+  // Allow user to set any option except for dataType, cache, and url
+  options = $.extend( options || {}, {
+    dataType: "script",
+    cache: true,
+    url: url
+  });
+​
+  // Use $.ajax() since it is more flexible than $.getScript
+  // Return the jqXHR object so we can chain callbacks
+  return jQuery.ajax( options );
+};
+​
+// Usage
+$.cachedScript( "ajax/test.js" ).done(function( script, textStatus ) {
+  console.log( textStatus );
+});
+```
+     * @example ​ ````Load the official jQuery Color Animation plugin dynamically and bind some color animations to occur once the new functionality is loaded.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.getScript demo</title>
+  <style>
+  .block {
+     background-color: blue;
+     width: 150px;
+     height: 70px;
+     margin: 10px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="go">&raquo; Run</button>
+<div class="block"></div>
+​
+<script>
+var url = "https://code.jquery.com/color/jquery.color.js";
+$.getScript( url, function() {
+  $( "#go" ).click(function() {
+    $( ".block" )
+      .animate({
+        backgroundColor: "rgb(255, 180, 180)"
+      }, 1000 )
+      .delay( 500 )
+      .animate({
+        backgroundColor: "olive"
+      }, 1000 )
+      .delay( 500 )
+      .animate({
+        backgroundColor: "#00f"
+      }, 1000 );
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    getScript(url: string,
+              success?: JQuery.jqXHR.DoneCallback<string | undefined>): JQuery.jqXHR<string | undefined>;
+    /**
+     * Load a JavaScript file from the server using a GET HTTP request, then execute it.
+     * @see \`{@link https://api.jquery.com/jQuery.getScript/ }\`
+     * @since 1.12
+     * @since 2.2
+     */
+    getScript(options: JQuery.UrlAjaxSettings): JQuery.jqXHR<string | undefined>;
+    /**
+     * Execute some JavaScript code globally.
+     * @param code The JavaScript code to execute.
+     * @see \`{@link https://api.jquery.com/jQuery.globalEval/ }\`
+     * @since 1.0.4
+     * @example ​ ````Execute a script in the global context.
+```javascript
+function test() {
+  jQuery.globalEval( "var newVar = true;" )
+}
+test();
+// newVar === true
+```
+     */
+    globalEval(code: string): void;
+    /**
+     * Finds the elements of an array which satisfy a filter function. The original array is not affected.
+     * @param array The array-like object to search through.
+     * @param fn The function to process each item against. The first argument to the function is the item, and the
+     *           second argument is the index. The function should return a Boolean value. this will be the global window object.
+     * @param invert If "invert" is false, or not provided, then the function returns an array consisting of all elements
+     *               for which "callback" returns true. If "invert" is true, then the function returns an array
+     *               consisting of all elements for which "callback" returns false.
+     * @see \`{@link https://api.jquery.com/jQuery.grep/ }\`
+     * @since 1.0
+     * @example ​ ````Filters the original array of numbers leaving that are not 5 and have an index greater than 4.  Then it removes all 9s.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.grep demo</title>
+  <style>
+  div {
+    color: blue;
+  }
+  p {
+    color: green;
+    margin: 0;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div></div>
+<p></p>
+<span></span>
+​
+<script>
+var arr = [ 1, 9, 3, 8, 6, 1, 5, 9, 4, 7, 3, 8, 6, 9, 1 ];
+$( "div" ).text( arr.join( ", " ) );
+​
+arr = jQuery.grep(arr, function( n, i ) {
+  return ( n !== 5 && i > 4 );
+});
+$( "p" ).text( arr.join( ", " ) );
+​
+arr = jQuery.grep(arr, function( a ) {
+  return a !== 9;
+});
+​
+$( "span" ).text( arr.join( ", " ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Filter an array of numbers to include only numbers bigger then zero.
+```javascript
+$.grep( [ 0, 1, 2 ], function( n, i ) {
+  return n > 0;
+});
+```
+     * @example ​ ````Filter an array of numbers to include numbers that are not bigger than zero.
+```javascript
+$.grep( [ 0, 1, 2 ], function( n, i ) {
+    return n > 0;
+}, true );
+```
+     */
+    grep<T>(array: ArrayLike<T>,
+            fn: (elementOfArray: T, indexInArray: number) => boolean,
+            invert?: boolean): T[];
+    /**
+     * Determine whether an element has any jQuery data associated with it.
+     * @param element A DOM element to be checked for data.
+     * @see \`{@link https://api.jquery.com/jQuery.hasData/ }\`
+     * @since 1.5
+     * @example ​ ````Set data on an element and see the results of hasData.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.hasData demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>Results: </p>
+​
+<script>
+var $p = jQuery( "p" ), p = $p[ 0 ];
+$p.append( jQuery.hasData( p ) + " " ); // false
+​
+$.data( p, "testing", 123 );
+$p.append( jQuery.hasData( p ) + " " ); // true
+​
+$.removeData( p, "testing" );
+$p.append( jQuery.hasData( p ) + " " ); // false
+​
+$p.on( "click", function() {} );
+$p.append( jQuery.hasData( p ) + " " ); // true
+​
+$p.off( "click" );
+$p.append( jQuery.hasData( p ) + " " ); // false
+</script>
+​
+</body>
+</html>
+```
+     */
+    hasData(element: Element | Document | Window | JQuery.PlainObject): boolean;
+    /**
+     * Holds or releases the execution of jQuery's ready event.
+     * @param hold Indicates whether the ready hold is being requested or released
+     * @see \`{@link https://api.jquery.com/jQuery.holdReady/ }\`
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.2. See \`{@link https://github.com/jquery/jquery/issues/3288 }\`.
+     *
+     * **Cause**: The `jQuery.holdReady()` method has been deprecated due to its detrimental effect on the global performance of the page. This method can prevent all the code on the page from initializing for extended lengths of time.
+     *
+     * **Solution**: Rewrite the page so that it does not require all jQuery ready handlers to be delayed. This might be accomplished, for example, by late-loading only the code that requires the delay when it is safe to run. Due to the complexity of this method, jQuery Migrate does not attempt to fill the functionality. If the underlying version of jQuery used with jQuery Migrate no longer contains `jQuery.holdReady()` the code will fail shortly after this warning appears.
+     * @example ​ ````Delay the ready event until a custom plugin has loaded.
+```javascript
+$.holdReady( true );
+$.getScript( "myplugin.js", function() {
+  $.holdReady( false );
+});
+```
+     */
+    holdReady(hold: boolean): void;
+    /**
+     * Modify and filter HTML strings passed through jQuery manipulation methods.
+     * @param html The HTML string on which to operate.
+     * @see \`{@link https://api.jquery.com/jQuery.htmlPrefilter/ }\`
+     * @since 1.12
+     * @since 2.2
+     */
+    htmlPrefilter(html: JQuery.htmlString): JQuery.htmlString;
+    /**
+     * Search for a specified value within an array and return its index (or -1 if not found).
+     * @param value The value to search for.
+     * @param array An array through which to search.
+     * @param fromIndex The index of the array at which to begin the search. The default is 0, which will search the whole array.
+     * @see \`{@link https://api.jquery.com/jQuery.inArray/ }\`
+     * @since 1.2
+     * @example ​ ````Report the index of some elements in the array.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.inArray demo</title>
+  <style>
+  div {
+    color: blue;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>"John" found at <span></span></div>
+<div>4 found at <span></span></div>
+<div>"Karl" not found, so <span></span></div>
+<div>"Pete" is in the array, but not at or after index 2, so <span></span></div>
+​
+<script>
+var arr = [ 4, "Pete", 8, "John" ];
+var $spans = $( "span" );
+$spans.eq( 0 ).text( jQuery.inArray( "John", arr ) );
+$spans.eq( 1 ).text( jQuery.inArray( 4, arr ) );
+$spans.eq( 2 ).text( jQuery.inArray( "Karl", arr ) );
+$spans.eq( 3 ).text( jQuery.inArray( "Pete", arr, 2 ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    inArray<T>(value: T, array: T[], fromIndex?: number): number;
+    /**
+     * Determine whether the argument is an array.
+     * @param obj Object to test whether or not it is an array.
+     * @see \`{@link https://api.jquery.com/jQuery.isArray/ }\`
+     * @since 1.3
+     * @deprecated ​ Deprecated since 3.2. Use \`{@link ArrayConstructor.isArray Array.isArray}\`.
+     * @example ​ ````Finds out if the parameter is an array.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.isArray demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+Is [] an Array? <b></b>
+​
+<script>
+$( "b" ).append( "" + $.isArray([]) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    isArray(obj: any): obj is any[];
+    /**
+     * Check to see if an object is empty (contains no enumerable properties).
+     * @param obj The object that will be checked to see if it's empty.
+     * @see \`{@link https://api.jquery.com/jQuery.isEmptyObject/ }\`
+     * @since 1.4
+     * @example ​ ````Check an object to see if it&#39;s empty.
+```javascript
+jQuery.isEmptyObject({}); // true
+jQuery.isEmptyObject({ foo: "bar" }); // false
+```
+     */
+    isEmptyObject(obj: any): boolean;
+    /**
+     * Determine if the argument passed is a JavaScript function object.
+     * @param obj Object to test whether or not it is a function.
+     * @see \`{@link https://api.jquery.com/jQuery.isFunction/ }\`
+     * @since 1.2
+     * @deprecated ​ Deprecated since 3.3. Use `typeof x === "function"`.
+     * @example ​ ````Test a few parameter examples.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.isFunction demo</title>
+  <style>
+  div {
+    color: blue;
+    margin: 2px;
+    font-size: 14px;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>jQuery.isFunction( objs[ 0 ] ) = <span></span></div>
+<div>jQuery.isFunction( objs[ 1 ] ) = <span></span></div>
+<div>jQuery.isFunction( objs[ 2 ] ) = <span></span></div>
+<div>jQuery.isFunction( objs[ 3 ] ) = <span></span></div>
+<div>jQuery.isFunction( objs[ 4 ] ) = <span></span></div>
+​
+<script>
+function stub() {}
+var objs = [
+  function() {},
+  { x:15, y:20 },
+  null,
+  stub,
+  "function"
+];
+​
+jQuery.each( objs, function( i ) {
+  var isFunc = jQuery.isFunction( objs[ i ]);
+  $( "span" ).eq( i ).text( isFunc );
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Finds out if the parameter is a function.
+```javascript
+$.isFunction(function() {});
+```
+     */
+    // tslint:disable-next-line:ban-types
+    isFunction(obj: any): obj is Function;
+    /**
+     * Determines whether its argument represents a JavaScript number.
+     * @param value The value to be tested.
+     * @see \`{@link https://api.jquery.com/jQuery.isNumeric/ }\`
+     * @since 1.7
+     * @deprecated ​ Deprecated since 3.3. Internal. See \`{@link https://github.com/jquery/jquery/issues/2960 }\`.
+     * @example ​ ````Sample return values of $.isNumeric with various inputs.
+```javascript
+// true (numeric)
+$.isNumeric( "-10" )
+$.isNumeric( "0" )
+$.isNumeric( 0xFF )
+$.isNumeric( "0xFF" )
+$.isNumeric( "8e5" )
+$.isNumeric( "3.1415" )
+$.isNumeric( +10 )
+$.isNumeric( 0144 )
+​
+// false (non-numeric)
+$.isNumeric( "-0x42" )
+$.isNumeric( "7.2acdgs" )
+$.isNumeric( "" )
+$.isNumeric( {} )
+$.isNumeric( NaN )
+$.isNumeric( null )
+$.isNumeric( true )
+$.isNumeric( Infinity )
+$.isNumeric( undefined )
+```
+     */
+    isNumeric(value: any): boolean;
+    /**
+     * Check to see if an object is a plain object (created using "{}" or "new Object").
+     * @param obj The object that will be checked to see if it's a plain object.
+     * @see \`{@link https://api.jquery.com/jQuery.isPlainObject/ }\`
+     * @since 1.4
+     * @example ​ ````Check an object to see if it&#39;s a plain object.
+```javascript
+jQuery.isPlainObject({}) // true
+jQuery.isPlainObject( "test" ) // false
+```
+     */
+    isPlainObject(obj: any): boolean;
+    /**
+     * Determine whether the argument is a window.
+     * @param obj Object to test whether or not it is a window.
+     * @see \`{@link https://api.jquery.com/jQuery.isWindow/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Internal. See \`{@link https://github.com/jquery/jquery/issues/3629 }\`.
+     *
+     * **Cause**: This method returns `true` if its argument is thought to be a `window` element. It was created for internal use and is not a reliable way of detecting `window` for public needs.
+     *
+     * **Solution**: Remove any use of `jQuery.isWindow()` from code. If it is truly needed it can be replaced with a check for `obj != null && obj === obj.window` which was the test used inside this method.
+     * @example ​ ````Finds out if the parameter is a window.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.isWindow demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+Is 'window' a window? <b></b>
+​
+<script>
+$( "b" ).append( "" + $.isWindow( window ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    isWindow(obj: any): obj is Window;
+    /**
+     * Check to see if a DOM node is within an XML document (or is an XML document).
+     * @param node The DOM node that will be checked to see if it's in an XML document.
+     * @see \`{@link https://api.jquery.com/jQuery.isXMLDoc/ }\`
+     * @since 1.1.4
+     * @example ​ ````Check an object to see if it&#39;s in an XML document.
+```javascript
+jQuery.isXMLDoc( document ) // false
+jQuery.isXMLDoc( document.body ) // false
+```
+     */
+    isXMLDoc(node: Node): boolean;
+    /**
+     * Convert an array-like object into a true JavaScript array.
+     * @param obj Any object to turn into a native Array.
+     * @see \`{@link https://api.jquery.com/jQuery.makeArray/ }\`
+     * @since 1.2
+     * @example ​ ````Turn a collection of HTMLElements into an Array of them.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.makeArray demo</title>
+  <style>
+  div {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>First</div>
+<div>Second</div>
+<div>Third</div>
+<div>Fourth</div>
+​
+<script>
+// Returns a NodeList
+var elems = document.getElementsByTagName( "div" );
+// Convert the NodeList to an Array
+var arr = jQuery.makeArray( elems );
+// Use an Array method on list of dom elements
+arr.reverse();
+$( arr ).appendTo( document.body );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Turn a jQuery object into an array
+```javascript
+var obj = $( "li" );
+var arr = $.makeArray( obj );
+```
+     */
+    makeArray<T>(obj: ArrayLike<T>): T[];
+    /**
+     * Translate all items in an array or object to new array of items.
+     * @param array The Array to translate.
+     * @param callback The function to process each item against. The first argument to the function is the array item, the
+     *                 second argument is the index in array The function can return any value. A returned array will be
+     *                 flattened into the resulting array. Within the function, this refers to the global (window) object.
+     * @see \`{@link https://api.jquery.com/jQuery.map/ }\`
+     * @since 1.0
+     * @example ​ ````Use $.map() to change the values of an array.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.map demo</title>
+  <style>
+  div {
+    color: blue;
+  }
+  p {
+    color: green;
+    margin: 0;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div></div>
+<p></p>
+<span></span>
+​
+<script>
+var arr = [ "a", "b", "c", "d", "e" ];
+$( "div" ).text( arr.join( ", " ) );
+​
+arr = jQuery.map( arr, function( n, i ) {
+  return ( n.toUpperCase() + i );
+});
+$( "p" ).text( arr.join( ", " ) );
+​
+arr = jQuery.map( arr, function( a ) {
+  return a + a;
+});
+$( "span" ).text( arr.join( ", " ) );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Map the original array to a new one and add 4 to each value.
+```javascript
+$.map( [ 0, 1, 2 ], function( n ) {
+  return n + 4;
+});
+```
+     * @example ​ ````Map the original array to a new one, adding 1 to each value if it is bigger then zero and removing it if not.
+```javascript
+$.map( [ 0, 1, 2 ], function( n ) {
+  return n > 0 ? n + 1 : null;
+});
+```
+     * @example ​ ````Map the original array to a new one; each element is added with its original value and the value plus one.
+```javascript
+$.map( [ 0, 1, 2 ], function( n ) {
+    return [ n, n + 1 ];
+});
+```
+     * @example ​ ````Map the original array to a new one; each element is squared.
+```javascript
+$.map( [ 0, 1, 2, 3 ], function( a ) {
+  return a * a;
+});
+```
+     * @example ​ ````Map the original array to a new one, removing numbers less than 50 by returning null and subtracting 45 from the rest.
+```javascript
+$.map( [ 0, 1, 52, 97 ], function( a ) {
+  return (a > 50 ? a - 45 : null);
+});
+```
+     * @example ​ ````Augment the resulting array by returning an array inside the function.
+```javascript
+var array = [ 0, 1, 52, 97 ];
+array = $.map( array, function( a, index ) {
+  return [ a - 45, index ];
+});
+```
+     */
+    map<T, TReturn>(array: T[], callback: (this: Window, elementOfArray: T, indexInArray: number) => JQuery.TypeOrArray<TReturn> | null | undefined): TReturn[];
+    /**
+     * Translate all items in an array or object to new array of items.
+     * @param obj The Object to translate.
+     * @param callback The function to process each item against. The first argument to the function is the value; the
+     *                 second argument is the key of the object property. The function can return any value to add to the
+     *                 array. A returned array will be flattened into the resulting array. Within the function, this refers
+     *                 to the global (window) object.
+     * @see \`{@link https://api.jquery.com/jQuery.map/ }\`
+     * @since 1.6
+     * @example ​ ````Map the original object to a new array and double each value.
+```javascript
+var dimensions = { width: 10, height: 15, length: 20 };
+dimensions = $.map( dimensions, function( value, index ) {
+  return value * 2;
+});
+```
+     * @example ​ ````Map an object&#39;s keys to an array.
+```javascript
+var dimensions = { width: 10, height: 15, length: 20 };
+var keys = $.map( dimensions, function( value, key ) {
+  return key;
+});
+```
+     */
+    map<T, K extends keyof T, TReturn>(obj: T, callback: (this: Window, propertyOfObject: T[K], key: K) => JQuery.TypeOrArray<TReturn> | null | undefined): TReturn[];
+    /**
+     * Merge the contents of two arrays together into the first array.
+     * @param first The first array-like object to merge, the elements of second added.
+     * @param second The second array-like object to merge into the first, unaltered.
+     * @see \`{@link https://api.jquery.com/jQuery.merge/ }\`
+     * @since 1.0
+     * @example ​ ````Merges two arrays, altering the first argument.
+```javascript
+$.merge( [ 0, 1, 2 ], [ 2, 3, 4 ] )
+```
+     * @example ​ ````Merges two arrays, altering the first argument.
+```javascript
+$.merge( [ 3, 2, 1 ], [ 4, 3, 2 ] )
+```
+     * @example ​ ````Merges two arrays, but uses a copy, so the original isn&#39;t altered.
+```javascript
+var first = [ "a", "b", "c" ];
+var second = [ "d", "e", "f" ];
+$.merge( $.merge( [], first ), second );
+```
+     */
+    merge<T, U>(first: ArrayLike<T>, second: ArrayLike<U>): Array<T | U>;
+    /**
+     * Relinquish jQuery's control of the $ variable.
+     * @param removeAll A Boolean indicating whether to remove all jQuery variables from the global scope (including jQuery itself).
+     * @see \`{@link https://api.jquery.com/jQuery.noConflict/ }\`
+     * @since 1.0
+     * @example ​ ````Map the original object that was referenced by $ back to $.
+```javascript
+jQuery.noConflict();
+// Do something with jQuery
+jQuery( "div p" ).hide();
+// Do something with another library's $()
+$( "content" ).style.display = "none";
+```
+     * @example ​ ````Revert the $ alias and then create and execute a function to provide the $ as a jQuery alias inside the function&#39;s scope. Inside the function the original $ object is not available. This works well for most plugins that don&#39;t rely on any other library.
+```javascript
+jQuery.noConflict();
+(function( $ ) {
+  $(function() {
+    // More code using $ as alias to jQuery
+  });
+})(jQuery);
+​
+// Other code using $ as an alias to the other library
+```
+     * @example ​ ````Create a different alias instead of jQuery to use in the rest of the script.
+```javascript
+var j = jQuery.noConflict();
+​
+// Do something with jQuery
+j( "div p" ).hide();
+​
+// Do something with another library's $()
+$( "content" ).style.display = "none";
+```
+     * @example ​ ````Completely move jQuery to a new namespace in another object.
+```javascript
+var dom = {};
+dom.query = jQuery.noConflict( true );
+```
+     * @example ​ ````Load two versions of jQuery (not recommended). Then, restore jQuery&#39;s globally scoped variables to the first loaded jQuery.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.noConflict demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log">
+  <h3>Before $.noConflict(true)</h3>
+</div>
+<script src="https://code.jquery.com/jquery-1.6.2.js"></script>
+​
+<script>
+var $log = $( "#log" );
+​
+$log.append( "2nd loaded jQuery version ($): " + $.fn.jquery + "<br>" );
+​
+// Restore globally scoped jQuery variables to the first version loaded
+// (the newer version)
+​
+jq162 = jQuery.noConflict( true );
+​
+$log.append( "<h3>After $.noConflict(true)</h3>" );
+$log.append( "1st loaded jQuery version ($): " + $.fn.jquery + "<br>" );
+$log.append( "2nd loaded jQuery version (jq162): " + jq162.fn.jquery + "<br>" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    noConflict(removeAll?: boolean): this;
+    /**
+     * @deprecated ​ Deprecated since 3.2.
+     *
+     * **Cause**: This public but never-documented method has been deprecated as of jQuery 3.2.0.
+     *
+     * **Solution**: Replace calls such as `jQuery.nodeName( elem, "div" )` with a test such as `elem.nodeName.toLowerCase() === "div"`.
+     */
+    nodeName(elem: Node, name: string): boolean;
+    /**
+     * An empty function.
+     * @see \`{@link https://api.jquery.com/jQuery.noop/ }\`
+     * @since 1.4
+     */
+    noop(): undefined;
+    /**
+     * Return a number representing the current time.
+     * @see \`{@link https://api.jquery.com/jQuery.now/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link DateConstructor.now Date.now}\`.
+     */
+    now(): number;
+    /**
+     * Create a serialized representation of an array, a plain object, or a jQuery object suitable for use in a URL query string or Ajax request. In case a jQuery object is passed, it should contain input elements with name/value properties.
+     * @param obj An array, a plain object, or a jQuery object to serialize.
+     * @param traditional A Boolean indicating whether to perform a traditional "shallow" serialization.
+     * @see \`{@link https://api.jquery.com/jQuery.param/ }\`
+     * @since 1.2
+     * @since 1.4
+     * @example ​ ````Serialize a key/value object.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.param demo</title>
+  <style>
+  div {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="results"></div>
+​
+<script>
+var params = { width:1680, height:1050 };
+var str = jQuery.param( params );
+$( "#results" ).text( str );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Serialize a few complex objects
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.param demo</title>
+  <style>
+  div {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​​
+<script>
+// <=1.3.2:
+$.param({ a: [ 2, 3, 4 ] }); // "a=2&a=3&a=4"
+// >=1.4:
+$.param({ a: [ 2, 3, 4 ] }); // "a[]=2&a[]=3&a[]=4"
+​
+// <=1.3.2:
+$.param({ a: { b: 1, c: 2 }, d: [ 3, 4, { e: 5 } ] });
+// "a=[object+Object]&d=3&d=4&d=[object+Object]"
+​
+// >=1.4:
+$.param({ a: { b: 1, c: 2 }, d: [ 3, 4, { e: 5 } ] });
+// "a[b]=1&a[c]=2&d[]=3&d[]=4&d[2][e]=5"
+</script>
+​
+</body>
+</html>
+```
+     */
+    param(obj: any[] | JQuery.PlainObject | JQuery, traditional?: boolean): string;
+    /**
+     * Parses a string into an array of DOM nodes.
+     * @param data HTML string to be parsed
+     * @param context Document element to serve as the context in which the HTML fragment will be created
+     * @param keepScripts A Boolean indicating whether to include scripts passed in the HTML string
+     * @see \`{@link https://api.jquery.com/jQuery.parseHTML/ }\`
+     * @since 1.8
+     */
+    parseHTML(data: string, context: Document | null | undefined, keepScripts: boolean): JQuery.Node[];
+    /**
+     * Parses a string into an array of DOM nodes.
+     * @param data HTML string to be parsed
+     * @param context_keepScripts _&#x40;param_ `context_keepScripts`
+     * <br>
+     * * `context` — Document element to serve as the context in which the HTML fragment will be created <br>
+     * * `keepScripts` — A Boolean indicating whether to include scripts passed in the HTML string
+     * @see \`{@link https://api.jquery.com/jQuery.parseHTML/ }\`
+     * @since 1.8
+     * @example ​ ````Create an array of DOM nodes using an HTML string and insert it into a div.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.parseHTML demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log">
+  <h3>Content:</h3>
+</div>
+​
+<script>
+var $log = $( "#log" ),
+  str = "hello, <b>my name is</b> jQuery.",
+  html = $.parseHTML( str ),
+  nodeNames = [];
+​
+// Append the parsed HTML
+$log.append( html );
+​
+// Gather the parsed HTML's node names
+$.each( html, function( i, el ) {
+  nodeNames[ i ] = "<li>" + el.nodeName + "</li>";
+});
+​
+// Insert the node names
+$log.append( "<h3>Node Names:</h3>" );
+$( "<ol></ol>" )
+  .append( nodeNames.join( "" ) )
+  .appendTo( $log );
+</script>
+​
+</body>
+</html>
+```
+     */
+    parseHTML(data: string, context_keepScripts?: Document | null | boolean): JQuery.Node[];
+    /**
+     * Takes a well-formed JSON string and returns the resulting JavaScript value.
+     * @param json The JSON string to parse.
+     * @see \`{@link https://api.jquery.com/jQuery.parseJSON/ }\`
+     * @since 1.4.1
+     * @deprecated ​ Deprecated since 3.0. Use \`{@link JSON.parse }\`.
+     *
+     * **Cause**: The `jQuery.parseJSON` method in recent jQuery is identical to the native `JSON.parse`. As of jQuery 3.0 `jQuery.parseJSON` is deprecated.
+     *
+     * **Solution**: Replace any use of `jQuery.parseJSON` with `JSON.parse`.
+     * @example ​ ````Parse a JSON string.
+```javascript
+var obj = jQuery.parseJSON( '{ "name": "John" }' );
+alert( obj.name === "John" );
+```
+     */
+    parseJSON(json: string): any;
+    /**
+     * Parses a string into an XML document.
+     * @param data a well-formed XML string to be parsed
+     * @see \`{@link https://api.jquery.com/jQuery.parseXML/ }\`
+     * @since 1.5
+     * @example ​ ````Create a jQuery object using an XML string and obtain the value of the title node.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.parseXML demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p id="someElement"></p>
+<p id="anotherElement"></p>
+​
+<script>
+var xml = "<rss version='2.0'><channel><title>RSS Title</title></channel></rss>",
+  xmlDoc = $.parseXML( xml ),
+  $xml = $( xmlDoc ),
+  $title = $xml.find( "title" );
+​
+// Append "RSS Title" to #someElement
+$( "#someElement" ).append( $title.text() );
+​
+// Change the title to "XML Title"
+$title.text( "XML Title" );
+​
+// Append "XML Title" to #anotherElement
+$( "#anotherElement" ).append( $title.text() );
+</script>
+​
+</body>
+</html>
+```
+     */
+    parseXML(data: string): XMLDocument;
+    /**
+     * Load data from the server using a HTTP POST request.
+     * @param url A string containing the URL to which the request is sent.
+     * @param data A plain object or string that is sent to the server with the request.
+     * @param success A callback function that is executed if the request succeeds. Required if dataType is provided, but
+     *                can be null in that case.
+     * @param dataType The type of data expected from the server. Default: Intelligent Guess (xml, json, script, text, html).
+     * @see \`{@link https://api.jquery.com/jQuery.post/ }\`
+     * @since 1.0
+     * @example ​ ````Post to the test.php page and get content which has been returned in json format (&lt;?php echo json_encode(array(&quot;name&quot;=&gt;&quot;John&quot;,&quot;time&quot;=&gt;&quot;2pm&quot;)); ?&gt;).
+```javascript
+$.post( "test.php", { func: "getNameAndTime" }, function( data ) {
+  console.log( data.name ); // John
+  console.log( data.time ); // 2pm
+}, "json");
+```
+     */
+    post(url: string,
+         data: JQuery.PlainObject | string,
+         success: JQuery.jqXHR.DoneCallback | null,
+         dataType?: string): JQuery.jqXHR;
+    /**
+     * Load data from the server using a HTTP POST request.
+     * @param url A string containing the URL to which the request is sent.
+     * @param success A callback function that is executed if the request succeeds. Required if dataType is provided, but
+     *                can be null in that case.
+     * @param dataType The type of data expected from the server. Default: Intelligent Guess (xml, json, script, text, html).
+     * @see \`{@link https://api.jquery.com/jQuery.post/ }\`
+     * @since 1.0
+     */
+    post(url: string,
+         success: JQuery.jqXHR.DoneCallback | null,
+         dataType: string): JQuery.jqXHR;
+    /**
+     * Load data from the server using a HTTP POST request.
+     * @param url A string containing the URL to which the request is sent.
+     * @param success_data _&#x40;param_ `success_data`
+     * <br>
+     * * `success` — A callback function that is executed if the request succeeds. Required if `dataType` is provided,
+     *               but can be `null` in that case. <br>
+     * * `data` — A plain object or string that is sent to the server with the request.
+     * @see \`{@link https://api.jquery.com/jQuery.post/ }\`
+     * @since 1.0
+     * @example ​ ````Request the test.php page and send some additional data along (while still ignoring the return results).
+```javascript
+$.post( "test.php", { name: "John", time: "2pm" } );
+```
+     * @example ​ ````Pass arrays of data to the server (while still ignoring the return results).
+```javascript
+$.post( "test.php", { 'choices[]': [ "Jon", "Susan" ] } );
+```
+     * @example ​ ````Send form data using Ajax requests
+```javascript
+$.post( "test.php", $( "#testform" ).serialize() );
+```
+     * @example ​ ````Alert the results from requesting test.php (HTML or XML, depending on what was returned).
+```javascript
+$.post( "test.php", function( data ) {
+  alert( "Data Loaded: " + data );
+});
+```
+     * @example ​ ````Alert the results from requesting test.php with an additional payload of data (HTML or XML, depending on what was returned).
+```javascript
+$.post( "test.php", { name: "John", time: "2pm" })
+  .done(function( data ) {
+    alert( "Data Loaded: " + data );
+  });
+```
+     * @example ​ ````Post a form using Ajax and put results in a div
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.post demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<form action="/" id="searchForm">
+  <input type="text" name="s" placeholder="Search...">
+  <input type="submit" value="Search">
+</form>
+<!-- the result of the search will be rendered inside this div -->
+<div id="result"></div>
+​
+<script>
+// Attach a submit handler to the form
+$( "#searchForm" ).submit(function( event ) {
+​
+  // Stop form from submitting normally
+  event.preventDefault();
+​
+  // Get some values from elements on the page:
+  var $form = $( this ),
+    term = $form.find( "input[name='s']" ).val(),
+    url = $form.attr( "action" );
+​
+  // Send the data using post
+  var posting = $.post( url, { s: term } );
+​
+  // Put the results in a div
+  posting.done(function( data ) {
+    var content = $( data ).find( "#content" );
+    $( "#result" ).empty().append( content );
+  });
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    post(url: string,
+         success_data: JQuery.jqXHR.DoneCallback | JQuery.PlainObject | string): JQuery.jqXHR;
+    /**
+     * Load data from the server using a HTTP POST request.
+     * @param url_settings _&#x40;param_ `url_settings`
+     * <br>
+     * * `url` — A string containing the URL to which the request is sent. <br>
+     * * `settings` — A set of key/value pairs that configure the Ajax request. All properties except for `url` are optional.
+     *                A default can be set for any option with \`{@link ajaxSetup $.ajaxSetup()}\`. See \`{@link https://api.jquery.com/jquery.ajax/#jQuery-ajax-settings jQuery.ajax( settings )}\`
+     *                for a complete list of all settings. Type will automatically be set to `POST`.
+     * @see \`{@link https://api.jquery.com/jQuery.post/ }\`
+     * @since 1.0
+     * @since 1.12
+     * @since 2.2
+     * @example ​ ````Request the test.php page, but ignore the return results.
+```javascript
+$.post( "test.php" );
+```
+     */
+    post(url_settings?: string | JQuery.UrlAjaxSettings): JQuery.jqXHR;
+
+    // region proxy
+    // #region proxy
+
+    // region (fn, null | undefined)
+    // #region (fn, null | undefined)
+
+    // region 0 to 7 additional arguments
+    // #region 0 to 7 additional arguments
+
+    // region 0 parameters
+    // #region 0 parameters
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E, F, G>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => TReturn,
+                             context: null | undefined,
+                             a: A, b: B, c: C, d: D, e: E, f: F, g: G): () => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E, F>(fn: (a: A, b: B, c: C, d: D, e: E, f: F) => TReturn,
+                          context: null | undefined,
+                          a: A, b: B, c: C, d: D, e: E, f: F): () => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E>(fn: (a: A, b: B, c: C, d: D, e: E) => TReturn,
+                       context: null | undefined,
+                       a: A, b: B, c: C, d: D, e: E): () => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D>(fn: (a: A, b: B, c: C, d: D) => TReturn,
+                    context: null | undefined,
+                    a: A, b: B, c: C, d: D): () => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C>(fn: (a: A, b: B, c: C) => TReturn,
+                 context: null | undefined,
+                 a: A, b: B, c: C): () => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B>(fn: (a: A, b: B) => TReturn,
+              context: null | undefined,
+              a: A, b: B): () => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A>(fn: (a: A) => TReturn,
+           context: null | undefined,
+           a: A): () => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn>(fn: () => TReturn,
+                   context: null | undefined): () => TReturn;
+
+    // #endregion
+
+    // region 1 parameters
+    // #region 1 parameters
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E, F, G,
+        T>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
+                t: T) => TReturn,
+           context: null | undefined,
+           a: A, b: B, c: C, d: D, e: E, f: F, g: G): (t: T) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E, F,
+        T>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
+                t: T) => TReturn,
+           context: null | undefined,
+           a: A, b: B, c: C, d: D, e: E, f: F): (t: T) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E,
+        T>(fn: (a: A, b: B, c: C, d: D, e: E,
+                t: T) => TReturn,
+           context: null | undefined,
+           a: A, b: B, c: C, d: D, e: E): (t: T) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D,
+        T>(fn: (a: A, b: B, c: C, d: D,
+                t: T) => TReturn,
+           context: null | undefined,
+           a: A, b: B, c: C, d: D): (t: T) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C,
+        T>(fn: (a: A, b: B, c: C,
+                t: T) => TReturn,
+           context: null | undefined,
+           a: A, b: B, c: C): (t: T) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B,
+        T>(fn: (a: A, b: B,
+                t: T) => TReturn,
+           context: null | undefined,
+           a: A, b: B): (t: T) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A,
+        T>(fn: (a: A,
+                t: T) => TReturn,
+           context: null | undefined,
+           a: A): (t: T) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        T>(fn: (t: T) => TReturn,
+           context: null | undefined): (t: T) => TReturn;
+
+    // #endregion
+
+    // region 2 parameters
+    // #region 2 parameters
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E, F, G,
+        T, U>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
+                   t: T, u: U) => TReturn,
+              context: null | undefined,
+              a: A, b: B, c: C, d: D, e: E, f: F, g: G): (t: T, u: U) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E, F,
+        T, U>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
+                   t: T, u: U) => TReturn,
+              context: null | undefined,
+              a: A, b: B, c: C, d: D, e: E, f: F): (t: T, u: U) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E,
+        T, U>(fn: (a: A, b: B, c: C, d: D, e: E,
+                   t: T, u: U) => TReturn,
+              context: null | undefined,
+              a: A, b: B, c: C, d: D, e: E): (t: T, u: U) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D,
+        T, U>(fn: (a: A, b: B, c: C, d: D,
+                   t: T, u: U) => TReturn,
+              context: null | undefined,
+              a: A, b: B, c: C, d: D): (t: T, u: U) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C,
+        T, U>(fn: (a: A, b: B, c: C,
+                   t: T, u: U) => TReturn,
+              context: null | undefined,
+              a: A, b: B, c: C): (t: T, u: U) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B,
+        T, U>(fn: (a: A, b: B,
+                   t: T, u: U) => TReturn,
+              context: null | undefined,
+              a: A, b: B): (t: T, u: U) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A,
+        T, U>(fn: (a: A,
+                   t: T, u: U) => TReturn,
+              context: null | undefined,
+              a: A): (t: T, u: U) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        T, U>(fn: (t: T, u: U) => TReturn,
+              context: null | undefined): (t: T, u: U) => TReturn;
+
+    // #endregion
+
+    // region 3 parameters
+    // #region 3 parameters
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E, F, G,
+        T, U, V>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
+                      t: T, u: U, v: V) => TReturn,
+                 context: null | undefined,
+                 a: A, b: B, c: C, d: D, e: E, f: F, g: G): (t: T, u: U, v: V) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E, F,
+        T, U, V>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
+                      t: T, u: U, v: V) => TReturn,
+                 context: null | undefined,
+                 a: A, b: B, c: C, d: D, e: E, f: F): (t: T, u: U, v: V) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E,
+        T, U, V>(fn: (a: A, b: B, c: C, d: D, e: E,
+                      t: T, u: U, v: V) => TReturn,
+                 context: null | undefined,
+                 a: A, b: B, c: C, d: D, e: E): (t: T, u: U, v: V) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D,
+        T, U, V>(fn: (a: A, b: B, c: C, d: D,
+                      t: T, u: U, v: V) => TReturn,
+                 context: null | undefined,
+                 a: A, b: B, c: C, d: D): (t: T, u: U, v: V) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C,
+        T, U, V>(fn: (a: A, b: B, c: C,
+                      t: T, u: U, v: V) => TReturn,
+                 context: null | undefined,
+                 a: A, b: B, c: C): (t: T, u: U, v: V) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B,
+        T, U, V>(fn: (a: A, b: B,
+                      t: T, u: U, v: V) => TReturn,
+                 context: null | undefined,
+                 a: A, b: B): (t: T, u: U, v: V) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A,
+        T, U, V>(fn: (a: A,
+                      t: T, u: U, v: V) => TReturn,
+                 context: null | undefined,
+                 a: A): (t: T, u: U, v: V) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        T, U, V>(fn: (t: T, u: U, v: V) => TReturn,
+                 context: null | undefined): (t: T, u: U, v: V) => TReturn;
+
+    // #endregion
+
+    // region 4 parameters
+    // #region 4 parameters
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E, F, G,
+        T, U, V, W>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
+                         t: T, u: U, v: V, w: W) => TReturn,
+                    context: null | undefined,
+                    a: A, b: B, c: C, d: D, e: E, f: F, g: G): (t: T, u: U, v: V, w: W) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E, F,
+        T, U, V, W>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
+                         t: T, u: U, v: V, w: W) => TReturn,
+                    context: null | undefined,
+                    a: A, b: B, c: C, d: D, e: E, f: F): (t: T, u: U, v: V, w: W) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E,
+        T, U, V, W>(fn: (a: A, b: B, c: C, d: D, e: E,
+                         t: T, u: U, v: V, w: W) => TReturn,
+                    context: null | undefined,
+                    a: A, b: B, c: C, d: D, e: E): (t: T, u: U, v: V, w: W) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D,
+        T, U, V, W>(fn: (a: A, b: B, c: C, d: D,
+                         t: T, u: U, v: V, w: W) => TReturn,
+                    context: null | undefined,
+                    a: A, b: B, c: C, d: D): (t: T, u: U, v: V, w: W) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C,
+        T, U, V, W>(fn: (a: A, b: B, c: C,
+                         t: T, u: U, v: V, w: W) => TReturn,
+                    context: null | undefined,
+                    a: A, b: B, c: C): (t: T, u: U, v: V, w: W) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B,
+        T, U, V, W>(fn: (a: A, b: B,
+                         t: T, u: U, v: V, w: W) => TReturn,
+                    context: null | undefined,
+                    a: A, b: B): (t: T, u: U, v: V, w: W) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A,
+        T, U, V, W>(fn: (a: A,
+                         t: T, u: U, v: V, w: W) => TReturn,
+                    context: null | undefined,
+                    a: A): (t: T, u: U, v: V, w: W) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        T, U, V, W>(fn: (t: T, u: U, v: V, w: W) => TReturn,
+                    context: null | undefined): (t: T, u: U, v: V, w: W) => TReturn;
+
+    // #endregion
+
+    // region 5 parameters
+    // #region 5 parameters
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E, F, G,
+        T, U, V, W, X>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
+                            t: T, u: U, v: V, w: W, x: X) => TReturn,
+                       context: null | undefined,
+                       a: A, b: B, c: C, d: D, e: E, f: F, g: G): (t: T, u: U, v: V, w: W, x: X) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E, F,
+        T, U, V, W, X>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
+                            t: T, u: U, v: V, w: W, x: X) => TReturn,
+                       context: null | undefined,
+                       a: A, b: B, c: C, d: D, e: E, f: F): (t: T, u: U, v: V, w: W, x: X) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E,
+        T, U, V, W, X>(fn: (a: A, b: B, c: C, d: D, e: E,
+                            t: T, u: U, v: V, w: W, x: X) => TReturn,
+                       context: null | undefined,
+                       a: A, b: B, c: C, d: D, e: E): (t: T, u: U, v: V, w: W, x: X) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D,
+        T, U, V, W, X>(fn: (a: A, b: B, c: C, d: D,
+                            t: T, u: U, v: V, w: W, x: X) => TReturn,
+                       context: null | undefined,
+                       a: A, b: B, c: C, d: D): (t: T, u: U, v: V, w: W, x: X) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C,
+        T, U, V, W, X>(fn: (a: A, b: B, c: C,
+                            t: T, u: U, v: V, w: W, x: X) => TReturn,
+                       context: null | undefined,
+                       a: A, b: B, c: C): (t: T, u: U, v: V, w: W, x: X) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B,
+        T, U, V, W, X>(fn: (a: A, b: B,
+                            t: T, u: U, v: V, w: W, x: X) => TReturn,
+                       context: null | undefined,
+                       a: A, b: B): (t: T, u: U, v: V, w: W, x: X) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A,
+        T, U, V, W, X>(fn: (a: A,
+                            t: T, u: U, v: V, w: W, x: X) => TReturn,
+                       context: null | undefined,
+                       a: A): (t: T, u: U, v: V, w: W, x: X) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        T, U, V, W, X>(fn: (t: T, u: U, v: V, w: W, x: X) => TReturn,
+                       context: null | undefined): (t: T, u: U, v: V, w: W, x: X) => TReturn;
+
+    // #endregion
+
+    // region 6 parameters
+    // #region 6 parameters
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E, F, G,
+        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
+                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
+                          context: null | undefined,
+                          a: A, b: B, c: C, d: D, e: E, f: F, g: G): (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E, F,
+        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
+                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
+                          context: null | undefined,
+                          a: A, b: B, c: C, d: D, e: E, f: F): (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E,
+        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C, d: D, e: E,
+                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
+                          context: null | undefined,
+                          a: A, b: B, c: C, d: D, e: E): (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D,
+        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C, d: D,
+                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
+                          context: null | undefined,
+                          a: A, b: B, c: C, d: D): (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C,
+        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C,
+                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
+                          context: null | undefined,
+                          a: A, b: B, c: C): (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B,
+        T, U, V, W, X, Y>(fn: (a: A, b: B,
+                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
+                          context: null | undefined,
+                          a: A, b: B): (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A,
+        T, U, V, W, X, Y>(fn: (a: A,
+                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
+                          context: null | undefined,
+                          a: A): (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        T, U, V, W, X, Y>(fn: (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
+                          context: null | undefined): (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
+
+    // #endregion
+
+    // region 7+ parameters
+    // #region 7+ parameters
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E, F, G,
+        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
+                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
+                             context: null | undefined,
+                             a: A, b: B, c: C, d: D, e: E, f: F, g: G): (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E, F,
+        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
+                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
+                             context: null | undefined,
+                             a: A, b: B, c: C, d: D, e: E, f: F): (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D, E,
+        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C, d: D, e: E,
+                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
+                             context: null | undefined,
+                             a: A, b: B, c: C, d: D, e: E): (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C, D,
+        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C, d: D,
+                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
+                             context: null | undefined,
+                             a: A, b: B, c: C, d: D): (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B, C,
+        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C,
+                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
+                             context: null | undefined,
+                             a: A, b: B, c: C): (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A, B,
+        T, U, V, W, X, Y, Z>(fn: (a: A, b: B,
+                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
+                             context: null | undefined,
+                             a: A, b: B): (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        A,
+        T, U, V, W, X, Y, Z>(fn: (a: A,
+                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
+                             context: null | undefined,
+                             a: A): (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn,
+        T, U, V, W, X, Y, Z>(fn: (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
+                             context: null | undefined): (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
+
+    // #endregion
+
+    // #endregion
+
+    // region 8+ additional arguments
+    // #region 8+ additional arguments
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @param additionalArguments Any number of arguments to be passed to the function referenced in the function argument.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.9
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     */
+    proxy<TReturn>(fn: (...args: any[]) => TReturn,
+                   context: null | undefined,
+                   ...additionalArguments: any[]): (...args: any[]) => TReturn;
+
+    // #endregion
+
+    // #endregion
+
+    // region (fn, context)
+    // #region (fn, context)
+
+    // region 0 to 7 additional arguments
+    // #region 0 to 7 additional arguments
+
+    // region 0 parameters
+    // #region 0 parameters
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E, F, G>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => TReturn,
+                             context: TContext,
+                             a: A, b: B, c: C, d: D, e: E, f: F, g: G): (this: TContext) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E, F>(fn: (a: A, b: B, c: C, d: D, e: E, f: F) => TReturn,
+                          context: TContext,
+                          a: A, b: B, c: C, d: D, e: E, f: F): (this: TContext) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E>(fn: (a: A, b: B, c: C, d: D, e: E) => TReturn,
+                       context: TContext,
+                       a: A, b: B, c: C, d: D, e: E): (this: TContext) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D>(fn: (a: A, b: B, c: C, d: D) => TReturn,
+                    context: TContext,
+                    a: A, b: B, c: C, d: D): (this: TContext) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C>(fn: (a: A, b: B, c: C) => TReturn,
+                 context: TContext,
+                 a: A, b: B, c: C): (this: TContext) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B>(fn: (a: A, b: B) => TReturn,
+              context: TContext,
+              a: A, b: B): (this: TContext) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4`
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A>(fn: (a: A) => TReturn,
+           context: TContext,
+           a: A): (this: TContext) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn>(fn: () => TReturn,
+                 context: TContext): (this: TContext) => TReturn;
+
+    // #endregion
+
+    // region 1 parameters
+    // #region 1 parameters
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E, F, G,
+        T>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
+                t: T) => TReturn,
+           context: TContext,
+           a: A, b: B, c: C, d: D, e: E, f: F, g: G): (this: TContext, t: T) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E, F,
+        T>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
+                t: T) => TReturn,
+           context: TContext,
+           a: A, b: B, c: C, d: D, e: E, f: F): (this: TContext, t: T) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E,
+        T>(fn: (a: A, b: B, c: C, d: D, e: E,
+                t: T) => TReturn,
+           context: TContext,
+           a: A, b: B, c: C, d: D, e: E): (this: TContext, t: T) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D,
+        T>(fn: (a: A, b: B, c: C, d: D,
+                t: T) => TReturn,
+           context: TContext,
+           a: A, b: B, c: C, d: D): (this: TContext, t: T) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C,
+        T>(fn: (a: A, b: B, c: C,
+                t: T) => TReturn,
+           context: TContext,
+           a: A, b: B, c: C): (this: TContext, t: T) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B,
+        T>(fn: (a: A, b: B,
+                t: T) => TReturn,
+           context: TContext,
+           a: A, b: B): (this: TContext, t: T) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A,
+        T>(fn: (a: A,
+                t: T) => TReturn,
+           context: TContext,
+           a: A): (this: TContext, t: T) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        T>(fn: (t: T) => TReturn,
+           context: TContext): (this: TContext, t: T) => TReturn;
+
+    // #endregion
+
+    // region 2 parameters
+    // #region 2 parameters
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E, F, G,
+        T, U>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
+                   t: T, u: U) => TReturn,
+              context: TContext,
+              a: A, b: B, c: C, d: D, e: E, f: F, g: G): (this: TContext, t: T, u: U) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E, F,
+        T, U>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
+                   t: T, u: U) => TReturn,
+              context: TContext,
+              a: A, b: B, c: C, d: D, e: E, f: F): (this: TContext, t: T, u: U) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E,
+        T, U>(fn: (a: A, b: B, c: C, d: D, e: E,
+                   t: T, u: U) => TReturn,
+              context: TContext,
+              a: A, b: B, c: C, d: D, e: E): (this: TContext, t: T, u: U) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D,
+        T, U>(fn: (a: A, b: B, c: C, d: D,
+                   t: T, u: U) => TReturn,
+              context: TContext,
+              a: A, b: B, c: C, d: D): (this: TContext, t: T, u: U) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C,
+        T, U>(fn: (a: A, b: B, c: C,
+                   t: T, u: U) => TReturn,
+              context: TContext,
+              a: A, b: B, c: C): (this: TContext, t: T, u: U) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B,
+        T, U>(fn: (a: A, b: B,
+                   t: T, u: U) => TReturn,
+              context: TContext,
+              a: A, b: B): (this: TContext, t: T, u: U) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A,
+        T, U>(fn: (a: A,
+                   t: T, u: U) => TReturn,
+              context: TContext,
+              a: A): (this: TContext, t: T, u: U) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        T, U>(fn: (t: T, u: U) => TReturn,
+              context: TContext): (this: TContext, t: T, u: U) => TReturn;
+
+    // #endregion
+
+    // region 3 parameters
+    // #region 3 parameters
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E, F, G,
+        T, U, V>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
+                      t: T, u: U, v: V) => TReturn,
+                 context: TContext,
+                 a: A, b: B, c: C, d: D, e: E, f: F, g: G): (this: TContext, t: T, u: U, v: V) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E, F,
+        T, U, V>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
+                      t: T, u: U, v: V) => TReturn,
+                 context: TContext,
+                 a: A, b: B, c: C, d: D, e: E, f: F): (this: TContext, t: T, u: U, v: V) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E,
+        T, U, V>(fn: (a: A, b: B, c: C, d: D, e: E,
+                      t: T, u: U, v: V) => TReturn,
+                 context: TContext,
+                 a: A, b: B, c: C, d: D, e: E): (this: TContext, t: T, u: U, v: V) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D,
+        T, U, V>(fn: (a: A, b: B, c: C, d: D,
+                      t: T, u: U, v: V) => TReturn,
+                 context: TContext,
+                 a: A, b: B, c: C, d: D): (this: TContext, t: T, u: U, v: V) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C,
+        T, U, V>(fn: (a: A, b: B, c: C,
+                      t: T, u: U, v: V) => TReturn,
+                 context: TContext,
+                 a: A, b: B, c: C): (this: TContext, t: T, u: U, v: V) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B,
+        T, U, V>(fn: (a: A, b: B,
+                      t: T, u: U, v: V) => TReturn,
+                 context: TContext,
+                 a: A, b: B): (this: TContext, t: T, u: U, v: V) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A,
+        T, U, V>(fn: (a: A,
+                      t: T, u: U, v: V) => TReturn,
+                 context: TContext,
+                 a: A): (this: TContext, t: T, u: U, v: V) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        T, U, V>(fn: (t: T, u: U, v: V) => TReturn,
+                 context: TContext): (this: TContext, t: T, u: U, v: V) => TReturn;
+
+    // #endregion
+
+    // region 4 parameters
+    // #region 4 parameters
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E, F, G,
+        T, U, V, W>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
+                         t: T, u: U, v: V, w: W) => TReturn,
+                    context: TContext,
+                    a: A, b: B, c: C, d: D, e: E, f: F, g: G): (this: TContext, t: T, u: U, v: V, w: W) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E, F,
+        T, U, V, W>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
+                         t: T, u: U, v: V, w: W) => TReturn,
+                    context: TContext,
+                    a: A, b: B, c: C, d: D, e: E, f: F): (this: TContext, t: T, u: U, v: V, w: W) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E,
+        T, U, V, W>(fn: (a: A, b: B, c: C, d: D, e: E,
+                         t: T, u: U, v: V, w: W) => TReturn,
+                    context: TContext,
+                    a: A, b: B, c: C, d: D, e: E): (this: TContext, t: T, u: U, v: V, w: W) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D,
+        T, U, V, W>(fn: (a: A, b: B, c: C, d: D,
+                         t: T, u: U, v: V, w: W) => TReturn,
+                    context: TContext,
+                    a: A, b: B, c: C, d: D): (this: TContext, t: T, u: U, v: V, w: W) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C,
+        T, U, V, W>(fn: (a: A, b: B, c: C,
+                         t: T, u: U, v: V, w: W) => TReturn,
+                    context: TContext,
+                    a: A, b: B, c: C): (this: TContext, t: T, u: U, v: V, w: W) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B,
+        T, U, V, W>(fn: (a: A, b: B,
+                         t: T, u: U, v: V, w: W) => TReturn,
+                    context: TContext,
+                    a: A, b: B): (this: TContext, t: T, u: U, v: V, w: W) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A,
+        T, U, V, W>(fn: (a: A,
+                         t: T, u: U, v: V, w: W) => TReturn,
+                    context: TContext,
+                    a: A): (this: TContext, t: T, u: U, v: V, w: W) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        T, U, V, W>(fn: (t: T, u: U, v: V, w: W) => TReturn,
+                    context: TContext): (this: TContext, t: T, u: U, v: V, w: W) => TReturn;
+
+    // #endregion
+
+    // region 5 parameters
+    // #region 5 parameters
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E, F, G,
+        T, U, V, W, X>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
+                            t: T, u: U, v: V, w: W, x: X) => TReturn,
+                       context: TContext,
+                       a: A, b: B, c: C, d: D, e: E, f: F, g: G): (this: TContext, t: T, u: U, v: V, w: W, x: X) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E, F,
+        T, U, V, W, X>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
+                            t: T, u: U, v: V, w: W, x: X) => TReturn,
+                       context: TContext,
+                       a: A, b: B, c: C, d: D, e: E, f: F): (this: TContext, t: T, u: U, v: V, w: W, x: X) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E,
+        T, U, V, W, X>(fn: (a: A, b: B, c: C, d: D, e: E,
+                            t: T, u: U, v: V, w: W, x: X) => TReturn,
+                       context: TContext,
+                       a: A, b: B, c: C, d: D, e: E): (this: TContext, t: T, u: U, v: V, w: W, x: X) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D,
+        T, U, V, W, X>(fn: (a: A, b: B, c: C, d: D,
+                            t: T, u: U, v: V, w: W, x: X) => TReturn,
+                       context: TContext,
+                       a: A, b: B, c: C, d: D): (this: TContext, t: T, u: U, v: V, w: W, x: X) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C,
+        T, U, V, W, X>(fn: (a: A, b: B, c: C,
+                            t: T, u: U, v: V, w: W, x: X) => TReturn,
+                       context: TContext,
+                       a: A, b: B, c: C): (this: TContext, t: T, u: U, v: V, w: W, x: X) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B,
+        T, U, V, W, X>(fn: (a: A, b: B,
+                            t: T, u: U, v: V, w: W, x: X) => TReturn,
+                       context: TContext,
+                       a: A, b: B): (this: TContext, t: T, u: U, v: V, w: W, x: X) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A,
+        T, U, V, W, X>(fn: (a: A,
+                            t: T, u: U, v: V, w: W, x: X) => TReturn,
+                       context: TContext,
+                       a: A): (this: TContext, t: T, u: U, v: V, w: W, x: X) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        T, U, V, W, X>(fn: (t: T, u: U, v: V, w: W, x: X) => TReturn,
+                       context: TContext): (this: TContext, t: T, u: U, v: V, w: W, x: X) => TReturn;
+
+    // #endregion
+
+    // region 6 parameters
+    // #region 6 parameters
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E, F, G,
+        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
+                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
+                          context: TContext,
+                          a: A, b: B, c: C, d: D, e: E, f: F, g: G): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E, F,
+        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
+                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
+                          context: TContext,
+                          a: A, b: B, c: C, d: D, e: E, f: F): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E,
+        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C, d: D, e: E,
+                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
+                          context: TContext,
+                          a: A, b: B, c: C, d: D, e: E): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D,
+        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C, d: D,
+                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
+                          context: TContext,
+                          a: A, b: B, c: C, d: D): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C,
+        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C,
+                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
+                          context: TContext,
+                          a: A, b: B, c: C): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B,
+        T, U, V, W, X, Y>(fn: (a: A, b: B,
+                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
+                          context: TContext,
+                          a: A, b: B): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A,
+        T, U, V, W, X, Y>(fn: (a: A,
+                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
+                          context: TContext,
+                          a: A): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        T, U, V, W, X, Y>(fn: (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
+                          context: TContext): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
+
+    // #endregion
+
+    // region 7+ parameters
+    // #region 7+ parameters
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E, F, G,
+        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
+                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
+                             context: TContext,
+                             a: A, b: B, c: C, d: D, e: E, f: F, g: G): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E, F,
+        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
+                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
+                             context: TContext,
+                             a: A, b: B, c: C, d: D, e: E, f: F): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D, E,
+        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C, d: D, e: E,
+                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
+                             context: TContext,
+                             a: A, b: B, c: C, d: D, e: E): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C, D,
+        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C, d: D,
+                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
+                             context: TContext,
+                             a: A, b: B, c: C, d: D): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B, C,
+        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C,
+                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
+                             context: TContext,
+                             a: A, b: B, c: C): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A, B,
+        T, U, V, W, X, Y, Z>(fn: (a: A, b: B,
+                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
+                             context: TContext,
+                             a: A, b: B): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        A,
+        T, U, V, W, X, Y, Z>(fn: (a: A,
+                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
+                             context: TContext,
+                             a: A): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn,
+        T, U, V, W, X, Y, Z>(fn: (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
+                             context: TContext): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
+
+    // #endregion
+
+    // #endregion
+
+    // region 8+ additional arguments
+    // #region 8+ additional arguments
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param fn The function whose context will be changed.
+     * @param context The object to which the context (`this`) of the function should be set.
+     * @param additionalArguments Any number of arguments to be passed to the function referenced in the function argument.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  type: "zombie",
+  test: function( event ) {
+    // Without proxy, `this` would refer to the event target
+    // use event.target to reference that element.
+    var element = event.target;
+    $( element ).css( "background-color", "red" );
+​
+    // With proxy, `this` refers to the me object encapsulating
+    // this function.
+    $( "#log" ).append( "Hello " + this.type + "<br>" );
+    $( "#test" ).off( "click", this.test );
+  }
+};
+​
+var you = {
+  type: "person",
+  test: function( event ) {
+    $( "#log" ).append( this.type + " " );
+  }
+};
+​
+// Execute you.test() in the context of the `you` object
+// no matter where it is called
+// i.e. the `this` keyword will refer to `you`
+var youClick = $.proxy( you.test, you );
+​
+// attach click handlers to #test
+$( "#test" )
+  // this === "zombie"; handler unbound after first click
+  .on( "click", $.proxy( me.test, me ) )
+​
+  // this === "person"
+  .on( "click", youClick )
+​
+  // this === "zombie"
+  .on( "click", $.proxy( you.test, me ) )
+​
+  // this === "<button> element"
+  .on( "click", you.test );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Change the context of a function bound to the click handler,
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><button type="button" id="test">Test</button></p>
+<div id="log"></div>
+​
+<script>
+var me = {
+  // I'm a dog
+  type: "dog",
+​
+  // Note that event comes *after* one and two
+  test: function( one, two, event ) {
+    $( "#log" )
+​
+      // `one` maps to `you`, the 1st additional
+      // argument in the $.proxy function call
+      .append( "<h3>Hello " + one.type + ":</h3>" )
+​
+      // The `this` keyword refers to `me`
+      // (the 2nd, context, argument of $.proxy)
+      .append( "I am a " + this.type + ", " )
+​
+      // `two` maps to `they`, the 2nd additional
+      // argument in the $.proxy function call
+      .append( "and they are " + two.type + ".<br>" )
+​
+      // The event type is "click"
+      .append( "Thanks for " + event.type + "ing." )
+​
+      // The clicked element is `event.target`,
+      // and its type is "button"
+      .append( "the " + event.target.type + "." );
+  }
+};
+​
+var you = { type: "cat" };
+var they = { type: "fish" };
+​
+// Set up handler to execute me.test() in the context
+// of `me`, with `you` and `they` as additional arguments
+var proxy = $.proxy( me.test, me, you, they );
+​
+$( "#test" )
+  .on( "click", proxy );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object,
+        TReturn>(fn: (...args: any[]) => TReturn,
+                 context: TContext,
+                 ...additionalArguments: any[]): (this: TContext, ...args: any[]) => TReturn;
+
+    // #endregion
+
+    // #endregion
+
+    // region (context, name)
+    // #region (context, name)
+
+    /**
+     * Takes a function and returns a new one that will always have a particular context.
+     * @param context The object to which the context of the function should be set.
+     * @param name The name of the function whose context will be changed (should be a property of the context object).
+     * @param additionalArguments Any number of arguments to be passed to the function named in the name argument.
+     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
+     * @since 1.4
+     * @since 1.6
+     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
+     * @example ​ ````Enforce the context of the function using the &quot;context, function name&quot; signature. Unbind the handler after first click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.proxy demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+  <p><button id="test">Test</button></p>
+  <p id="log"></p>
+​
+<script>
+var obj = {
+  name: "John",
+  test: function() {
+    $( "#log" ).append( this.name );
+    $( "#test" ).off( "click", obj.test );
+  }
+};
+$( "#test" ).on( "click", jQuery.proxy( obj, "test" ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    proxy<TContext extends object>(context: TContext,
+                                   name: keyof TContext,
+                                   ...additionalArguments: any[]): (this: TContext, ...args: any[]) => any;
+
+    // #endregion
+
+    // #endregion
+
+    /**
+     * Manipulate the queue of functions to be executed on the matched element.
+     * @param element A DOM element where the array of queued functions is attached.
+     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
+     * @param newQueue The new function to add to the queue.
+     *                 An array of functions to replace the current queue contents.
+     * @see \`{@link https://api.jquery.com/jQuery.queue/ }\`
+     * @since 1.3
+     * @example ​ ````Show the length of the queue.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.queue demo</title>
+  <style>
+  div {
+    margin: 3px;
+    width: 40px;
+    height: 40px;
+    position: absolute;
+    left: 0px;
+    top: 30px;
+    background: green;
+    display: none;
+  }
+  div.newcolor {
+    background: blue;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="show">Show Length of Queue</button>
+<span></span>
+<div></div>
+  ​
+<script>
+$( "#show" ).click(function() {
+  var n = jQuery.queue( $( "div" )[ 0 ], "fx" );
+  $( "span" ).text( "Queue length is: " + n.length );
+});
+​
+function runIt() {
+  $( "div" )
+    .show( "slow" )
+    .animate({
+      left: "+=200"
+    }, 2000 )
+    .slideToggle( 1000 )
+    .slideToggle( "fast" )
+    .animate({
+      left: "-=200"
+    }, 1500 )
+    .hide( "slow" )
+    .show( 1200 )
+    .slideUp( "normal", runIt );
+}
+​
+runIt();
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Queue a custom function.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.queue demo</title>
+  <style>
+  div {
+    margin: 3px;
+    width: 40px;
+    height: 40px;
+    position: absolute;
+    left: 0px;
+    top: 30px;
+    background: green;
+    display: none;
+  }
+  div.newcolor {
+    background: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+Click here...
+<div></div>
+​
+<script>
+$( document.body ).click(function() {
+  var divs = $( "div" )
+    .show( "slow" )
+    .animate({ left: "+=200" }, 2000 );
+  jQuery.queue( divs[ 0 ], "fx", function() {
+    $( this ).addClass( "newcolor" );
+    jQuery.dequeue( this );
+  });
+  divs.animate({ left: "-=200" }, 500 );
+  jQuery.queue( divs[ 0 ], "fx", function() {
+    $( this ).removeClass( "newcolor" );
+    jQuery.dequeue( this );
+  });
+  divs.slideUp();
+});
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Set a queue array to delete the queue.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.queue demo</title>
+  <style>
+  div {
+    margin: 3px;
+    width: 40px;
+    height: 40px;
+    position: absolute;
+    left: 0px;
+    top: 30px;
+    background: green;
+    display: none;
+  }
+  div.newcolor {
+    background: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button id="start">Start</button>
+<button id="stop">Stop</button>
+<div></div>
+​
+<script>
+$( "#start" ).click(function() {
+  var divs = $( "div" )
+    .show( "slow" )
+    .animate({ left: "+=200" }, 5000 );
+  jQuery.queue( divs[ 0 ], "fx", function() {
+    $( this ).addClass( "newcolor" );
+    jQuery.dequeue( this );
+  });
+  divs.animate({ left: "-=200" }, 1500 );
+  jQuery.queue( divs[ 0 ], "fx", function() {
+    $( this ).removeClass( "newcolor" );
+    jQuery.dequeue( this );
+  });
+  divs.slideUp();
+});
+$( "#stop" ).click(function() {
+  jQuery.queue( $( "div" )[ 0 ], "fx", [] );
+  $( "div" ).stop();
+});
+</script>
+​
+</body>
+</html>
+```
+     */
+    queue<T extends Element>(element: T, queueName?: string, newQueue?: JQuery.TypeOrArray<JQuery.QueueFunction<T>>): JQuery.Queue<T>;
+    /**
+     * Handles errors thrown synchronously in functions wrapped in jQuery().
+     * @param error An error thrown in the function wrapped in jQuery().
+     * @see \`{@link https://api.jquery.com/jQuery.readyException/ }\`
+     * @since 3.1
+     * @example ​ ````Pass the received error to console.error.
+```javascript
+jQuery.readyException = function( error ) {
+  console.error( error );
+};
+```
+     */
+    readyException(error: Error): any;
+    /**
+     * Remove a previously-stored piece of data.
+     * @param element A DOM element from which to remove data.
+     * @param name A string naming the piece of data to remove.
+     * @see \`{@link https://api.jquery.com/jQuery.removeData/ }\`
+     * @since 1.2.3
+     * @example ​ ````Set a data store for 2 names then remove one of them.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.removeData demo</title>
+  <style>
+  div {
+    margin: 2px;
+    color: blue;
+  }
+  span {
+    color: red;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>value1 before creation: <span></span></div>
+<div>value1 after creation: <span></span></div>
+<div>value1 after removal: <span></span></div>
+<div>value2 after removal: <span></span></div>
+​
+<script>
+var div = $( "div" )[ 0 ];
+$( "span:eq(0)" ).text( "" + $( "div" ).data( "test1" ) );
+jQuery.data( div, "test1", "VALUE-1" );
+jQuery.data( div, "test2", "VALUE-2" );
+$( "span:eq(1)" ).text( "" + jQuery.data( div, "test1" ) );
+jQuery.removeData( div, "test1" );
+$( "span:eq(2)" ).text( "" + jQuery.data( div, "test1" ) );
+$( "span:eq(3)" ).text( "" + jQuery.data( div, "test2" ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    removeData(element: Element | Document | Window | JQuery.PlainObject, name?: string): void;
+    /**
+     * Creates an object containing a set of properties ready to be used in the definition of custom animations.
+     * @param duration A string or number determining how long the animation will run.
+     * @param easing A string indicating which easing function to use for the transition.
+     * @param complete A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/jQuery.speed/ }\`
+     * @since 1.1
+     */
+    speed<TElement extends Element = HTMLElement>(duration: JQuery.Duration, easing: string, complete: (this: TElement) => void): JQuery.EffectsOptions<TElement>;
+    /**
+     * Creates an object containing a set of properties ready to be used in the definition of custom animations.
+     * @param duration A string or number determining how long the animation will run.
+     * @param easing_complete _&#x40;param_ `easing_complete`
+     * <br>
+     * * `easing` — A string indicating which easing function to use for the transition. <br>
+     * * `complete` — A function to call once the animation is complete, called once per matched element.
+     * @see \`{@link https://api.jquery.com/jQuery.speed/ }\`
+     * @since 1.0
+     * @since 1.1
+     */
+    speed<TElement extends Element = HTMLElement>(duration: JQuery.Duration,
+                                                  easing_complete: string | ((this: TElement) => void)): JQuery.EffectsOptions<TElement>;
+    /**
+     * Creates an object containing a set of properties ready to be used in the definition of custom animations.
+     * @param duration_complete_settings _&#x40;param_ `duration_complete_settings`
+     * <br>
+     * * `duration` — A string or number determining how long the animation will run. <br>
+     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
+     * * `settings` —
+     * @see \`{@link https://api.jquery.com/jQuery.speed/ }\`
+     * @since 1.0
+     * @since 1.1
+     */
+    speed<TElement extends Element = HTMLElement>(duration_complete_settings?: JQuery.Duration | ((this: TElement) => void) | JQuery.SpeedSettings<TElement>): JQuery.EffectsOptions<TElement>;
+    /**
+     * Remove the whitespace from the beginning and end of a string.
+     * @param str The string to trim.
+     * @see \`{@link https://api.jquery.com/jQuery.trim/ }\`
+     * @since 1.0
+     * @example ​ ````Remove the white spaces at the start and at the end of the string.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.trim demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<pre id="original"></pre>
+<pre id="trimmed"></pre>
+​
+<script>
+var str = "         lots of spaces before and after         ";
+$( "#original" ).html( "Original String: '" + str + "'" );
+$( "#trimmed" ).html( "$.trim()'ed: '" + $.trim(str) + "'" );
+</script>
+​
+</body>
+</html>
+```
+     * @example ​ ````Remove the white spaces at the start and at the end of the string.
+```javascript
+$.trim("    hello, how are you?    ");
+```
+     * @example ​ ````Remove the white spaces at the start and at the end of the string.
+```javascript
+$.trim("    hello, how are you?    ");
+```
+     */
+    trim(str: string): string;
+    /**
+     * Determine the internal JavaScript [[Class]] of an object.
+     * @param obj Object to get the internal JavaScript [[Class]] of.
+     * @see \`{@link https://api.jquery.com/jQuery.type/ }\`
+     * @since 1.4.3
+     * @deprecated ​ Deprecated since 3.3. See \`{@link https://github.com/jquery/jquery/issues/3605 }\`.
+     * @example ​ ````Find out if the parameter is a RegExp.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.type demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+Is it a RegExp? <b></b>
+​
+<script>
+$( "b" ).append( "" + jQuery.type( /test/ ) );
+</script>
+​
+</body>
+</html>
+```
+     */
+    type(obj: any): 'array' | 'boolean' | 'date' | 'error' | 'function' | 'null' | 'number' | 'object' | 'regexp' | 'string' | 'symbol' | 'undefined';
+    /**
+     * Sorts an array of DOM elements, in place, with the duplicates removed. Note that this only works on arrays of DOM elements, not strings or numbers.
+     * @param array The Array of DOM elements.
+     * @see \`{@link https://api.jquery.com/jQuery.unique/ }\`
+     * @since 1.1.3
+     * @deprecated ​ Deprecated since 3.0. Use \`{@link uniqueSort }\`.
+     *
+     * **Cause**: The fact that `jQuery.unique` sorted its results in DOM order was surprising to many who did not read the documentation carefully. As of jQuery 3.0 this function is being renamed to make it clear.
+     *
+     * **Solution**: Replace all uses of `jQuery.unique` with `jQuery.uniqueSort` which is the same function with a better name.
+     * @example ​ ````Removes any duplicate elements from the array of divs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.unique demo</title>
+  <style>
+  div {
+    color: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>There are 6 divs in this document.</div>
+<div></div>
+<div class="dup"></div>
+<div class="dup"></div>
+<div class="dup"></div>
+<div></div>
+​
+<script>
+// unique() must take a native array
+var divs = $( "div" ).get();
+​
+// Add 3 elements of class dup too (they are divs)
+divs = divs.concat( $( ".dup" ).get() );
+$( "div:eq(1)" ).text( "Pre-unique there are " + divs.length + " elements." );
+​
+divs = jQuery.unique( divs );
+$( "div:eq(2)" ).text( "Post-unique there are " + divs.length + " elements." )
+  .css( "color", "red" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    unique<T extends Element>(array: T[]): T[];
+    /**
+     * Sorts an array of DOM elements, in place, with the duplicates removed. Note that this only works on arrays of DOM elements, not strings or numbers.
+     * @param array The Array of DOM elements.
+     * @see \`{@link https://api.jquery.com/jQuery.uniqueSort/ }\`
+     * @since 1.12
+     * @since 2.2
+     * @example ​ ````Removes any duplicate elements from the array of divs.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.uniqueSort demo</title>
+  <style>
+  div {
+    color: blue;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>There are 6 divs in this document.</div>
+<div></div>
+<div class="dup"></div>
+<div class="dup"></div>
+<div class="dup"></div>
+<div></div>
+​
+<script>
+// unique() must take a native array
+var divs = $( "div" ).get();
+​
+// Add 3 elements of class dup too (they are divs)
+divs = divs.concat( $( ".dup" ).get() );
+$( "div:eq(1)" ).text( "Pre-unique there are " + divs.length + " elements." );
+​
+divs = jQuery.uniqueSort( divs );
+$( "div:eq(2)" ).text( "Post-unique there are " + divs.length + " elements." )
+  .css( "color", "red" );
+</script>
+​
+</body>
+</html>
+```
+     */
+    uniqueSort<T extends Element>(array: T[]): T[];
+    /**
+     * Provides a way to execute callback functions based on zero or more Thenable objects, usually Deferred objects that represent asynchronous events.
+     * @see \`{@link https://api.jquery.com/jQuery.when/ }\`
+     * @since 1.5
+     * @example ​ ````Execute a function after two Ajax requests are successful. (See the jQuery.ajax() documentation for a complete description of success and error cases for an ajax request).
+```javascript
+$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) ).done(function( a1, a2 ) {
+  // a1 and a2 are arguments resolved for the page1 and page2 ajax requests, respectively.
+  // Each argument is an array with the following structure: [ data, statusText, jqXHR ]
+  var data = a1[ 0 ] + a2[ 0 ]; // a1[ 0 ] = "Whip", a2[ 0 ] = " It"
+  if ( /Whip It/.test( data ) ) {
+    alert( "We got what we came for!" );
+  }
+});
+```
+     * @example ​ ````Execute the function myFunc when both ajax requests are successful, or myFailure if either one has an error.
+```javascript
+$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) )
+  .then( myFunc, myFailure );
+```
+     */
+    when<TR1, UR1, VR1,
+        TJ1 = any, UJ1 = any, VJ1 = any>(
+            deferredT: JQuery.Promise<TR1, TJ1> | JQuery.Thenable<TR1> | TR1,
+            deferredU: JQuery.Promise<UR1, UJ1> | JQuery.Thenable<UR1> | UR1,
+            deferredV: JQuery.Promise<VR1, VJ1> | JQuery.Thenable<VR1> | VR1,
+    ): JQuery.Promise3<
+        TR1, TJ1, never,
+        UR1, UJ1, never,
+        VR1, VJ1, never>;
+    /**
+     * Provides a way to execute callback functions based on zero or more Thenable objects, usually Deferred objects that represent asynchronous events.
+     * @see \`{@link https://api.jquery.com/jQuery.when/ }\`
+     * @since 1.5
+     * @example ​ ````Execute a function after two Ajax requests are successful. (See the jQuery.ajax() documentation for a complete description of success and error cases for an ajax request).
+```javascript
+$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) ).done(function( a1, a2 ) {
+  // a1 and a2 are arguments resolved for the page1 and page2 ajax requests, respectively.
+  // Each argument is an array with the following structure: [ data, statusText, jqXHR ]
+  var data = a1[ 0 ] + a2[ 0 ]; // a1[ 0 ] = "Whip", a2[ 0 ] = " It"
+  if ( /Whip It/.test( data ) ) {
+    alert( "We got what we came for!" );
+  }
+});
+```
+     * @example ​ ````Execute the function myFunc when both ajax requests are successful, or myFailure if either one has an error.
+```javascript
+$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) )
+  .then( myFunc, myFailure );
+```
+     */
+    when<TR1, UR1,
+        TJ1 = any, UJ1 = any>(
+            deferredT: JQuery.Promise<TR1, TJ1> | JQuery.Thenable<TR1> | TR1,
+            deferredU: JQuery.Promise<UR1, UJ1> | JQuery.Thenable<UR1> | UR1,
+    ): JQuery.Promise2<
+        TR1, TJ1, never,
+        UR1, UJ1, never>;
+    /**
+     * Provides a way to execute callback functions based on zero or more Thenable objects, usually Deferred objects that represent asynchronous events.
+     * @see \`{@link https://api.jquery.com/jQuery.when/ }\`
+     * @since 1.5
+     * @example ​ ````Execute a function after two Ajax requests are successful. (See the jQuery.ajax() documentation for a complete description of success and error cases for an ajax request).
+```javascript
+$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) ).done(function( a1, a2 ) {
+  // a1 and a2 are arguments resolved for the page1 and page2 ajax requests, respectively.
+  // Each argument is an array with the following structure: [ data, statusText, jqXHR ]
+  var data = a1[ 0 ] + a2[ 0 ]; // a1[ 0 ] = "Whip", a2[ 0 ] = " It"
+  if ( /Whip It/.test( data ) ) {
+    alert( "We got what we came for!" );
+  }
+});
+```
+     * @example ​ ````Execute the function myFunc when both ajax requests are successful, or myFailure if either one has an error.
+```javascript
+$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) )
+  .then( myFunc, myFailure );
+```
+     */
+    when<TR1, TJ1,
+        TR2, TJ2,
+        TR3 = never, TJ3 = never>(
+            deferredT: JQuery.Promise3<TR1, TJ1, any, TR2, TJ2, any, TR3, TJ3, any> |
+                       JQuery.Promise2<TR1, TJ1, any, TR2, TJ2, any>
+    ): JQuery.Promise3<
+        TR1, TJ1, never,
+        TR2, TJ2, never,
+        TR3, TJ3, never>;
+    /**
+     * Provides a way to execute callback functions based on zero or more Thenable objects, usually Deferred objects that represent asynchronous events.
+     * @see \`{@link https://api.jquery.com/jQuery.when/ }\`
+     * @since 1.5
+     * @example ​ ````Execute a function after two Ajax requests are successful. (See the jQuery.ajax() documentation for a complete description of success and error cases for an ajax request).
+```javascript
+$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) ).done(function( a1, a2 ) {
+  // a1 and a2 are arguments resolved for the page1 and page2 ajax requests, respectively.
+  // Each argument is an array with the following structure: [ data, statusText, jqXHR ]
+  var data = a1[ 0 ] + a2[ 0 ]; // a1[ 0 ] = "Whip", a2[ 0 ] = " It"
+  if ( /Whip It/.test( data ) ) {
+    alert( "We got what we came for!" );
+  }
+});
+```
+     * @example ​ ````Execute the function myFunc when both ajax requests are successful, or myFailure if either one has an error.
+```javascript
+$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) )
+  .then( myFunc, myFailure );
+```
+     */
+    when<TR1, TJ1 = any>(deferred: JQuery.Promise<TR1, TJ1> | JQuery.Thenable<TR1> | TR1): JQuery.Promise<TR1, TJ1, never>;
+    /**
+     * Provides a way to execute callback functions based on zero or more Thenable objects, usually Deferred objects that represent asynchronous events.
+     * @param deferreds Zero or more Thenable objects.
+     * @see \`{@link https://api.jquery.com/jQuery.when/ }\`
+     * @since 1.5
+     * @example ​ ````Execute a function after two Ajax requests are successful. (See the jQuery.ajax() documentation for a complete description of success and error cases for an ajax request).
+```javascript
+$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) ).done(function( a1, a2 ) {
+  // a1 and a2 are arguments resolved for the page1 and page2 ajax requests, respectively.
+  // Each argument is an array with the following structure: [ data, statusText, jqXHR ]
+  var data = a1[ 0 ] + a2[ 0 ]; // a1[ 0 ] = "Whip", a2[ 0 ] = " It"
+  if ( /Whip It/.test( data ) ) {
+    alert( "We got what we came for!" );
+  }
+});
+```
+     * @example ​ ````Execute the function myFunc when both ajax requests are successful, or myFailure if either one has an error.
+```javascript
+$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) )
+  .then( myFunc, myFailure );
+```
+     */
+    when<TR1 = never, TJ1 = never>(...deferreds: Array<JQuery.Promise<TR1, TJ1> | JQuery.Thenable<TR1> | TR1>): JQuery.Promise<TR1, TJ1, never>;
+    /**
+     * Provides a way to execute callback functions based on zero or more Thenable objects, usually Deferred objects that represent asynchronous events.
+     * @param deferreds Zero or more Thenable objects.
+     * @see \`{@link https://api.jquery.com/jQuery.when/ }\`
+     * @since 1.5
+     * @example ​ ````Execute a function after two Ajax requests are successful. (See the jQuery.ajax() documentation for a complete description of success and error cases for an ajax request).
+```javascript
+$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) ).done(function( a1, a2 ) {
+  // a1 and a2 are arguments resolved for the page1 and page2 ajax requests, respectively.
+  // Each argument is an array with the following structure: [ data, statusText, jqXHR ]
+  var data = a1[ 0 ] + a2[ 0 ]; // a1[ 0 ] = "Whip", a2[ 0 ] = " It"
+  if ( /Whip It/.test( data ) ) {
+    alert( "We got what we came for!" );
+  }
+});
+```
+     * @example ​ ````Execute the function myFunc when both ajax requests are successful, or myFailure if either one has an error.
+```javascript
+$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) )
+  .then( myFunc, myFailure );
+```
+     */
+    when(...deferreds: any[]): JQuery.Promise<any, any, never>;
+}
diff --git a/types/jquery/dist/jquery.slim.d.ts b/types/jquery/dist/jquery.slim.d.ts
new file mode 100644
index 0000000000..bdd21a7523
--- /dev/null
+++ b/types/jquery/dist/jquery.slim.d.ts
@@ -0,0 +1,3 @@
+/// <reference types="jquery" />
+
+export = jQuery;
diff --git a/types/jquery/index.d.ts b/types/jquery/index.d.ts
index ce7955846b..2d4171320b 100644
--- a/types/jquery/index.d.ts
+++ b/types/jquery/index.d.ts
@@ -25,31475 +25,10 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
-// tslint:disable:jsdoc-format
-// tslint:disable:max-line-length
-// tslint:disable:no-irregular-whitespace
-
 /// <reference types="sizzle" />
+/// <reference path="JQueryStatic.d.ts" />
+/// <reference path="JQuery.d.ts" />
+/// <reference path="misc.d.ts" />
+/// <reference path="legacy.d.ts" />
 
-declare module 'jquery' {
-    export = jQuery;
-}
-
-declare module 'jquery/dist/jquery.slim' {
-    export = jQuery;
-}
-
-declare const jQuery: JQueryStatic;
-declare const $: JQueryStatic;
-
-// Used by JQuery.Event
-type _Event = Event;
-
-interface JQueryStatic {
-    /**
-     * @see \`{@link https://api.jquery.com/jquery.ajax/#jQuery-ajax1 }\`
-     * @deprecated ​ Deprecated. Use \`{@link ajaxSetup }\`.
-     */
-    ajaxSettings: JQuery.AjaxSettings;
-    Callbacks: JQuery.CallbacksStatic;
-    /**
-     * Hook directly into jQuery to override how particular CSS properties are retrieved or set, normalize
-     * CSS property naming, or create custom properties.
-     *
-     * @see \`{@link https://api.jquery.com/jQuery.cssHooks/ }\`
-     * @since 1.4.3
-     */
-    // Set to HTMLElement to minimize breaks but should probably be Element.
-    cssHooks: JQuery.PlainObject<JQuery.CSSHook<HTMLElement>>;
-    /**
-     * An object containing all CSS properties that may be used without a unit. The .css() method uses this
-     * object to see if it may append px to unitless values.
-     *
-     * @see \`{@link https://api.jquery.com/jQuery.cssNumber/ }\`
-     * @since 1.4.3
-     */
-    cssNumber: JQuery.PlainObject<boolean>;
-    Deferred: JQuery.DeferredStatic;
-    easing: JQuery.Easings;
-    Event: JQuery.EventStatic;
-    /**
-     * @see \`{@link https://learn.jquery.com/events/event-extensions/ }\`
-     */
-    event: JQuery.EventExtensions;
-    expr: JQuery.Selectors;
-    // Set to HTMLElement to minimize breaks but should probably be Element.
-    readonly fn: JQuery;
-    fx: JQuery.Effects;
-    /**
-     * A Promise-like object (or "thenable") that resolves when the document is ready.
-     *
-     * @see \`{@link https://api.jquery.com/jQuery.ready/ }\`
-     * @since 1.8
-     * @example ​ ````Listen for document ready using jQuery.when.
-```javascript
-$.when( $.ready ).then(function() {
-  // Document is ready.
-});
-```
-     * @example ​ ````Typical usage involving another promise, using jQuery.when.
-```javascript
-$.when(
-  $.getJSON( "ajax/test.json" ),
-  $.ready
-).done(function( data ) {
-  // Document is ready.
-  // Value of test.json is passed as `data`.
-});
-```
-     */
-    ready: JQuery.Thenable<JQueryStatic>;
-    /**
-     * A collection of properties that represent the presence of different browser features or bugs.
-     * Intended for jQuery's internal use; specific properties may be removed when they are no longer
-     * needed internally to improve page startup performance. For your own project's feature-detection
-     * needs, we strongly recommend the use of an external library such as Modernizr instead of dependency
-     * on properties in jQuery.support.
-     *
-     * @see \`{@link https://api.jquery.com/jQuery.support/ }\`
-     * @since 1.3
-     * @deprecated ​ Deprecated since 1.9. See \`{@link https://api.jquery.com/jQuery.support/ }\`.
-     */
-    support: JQuery.PlainObject;
-    // Set to HTMLElement to minimize breaks but should probably be Element.
-    valHooks: JQuery.PlainObject<JQuery.ValHook<HTMLElement>>;
-    // HACK: This is the factory function returned when importing jQuery without a DOM. Declaring it separately breaks using the type parameter on JQueryStatic.
-    // HACK: The discriminator parameter handles the edge case of passing a Window object to JQueryStatic. It doesn't actually exist on the factory function.
-    (window: Window, discriminator: boolean): JQueryStatic;
-    /**
-     * Creates DOM elements on the fly from the provided string of raw HTML.
-     *
-     * @param html _&#x40;param_ `html`
-     * <br>
-     * * `html (ownerDocument)` — A string of HTML to create on the fly. Note that this parses HTML, not XML. <br>
-     * * `html (attributes)` — A string defining a single, standalone, HTML element (e.g. &lt;div/&gt; or &lt;div&gt;&lt;/div&gt;).
-     * @param ownerDocument_attributes _&#x40;param_ `ownerDocument_attributes`
-     * <br>
-     * * `ownerDocument` — A document in which the new elements will be created. <br>
-     * * `attributes` — An object of attributes, events, and methods to call on the newly-created element.
-     * @see \`{@link https://api.jquery.com/jQuery/ }\`
-     * @since 1.0
-     * @since 1.4
-     * @example ​ ````Create a div element (and all of its contents) dynamically and append it to the body element. Internally, an element is created and its innerHTML property set to the given markup.
-```javascript
-$( "<div><p>Hello</p></div>" ).appendTo( "body" )
-```
-     * @example ​ ````Create some DOM elements.
-```javascript
-$( "<div/>", {
-  "class": "test",
-  text: "Click me!",
-  click: function() {
-    $( this ).toggleClass( "test" );
-  }
-})
-  .appendTo( "body" );
-```
-     */
-    // tslint:disable-next-line:no-unnecessary-generics
-    <TElement extends HTMLElement = HTMLElement>(html: JQuery.htmlString, ownerDocument_attributes?: Document | JQuery.PlainObject): JQuery<TElement>;
-    /**
-     * Accepts a string containing a CSS selector which is then used to match a set of elements.
-     *
-     * @param selector A string containing a selector expression
-     * @param context A DOM Element, Document, or jQuery to use as context
-     * @see \`{@link https://api.jquery.com/jQuery/ }\`
-     * @since 1.0
-     * @example ​ ````Find all p elements that are children of a div element and apply a border to them.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>one</p>
-<div><p>two</p></div>
-<p>three</p>
-​
-<script>
-$( "div > p" ).css( "border", "1px solid gray" );
-</script>
-</body>
-</html>
-```
-     * @example ​ ````Find all inputs of type radio within the first form in the document.
-```javascript
-$( "input:radio", document.forms[ 0 ] );
-```
-     * @example ​ ````Find all div elements within an XML document from an Ajax response.
-```javascript
-$( "div", xml.responseXML );
-```
-​
-     */
-    // tslint:disable-next-line:no-unnecessary-generics
-    <TElement extends Element = HTMLElement>(selector: JQuery.Selector, context?: Element | Document | JQuery): JQuery<TElement>;
-    /**
-     * Return a collection of matched elements either found in the DOM based on passed argument(s) or created
-     * by passing an HTML string.
-     *
-     * @param element A DOM element to wrap in a jQuery object.
-     * @see \`{@link https://api.jquery.com/jQuery/ }\`
-     * @since 1.0
-     * @example ​ ````Set the background color of the page to black.
-```javascript
-$( document.body ).css( "background", "black" );
-```
-     */
-    // Using a unified signature is not possible due to a TypeScript 2.4 bug (DefinitelyTyped#27810)
-    // tslint:disable-next-line:unified-signatures
-    <T extends Element>(element: T): JQuery<T>;
-    /**
-     * Return a collection of matched elements either found in the DOM based on passed argument(s) or created
-     * by passing an HTML string.
-     *
-     * @param elementArray An array containing a set of DOM elements to wrap in a jQuery object.
-     * @see \`{@link https://api.jquery.com/jQuery/ }\`
-     * @since 1.0
-     * @example ​ ````Hide all the input elements within a form.
-```javascript
-$( myForm.elements ).hide();
-```
-     */
-    // Using a unified signature is not possible due to a TypeScript 2.4 bug (DefinitelyTyped#27810)
-    // tslint:disable-next-line:unified-signatures
-    <T extends Element>(elementArray: T[]): JQuery<T>;
-    /**
-     * Return a collection of matched elements either found in the DOM based on passed argument(s) or created
-     * by passing an HTML string.
-     *
-     * @param selection An existing jQuery object to clone.
-     * @see \`{@link https://api.jquery.com/jQuery/ }\`
-     * @since 1.0
-     */
-    <T>(selection: JQuery<T>): JQuery<T>;
-    /**
-     * Binds a function to be executed when the DOM has finished loading.
-     *
-     * @param callback The function to execute when the DOM is ready.
-     * @see \`{@link https://api.jquery.com/jQuery/ }\`
-     * @since 1.0
-     * @example ​ ````Execute the function when the DOM is ready to be used.
-```javascript
-$(function() {
-  // Document is ready
-});
-```
-     * @example ​ ````Use both the shortcut for $(document).ready() and the argument to write failsafe jQuery code using the $ alias, without relying on the global alias.
-```javascript
-jQuery(function( $ ) {
-  // Your code using failsafe $ alias here...
-});
-```
-     */
-    // tslint:disable-next-line:no-unnecessary-generics unified-signatures
-    <TElement = HTMLElement>(callback: ((this: Document, $: JQueryStatic) => void)): JQuery<TElement>;
-    /**
-     * Return a collection of matched elements either found in the DOM based on passed argument(s) or created by passing an HTML string.
-     *
-     * @param object A plain object to wrap in a jQuery object.
-     * @see \`{@link https://api.jquery.com/jQuery/ }\`
-     * @since 1.0
-     */
-    <T extends JQuery.PlainObject>(object: T): JQuery<T>;
-    /**
-     * Returns an empty jQuery set.
-     *
-     * @see \`{@link https://api.jquery.com/jQuery/ }\`
-     * @since 1.4
-     */
-    // tslint:disable-next-line:no-unnecessary-generics
-    <TElement = HTMLElement>(): JQuery<TElement>;
-    /**
-     * Perform an asynchronous HTTP (Ajax) request.
-     *
-     * @param url A string containing the URL to which the request is sent.
-     * @param settings A set of key/value pairs that configure the Ajax request. All settings are optional. A default can
-     *                 be set for any option with $.ajaxSetup(). See jQuery.ajax( settings ) below for a complete list of all settings.
-     * @see \`{@link https://api.jquery.com/jQuery.ajax/ }\`
-     * @since 1.5
-     */
-    ajax(url: string, settings?: JQuery.AjaxSettings): JQuery.jqXHR;
-    /**
-     * Perform an asynchronous HTTP (Ajax) request.
-     *
-     * @param settings A set of key/value pairs that configure the Ajax request. All settings are optional. A default can
-     *                 be set for any option with $.ajaxSetup().
-     * @see \`{@link https://api.jquery.com/jQuery.ajax/ }\`
-     * @since 1.0
-     * @example ​ ````Save some data to the server and notify the user once it&#39;s complete.
-```javascript
-$.ajax({
-  method: "POST",
-  url: "some.php",
-  data: { name: "John", location: "Boston" }
-})
-  .done(function( msg ) {
-    alert( "Data Saved: " + msg );
-  });
-```
-     * @example ​ ````Retrieve the latest version of an HTML page.
-```javascript
-$.ajax({
-  url: "test.html",
-  cache: false
-})
-  .done(function( html ) {
-    $( "#results" ).append( html );
-  });
-```
-     * @example ​ ````Send an xml document as data to the server. By setting the processData
-    option to false, the automatic conversion of data to strings is prevented.
-```javascript
-var xmlDocument = [create xml document];
-var xmlRequest = $.ajax({
-  url: "page.php",
-  processData: false,
-  data: xmlDocument
-});
-​
-xmlRequest.done( handleResponse );
-```
-     * @example ​ ````Send an id as data to the server, save some data to the server, and notify the user once it&#39;s complete. If the request fails, alert the user.
-```javascript
-var menuId = $( "ul.nav" ).first().attr( "id" );
-var request = $.ajax({
-  url: "script.php",
-  method: "POST",
-  data: { id : menuId },
-  dataType: "html"
-});
-​
-request.done(function( msg ) {
-  $( "#log" ).html( msg );
-});
-​
-request.fail(function( jqXHR, textStatus ) {
-  alert( "Request failed: " + textStatus );
-});
-```
-     * @example ​ ````Load and execute a JavaScript file.
-```javascript
-$.ajax({
-  method: "GET",
-  url: "test.js",
-  dataType: "script"
-});
-```
-     */
-    ajax(settings?: JQuery.AjaxSettings): JQuery.jqXHR;
-    /**
-     * Handle custom Ajax options or modify existing options before each request is sent and before they
-     * are processed by $.ajax().
-     *
-     * @param dataTypes An optional string containing one or more space-separated dataTypes
-     * @param handler A handler to set default values for future Ajax requests.
-     * @see \`{@link https://api.jquery.com/jQuery.ajaxPrefilter/ }\`
-     * @since 1.5
-     */
-    ajaxPrefilter(dataTypes: string,
-                  handler: (options: JQuery.AjaxSettings, originalOptions: JQuery.AjaxSettings, jqXHR: JQuery.jqXHR) => string | void): void;
-    /**
-     * Handle custom Ajax options or modify existing options before each request is sent and before they
-     * are processed by $.ajax().
-     *
-     * @param handler A handler to set default values for future Ajax requests.
-     * @see \`{@link https://api.jquery.com/jQuery.ajaxPrefilter/ }\`
-     * @since 1.5
-     */
-    ajaxPrefilter(handler: (options: JQuery.AjaxSettings, originalOptions: JQuery.AjaxSettings, jqXHR: JQuery.jqXHR) => string | void): void;
-    /**
-     * Set default values for future Ajax requests. Its use is not recommended.
-     *
-     * @param options A set of key/value pairs that configure the default Ajax request. All options are optional.
-     * @see \`{@link https://api.jquery.com/jQuery.ajaxSetup/ }\`
-     * @since 1.1
-     * @example ​ ````Sets the defaults for Ajax requests to the url &quot;/xmlhttp/&quot;, disables global handlers and uses POST instead of GET. The following Ajax requests then sends some data without having to set anything else.
-```javascript
-$.ajaxSetup({
-  url: "/xmlhttp/",
-  global: false,
-  type: "POST"
-});
-$.ajax({ data: myData });
-```
-     */
-    ajaxSetup(options: JQuery.AjaxSettings): JQuery.AjaxSettings;
-    /**
-     * 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/ }\`
-     * @since 1.5
-     */
-    ajaxTransport(dataType: string,
-                  handler: (options: JQuery.AjaxSettings, originalOptions: JQuery.AjaxSettings, jqXHR: JQuery.jqXHR) => JQuery.Transport | void): void;
-    /**
-     * @deprecated ​ Deprecated since 3.3. Internal. See \`{@link https://github.com/jquery/jquery/issues/3384 }\`.
-     */
-    camelCase(value: string): string;
-    cleanData(elems: ArrayLike<Element | Document | Window | JQuery.PlainObject>): void;
-    /**
-     * Check to see if a DOM element is a descendant of another DOM element.
-     *
-     * @param container The DOM element that may contain the other element.
-     * @param contained The DOM element that may be contained by (a descendant of) the other element.
-     * @see \`{@link https://api.jquery.com/jQuery.contains/ }\`
-     * @since 1.4
-     * @example ​ ````Check if an element is a descendant of another.
-```javascript
-$.contains( document.documentElement, document.body ); // true
-$.contains( document.body, document.documentElement ); // false
-```
-     */
-    contains(container: Element, contained: Element): boolean;
-    css(elem: Element, name: string): any;
-    /**
-     * Store arbitrary data associated with the specified element. Returns the value that was set.
-     *
-     * @param element The DOM element to associate with the data.
-     * @param key A string naming the piece of data to set.
-     * @param value The new data value; this can be any Javascript type except `undefined`.
-     * @see \`{@link https://api.jquery.com/jQuery.data/ }\`
-     * @since 1.2.3
-     * @example ​ ````Get the data named &quot;blah&quot; stored at for an element.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.data demo</title>
-  <style>
-  div {
-    margin: 5px;
-    background: yellow;
-  }
-  button {
-    margin: 5px;
-    font-size: 14px;
-  }
-  p {
-    margin: 5px;
-    color: blue;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>A div</div>
-<button>Get "blah" from the div</button>
-<button>Set "blah" to "hello"</button>
-<button>Set "blah" to 86</button>
-<button>Remove "blah" from the div</button>
-<p>The "blah" value of this div is <span>?</span></p>
-​
-<script>
-$( "button" ).click( function() {
-  var value,
-    div = $( "div" )[ 0 ];
-  switch ( $( "button" ).index( this ) ) {
-  case 0 :
-    value = jQuery.data( div, "blah" );
-    break;
-  case 1 :
-    jQuery.data( div, "blah", "hello" );
-    value = "Stored!";
-    break;
-  case 2 :
-    jQuery.data( div, "blah", 86 );
-    value = "Stored!";
-    break;
-  case 3 :
-    jQuery.removeData( div, "blah" );
-    value = "Removed!";
-    break;
-  }
-  $( "span" ).text( "" + value );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    data<T extends string | number | boolean | symbol | object | null>(element: Element | Document | Window | JQuery.PlainObject, key: string, value: T): T;
-    /**
-     * Returns value at named data store for the element, as set by `jQuery.data(element, name, value)`, or
-     * the full data store for the element.
-     *
-     * @param element The DOM element to query for the data.
-     * @param key Name of the data stored.
-     * @param value `undefined` is not recognized as a data value. Calls such as `jQuery.data( el, "name", undefined )`
-     *              will return the corresponding data for "name", and is therefore the same as `jQuery.data( el, "name" )`
-     * @see \`{@link https://api.jquery.com/jQuery.data/ }\`
-     * @since 1.2.3
-     */
-    // `unified-signatures` is disabled so that behavior when passing `undefined` to `value` can be documented. Unifying the signatures
-    // results in potential confusion for users from an unexpected parameter.
-    // tslint:disable-next-line:unified-signatures
-    data(element: Element | Document | Window | JQuery.PlainObject, key: string, value: undefined): any;
-    /**
-     * Returns value at named data store for the element, as set by `jQuery.data(element, name, value)`, or
-     * the full data store for the element.
-     *
-     * @param element The DOM element to query for the data.
-     * @param key Name of the data stored.
-     * @see \`{@link https://api.jquery.com/jQuery.data/ }\`
-     * @since 1.2.3
-     * @since 1.4
-     * @example ​ ````Store then retrieve a value from the div element.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.data demo</title>
-  <style>
-  div {
-    color: blue;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>
-  The values stored were
-  <span></span>
-  and
-  <span></span>
-</div>
-​
-<script>
-var div = $( "div" )[ 0 ];
-jQuery.data( div, "test", {
-  first: 16,
-  last: "pizza!"
-});
-$( "span:first" ).text( jQuery.data( div, "test" ).first );
-$( "span:last" ).text( jQuery.data( div, "test" ).last );
-</script>
-​
-</body>
-</html>
-```
-     */
-    data(element: Element | Document | Window | JQuery.PlainObject, key?: string): any;
-    /**
-     * Execute the next function on the queue for the matched element.
-     *
-     * @param element A DOM element from which to remove and execute a queued function.
-     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
-     * @see \`{@link https://api.jquery.com/jQuery.dequeue/ }\`
-     * @since 1.3
-     * @example ​ ````Use jQuery.dequeue() to end a custom queue function which allows the queue to keep going.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.dequeue demo</title>
-  <style>
-  div {
-    margin: 3px;
-    width: 50px;
-    position: absolute;
-    height: 50px;
-    left: 10px;
-    top: 30px;
-    background-color: yellow;
-  }
-  div.red {
-    background-color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Start</button>
-<div></div>
-​
-<script>
-$( "button" ).click(function() {
-  $( "div" )
-    .animate({ left: '+=200px' }, 2000 )
-    .animate({ top: '0px' }, 600 )
-    .queue(function() {
-      $( this ).toggleClass( "red" );
-      $.dequeue( this );
-    })
-    .animate({ left:'10px', top:'30px' }, 700 );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    dequeue(element: Element, queueName?: string): void;
-    /**
-     * A generic iterator function, which can be used to seamlessly iterate over both objects and arrays.
-     * Arrays and array-like objects with a length property (such as a function's arguments object) are
-     * iterated by numeric index, from 0 to length-1. Other objects are iterated via their named properties.
-     *
-     * @param array The array to iterate over.
-     * @param callback The function that will be executed on every object.
-     * @see \`{@link https://api.jquery.com/jQuery.each/ }\`
-     * @since 1.0
-     * @example ​ ````Iterates through the array displaying each number as both a word and numeral
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.each demo</title>
-  <style>
-  div {
-    color: blue;
-  }
-  div#five {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="one"></div>
-<div id="two"></div>
-<div id="three"></div>
-<div id="four"></div>
-<div id="five"></div>
-​
-<script>
-var arr = [ "one", "two", "three", "four", "five" ];
-var obj = { one: 1, two: 2, three: 3, four: 4, five: 5 };
-​
-jQuery.each( arr, function( i, val ) {
-  $( "#" + val ).text( "Mine is " + val + "." );
-​
-  // Will stop running after "three"
-  return ( val !== "three" );
-});
-​
-jQuery.each( obj, function( i, val ) {
-  $( "#" + i ).append( document.createTextNode( " - " + val ) );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Iterates over items in an array, accessing both the current item and its index.
-```javascript
-$.each( [ "a", "b", "c" ], function( i, l ){
-  alert( "Index #" + i + ": " + l );
-});
-```
-     */
-    each<T>(array: ArrayLike<T>, callback: (this: T, indexInArray: number, value: T) => false | any): ArrayLike<T>;
-    /**
-     * A generic iterator function, which can be used to seamlessly iterate over both objects and arrays.
-     * Arrays and array-like objects with a length property (such as a function's arguments object) are
-     * iterated by numeric index, from 0 to length-1. Other objects are iterated via their named properties.
-     *
-     * @param obj The object to iterate over.
-     * @param callback The function that will be executed on every object.
-     * @see \`{@link https://api.jquery.com/jQuery.each/ }\`
-     * @since 1.0
-     * @example ​ ````Iterates through the array displaying each number as both a word and numeral
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.each demo</title>
-  <style>
-  div {
-    color: blue;
-  }
-  div#five {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="one"></div>
-<div id="two"></div>
-<div id="three"></div>
-<div id="four"></div>
-<div id="five"></div>
-​
-<script>
-var arr = [ "one", "two", "three", "four", "five" ];
-var obj = { one: 1, two: 2, three: 3, four: 4, five: 5 };
-​
-jQuery.each( arr, function( i, val ) {
-  $( "#" + val ).text( "Mine is " + val + "." );
-​
-  // Will stop running after "three"
-  return ( val !== "three" );
-});
-​
-jQuery.each( obj, function( i, val ) {
-  $( "#" + i ).append( document.createTextNode( " - " + val ) );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Iterates over the properties in an object, accessing both the current item and its key.
-```javascript
-$.each({ name: "John", lang: "JS" }, function( k, v ) {
-  alert( "Key: " + k + ", Value: " + v );
-});
-```
-     */
-    each<T, K extends keyof T>(obj: T, callback: (this: T[K], propertyName: K, valueOfProperty: T[K]) => false | any): T;
-    /**
-     * Takes a string and throws an exception containing it.
-     *
-     * @param message The message to send out.
-     * @see \`{@link https://api.jquery.com/jQuery.error/ }\`
-     * @since 1.4.1
-     * @example ​ ````Override jQuery.error for display in Firebug.
-```javascript
-jQuery.error = console.error;
-```
-     */
-    error(message: string): any;
-    /**
-     * Escapes any character that has a special meaning in a CSS selector.
-     *
-     * @param selector A string containing a selector expression to escape.
-     * @see \`{@link https://api.jquery.com/jQuery.escapeSelector/ }\`
-     * @since 3.0
-     * @example ​ ````Escape an ID containing a hash.
-```javascript
-$.escapeSelector( "#target" ); // "\#target"
-```
-     * @example ​ ````Select all the elements having a class name of .box inside a div.
-```javascript
-$( "div" ).find( "." + $.escapeSelector( ".box" ) );
-```
-     */
-    escapeSelector(selector: JQuery.Selector): JQuery.Selector;
-    /**
-     * Merge the contents of two or more objects together into the first object.
-     *
-     * @param deep If true, the merge becomes recursive (aka. deep copy). Passing false for this argument is not supported.
-     * @param target The object to extend. It will receive the new properties.
-     * @param object1 An object containing additional properties to merge in.
-     * @param object2 An object containing additional properties to merge in.
-     * @param object3 An object containing additional properties to merge in.
-     * @param object4 An object containing additional properties to merge in.
-     * @param object5 An object containing additional properties to merge in.
-     * @param object6 An object containing additional properties to merge in.
-     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
-     * @since 1.1.4
-     * @example ​ ````Merge two objects recursively, modifying the first.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var object1 = {
-  apple: 0,
-  banana: { weight: 52, price: 100 },
-  cherry: 97
-};
-var object2 = {
-  banana: { price: 200 },
-  durian: 100
-};
-​
-// Merge object2 into object1, recursively
-$.extend( true, object1, object2 );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( JSON.stringify( object1 ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    extend<T, U, V, W, X, Y, Z>(deep: true, target: T, object1: U, object2: V, object3: W, object4: X, object5: Y, object6: Z): T & U & V & W & X & Y & Z;
-    /**
-     * Merge the contents of two or more objects together into the first object.
-     *
-     * @param deep If true, the merge becomes recursive (aka. deep copy). Passing false for this argument is not supported.
-     * @param target The object to extend. It will receive the new properties.
-     * @param object1 An object containing additional properties to merge in.
-     * @param object2 An object containing additional properties to merge in.
-     * @param object3 An object containing additional properties to merge in.
-     * @param object4 An object containing additional properties to merge in.
-     * @param object5 An object containing additional properties to merge in.
-     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
-     * @since 1.1.4
-     * @example ​ ````Merge two objects recursively, modifying the first.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var object1 = {
-  apple: 0,
-  banana: { weight: 52, price: 100 },
-  cherry: 97
-};
-var object2 = {
-  banana: { price: 200 },
-  durian: 100
-};
-​
-// Merge object2 into object1, recursively
-$.extend( true, object1, object2 );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( JSON.stringify( object1 ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    extend<T, U, V, W, X, Y>(deep: true, target: T, object1: U, object2: V, object3: W, object4: X, object5: Y): T & U & V & W & X & Y;
-    /**
-     * Merge the contents of two or more objects together into the first object.
-     *
-     * @param deep If true, the merge becomes recursive (aka. deep copy). Passing false for this argument is not supported.
-     * @param target The object to extend. It will receive the new properties.
-     * @param object1 An object containing additional properties to merge in.
-     * @param object2 An object containing additional properties to merge in.
-     * @param object3 An object containing additional properties to merge in.
-     * @param object4 An object containing additional properties to merge in.
-     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
-     * @since 1.1.4
-     * @example ​ ````Merge two objects recursively, modifying the first.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var object1 = {
-  apple: 0,
-  banana: { weight: 52, price: 100 },
-  cherry: 97
-};
-var object2 = {
-  banana: { price: 200 },
-  durian: 100
-};
-​
-// Merge object2 into object1, recursively
-$.extend( true, object1, object2 );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( JSON.stringify( object1 ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    extend<T, U, V, W, X>(deep: true, target: T, object1: U, object2: V, object3: W, object4: X): T & U & V & W & X;
-    /**
-     * Merge the contents of two or more objects together into the first object.
-     *
-     * @param deep If true, the merge becomes recursive (aka. deep copy). Passing false for this argument is not supported.
-     * @param target The object to extend. It will receive the new properties.
-     * @param object1 An object containing additional properties to merge in.
-     * @param object2 An object containing additional properties to merge in.
-     * @param object3 An object containing additional properties to merge in.
-     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
-     * @since 1.1.4
-     * @example ​ ````Merge two objects recursively, modifying the first.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var object1 = {
-  apple: 0,
-  banana: { weight: 52, price: 100 },
-  cherry: 97
-};
-var object2 = {
-  banana: { price: 200 },
-  durian: 100
-};
-​
-// Merge object2 into object1, recursively
-$.extend( true, object1, object2 );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( JSON.stringify( object1 ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    extend<T, U, V, W>(deep: true, target: T, object1: U, object2: V, object3: W): T & U & V & W;
-    /**
-     * Merge the contents of two or more objects together into the first object.
-     *
-     * @param deep If true, the merge becomes recursive (aka. deep copy). Passing false for this argument is not supported.
-     * @param target The object to extend. It will receive the new properties.
-     * @param object1 An object containing additional properties to merge in.
-     * @param object2 An object containing additional properties to merge in.
-     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
-     * @since 1.1.4
-     * @example ​ ````Merge two objects recursively, modifying the first.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var object1 = {
-  apple: 0,
-  banana: { weight: 52, price: 100 },
-  cherry: 97
-};
-var object2 = {
-  banana: { price: 200 },
-  durian: 100
-};
-​
-// Merge object2 into object1, recursively
-$.extend( true, object1, object2 );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( JSON.stringify( object1 ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    extend<T, U, V>(deep: true, target: T, object1: U, object2: V): T & U & V;
-    /**
-     * Merge the contents of two or more objects together into the first object.
-     *
-     * @param deep If true, the merge becomes recursive (aka. deep copy). Passing false for this argument is not supported.
-     * @param target The object to extend. It will receive the new properties.
-     * @param object1 An object containing additional properties to merge in.
-     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
-     * @since 1.1.4
-     * @example ​ ````Merge two objects recursively, modifying the first.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var object1 = {
-  apple: 0,
-  banana: { weight: 52, price: 100 },
-  cherry: 97
-};
-var object2 = {
-  banana: { price: 200 },
-  durian: 100
-};
-​
-// Merge object2 into object1, recursively
-$.extend( true, object1, object2 );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( JSON.stringify( object1 ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    extend<T, U>(deep: true, target: T, object1: U): T & U;
-    /**
-     * Merge the contents of two or more objects together into the first object.
-     *
-     * @param deep If true, the merge becomes recursive (aka. deep copy). Passing false for this argument is not supported.
-     * @param target The object to extend. It will receive the new properties.
-     * @param object1 An object containing additional properties to merge in.
-     * @param objectN Additional objects containing properties to merge in.
-     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
-     * @since 1.1.4
-     * @example ​ ````Merge two objects recursively, modifying the first.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var object1 = {
-  apple: 0,
-  banana: { weight: 52, price: 100 },
-  cherry: 97
-};
-var object2 = {
-  banana: { price: 200 },
-  durian: 100
-};
-​
-// Merge object2 into object1, recursively
-$.extend( true, object1, object2 );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( JSON.stringify( object1 ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    extend(deep: true, target: any, object1: any, ...objectN: any[]): any;
-    /**
-     * Merge the contents of two or more objects together into the first object.
-     *
-     * @param target An object that will receive the new properties if additional objects are passed in or that will
-     *               extend the jQuery namespace if it is the sole argument.
-     * @param object1 An object containing additional properties to merge in.
-     * @param object2 An object containing additional properties to merge in.
-     * @param object3 An object containing additional properties to merge in.
-     * @param object4 An object containing additional properties to merge in.
-     * @param object5 An object containing additional properties to merge in.
-     * @param object6 An object containing additional properties to merge in.
-     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
-     * @since 1.0
-     * @example ​ ````Merge two objects, modifying the first.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var object1 = {
-  apple: 0,
-  banana: { weight: 52, price: 100 },
-  cherry: 97
-};
-var object2 = {
-  banana: { price: 200 },
-  durian: 100
-};
-​
-// Merge object2 into object1
-$.extend( object1, object2 );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( JSON.stringify( object1 ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Merge defaults and options, without modifying the defaults. This is a common plugin development pattern.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var defaults = { validate: false, limit: 5, name: "foo" };
-var options = { validate: true, name: "bar" };
-​
-// Merge defaults and options, without modifying defaults
-var settings = $.extend( {}, defaults, options );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( "<div><b>defaults -- </b>" + JSON.stringify( defaults ) + "</div>" );
-$( "#log" ).append( "<div><b>options -- </b>" + JSON.stringify( options ) + "</div>" );
-$( "#log" ).append( "<div><b>settings -- </b>" + JSON.stringify( settings ) + "</div>" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    extend<T, U, V, W, X, Y, Z>(target: T, object1: U, object2: V, object3: W, object4: X, object5: Y, object6: Z): T & U & V & W & X & Y & Z;
-    /**
-     * Merge the contents of two or more objects together into the first object.
-     *
-     * @param target An object that will receive the new properties if additional objects are passed in or that will
-     *               extend the jQuery namespace if it is the sole argument.
-     * @param object1 An object containing additional properties to merge in.
-     * @param object2 An object containing additional properties to merge in.
-     * @param object3 An object containing additional properties to merge in.
-     * @param object4 An object containing additional properties to merge in.
-     * @param object5 An object containing additional properties to merge in.
-     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
-     * @since 1.0
-     * @example ​ ````Merge two objects, modifying the first.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var object1 = {
-  apple: 0,
-  banana: { weight: 52, price: 100 },
-  cherry: 97
-};
-var object2 = {
-  banana: { price: 200 },
-  durian: 100
-};
-​
-// Merge object2 into object1
-$.extend( object1, object2 );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( JSON.stringify( object1 ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Merge defaults and options, without modifying the defaults. This is a common plugin development pattern.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var defaults = { validate: false, limit: 5, name: "foo" };
-var options = { validate: true, name: "bar" };
-​
-// Merge defaults and options, without modifying defaults
-var settings = $.extend( {}, defaults, options );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( "<div><b>defaults -- </b>" + JSON.stringify( defaults ) + "</div>" );
-$( "#log" ).append( "<div><b>options -- </b>" + JSON.stringify( options ) + "</div>" );
-$( "#log" ).append( "<div><b>settings -- </b>" + JSON.stringify( settings ) + "</div>" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    extend<T, U, V, W, X, Y>(target: T, object1: U, object2: V, object3: W, object4: X, object5: Y): T & U & V & W & X & Y;
-    /**
-     * Merge the contents of two or more objects together into the first object.
-     *
-     * @param target An object that will receive the new properties if additional objects are passed in or that will
-     *               extend the jQuery namespace if it is the sole argument.
-     * @param object1 An object containing additional properties to merge in.
-     * @param object2 An object containing additional properties to merge in.
-     * @param object3 An object containing additional properties to merge in.
-     * @param object4 An object containing additional properties to merge in.
-     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
-     * @since 1.0
-     * @example ​ ````Merge two objects, modifying the first.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var object1 = {
-  apple: 0,
-  banana: { weight: 52, price: 100 },
-  cherry: 97
-};
-var object2 = {
-  banana: { price: 200 },
-  durian: 100
-};
-​
-// Merge object2 into object1
-$.extend( object1, object2 );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( JSON.stringify( object1 ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Merge defaults and options, without modifying the defaults. This is a common plugin development pattern.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var defaults = { validate: false, limit: 5, name: "foo" };
-var options = { validate: true, name: "bar" };
-​
-// Merge defaults and options, without modifying defaults
-var settings = $.extend( {}, defaults, options );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( "<div><b>defaults -- </b>" + JSON.stringify( defaults ) + "</div>" );
-$( "#log" ).append( "<div><b>options -- </b>" + JSON.stringify( options ) + "</div>" );
-$( "#log" ).append( "<div><b>settings -- </b>" + JSON.stringify( settings ) + "</div>" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    extend<T, U, V, W, X>(target: T, object1: U, object2: V, object3: W, object4: X): T & U & V & W & X;
-    /**
-     * Merge the contents of two or more objects together into the first object.
-     *
-     * @param target An object that will receive the new properties if additional objects are passed in or that will
-     *               extend the jQuery namespace if it is the sole argument.
-     * @param object1 An object containing additional properties to merge in.
-     * @param object2 An object containing additional properties to merge in.
-     * @param object3 An object containing additional properties to merge in.
-     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
-     * @since 1.0
-     * @example ​ ````Merge two objects, modifying the first.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var object1 = {
-  apple: 0,
-  banana: { weight: 52, price: 100 },
-  cherry: 97
-};
-var object2 = {
-  banana: { price: 200 },
-  durian: 100
-};
-​
-// Merge object2 into object1
-$.extend( object1, object2 );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( JSON.stringify( object1 ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Merge defaults and options, without modifying the defaults. This is a common plugin development pattern.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var defaults = { validate: false, limit: 5, name: "foo" };
-var options = { validate: true, name: "bar" };
-​
-// Merge defaults and options, without modifying defaults
-var settings = $.extend( {}, defaults, options );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( "<div><b>defaults -- </b>" + JSON.stringify( defaults ) + "</div>" );
-$( "#log" ).append( "<div><b>options -- </b>" + JSON.stringify( options ) + "</div>" );
-$( "#log" ).append( "<div><b>settings -- </b>" + JSON.stringify( settings ) + "</div>" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    extend<T, U, V, W>(target: T, object1: U, object2: V, object3: W): T & U & V & W;
-    /**
-     * Merge the contents of two or more objects together into the first object.
-     *
-     * @param target An object that will receive the new properties if additional objects are passed in or that will
-     *               extend the jQuery namespace if it is the sole argument.
-     * @param object1 An object containing additional properties to merge in.
-     * @param object2 An object containing additional properties to merge in.
-     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
-     * @since 1.0
-     * @example ​ ````Merge two objects, modifying the first.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var object1 = {
-  apple: 0,
-  banana: { weight: 52, price: 100 },
-  cherry: 97
-};
-var object2 = {
-  banana: { price: 200 },
-  durian: 100
-};
-​
-// Merge object2 into object1
-$.extend( object1, object2 );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( JSON.stringify( object1 ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Merge defaults and options, without modifying the defaults. This is a common plugin development pattern.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var defaults = { validate: false, limit: 5, name: "foo" };
-var options = { validate: true, name: "bar" };
-​
-// Merge defaults and options, without modifying defaults
-var settings = $.extend( {}, defaults, options );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( "<div><b>defaults -- </b>" + JSON.stringify( defaults ) + "</div>" );
-$( "#log" ).append( "<div><b>options -- </b>" + JSON.stringify( options ) + "</div>" );
-$( "#log" ).append( "<div><b>settings -- </b>" + JSON.stringify( settings ) + "</div>" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    extend<T, U, V>(target: T, object1: U, object2: V): T & U & V;
-    /**
-     * Merge the contents of two or more objects together into the first object.
-     *
-     * @param target An object that will receive the new properties if additional objects are passed in or that will
-     *               extend the jQuery namespace if it is the sole argument.
-     * @param object1 An object containing additional properties to merge in.
-     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
-     * @since 1.0
-     * @example ​ ````Merge two objects, modifying the first.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var object1 = {
-  apple: 0,
-  banana: { weight: 52, price: 100 },
-  cherry: 97
-};
-var object2 = {
-  banana: { price: 200 },
-  durian: 100
-};
-​
-// Merge object2 into object1
-$.extend( object1, object2 );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( JSON.stringify( object1 ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Merge defaults and options, without modifying the defaults. This is a common plugin development pattern.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var defaults = { validate: false, limit: 5, name: "foo" };
-var options = { validate: true, name: "bar" };
-​
-// Merge defaults and options, without modifying defaults
-var settings = $.extend( {}, defaults, options );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( "<div><b>defaults -- </b>" + JSON.stringify( defaults ) + "</div>" );
-$( "#log" ).append( "<div><b>options -- </b>" + JSON.stringify( options ) + "</div>" );
-$( "#log" ).append( "<div><b>settings -- </b>" + JSON.stringify( settings ) + "</div>" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    extend<T, U>(target: T, object1: U): T & U;
-    /**
-     * Merge the contents of two or more objects together into the first object.
-     *
-     * @param target An object that will receive the new properties if additional objects are passed in or that will
-     *               extend the jQuery namespace if it is the sole argument.
-     * @param object1 An object containing additional properties to merge in.
-     * @param objectN Additional objects containing properties to merge in.
-     * @see \`{@link https://api.jquery.com/jQuery.extend/ }\`
-     * @since 1.0
-     * @example ​ ````Merge two objects, modifying the first.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var object1 = {
-  apple: 0,
-  banana: { weight: 52, price: 100 },
-  cherry: 97
-};
-var object2 = {
-  banana: { price: 200 },
-  durian: 100
-};
-​
-// Merge object2 into object1
-$.extend( object1, object2 );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( JSON.stringify( object1 ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Merge defaults and options, without modifying the defaults. This is a common plugin development pattern.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.extend demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-var defaults = { validate: false, limit: 5, name: "foo" };
-var options = { validate: true, name: "bar" };
-​
-// Merge defaults and options, without modifying defaults
-var settings = $.extend( {}, defaults, options );
-​
-// Assuming JSON.stringify - not available in IE<8
-$( "#log" ).append( "<div><b>defaults -- </b>" + JSON.stringify( defaults ) + "</div>" );
-$( "#log" ).append( "<div><b>options -- </b>" + JSON.stringify( options ) + "</div>" );
-$( "#log" ).append( "<div><b>settings -- </b>" + JSON.stringify( settings ) + "</div>" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    extend(target: any, object1: any, ...objectN: any[]): any;
-    /**
-     * Load data from the server using a HTTP GET request.
-     *
-     * @param url A string containing the URL to which the request is sent.
-     * @param data A plain object or string that is sent to the server with the request.
-     * @param success A callback function that is executed if the request succeeds. Required if `dataType` is provided,
-     *                but you can use `null` or \`{@link noop jQuery.noop}\` as a placeholder.
-     * @param dataType The type of data expected from the server. Default: Intelligent Guess (xml, json, script, text, html).
-     * @see \`{@link https://api.jquery.com/jQuery.get/ }\`
-     * @since 1.0
-     */
-    get(url: string,
-        data: JQuery.PlainObject | string,
-        success: JQuery.jqXHR.DoneCallback | null,
-        dataType?: string): JQuery.jqXHR;
-    /**
-     * Load data from the server using a HTTP GET request.
-     *
-     * @param url A string containing the URL to which the request is sent.
-     * @param success A callback function that is executed if the request succeeds. Required if `dataType` is provided,
-     *                but you can use `null` or \`{@link noop jQuery.noop}\` as a placeholder.
-     * @param dataType The type of data expected from the server. Default: Intelligent Guess (xml, json, script, text, html).
-     * @see \`{@link https://api.jquery.com/jQuery.get/ }\`
-     * @since 1.0
-     * @example ​ ````Get the test.php page contents, which has been returned in json format (&lt;?php echo json_encode( array( &quot;name&quot;=&gt;&quot;John&quot;,&quot;time&quot;=&gt;&quot;2pm&quot; ) ); ?&gt;), and add it to the page.
-```javascript
-$.get( "test.php", function( data ) {
-  $( "body" )
-    .append( "Name: " + data.name ) // John
-    .append( "Time: " + data.time ); //  2pm
-}, "json" );
-```
-     */
-    get(url: string,
-        success: JQuery.jqXHR.DoneCallback | null,
-        dataType: string): JQuery.jqXHR;
-    /**
-     * Load data from the server using a HTTP GET request.
-     *
-     * @param url A string containing the URL to which the request is sent.
-     * @param success_data _&#x40;param_ `success_data`
-     * <br>
-     * * `success` — A callback function that is executed if the request succeeds. Required if `dataType` is provided,
-     *               but you can use `null` or \`{@link noop jQuery.noop}\` as a placeholder. <br>
-     * * `data` — A plain object or string that is sent to the server with the request.
-     * @see \`{@link https://api.jquery.com/jQuery.get/ }\`
-     * @since 1.0
-     * @example ​ ````Request the test.php page and send some additional data along (while still ignoring the return results).
-```javascript
-$.get( "test.php", { name: "John", time: "2pm" } );
-```
-     * @example ​ ````Pass arrays of data to the server (while still ignoring the return results).
-```javascript
-$.get( "test.php", { "choices[]": ["Jon", "Susan"] } );
-```
-     * @example ​ ````Alert the results from requesting test.php (HTML or XML, depending on what was returned).
-```javascript
-$.get( "test.php", function( data ) {
-  alert( "Data Loaded: " + data );
-});
-```
-     * @example ​ ````Alert the results from requesting test.cgi with an additional payload of data (HTML or XML, depending on what was returned).
-```javascript
-$.get( "test.cgi", { name: "John", time: "2pm" } )
-  .done(function( data ) {
-    alert( "Data Loaded: " + data );
-  });
-```
-     */
-    get(url: string,
-        success_data: JQuery.jqXHR.DoneCallback | JQuery.PlainObject | string): JQuery.jqXHR;
-    /**
-     * Load data from the server using a HTTP GET request.
-     *
-     * @param url_settings _&#x40;param_ `url_settings`
-     * <br>
-     * * `url` — A string containing the URL to which the request is sent. <br>
-     * * `settings` — A set of key/value pairs that configure the Ajax request. All properties except for `url` are
-     *                optional. A default can be set for any option with \`{@link ajaxSetup $.ajaxSetup()}\`. See \`{@link https://api.jquery.com/jquery.ajax/#jQuery-ajax-settings jQuery.ajax( settings )}\`
-     *                for a complete list of all settings. The type option will automatically be set to `GET`.
-     * @see \`{@link https://api.jquery.com/jQuery.get/ }\`
-     * @since 1.0
-     * @since 1.12
-     * @since 2.2
-     * @example ​ ````Request the test.php page, but ignore the return results.
-```javascript
-$.get( "test.php" );
-```
-     */
-    get(url_settings?: string | JQuery.UrlAjaxSettings): JQuery.jqXHR;
-    /**
-     * Load JSON-encoded data from the server using a GET HTTP request.
-     *
-     * @param url A string containing the URL to which the request is sent.
-     * @param data A plain object or string that is sent to the server with the request.
-     * @param success A callback function that is executed if the request succeeds.
-     * @see \`{@link https://api.jquery.com/jQuery.getJSON/ }\`
-     * @since 1.0
-     */
-    getJSON(url: string,
-            data: JQuery.PlainObject | string,
-            success: JQuery.jqXHR.DoneCallback): JQuery.jqXHR;
-    /**
-     * Load JSON-encoded data from the server using a GET HTTP request.
-     *
-     * @param url A string containing the URL to which the request is sent.
-     * @param success_data _&#x40;param_ `url_settings`
-     * <br>
-     * * `success` — A callback function that is executed if the request succeeds. <br>
-     * * `data` — A plain object or string that is sent to the server with the request.
-     * @see \`{@link https://api.jquery.com/jQuery.getJSON/ }\`
-     * @since 1.0
-     * @example ​ ````Loads the four most recent pictures of Mount Rainier from the Flickr JSONP API.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.getJSON demo</title>
-  <style>
-  img {
-    height: 100px;
-    float: left;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="images"></div>
-​
-<script>
-(function() {
-  var flickerAPI = "https://api.flickr.com/services/feeds/photos_public.gne?jsoncallback=?";
-  $.getJSON( flickerAPI, {
-    tags: "mount rainier",
-    tagmode: "any",
-    format: "json"
-  })
-    .done(function( data ) {
-      $.each( data.items, function( i, item ) {
-        $( "<img>" ).attr( "src", item.media.m ).appendTo( "#images" );
-        if ( i === 3 ) {
-          return false;
-        }
-      });
-    });
-})();
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Load the JSON data from test.js and access a name from the returned JSON data.
-```javascript
-$.getJSON( "test.js", function( json ) {
-  console.log( "JSON Data: " + json.users[ 3 ].name );
- });
- ```
-     * @example ​ ````Load the JSON data from test.js, passing along additional data, and access a name from the returned JSON data.
-      If an error occurs, log an error message instead.
-```javascript
-$.getJSON( "test.js", { name: "John", time: "2pm" } )
-  .done(function( json ) {
-    console.log( "JSON Data: " + json.users[ 3 ].name );
-  })
-  .fail(function( jqxhr, textStatus, error ) {
-    var err = textStatus + ", " + error;
-    console.log( "Request Failed: " + err );
-});
-```
-     */
-    getJSON(url: string,
-            success_data?: JQuery.jqXHR.DoneCallback | JQuery.PlainObject | string): JQuery.jqXHR;
-    /**
-     * Load a JavaScript file from the server using a GET HTTP request, then execute it.
-     *
-     * @param url A string containing the URL to which the request is sent.
-     * @param success A callback function that is executed if the request succeeds.
-     * @see \`{@link https://api.jquery.com/jQuery.getScript/ }\`
-     * @since 1.0
-     * @example ​ ````Define a $.cachedScript() method that allows fetching a cached script:
-```javascript
-jQuery.cachedScript = function( url, options ) {
-​
-  // Allow user to set any option except for dataType, cache, and url
-  options = $.extend( options || {}, {
-    dataType: "script",
-    cache: true,
-    url: url
-  });
-​
-  // Use $.ajax() since it is more flexible than $.getScript
-  // Return the jqXHR object so we can chain callbacks
-  return jQuery.ajax( options );
-};
-​
-// Usage
-$.cachedScript( "ajax/test.js" ).done(function( script, textStatus ) {
-  console.log( textStatus );
-});
-```
-     * @example ​ ````Load the official jQuery Color Animation plugin dynamically and bind some color animations to occur once the new functionality is loaded.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.getScript demo</title>
-  <style>
-  .block {
-     background-color: blue;
-     width: 150px;
-     height: 70px;
-     margin: 10px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="go">&raquo; Run</button>
-<div class="block"></div>
-​
-<script>
-var url = "https://code.jquery.com/color/jquery.color.js";
-$.getScript( url, function() {
-  $( "#go" ).click(function() {
-    $( ".block" )
-      .animate({
-        backgroundColor: "rgb(255, 180, 180)"
-      }, 1000 )
-      .delay( 500 )
-      .animate({
-        backgroundColor: "olive"
-      }, 1000 )
-      .delay( 500 )
-      .animate({
-        backgroundColor: "#00f"
-      }, 1000 );
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    getScript(url: string,
-              success?: JQuery.jqXHR.DoneCallback<string | undefined>): JQuery.jqXHR<string | undefined>;
-    /**
-     * Load a JavaScript file from the server using a GET HTTP request, then execute it.
-     *
-     * @see \`{@link https://api.jquery.com/jQuery.getScript/ }\`
-     * @since 1.12
-     * @since 2.2
-     */
-    getScript(options: JQuery.UrlAjaxSettings): JQuery.jqXHR<string | undefined>;
-    /**
-     * Execute some JavaScript code globally.
-     *
-     * @param code The JavaScript code to execute.
-     * @see \`{@link https://api.jquery.com/jQuery.globalEval/ }\`
-     * @since 1.0.4
-     * @example ​ ````Execute a script in the global context.
-```javascript
-function test() {
-  jQuery.globalEval( "var newVar = true;" )
-}
-test();
-// newVar === true
-```
-     */
-    globalEval(code: string): void;
-    /**
-     * Finds the elements of an array which satisfy a filter function. The original array is not affected.
-     *
-     * @param array The array-like object to search through.
-     * @param fn The function to process each item against. The first argument to the function is the item, and the
-     *           second argument is the index. The function should return a Boolean value. this will be the global window object.
-     * @param invert If "invert" is false, or not provided, then the function returns an array consisting of all elements
-     *               for which "callback" returns true. If "invert" is true, then the function returns an array
-     *               consisting of all elements for which "callback" returns false.
-     * @see \`{@link https://api.jquery.com/jQuery.grep/ }\`
-     * @since 1.0
-     * @example ​ ````Filters the original array of numbers leaving that are not 5 and have an index greater than 4.  Then it removes all 9s.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.grep demo</title>
-  <style>
-  div {
-    color: blue;
-  }
-  p {
-    color: green;
-    margin: 0;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div></div>
-<p></p>
-<span></span>
-​
-<script>
-var arr = [ 1, 9, 3, 8, 6, 1, 5, 9, 4, 7, 3, 8, 6, 9, 1 ];
-$( "div" ).text( arr.join( ", " ) );
-​
-arr = jQuery.grep(arr, function( n, i ) {
-  return ( n !== 5 && i > 4 );
-});
-$( "p" ).text( arr.join( ", " ) );
-​
-arr = jQuery.grep(arr, function( a ) {
-  return a !== 9;
-});
-​
-$( "span" ).text( arr.join( ", " ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Filter an array of numbers to include only numbers bigger then zero.
-```javascript
-$.grep( [ 0, 1, 2 ], function( n, i ) {
-  return n > 0;
-});
-```
-     * @example ​ ````Filter an array of numbers to include numbers that are not bigger than zero.
-```javascript
-$.grep( [ 0, 1, 2 ], function( n, i ) {
-    return n > 0;
-}, true );
-```
-     */
-    grep<T>(array: ArrayLike<T>,
-            fn: (elementOfArray: T, indexInArray: number) => boolean,
-            invert?: boolean): T[];
-    /**
-     * Determine whether an element has any jQuery data associated with it.
-     *
-     * @param element A DOM element to be checked for data.
-     * @see \`{@link https://api.jquery.com/jQuery.hasData/ }\`
-     * @since 1.5
-     * @example ​ ````Set data on an element and see the results of hasData.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.hasData demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Results: </p>
-​
-<script>
-var $p = jQuery( "p" ), p = $p[ 0 ];
-$p.append( jQuery.hasData( p ) + " " ); // false
-​
-$.data( p, "testing", 123 );
-$p.append( jQuery.hasData( p ) + " " ); // true
-​
-$.removeData( p, "testing" );
-$p.append( jQuery.hasData( p ) + " " ); // false
-​
-$p.on( "click", function() {} );
-$p.append( jQuery.hasData( p ) + " " ); // true
-​
-$p.off( "click" );
-$p.append( jQuery.hasData( p ) + " " ); // false
-</script>
-​
-</body>
-</html>
-```
-     */
-    hasData(element: Element | Document | Window | JQuery.PlainObject): boolean;
-    /**
-     * Holds or releases the execution of jQuery's ready event.
-     *
-     * @param hold Indicates whether the ready hold is being requested or released
-     * @see \`{@link https://api.jquery.com/jQuery.holdReady/ }\`
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.2. See \`{@link https://github.com/jquery/jquery/issues/3288 }\`.
-     *
-     * **Cause**: The `jQuery.holdReady()` method has been deprecated due to its detrimental effect on the global performance of the page. This method can prevent all the code on the page from initializing for extended lengths of time.
-     *
-     * **Solution**: Rewrite the page so that it does not require all jQuery ready handlers to be delayed. This might be accomplished, for example, by late-loading only the code that requires the delay when it is safe to run. Due to the complexity of this method, jQuery Migrate does not attempt to fill the functionality. If the underlying version of jQuery used with jQuery Migrate no longer contains `jQuery.holdReady()` the code will fail shortly after this warning appears.
-     * @example ​ ````Delay the ready event until a custom plugin has loaded.
-```javascript
-$.holdReady( true );
-$.getScript( "myplugin.js", function() {
-  $.holdReady( false );
-});
-```
-     */
-    holdReady(hold: boolean): void;
-    /**
-     * Modify and filter HTML strings passed through jQuery manipulation methods.
-     *
-     * @param html The HTML string on which to operate.
-     * @see \`{@link https://api.jquery.com/jQuery.htmlPrefilter/ }\`
-     * @since 1.12/2.2
-     */
-    htmlPrefilter(html: JQuery.htmlString): JQuery.htmlString;
-    /**
-     * Search for a specified value within an array and return its index (or -1 if not found).
-     *
-     * @param value The value to search for.
-     * @param array An array through which to search.
-     * @param fromIndex The index of the array at which to begin the search. The default is 0, which will search the whole array.
-     * @see \`{@link https://api.jquery.com/jQuery.inArray/ }\`
-     * @since 1.2
-     * @example ​ ````Report the index of some elements in the array.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.inArray demo</title>
-  <style>
-  div {
-    color: blue;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>"John" found at <span></span></div>
-<div>4 found at <span></span></div>
-<div>"Karl" not found, so <span></span></div>
-<div>"Pete" is in the array, but not at or after index 2, so <span></span></div>
-​
-<script>
-var arr = [ 4, "Pete", 8, "John" ];
-var $spans = $( "span" );
-$spans.eq( 0 ).text( jQuery.inArray( "John", arr ) );
-$spans.eq( 1 ).text( jQuery.inArray( 4, arr ) );
-$spans.eq( 2 ).text( jQuery.inArray( "Karl", arr ) );
-$spans.eq( 3 ).text( jQuery.inArray( "Pete", arr, 2 ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    inArray<T>(value: T, array: T[], fromIndex?: number): number;
-    /**
-     * Determine whether the argument is an array.
-     *
-     * @param obj Object to test whether or not it is an array.
-     * @see \`{@link https://api.jquery.com/jQuery.isArray/ }\`
-     * @since 1.3
-     * @deprecated ​ Deprecated since 3.2. Use \`{@link ArrayConstructor.isArray Array.isArray}\`.
-     * @example ​ ````Finds out if the parameter is an array.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.isArray demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-Is [] an Array? <b></b>
-​
-<script>
-$( "b" ).append( "" + $.isArray([]) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    isArray(obj: any): obj is any[];
-    /**
-     * Check to see if an object is empty (contains no enumerable properties).
-     *
-     * @param obj The object that will be checked to see if it's empty.
-     * @see \`{@link https://api.jquery.com/jQuery.isEmptyObject/ }\`
-     * @since 1.4
-     * @example ​ ````Check an object to see if it&#39;s empty.
-```javascript
-jQuery.isEmptyObject({}); // true
-jQuery.isEmptyObject({ foo: "bar" }); // false
-```
-     */
-    isEmptyObject(obj: any): boolean;
-    /**
-     * Determine if the argument passed is a JavaScript function object.
-     *
-     * @param obj Object to test whether or not it is a function.
-     * @see \`{@link https://api.jquery.com/jQuery.isFunction/ }\`
-     * @since 1.2
-     * @deprecated ​ Deprecated since 3.3. Use `typeof x === "function"`.
-     * @example ​ ````Test a few parameter examples.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.isFunction demo</title>
-  <style>
-  div {
-    color: blue;
-    margin: 2px;
-    font-size: 14px;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>jQuery.isFunction( objs[ 0 ] ) = <span></span></div>
-<div>jQuery.isFunction( objs[ 1 ] ) = <span></span></div>
-<div>jQuery.isFunction( objs[ 2 ] ) = <span></span></div>
-<div>jQuery.isFunction( objs[ 3 ] ) = <span></span></div>
-<div>jQuery.isFunction( objs[ 4 ] ) = <span></span></div>
-​
-<script>
-function stub() {}
-var objs = [
-  function() {},
-  { x:15, y:20 },
-  null,
-  stub,
-  "function"
-];
-​
-jQuery.each( objs, function( i ) {
-  var isFunc = jQuery.isFunction( objs[ i ]);
-  $( "span" ).eq( i ).text( isFunc );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Finds out if the parameter is a function.
-```javascript
-$.isFunction(function() {});
-```
-     */
-    // tslint:disable-next-line:ban-types
-    isFunction(obj: any): obj is Function;
-    /**
-     * Determines whether its argument represents a JavaScript number.
-     *
-     * @param value The value to be tested.
-     * @see \`{@link https://api.jquery.com/jQuery.isNumeric/ }\`
-     * @since 1.7
-     * @deprecated ​ Deprecated since 3.3. Internal. See \`{@link https://github.com/jquery/jquery/issues/2960 }\`.
-     * @example ​ ````Sample return values of $.isNumeric with various inputs.
-```javascript
-// true (numeric)
-$.isNumeric( "-10" )
-$.isNumeric( "0" )
-$.isNumeric( 0xFF )
-$.isNumeric( "0xFF" )
-$.isNumeric( "8e5" )
-$.isNumeric( "3.1415" )
-$.isNumeric( +10 )
-$.isNumeric( 0144 )
-​
-// false (non-numeric)
-$.isNumeric( "-0x42" )
-$.isNumeric( "7.2acdgs" )
-$.isNumeric( "" )
-$.isNumeric( {} )
-$.isNumeric( NaN )
-$.isNumeric( null )
-$.isNumeric( true )
-$.isNumeric( Infinity )
-$.isNumeric( undefined )
-```
-     */
-    isNumeric(value: any): boolean;
-    /**
-     * Check to see if an object is a plain object (created using "{}" or "new Object").
-     *
-     * @param obj The object that will be checked to see if it's a plain object.
-     * @see \`{@link https://api.jquery.com/jQuery.isPlainObject/ }\`
-     * @since 1.4
-     * @example ​ ````Check an object to see if it&#39;s a plain object.
-```javascript
-jQuery.isPlainObject({}) // true
-jQuery.isPlainObject( "test" ) // false
-```
-     */
-    isPlainObject(obj: any): boolean;
-    /**
-     * Determine whether the argument is a window.
-     *
-     * @param obj Object to test whether or not it is a window.
-     * @see \`{@link https://api.jquery.com/jQuery.isWindow/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Internal. See \`{@link https://github.com/jquery/jquery/issues/3629 }\`.
-     *
-     * **Cause**: This method returns `true` if its argument is thought to be a `window` element. It was created for internal use and is not a reliable way of detecting `window` for public needs.
-     *
-     * **Solution**: Remove any use of `jQuery.isWindow()` from code. If it is truly needed it can be replaced with a check for `obj != null && obj === obj.window` which was the test used inside this method.
-     * @example ​ ````Finds out if the parameter is a window.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.isWindow demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-Is 'window' a window? <b></b>
-​
-<script>
-$( "b" ).append( "" + $.isWindow( window ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    isWindow(obj: any): obj is Window;
-    /**
-     * Check to see if a DOM node is within an XML document (or is an XML document).
-     *
-     * @param node The DOM node that will be checked to see if it's in an XML document.
-     * @see \`{@link https://api.jquery.com/jQuery.isXMLDoc/ }\`
-     * @since 1.1.4
-     * @example ​ ````Check an object to see if it&#39;s in an XML document.
-```javascript
-jQuery.isXMLDoc( document ) // false
-jQuery.isXMLDoc( document.body ) // false
-```
-     */
-    isXMLDoc(node: Node): boolean;
-    /**
-     * Convert an array-like object into a true JavaScript array.
-     *
-     * @param obj Any object to turn into a native Array.
-     * @see \`{@link https://api.jquery.com/jQuery.makeArray/ }\`
-     * @since 1.2
-     * @example ​ ````Turn a collection of HTMLElements into an Array of them.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.makeArray demo</title>
-  <style>
-  div {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>First</div>
-<div>Second</div>
-<div>Third</div>
-<div>Fourth</div>
-​
-<script>
-// Returns a NodeList
-var elems = document.getElementsByTagName( "div" );
-// Convert the NodeList to an Array
-var arr = jQuery.makeArray( elems );
-// Use an Array method on list of dom elements
-arr.reverse();
-$( arr ).appendTo( document.body );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Turn a jQuery object into an array
-```javascript
-var obj = $( "li" );
-var arr = $.makeArray( obj );
-```
-     */
-    makeArray<T>(obj: ArrayLike<T>): T[];
-    /**
-     * Translate all items in an array or object to new array of items.
-     *
-     * @param array The Array to translate.
-     * @param callback The function to process each item against. The first argument to the function is the array item, the
-     *                 second argument is the index in array The function can return any value. A returned array will be
-     *                 flattened into the resulting array. Within the function, this refers to the global (window) object.
-     * @see \`{@link https://api.jquery.com/jQuery.map/ }\`
-     * @since 1.0
-     * @example ​ ````Use $.map() to change the values of an array.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.map demo</title>
-  <style>
-  div {
-    color: blue;
-  }
-  p {
-    color: green;
-    margin: 0;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div></div>
-<p></p>
-<span></span>
-​
-<script>
-var arr = [ "a", "b", "c", "d", "e" ];
-$( "div" ).text( arr.join( ", " ) );
-​
-arr = jQuery.map( arr, function( n, i ) {
-  return ( n.toUpperCase() + i );
-});
-$( "p" ).text( arr.join( ", " ) );
-​
-arr = jQuery.map( arr, function( a ) {
-  return a + a;
-});
-$( "span" ).text( arr.join( ", " ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Map the original array to a new one and add 4 to each value.
-```javascript
-$.map( [ 0, 1, 2 ], function( n ) {
-  return n + 4;
-});
-```
-     * @example ​ ````Map the original array to a new one, adding 1 to each value if it is bigger then zero and removing it if not.
-```javascript
-$.map( [ 0, 1, 2 ], function( n ) {
-  return n > 0 ? n + 1 : null;
-});
-```
-     * @example ​ ````Map the original array to a new one; each element is added with its original value and the value plus one.
-```javascript
-$.map( [ 0, 1, 2 ], function( n ) {
-    return [ n, n + 1 ];
-});
-```
-     * @example ​ ````Map the original array to a new one; each element is squared.
-```javascript
-$.map( [ 0, 1, 2, 3 ], function( a ) {
-  return a * a;
-});
-```
-     * @example ​ ````Map the original array to a new one, removing numbers less than 50 by returning null and subtracting 45 from the rest.
-```javascript
-$.map( [ 0, 1, 52, 97 ], function( a ) {
-  return (a > 50 ? a - 45 : null);
-});
-```
-     * @example ​ ````Augment the resulting array by returning an array inside the function.
-```javascript
-var array = [ 0, 1, 52, 97 ];
-array = $.map( array, function( a, index ) {
-  return [ a - 45, index ];
-});
-```
-     */
-    map<T, TReturn>(array: T[], callback: (this: Window, elementOfArray: T, indexInArray: number) => JQuery.TypeOrArray<TReturn> | null | undefined): TReturn[];
-    /**
-     * Translate all items in an array or object to new array of items.
-     *
-     * @param obj The Object to translate.
-     * @param callback The function to process each item against. The first argument to the function is the value; the
-     *                 second argument is the key of the object property. The function can return any value to add to the
-     *                 array. A returned array will be flattened into the resulting array. Within the function, this refers
-     *                 to the global (window) object.
-     * @see \`{@link https://api.jquery.com/jQuery.map/ }\`
-     * @since 1.6
-     * @example ​ ````Map the original object to a new array and double each value.
-```javascript
-var dimensions = { width: 10, height: 15, length: 20 };
-dimensions = $.map( dimensions, function( value, index ) {
-  return value * 2;
-});
-```
-     * @example ​ ````Map an object&#39;s keys to an array.
-```javascript
-var dimensions = { width: 10, height: 15, length: 20 };
-var keys = $.map( dimensions, function( value, key ) {
-  return key;
-});
-```
-     */
-    map<T, K extends keyof T, TReturn>(obj: T, callback: (this: Window, propertyOfObject: T[K], key: K) => JQuery.TypeOrArray<TReturn> | null | undefined): TReturn[];
-    /**
-     * Merge the contents of two arrays together into the first array.
-     *
-     * @param first The first array-like object to merge, the elements of second added.
-     * @param second The second array-like object to merge into the first, unaltered.
-     * @see \`{@link https://api.jquery.com/jQuery.merge/ }\`
-     * @since 1.0
-     * @example ​ ````Merges two arrays, altering the first argument.
-```javascript
-$.merge( [ 0, 1, 2 ], [ 2, 3, 4 ] )
-```
-     * @example ​ ````Merges two arrays, altering the first argument.
-```javascript
-$.merge( [ 3, 2, 1 ], [ 4, 3, 2 ] )
-```
-     * @example ​ ````Merges two arrays, but uses a copy, so the original isn&#39;t altered.
-```javascript
-var first = [ "a", "b", "c" ];
-var second = [ "d", "e", "f" ];
-$.merge( $.merge( [], first ), second );
-```
-     */
-    merge<T, U>(first: ArrayLike<T>, second: ArrayLike<U>): Array<T | U>;
-    /**
-     * Relinquish jQuery's control of the $ variable.
-     *
-     * @param removeAll A Boolean indicating whether to remove all jQuery variables from the global scope (including jQuery itself).
-     * @see \`{@link https://api.jquery.com/jQuery.noConflict/ }\`
-     * @since 1.0
-     * @example ​ ````Map the original object that was referenced by $ back to $.
-```javascript
-jQuery.noConflict();
-// Do something with jQuery
-jQuery( "div p" ).hide();
-// Do something with another library's $()
-$( "content" ).style.display = "none";
-```
-     * @example ​ ````Revert the $ alias and then create and execute a function to provide the $ as a jQuery alias inside the function&#39;s scope. Inside the function the original $ object is not available. This works well for most plugins that don&#39;t rely on any other library.
-```javascript
-jQuery.noConflict();
-(function( $ ) {
-  $(function() {
-    // More code using $ as alias to jQuery
-  });
-})(jQuery);
-​
-// Other code using $ as an alias to the other library
-```
-     * @example ​ ````Create a different alias instead of jQuery to use in the rest of the script.
-```javascript
-var j = jQuery.noConflict();
-​
-// Do something with jQuery
-j( "div p" ).hide();
-​
-// Do something with another library's $()
-$( "content" ).style.display = "none";
-```
-     * @example ​ ````Completely move jQuery to a new namespace in another object.
-```javascript
-var dom = {};
-dom.query = jQuery.noConflict( true );
-```
-     * @example ​ ````Load two versions of jQuery (not recommended). Then, restore jQuery&#39;s globally scoped variables to the first loaded jQuery.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.noConflict demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log">
-  <h3>Before $.noConflict(true)</h3>
-</div>
-<script src="https://code.jquery.com/jquery-1.6.2.js"></script>
-​
-<script>
-var $log = $( "#log" );
-​
-$log.append( "2nd loaded jQuery version ($): " + $.fn.jquery + "<br>" );
-​
-// Restore globally scoped jQuery variables to the first version loaded
-// (the newer version)
-​
-jq162 = jQuery.noConflict( true );
-​
-$log.append( "<h3>After $.noConflict(true)</h3>" );
-$log.append( "1st loaded jQuery version ($): " + $.fn.jquery + "<br>" );
-$log.append( "2nd loaded jQuery version (jq162): " + jq162.fn.jquery + "<br>" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    noConflict(removeAll?: boolean): this;
-    /**
-     * @deprecated ​ Deprecated since 3.2.
-     *
-     * **Cause**: This public but never-documented method has been deprecated as of jQuery 3.2.0.
-     *
-     * **Solution**: Replace calls such as `jQuery.nodeName( elem, "div" )` with a test such as `elem.nodeName.toLowerCase() === "div"`.
-     */
-    nodeName(elem: Node, name: string): boolean;
-    /**
-     * An empty function.
-     *
-     * @see \`{@link https://api.jquery.com/jQuery.noop/ }\`
-     * @since 1.4
-     */
-    noop(): undefined;
-    /**
-     * Return a number representing the current time.
-     *
-     * @see \`{@link https://api.jquery.com/jQuery.now/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link DateConstructor.now Date.now}\`.
-     */
-    now(): number;
-    /**
-     * Create a serialized representation of an array, a plain object, or a jQuery object suitable for use
-     * in a URL query string or Ajax request. In case a jQuery object is passed, it should contain input
-     * elements with name/value properties.
-     *
-     * @param obj An array, a plain object, or a jQuery object to serialize.
-     * @param traditional A Boolean indicating whether to perform a traditional "shallow" serialization.
-     * @see \`{@link https://api.jquery.com/jQuery.param/ }\`
-     * @since 1.2
-     * @since 1.4
-     * @example ​ ````Serialize a key/value object.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.param demo</title>
-  <style>
-  div {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="results"></div>
-​
-<script>
-var params = { width:1680, height:1050 };
-var str = jQuery.param( params );
-$( "#results" ).text( str );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Serialize a few complex objects
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.param demo</title>
-  <style>
-  div {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​​
-<script>
-// <=1.3.2:
-$.param({ a: [ 2, 3, 4 ] }); // "a=2&a=3&a=4"
-// >=1.4:
-$.param({ a: [ 2, 3, 4 ] }); // "a[]=2&a[]=3&a[]=4"
-​
-// <=1.3.2:
-$.param({ a: { b: 1, c: 2 }, d: [ 3, 4, { e: 5 } ] });
-// "a=[object+Object]&d=3&d=4&d=[object+Object]"
-​
-// >=1.4:
-$.param({ a: { b: 1, c: 2 }, d: [ 3, 4, { e: 5 } ] });
-// "a[b]=1&a[c]=2&d[]=3&d[]=4&d[2][e]=5"
-</script>
-​
-</body>
-</html>
-```
-     */
-    param(obj: any[] | JQuery.PlainObject | JQuery, traditional?: boolean): string;
-    /**
-     * Parses a string into an array of DOM nodes.
-     *
-     * @param data HTML string to be parsed
-     * @param context Document element to serve as the context in which the HTML fragment will be created
-     * @param keepScripts A Boolean indicating whether to include scripts passed in the HTML string
-     * @see \`{@link https://api.jquery.com/jQuery.parseHTML/ }\`
-     * @since 1.8
-     */
-    parseHTML(data: string, context: Document | null | undefined, keepScripts: boolean): JQuery.Node[];
-    /**
-     * Parses a string into an array of DOM nodes.
-     *
-     * @param data HTML string to be parsed
-     * @param context_keepScripts _&#x40;param_ `context_keepScripts`
-     * <br>
-     * * `context` — Document element to serve as the context in which the HTML fragment will be created <br>
-     * * `keepScripts` — A Boolean indicating whether to include scripts passed in the HTML string
-     * @see \`{@link https://api.jquery.com/jQuery.parseHTML/ }\`
-     * @since 1.8
-     * @example ​ ````Create an array of DOM nodes using an HTML string and insert it into a div.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.parseHTML demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log">
-  <h3>Content:</h3>
-</div>
-​
-<script>
-var $log = $( "#log" ),
-  str = "hello, <b>my name is</b> jQuery.",
-  html = $.parseHTML( str ),
-  nodeNames = [];
-​
-// Append the parsed HTML
-$log.append( html );
-​
-// Gather the parsed HTML's node names
-$.each( html, function( i, el ) {
-  nodeNames[ i ] = "<li>" + el.nodeName + "</li>";
-});
-​
-// Insert the node names
-$log.append( "<h3>Node Names:</h3>" );
-$( "<ol></ol>" )
-  .append( nodeNames.join( "" ) )
-  .appendTo( $log );
-</script>
-​
-</body>
-</html>
-```
-     */
-    parseHTML(data: string, context_keepScripts?: Document | null | boolean): JQuery.Node[];
-    /**
-     * Takes a well-formed JSON string and returns the resulting JavaScript value.
-     *
-     * @param json The JSON string to parse.
-     * @see \`{@link https://api.jquery.com/jQuery.parseJSON/ }\`
-     * @since 1.4.1
-     * @deprecated ​ Deprecated since 3.0. Use \`{@link JSON.parse }\`.
-     *
-     * **Cause**: The `jQuery.parseJSON` method in recent jQuery is identical to the native `JSON.parse`. As of jQuery 3.0 `jQuery.parseJSON` is deprecated.
-     *
-     * **Solution**: Replace any use of `jQuery.parseJSON` with `JSON.parse`.
-     * @example ​ ````Parse a JSON string.
-```javascript
-var obj = jQuery.parseJSON( '{ "name": "John" }' );
-alert( obj.name === "John" );
-```
-     */
-    parseJSON(json: string): any;
-    /**
-     * Parses a string into an XML document.
-     *
-     * @param data a well-formed XML string to be parsed
-     * @see \`{@link https://api.jquery.com/jQuery.parseXML/ }\`
-     * @since 1.5
-     * @example ​ ````Create a jQuery object using an XML string and obtain the value of the title node.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.parseXML demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p id="someElement"></p>
-<p id="anotherElement"></p>
-​
-<script>
-var xml = "<rss version='2.0'><channel><title>RSS Title</title></channel></rss>",
-  xmlDoc = $.parseXML( xml ),
-  $xml = $( xmlDoc ),
-  $title = $xml.find( "title" );
-​
-// Append "RSS Title" to #someElement
-$( "#someElement" ).append( $title.text() );
-​
-// Change the title to "XML Title"
-$title.text( "XML Title" );
-​
-// Append "XML Title" to #anotherElement
-$( "#anotherElement" ).append( $title.text() );
-</script>
-​
-</body>
-</html>
-```
-     */
-    parseXML(data: string): XMLDocument;
-    /**
-     * Load data from the server using a HTTP POST request.
-     *
-     * @param url A string containing the URL to which the request is sent.
-     * @param data A plain object or string that is sent to the server with the request.
-     * @param success A callback function that is executed if the request succeeds. Required if dataType is provided, but
-     *                can be null in that case.
-     * @param dataType The type of data expected from the server. Default: Intelligent Guess (xml, json, script, text, html).
-     * @see \`{@link https://api.jquery.com/jQuery.post/ }\`
-     * @since 1.0
-     * @example ​ ````Post to the test.php page and get content which has been returned in json format (&lt;?php echo json_encode(array(&quot;name&quot;=&gt;&quot;John&quot;,&quot;time&quot;=&gt;&quot;2pm&quot;)); ?&gt;).
-```javascript
-$.post( "test.php", { func: "getNameAndTime" }, function( data ) {
-  console.log( data.name ); // John
-  console.log( data.time ); // 2pm
-}, "json");
-```
-     */
-    post(url: string,
-         data: JQuery.PlainObject | string,
-         success: JQuery.jqXHR.DoneCallback | null,
-         dataType?: string): JQuery.jqXHR;
-    /**
-     * Load data from the server using a HTTP POST request.
-     *
-     * @param url A string containing the URL to which the request is sent.
-     * @param success A callback function that is executed if the request succeeds. Required if dataType is provided, but
-     *                can be null in that case.
-     * @param dataType The type of data expected from the server. Default: Intelligent Guess (xml, json, script, text, html).
-     * @see \`{@link https://api.jquery.com/jQuery.post/ }\`
-     * @since 1.0
-     */
-    post(url: string,
-         success: JQuery.jqXHR.DoneCallback | null,
-         dataType: string): JQuery.jqXHR;
-    /**
-     * Load data from the server using a HTTP POST request.
-     *
-     * @param url A string containing the URL to which the request is sent.
-     * @param success_data _&#x40;param_ `success_data`
-     * <br>
-     * * `success` — A callback function that is executed if the request succeeds. Required if `dataType` is provided,
-     *               but can be `null` in that case. <br>
-     * * `data` — A plain object or string that is sent to the server with the request.
-     * @see \`{@link https://api.jquery.com/jQuery.post/ }\`
-     * @since 1.0
-     * @example ​ ````Request the test.php page and send some additional data along (while still ignoring the return results).
-```javascript
-$.post( "test.php", { name: "John", time: "2pm" } );
-```
-     * @example ​ ````Pass arrays of data to the server (while still ignoring the return results).
-```javascript
-$.post( "test.php", { 'choices[]': [ "Jon", "Susan" ] } );
-```
-     * @example ​ ````Send form data using Ajax requests
-```javascript
-$.post( "test.php", $( "#testform" ).serialize() );
-```
-     * @example ​ ````Alert the results from requesting test.php (HTML or XML, depending on what was returned).
-```javascript
-$.post( "test.php", function( data ) {
-  alert( "Data Loaded: " + data );
-});
-```
-     * @example ​ ````Alert the results from requesting test.php with an additional payload of data (HTML or XML, depending on what was returned).
-```javascript
-$.post( "test.php", { name: "John", time: "2pm" })
-  .done(function( data ) {
-    alert( "Data Loaded: " + data );
-  });
-```
-     * @example ​ ````Post a form using Ajax and put results in a div
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.post demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<form action="/" id="searchForm">
-  <input type="text" name="s" placeholder="Search...">
-  <input type="submit" value="Search">
-</form>
-<!-- the result of the search will be rendered inside this div -->
-<div id="result"></div>
-​
-<script>
-// Attach a submit handler to the form
-$( "#searchForm" ).submit(function( event ) {
-​
-  // Stop form from submitting normally
-  event.preventDefault();
-​
-  // Get some values from elements on the page:
-  var $form = $( this ),
-    term = $form.find( "input[name='s']" ).val(),
-    url = $form.attr( "action" );
-​
-  // Send the data using post
-  var posting = $.post( url, { s: term } );
-​
-  // Put the results in a div
-  posting.done(function( data ) {
-    var content = $( data ).find( "#content" );
-    $( "#result" ).empty().append( content );
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    post(url: string,
-         success_data: JQuery.jqXHR.DoneCallback | JQuery.PlainObject | string): JQuery.jqXHR;
-    /**
-     * Load data from the server using a HTTP POST request.
-     *
-     * @param url_settings _&#x40;param_ `url_settings`
-     * <br>
-     * * `url` — A string containing the URL to which the request is sent. <br>
-     * * `settings` — A set of key/value pairs that configure the Ajax request. All properties except for `url` are optional.
-     *                A default can be set for any option with \`{@link ajaxSetup $.ajaxSetup()}\`. See \`{@link https://api.jquery.com/jquery.ajax/#jQuery-ajax-settings jQuery.ajax( settings )}\`
-     *                for a complete list of all settings. Type will automatically be set to `POST`.
-     * @see \`{@link https://api.jquery.com/jQuery.post/ }\`
-     * @since 1.0
-     * @since 1.12
-     * @since 2.2
-     * @example ​ ````Request the test.php page, but ignore the return results.
-```javascript
-$.post( "test.php" );
-```
-     */
-    post(url_settings?: string | JQuery.UrlAjaxSettings): JQuery.jqXHR;
-
-    // region proxy
-    // #region proxy
-
-    // region (fn, null | undefined)
-    // #region (fn, null | undefined)
-
-    // region 0 to 7 additional arguments
-    // #region 0 to 7 additional arguments
-
-    // region 0 parameters
-    // #region 0 parameters
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E, F, G>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => TReturn,
-                             context: null | undefined,
-                             a: A, b: B, c: C, d: D, e: E, f: F, g: G): () => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E, F>(fn: (a: A, b: B, c: C, d: D, e: E, f: F) => TReturn,
-                          context: null | undefined,
-                          a: A, b: B, c: C, d: D, e: E, f: F): () => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E>(fn: (a: A, b: B, c: C, d: D, e: E) => TReturn,
-                       context: null | undefined,
-                       a: A, b: B, c: C, d: D, e: E): () => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D>(fn: (a: A, b: B, c: C, d: D) => TReturn,
-                    context: null | undefined,
-                    a: A, b: B, c: C, d: D): () => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C>(fn: (a: A, b: B, c: C) => TReturn,
-                 context: null | undefined,
-                 a: A, b: B, c: C): () => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B>(fn: (a: A, b: B) => TReturn,
-              context: null | undefined,
-              a: A, b: B): () => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A>(fn: (a: A) => TReturn,
-           context: null | undefined,
-           a: A): () => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn>(fn: () => TReturn,
-                   context: null | undefined): () => TReturn;
-
-    // #endregion
-
-    // region 1 parameters
-    // #region 1 parameters
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E, F, G,
-        T>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
-                t: T) => TReturn,
-           context: null | undefined,
-           a: A, b: B, c: C, d: D, e: E, f: F, g: G): (t: T) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E, F,
-        T>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
-                t: T) => TReturn,
-           context: null | undefined,
-           a: A, b: B, c: C, d: D, e: E, f: F): (t: T) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E,
-        T>(fn: (a: A, b: B, c: C, d: D, e: E,
-                t: T) => TReturn,
-           context: null | undefined,
-           a: A, b: B, c: C, d: D, e: E): (t: T) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D,
-        T>(fn: (a: A, b: B, c: C, d: D,
-                t: T) => TReturn,
-           context: null | undefined,
-           a: A, b: B, c: C, d: D): (t: T) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C,
-        T>(fn: (a: A, b: B, c: C,
-                t: T) => TReturn,
-           context: null | undefined,
-           a: A, b: B, c: C): (t: T) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B,
-        T>(fn: (a: A, b: B,
-                t: T) => TReturn,
-           context: null | undefined,
-           a: A, b: B): (t: T) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A,
-        T>(fn: (a: A,
-                t: T) => TReturn,
-           context: null | undefined,
-           a: A): (t: T) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        T>(fn: (t: T) => TReturn,
-           context: null | undefined): (t: T) => TReturn;
-
-    // #endregion
-
-    // region 2 parameters
-    // #region 2 parameters
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E, F, G,
-        T, U>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
-                   t: T, u: U) => TReturn,
-              context: null | undefined,
-              a: A, b: B, c: C, d: D, e: E, f: F, g: G): (t: T, u: U) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E, F,
-        T, U>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
-                   t: T, u: U) => TReturn,
-              context: null | undefined,
-              a: A, b: B, c: C, d: D, e: E, f: F): (t: T, u: U) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E,
-        T, U>(fn: (a: A, b: B, c: C, d: D, e: E,
-                   t: T, u: U) => TReturn,
-              context: null | undefined,
-              a: A, b: B, c: C, d: D, e: E): (t: T, u: U) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D,
-        T, U>(fn: (a: A, b: B, c: C, d: D,
-                   t: T, u: U) => TReturn,
-              context: null | undefined,
-              a: A, b: B, c: C, d: D): (t: T, u: U) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C,
-        T, U>(fn: (a: A, b: B, c: C,
-                   t: T, u: U) => TReturn,
-              context: null | undefined,
-              a: A, b: B, c: C): (t: T, u: U) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B,
-        T, U>(fn: (a: A, b: B,
-                   t: T, u: U) => TReturn,
-              context: null | undefined,
-              a: A, b: B): (t: T, u: U) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A,
-        T, U>(fn: (a: A,
-                   t: T, u: U) => TReturn,
-              context: null | undefined,
-              a: A): (t: T, u: U) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        T, U>(fn: (t: T, u: U) => TReturn,
-              context: null | undefined): (t: T, u: U) => TReturn;
-
-    // #endregion
-
-    // region 3 parameters
-    // #region 3 parameters
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E, F, G,
-        T, U, V>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
-                      t: T, u: U, v: V) => TReturn,
-                 context: null | undefined,
-                 a: A, b: B, c: C, d: D, e: E, f: F, g: G): (t: T, u: U, v: V) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E, F,
-        T, U, V>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
-                      t: T, u: U, v: V) => TReturn,
-                 context: null | undefined,
-                 a: A, b: B, c: C, d: D, e: E, f: F): (t: T, u: U, v: V) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E,
-        T, U, V>(fn: (a: A, b: B, c: C, d: D, e: E,
-                      t: T, u: U, v: V) => TReturn,
-                 context: null | undefined,
-                 a: A, b: B, c: C, d: D, e: E): (t: T, u: U, v: V) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D,
-        T, U, V>(fn: (a: A, b: B, c: C, d: D,
-                      t: T, u: U, v: V) => TReturn,
-                 context: null | undefined,
-                 a: A, b: B, c: C, d: D): (t: T, u: U, v: V) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C,
-        T, U, V>(fn: (a: A, b: B, c: C,
-                      t: T, u: U, v: V) => TReturn,
-                 context: null | undefined,
-                 a: A, b: B, c: C): (t: T, u: U, v: V) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B,
-        T, U, V>(fn: (a: A, b: B,
-                      t: T, u: U, v: V) => TReturn,
-                 context: null | undefined,
-                 a: A, b: B): (t: T, u: U, v: V) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A,
-        T, U, V>(fn: (a: A,
-                      t: T, u: U, v: V) => TReturn,
-                 context: null | undefined,
-                 a: A): (t: T, u: U, v: V) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        T, U, V>(fn: (t: T, u: U, v: V) => TReturn,
-                 context: null | undefined): (t: T, u: U, v: V) => TReturn;
-
-    // #endregion
-
-    // region 4 parameters
-    // #region 4 parameters
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E, F, G,
-        T, U, V, W>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
-                         t: T, u: U, v: V, w: W) => TReturn,
-                    context: null | undefined,
-                    a: A, b: B, c: C, d: D, e: E, f: F, g: G): (t: T, u: U, v: V, w: W) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E, F,
-        T, U, V, W>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
-                         t: T, u: U, v: V, w: W) => TReturn,
-                    context: null | undefined,
-                    a: A, b: B, c: C, d: D, e: E, f: F): (t: T, u: U, v: V, w: W) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E,
-        T, U, V, W>(fn: (a: A, b: B, c: C, d: D, e: E,
-                         t: T, u: U, v: V, w: W) => TReturn,
-                    context: null | undefined,
-                    a: A, b: B, c: C, d: D, e: E): (t: T, u: U, v: V, w: W) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D,
-        T, U, V, W>(fn: (a: A, b: B, c: C, d: D,
-                         t: T, u: U, v: V, w: W) => TReturn,
-                    context: null | undefined,
-                    a: A, b: B, c: C, d: D): (t: T, u: U, v: V, w: W) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C,
-        T, U, V, W>(fn: (a: A, b: B, c: C,
-                         t: T, u: U, v: V, w: W) => TReturn,
-                    context: null | undefined,
-                    a: A, b: B, c: C): (t: T, u: U, v: V, w: W) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B,
-        T, U, V, W>(fn: (a: A, b: B,
-                         t: T, u: U, v: V, w: W) => TReturn,
-                    context: null | undefined,
-                    a: A, b: B): (t: T, u: U, v: V, w: W) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A,
-        T, U, V, W>(fn: (a: A,
-                         t: T, u: U, v: V, w: W) => TReturn,
-                    context: null | undefined,
-                    a: A): (t: T, u: U, v: V, w: W) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        T, U, V, W>(fn: (t: T, u: U, v: V, w: W) => TReturn,
-                    context: null | undefined): (t: T, u: U, v: V, w: W) => TReturn;
-
-    // #endregion
-
-    // region 5 parameters
-    // #region 5 parameters
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E, F, G,
-        T, U, V, W, X>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
-                            t: T, u: U, v: V, w: W, x: X) => TReturn,
-                       context: null | undefined,
-                       a: A, b: B, c: C, d: D, e: E, f: F, g: G): (t: T, u: U, v: V, w: W, x: X) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E, F,
-        T, U, V, W, X>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
-                            t: T, u: U, v: V, w: W, x: X) => TReturn,
-                       context: null | undefined,
-                       a: A, b: B, c: C, d: D, e: E, f: F): (t: T, u: U, v: V, w: W, x: X) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E,
-        T, U, V, W, X>(fn: (a: A, b: B, c: C, d: D, e: E,
-                            t: T, u: U, v: V, w: W, x: X) => TReturn,
-                       context: null | undefined,
-                       a: A, b: B, c: C, d: D, e: E): (t: T, u: U, v: V, w: W, x: X) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D,
-        T, U, V, W, X>(fn: (a: A, b: B, c: C, d: D,
-                            t: T, u: U, v: V, w: W, x: X) => TReturn,
-                       context: null | undefined,
-                       a: A, b: B, c: C, d: D): (t: T, u: U, v: V, w: W, x: X) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C,
-        T, U, V, W, X>(fn: (a: A, b: B, c: C,
-                            t: T, u: U, v: V, w: W, x: X) => TReturn,
-                       context: null | undefined,
-                       a: A, b: B, c: C): (t: T, u: U, v: V, w: W, x: X) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B,
-        T, U, V, W, X>(fn: (a: A, b: B,
-                            t: T, u: U, v: V, w: W, x: X) => TReturn,
-                       context: null | undefined,
-                       a: A, b: B): (t: T, u: U, v: V, w: W, x: X) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A,
-        T, U, V, W, X>(fn: (a: A,
-                            t: T, u: U, v: V, w: W, x: X) => TReturn,
-                       context: null | undefined,
-                       a: A): (t: T, u: U, v: V, w: W, x: X) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        T, U, V, W, X>(fn: (t: T, u: U, v: V, w: W, x: X) => TReturn,
-                       context: null | undefined): (t: T, u: U, v: V, w: W, x: X) => TReturn;
-
-    // #endregion
-
-    // region 6 parameters
-    // #region 6 parameters
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E, F, G,
-        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
-                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
-                          context: null | undefined,
-                          a: A, b: B, c: C, d: D, e: E, f: F, g: G): (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E, F,
-        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
-                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
-                          context: null | undefined,
-                          a: A, b: B, c: C, d: D, e: E, f: F): (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E,
-        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C, d: D, e: E,
-                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
-                          context: null | undefined,
-                          a: A, b: B, c: C, d: D, e: E): (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D,
-        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C, d: D,
-                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
-                          context: null | undefined,
-                          a: A, b: B, c: C, d: D): (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C,
-        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C,
-                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
-                          context: null | undefined,
-                          a: A, b: B, c: C): (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B,
-        T, U, V, W, X, Y>(fn: (a: A, b: B,
-                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
-                          context: null | undefined,
-                          a: A, b: B): (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A,
-        T, U, V, W, X, Y>(fn: (a: A,
-                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
-                          context: null | undefined,
-                          a: A): (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        T, U, V, W, X, Y>(fn: (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
-                          context: null | undefined): (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
-
-    // #endregion
-
-    // region 7+ parameters
-    // #region 7+ parameters
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E, F, G,
-        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
-                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
-                             context: null | undefined,
-                             a: A, b: B, c: C, d: D, e: E, f: F, g: G): (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E, F,
-        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
-                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
-                             context: null | undefined,
-                             a: A, b: B, c: C, d: D, e: E, f: F): (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D, E,
-        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C, d: D, e: E,
-                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
-                             context: null | undefined,
-                             a: A, b: B, c: C, d: D, e: E): (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C, D,
-        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C, d: D,
-                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
-                             context: null | undefined,
-                             a: A, b: B, c: C, d: D): (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B, C,
-        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C,
-                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
-                             context: null | undefined,
-                             a: A, b: B, c: C): (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A, B,
-        T, U, V, W, X, Y, Z>(fn: (a: A, b: B,
-                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
-                             context: null | undefined,
-                             a: A, b: B): (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        A,
-        T, U, V, W, X, Y, Z>(fn: (a: A,
-                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
-                             context: null | undefined,
-                             a: A): (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn,
-        T, U, V, W, X, Y, Z>(fn: (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
-                             context: null | undefined): (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
-
-    // #endregion
-
-    // #endregion
-
-    // region 8+ additional arguments
-    // #region 8+ additional arguments
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @param additionalArguments Any number of arguments to be passed to the function referenced in the function argument.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.9
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     */
-    proxy<TReturn>(fn: (...args: any[]) => TReturn,
-                   context: null | undefined,
-                   ...additionalArguments: any[]): (...args: any[]) => TReturn;
-
-    // #endregion
-
-    // #endregion
-
-    // region (fn, context)
-    // #region (fn, context)
-
-    // region 0 to 7 additional arguments
-    // #region 0 to 7 additional arguments
-
-    // region 0 parameters
-    // #region 0 parameters
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E, F, G>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => TReturn,
-                             context: TContext,
-                             a: A, b: B, c: C, d: D, e: E, f: F, g: G): (this: TContext) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E, F>(fn: (a: A, b: B, c: C, d: D, e: E, f: F) => TReturn,
-                          context: TContext,
-                          a: A, b: B, c: C, d: D, e: E, f: F): (this: TContext) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E>(fn: (a: A, b: B, c: C, d: D, e: E) => TReturn,
-                       context: TContext,
-                       a: A, b: B, c: C, d: D, e: E): (this: TContext) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D>(fn: (a: A, b: B, c: C, d: D) => TReturn,
-                    context: TContext,
-                    a: A, b: B, c: C, d: D): (this: TContext) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C>(fn: (a: A, b: B, c: C) => TReturn,
-                 context: TContext,
-                 a: A, b: B, c: C): (this: TContext) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B>(fn: (a: A, b: B) => TReturn,
-              context: TContext,
-              a: A, b: B): (this: TContext) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4`
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A>(fn: (a: A) => TReturn,
-           context: TContext,
-           a: A): (this: TContext) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn>(fn: () => TReturn,
-                 context: TContext): (this: TContext) => TReturn;
-
-    // #endregion
-
-    // region 1 parameters
-    // #region 1 parameters
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E, F, G,
-        T>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
-                t: T) => TReturn,
-           context: TContext,
-           a: A, b: B, c: C, d: D, e: E, f: F, g: G): (this: TContext, t: T) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E, F,
-        T>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
-                t: T) => TReturn,
-           context: TContext,
-           a: A, b: B, c: C, d: D, e: E, f: F): (this: TContext, t: T) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E,
-        T>(fn: (a: A, b: B, c: C, d: D, e: E,
-                t: T) => TReturn,
-           context: TContext,
-           a: A, b: B, c: C, d: D, e: E): (this: TContext, t: T) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D,
-        T>(fn: (a: A, b: B, c: C, d: D,
-                t: T) => TReturn,
-           context: TContext,
-           a: A, b: B, c: C, d: D): (this: TContext, t: T) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C,
-        T>(fn: (a: A, b: B, c: C,
-                t: T) => TReturn,
-           context: TContext,
-           a: A, b: B, c: C): (this: TContext, t: T) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B,
-        T>(fn: (a: A, b: B,
-                t: T) => TReturn,
-           context: TContext,
-           a: A, b: B): (this: TContext, t: T) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A,
-        T>(fn: (a: A,
-                t: T) => TReturn,
-           context: TContext,
-           a: A): (this: TContext, t: T) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        T>(fn: (t: T) => TReturn,
-           context: TContext): (this: TContext, t: T) => TReturn;
-
-    // #endregion
-
-    // region 2 parameters
-    // #region 2 parameters
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E, F, G,
-        T, U>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
-                   t: T, u: U) => TReturn,
-              context: TContext,
-              a: A, b: B, c: C, d: D, e: E, f: F, g: G): (this: TContext, t: T, u: U) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E, F,
-        T, U>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
-                   t: T, u: U) => TReturn,
-              context: TContext,
-              a: A, b: B, c: C, d: D, e: E, f: F): (this: TContext, t: T, u: U) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E,
-        T, U>(fn: (a: A, b: B, c: C, d: D, e: E,
-                   t: T, u: U) => TReturn,
-              context: TContext,
-              a: A, b: B, c: C, d: D, e: E): (this: TContext, t: T, u: U) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D,
-        T, U>(fn: (a: A, b: B, c: C, d: D,
-                   t: T, u: U) => TReturn,
-              context: TContext,
-              a: A, b: B, c: C, d: D): (this: TContext, t: T, u: U) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C,
-        T, U>(fn: (a: A, b: B, c: C,
-                   t: T, u: U) => TReturn,
-              context: TContext,
-              a: A, b: B, c: C): (this: TContext, t: T, u: U) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B,
-        T, U>(fn: (a: A, b: B,
-                   t: T, u: U) => TReturn,
-              context: TContext,
-              a: A, b: B): (this: TContext, t: T, u: U) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A,
-        T, U>(fn: (a: A,
-                   t: T, u: U) => TReturn,
-              context: TContext,
-              a: A): (this: TContext, t: T, u: U) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        T, U>(fn: (t: T, u: U) => TReturn,
-              context: TContext): (this: TContext, t: T, u: U) => TReturn;
-
-    // #endregion
-
-    // region 3 parameters
-    // #region 3 parameters
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E, F, G,
-        T, U, V>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
-                      t: T, u: U, v: V) => TReturn,
-                 context: TContext,
-                 a: A, b: B, c: C, d: D, e: E, f: F, g: G): (this: TContext, t: T, u: U, v: V) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E, F,
-        T, U, V>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
-                      t: T, u: U, v: V) => TReturn,
-                 context: TContext,
-                 a: A, b: B, c: C, d: D, e: E, f: F): (this: TContext, t: T, u: U, v: V) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E,
-        T, U, V>(fn: (a: A, b: B, c: C, d: D, e: E,
-                      t: T, u: U, v: V) => TReturn,
-                 context: TContext,
-                 a: A, b: B, c: C, d: D, e: E): (this: TContext, t: T, u: U, v: V) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D,
-        T, U, V>(fn: (a: A, b: B, c: C, d: D,
-                      t: T, u: U, v: V) => TReturn,
-                 context: TContext,
-                 a: A, b: B, c: C, d: D): (this: TContext, t: T, u: U, v: V) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C,
-        T, U, V>(fn: (a: A, b: B, c: C,
-                      t: T, u: U, v: V) => TReturn,
-                 context: TContext,
-                 a: A, b: B, c: C): (this: TContext, t: T, u: U, v: V) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B,
-        T, U, V>(fn: (a: A, b: B,
-                      t: T, u: U, v: V) => TReturn,
-                 context: TContext,
-                 a: A, b: B): (this: TContext, t: T, u: U, v: V) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A,
-        T, U, V>(fn: (a: A,
-                      t: T, u: U, v: V) => TReturn,
-                 context: TContext,
-                 a: A): (this: TContext, t: T, u: U, v: V) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        T, U, V>(fn: (t: T, u: U, v: V) => TReturn,
-                 context: TContext): (this: TContext, t: T, u: U, v: V) => TReturn;
-
-    // #endregion
-
-    // region 4 parameters
-    // #region 4 parameters
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E, F, G,
-        T, U, V, W>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
-                         t: T, u: U, v: V, w: W) => TReturn,
-                    context: TContext,
-                    a: A, b: B, c: C, d: D, e: E, f: F, g: G): (this: TContext, t: T, u: U, v: V, w: W) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E, F,
-        T, U, V, W>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
-                         t: T, u: U, v: V, w: W) => TReturn,
-                    context: TContext,
-                    a: A, b: B, c: C, d: D, e: E, f: F): (this: TContext, t: T, u: U, v: V, w: W) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E,
-        T, U, V, W>(fn: (a: A, b: B, c: C, d: D, e: E,
-                         t: T, u: U, v: V, w: W) => TReturn,
-                    context: TContext,
-                    a: A, b: B, c: C, d: D, e: E): (this: TContext, t: T, u: U, v: V, w: W) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D,
-        T, U, V, W>(fn: (a: A, b: B, c: C, d: D,
-                         t: T, u: U, v: V, w: W) => TReturn,
-                    context: TContext,
-                    a: A, b: B, c: C, d: D): (this: TContext, t: T, u: U, v: V, w: W) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C,
-        T, U, V, W>(fn: (a: A, b: B, c: C,
-                         t: T, u: U, v: V, w: W) => TReturn,
-                    context: TContext,
-                    a: A, b: B, c: C): (this: TContext, t: T, u: U, v: V, w: W) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B,
-        T, U, V, W>(fn: (a: A, b: B,
-                         t: T, u: U, v: V, w: W) => TReturn,
-                    context: TContext,
-                    a: A, b: B): (this: TContext, t: T, u: U, v: V, w: W) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A,
-        T, U, V, W>(fn: (a: A,
-                         t: T, u: U, v: V, w: W) => TReturn,
-                    context: TContext,
-                    a: A): (this: TContext, t: T, u: U, v: V, w: W) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        T, U, V, W>(fn: (t: T, u: U, v: V, w: W) => TReturn,
-                    context: TContext): (this: TContext, t: T, u: U, v: V, w: W) => TReturn;
-
-    // #endregion
-
-    // region 5 parameters
-    // #region 5 parameters
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E, F, G,
-        T, U, V, W, X>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
-                            t: T, u: U, v: V, w: W, x: X) => TReturn,
-                       context: TContext,
-                       a: A, b: B, c: C, d: D, e: E, f: F, g: G): (this: TContext, t: T, u: U, v: V, w: W, x: X) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E, F,
-        T, U, V, W, X>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
-                            t: T, u: U, v: V, w: W, x: X) => TReturn,
-                       context: TContext,
-                       a: A, b: B, c: C, d: D, e: E, f: F): (this: TContext, t: T, u: U, v: V, w: W, x: X) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E,
-        T, U, V, W, X>(fn: (a: A, b: B, c: C, d: D, e: E,
-                            t: T, u: U, v: V, w: W, x: X) => TReturn,
-                       context: TContext,
-                       a: A, b: B, c: C, d: D, e: E): (this: TContext, t: T, u: U, v: V, w: W, x: X) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D,
-        T, U, V, W, X>(fn: (a: A, b: B, c: C, d: D,
-                            t: T, u: U, v: V, w: W, x: X) => TReturn,
-                       context: TContext,
-                       a: A, b: B, c: C, d: D): (this: TContext, t: T, u: U, v: V, w: W, x: X) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C,
-        T, U, V, W, X>(fn: (a: A, b: B, c: C,
-                            t: T, u: U, v: V, w: W, x: X) => TReturn,
-                       context: TContext,
-                       a: A, b: B, c: C): (this: TContext, t: T, u: U, v: V, w: W, x: X) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B,
-        T, U, V, W, X>(fn: (a: A, b: B,
-                            t: T, u: U, v: V, w: W, x: X) => TReturn,
-                       context: TContext,
-                       a: A, b: B): (this: TContext, t: T, u: U, v: V, w: W, x: X) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A,
-        T, U, V, W, X>(fn: (a: A,
-                            t: T, u: U, v: V, w: W, x: X) => TReturn,
-                       context: TContext,
-                       a: A): (this: TContext, t: T, u: U, v: V, w: W, x: X) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        T, U, V, W, X>(fn: (t: T, u: U, v: V, w: W, x: X) => TReturn,
-                       context: TContext): (this: TContext, t: T, u: U, v: V, w: W, x: X) => TReturn;
-
-    // #endregion
-
-    // region 6 parameters
-    // #region 6 parameters
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E, F, G,
-        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
-                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
-                          context: TContext,
-                          a: A, b: B, c: C, d: D, e: E, f: F, g: G): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E, F,
-        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
-                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
-                          context: TContext,
-                          a: A, b: B, c: C, d: D, e: E, f: F): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E,
-        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C, d: D, e: E,
-                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
-                          context: TContext,
-                          a: A, b: B, c: C, d: D, e: E): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D,
-        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C, d: D,
-                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
-                          context: TContext,
-                          a: A, b: B, c: C, d: D): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C,
-        T, U, V, W, X, Y>(fn: (a: A, b: B, c: C,
-                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
-                          context: TContext,
-                          a: A, b: B, c: C): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B,
-        T, U, V, W, X, Y>(fn: (a: A, b: B,
-                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
-                          context: TContext,
-                          a: A, b: B): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A,
-        T, U, V, W, X, Y>(fn: (a: A,
-                               t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
-                          context: TContext,
-                          a: A): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        T, U, V, W, X, Y>(fn: (t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn,
-                          context: TContext): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y) => TReturn;
-
-    // #endregion
-
-    // region 7+ parameters
-    // #region 7+ parameters
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E, F, G,
-        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C, d: D, e: E, f: F, g: G,
-                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
-                             context: TContext,
-                             a: A, b: B, c: C, d: D, e: E, f: F, g: G): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E, F,
-        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C, d: D, e: E, f: F,
-                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
-                             context: TContext,
-                             a: A, b: B, c: C, d: D, e: E, f: F): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D, E,
-        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C, d: D, e: E,
-                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
-                             context: TContext,
-                             a: A, b: B, c: C, d: D, e: E): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C, D,
-        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C, d: D,
-                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
-                             context: TContext,
-                             a: A, b: B, c: C, d: D): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B, C,
-        T, U, V, W, X, Y, Z>(fn: (a: A, b: B, c: C,
-                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
-                             context: TContext,
-                             a: A, b: B, c: C): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A, B,
-        T, U, V, W, X, Y, Z>(fn: (a: A, b: B,
-                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
-                             context: TContext,
-                             a: A, b: B): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        A,
-        T, U, V, W, X, Y, Z>(fn: (a: A,
-                                  t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
-                             context: TContext,
-                             a: A): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn,
-        T, U, V, W, X, Y, Z>(fn: (t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn,
-                             context: TContext): (this: TContext, t: T, u: U, v: V, w: W, x: X, y: Y, z: Z, ...args: any[]) => TReturn;
-
-    // #endregion
-
-    // #endregion
-
-    // region 8+ additional arguments
-    // #region 8+ additional arguments
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param fn The function whose context will be changed.
-     * @param context The object to which the context (`this`) of the function should be set.
-     * @param additionalArguments Any number of arguments to be passed to the function referenced in the function argument.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Change the context of functions bound to a click handler using the &quot;function, context&quot; signature. Unbind the first handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  type: "zombie",
-  test: function( event ) {
-    // Without proxy, `this` would refer to the event target
-    // use event.target to reference that element.
-    var element = event.target;
-    $( element ).css( "background-color", "red" );
-​
-    // With proxy, `this` refers to the me object encapsulating
-    // this function.
-    $( "#log" ).append( "Hello " + this.type + "<br>" );
-    $( "#test" ).off( "click", this.test );
-  }
-};
-​
-var you = {
-  type: "person",
-  test: function( event ) {
-    $( "#log" ).append( this.type + " " );
-  }
-};
-​
-// Execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
-var youClick = $.proxy( you.test, you );
-​
-// attach click handlers to #test
-$( "#test" )
-  // this === "zombie"; handler unbound after first click
-  .on( "click", $.proxy( me.test, me ) )
-​
-  // this === "person"
-  .on( "click", youClick )
-​
-  // this === "zombie"
-  .on( "click", $.proxy( you.test, me ) )
-​
-  // this === "<button> element"
-  .on( "click", you.test );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the context of a function bound to the click handler,
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button type="button" id="test">Test</button></p>
-<div id="log"></div>
-​
-<script>
-var me = {
-  // I'm a dog
-  type: "dog",
-​
-  // Note that event comes *after* one and two
-  test: function( one, two, event ) {
-    $( "#log" )
-​
-      // `one` maps to `you`, the 1st additional
-      // argument in the $.proxy function call
-      .append( "<h3>Hello " + one.type + ":</h3>" )
-​
-      // The `this` keyword refers to `me`
-      // (the 2nd, context, argument of $.proxy)
-      .append( "I am a " + this.type + ", " )
-​
-      // `two` maps to `they`, the 2nd additional
-      // argument in the $.proxy function call
-      .append( "and they are " + two.type + ".<br>" )
-​
-      // The event type is "click"
-      .append( "Thanks for " + event.type + "ing." )
-​
-      // The clicked element is `event.target`,
-      // and its type is "button"
-      .append( "the " + event.target.type + "." );
-  }
-};
-​
-var you = { type: "cat" };
-var they = { type: "fish" };
-​
-// Set up handler to execute me.test() in the context
-// of `me`, with `you` and `they` as additional arguments
-var proxy = $.proxy( me.test, me, you, they );
-​
-$( "#test" )
-  .on( "click", proxy );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object,
-        TReturn>(fn: (...args: any[]) => TReturn,
-                 context: TContext,
-                 ...additionalArguments: any[]): (this: TContext, ...args: any[]) => TReturn;
-
-    // #endregion
-
-    // #endregion
-
-    // region (context, name)
-    // #region (context, name)
-
-    /**
-     * Takes a function and returns a new one that will always have a particular context.
-     *
-     * @param context The object to which the context of the function should be set.
-     * @param name The name of the function whose context will be changed (should be a property of the context object).
-     * @param additionalArguments Any number of arguments to be passed to the function named in the name argument.
-     * @see \`{@link https://api.jquery.com/jQuery.proxy/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link Function#bind }\`.
-     * @example ​ ````Enforce the context of the function using the &quot;context, function name&quot; signature. Unbind the handler after first click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.proxy demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-  <p><button id="test">Test</button></p>
-  <p id="log"></p>
-​
-<script>
-var obj = {
-  name: "John",
-  test: function() {
-    $( "#log" ).append( this.name );
-    $( "#test" ).off( "click", obj.test );
-  }
-};
-$( "#test" ).on( "click", jQuery.proxy( obj, "test" ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    proxy<TContext extends object>(context: TContext,
-                                   name: keyof TContext,
-                                   ...additionalArguments: any[]): (this: TContext, ...args: any[]) => any;
-
-    // #endregion
-
-    // #endregion
-
-    /**
-     * Manipulate the queue of functions to be executed on the matched element.
-     *
-     * @param element A DOM element where the array of queued functions is attached.
-     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
-     * @param newQueue The new function to add to the queue.
-     *                 An array of functions to replace the current queue contents.
-     * @see \`{@link https://api.jquery.com/jQuery.queue/ }\`
-     * @since 1.3
-     * @example ​ ````Show the length of the queue.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.queue demo</title>
-  <style>
-  div {
-    margin: 3px;
-    width: 40px;
-    height: 40px;
-    position: absolute;
-    left: 0px;
-    top: 30px;
-    background: green;
-    display: none;
-  }
-  div.newcolor {
-    background: blue;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="show">Show Length of Queue</button>
-<span></span>
-<div></div>
-  ​
-<script>
-$( "#show" ).click(function() {
-  var n = jQuery.queue( $( "div" )[ 0 ], "fx" );
-  $( "span" ).text( "Queue length is: " + n.length );
-});
-​
-function runIt() {
-  $( "div" )
-    .show( "slow" )
-    .animate({
-      left: "+=200"
-    }, 2000 )
-    .slideToggle( 1000 )
-    .slideToggle( "fast" )
-    .animate({
-      left: "-=200"
-    }, 1500 )
-    .hide( "slow" )
-    .show( 1200 )
-    .slideUp( "normal", runIt );
-}
-​
-runIt();
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Queue a custom function.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.queue demo</title>
-  <style>
-  div {
-    margin: 3px;
-    width: 40px;
-    height: 40px;
-    position: absolute;
-    left: 0px;
-    top: 30px;
-    background: green;
-    display: none;
-  }
-  div.newcolor {
-    background: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-Click here...
-<div></div>
-​
-<script>
-$( document.body ).click(function() {
-  var divs = $( "div" )
-    .show( "slow" )
-    .animate({ left: "+=200" }, 2000 );
-  jQuery.queue( divs[ 0 ], "fx", function() {
-    $( this ).addClass( "newcolor" );
-    jQuery.dequeue( this );
-  });
-  divs.animate({ left: "-=200" }, 500 );
-  jQuery.queue( divs[ 0 ], "fx", function() {
-    $( this ).removeClass( "newcolor" );
-    jQuery.dequeue( this );
-  });
-  divs.slideUp();
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Set a queue array to delete the queue.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.queue demo</title>
-  <style>
-  div {
-    margin: 3px;
-    width: 40px;
-    height: 40px;
-    position: absolute;
-    left: 0px;
-    top: 30px;
-    background: green;
-    display: none;
-  }
-  div.newcolor {
-    background: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="start">Start</button>
-<button id="stop">Stop</button>
-<div></div>
-​
-<script>
-$( "#start" ).click(function() {
-  var divs = $( "div" )
-    .show( "slow" )
-    .animate({ left: "+=200" }, 5000 );
-  jQuery.queue( divs[ 0 ], "fx", function() {
-    $( this ).addClass( "newcolor" );
-    jQuery.dequeue( this );
-  });
-  divs.animate({ left: "-=200" }, 1500 );
-  jQuery.queue( divs[ 0 ], "fx", function() {
-    $( this ).removeClass( "newcolor" );
-    jQuery.dequeue( this );
-  });
-  divs.slideUp();
-});
-$( "#stop" ).click(function() {
-  jQuery.queue( $( "div" )[ 0 ], "fx", [] );
-  $( "div" ).stop();
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    queue<T extends Element>(element: T, queueName?: string, newQueue?: JQuery.TypeOrArray<JQuery.QueueFunction<T>>): JQuery.Queue<T>;
-    /**
-     * Handles errors thrown synchronously in functions wrapped in jQuery().
-     *
-     * @param error An error thrown in the function wrapped in jQuery().
-     * @see \`{@link https://api.jquery.com/jQuery.readyException/ }\`
-     * @since 3.1
-     * @example ​ ````Pass the received error to console.error.
-```javascript
-jQuery.readyException = function( error ) {
-  console.error( error );
-};
-```
-     */
-    readyException(error: Error): any;
-    /**
-     * Remove a previously-stored piece of data.
-     *
-     * @param element A DOM element from which to remove data.
-     * @param name A string naming the piece of data to remove.
-     * @see \`{@link https://api.jquery.com/jQuery.removeData/ }\`
-     * @since 1.2.3
-     * @example ​ ````Set a data store for 2 names then remove one of them.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.removeData demo</title>
-  <style>
-  div {
-    margin: 2px;
-    color: blue;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>value1 before creation: <span></span></div>
-<div>value1 after creation: <span></span></div>
-<div>value1 after removal: <span></span></div>
-<div>value2 after removal: <span></span></div>
-​
-<script>
-var div = $( "div" )[ 0 ];
-$( "span:eq(0)" ).text( "" + $( "div" ).data( "test1" ) );
-jQuery.data( div, "test1", "VALUE-1" );
-jQuery.data( div, "test2", "VALUE-2" );
-$( "span:eq(1)" ).text( "" + jQuery.data( div, "test1" ) );
-jQuery.removeData( div, "test1" );
-$( "span:eq(2)" ).text( "" + jQuery.data( div, "test1" ) );
-$( "span:eq(3)" ).text( "" + jQuery.data( div, "test2" ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    removeData(element: Element | Document | Window | JQuery.PlainObject, name?: string): void;
-    /**
-     * Creates an object containing a set of properties ready to be used in the definition of custom animations.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param easing A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/jQuery.speed/ }\`
-     * @since 1.1
-     */
-    speed<TElement extends Element = HTMLElement>(duration: JQuery.Duration, easing: string, complete: (this: TElement) => void): JQuery.EffectsOptions<TElement>;
-    /**
-     * Creates an object containing a set of properties ready to be used in the definition of custom animations.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param easing_complete _&#x40;param_ `easing_complete`
-     * <br>
-     * * `easing` — A string indicating which easing function to use for the transition. <br>
-     * * `complete` — A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/jQuery.speed/ }\`
-     * @since 1.0
-     * @since 1.1
-     */
-    speed<TElement extends Element = HTMLElement>(duration: JQuery.Duration,
-                                                  easing_complete: string | ((this: TElement) => void)): JQuery.EffectsOptions<TElement>;
-    /**
-     * Creates an object containing a set of properties ready to be used in the definition of custom animations.
-     *
-     * @param duration_complete_settings _&#x40;param_ `duration_complete_settings`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
-     * * `settings` —
-     * @see \`{@link https://api.jquery.com/jQuery.speed/ }\`
-     * @since 1.0
-     * @since 1.1
-     */
-    speed<TElement extends Element = HTMLElement>(duration_complete_settings?: JQuery.Duration | ((this: TElement) => void) | JQuery.SpeedSettings<TElement>): JQuery.EffectsOptions<TElement>;
-    /**
-     * Remove the whitespace from the beginning and end of a string.
-     *
-     * @param str The string to trim.
-     * @see \`{@link https://api.jquery.com/jQuery.trim/ }\`
-     * @since 1.0
-     * @example ​ ````Remove the white spaces at the start and at the end of the string.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.trim demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<pre id="original"></pre>
-<pre id="trimmed"></pre>
-​
-<script>
-var str = "         lots of spaces before and after         ";
-$( "#original" ).html( "Original String: '" + str + "'" );
-$( "#trimmed" ).html( "$.trim()'ed: '" + $.trim(str) + "'" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Remove the white spaces at the start and at the end of the string.
-```javascript
-$.trim("    hello, how are you?    ");
-```
-     * @example ​ ````Remove the white spaces at the start and at the end of the string.
-```javascript
-$.trim("    hello, how are you?    ");
-```
-     */
-    trim(str: string): string;
-    /**
-     * Determine the internal JavaScript [[Class]] of an object.
-     *
-     * @param obj Object to get the internal JavaScript [[Class]] of.
-     * @see \`{@link https://api.jquery.com/jQuery.type/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. See \`{@link https://github.com/jquery/jquery/issues/3605 }`.
-     * @example ​ ````Find out if the parameter is a RegExp.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.type demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-Is it a RegExp? <b></b>
-​
-<script>
-$( "b" ).append( "" + jQuery.type( /test/ ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    type(obj: any): 'array' | 'boolean' | 'date' | 'error' | 'function' | 'null' | 'number' | 'object' | 'regexp' | 'string' | 'symbol' | 'undefined';
-    /**
-     * @description Sorts an array of DOM elements, in place, with the duplicates removed. Note that this only works on
-     * arrays of DOM elements, not strings or numbers.
-     *
-     * @param array The Array of DOM elements.
-     * @see \`{@link https://api.jquery.com/jQuery.unique/ }\`
-     * @since 1.1.3
-     * @deprecated ​ Deprecated since 3.0. Use \`{@link uniqueSort }\`.
-     *
-     * **Cause**: The fact that `jQuery.unique` sorted its results in DOM order was surprising to many who did not read the documentation carefully. As of jQuery 3.0 this function is being renamed to make it clear.
-     *
-     * **Solution**: Replace all uses of `jQuery.unique` with `jQuery.uniqueSort` which is the same function with a better name.
-     * @example ​ ````Removes any duplicate elements from the array of divs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.unique demo</title>
-  <style>
-  div {
-    color: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>There are 6 divs in this document.</div>
-<div></div>
-<div class="dup"></div>
-<div class="dup"></div>
-<div class="dup"></div>
-<div></div>
-​
-<script>
-// unique() must take a native array
-var divs = $( "div" ).get();
-​
-// Add 3 elements of class dup too (they are divs)
-divs = divs.concat( $( ".dup" ).get() );
-$( "div:eq(1)" ).text( "Pre-unique there are " + divs.length + " elements." );
-​
-divs = jQuery.unique( divs );
-$( "div:eq(2)" ).text( "Post-unique there are " + divs.length + " elements." )
-  .css( "color", "red" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    unique<T extends Element>(array: T[]): T[];
-    /**
-     * Sorts an array of DOM elements, in place, with the duplicates removed. Note that this only works on
-     * arrays of DOM elements, not strings or numbers.
-     *
-     * @param array The Array of DOM elements.
-     * @see \`{@link https://api.jquery.com/jQuery.uniqueSort/ }\`
-     * @since 1.12
-     * @since 2.2
-     * @example ​ ````Removes any duplicate elements from the array of divs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.uniqueSort demo</title>
-  <style>
-  div {
-    color: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>There are 6 divs in this document.</div>
-<div></div>
-<div class="dup"></div>
-<div class="dup"></div>
-<div class="dup"></div>
-<div></div>
-​
-<script>
-// unique() must take a native array
-var divs = $( "div" ).get();
-​
-// Add 3 elements of class dup too (they are divs)
-divs = divs.concat( $( ".dup" ).get() );
-$( "div:eq(1)" ).text( "Pre-unique there are " + divs.length + " elements." );
-​
-divs = jQuery.uniqueSort( divs );
-$( "div:eq(2)" ).text( "Post-unique there are " + divs.length + " elements." )
-  .css( "color", "red" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    uniqueSort<T extends Element>(array: T[]): T[];
-    /**
-     * Provides a way to execute callback functions based on zero or more Thenable objects, usually
-     * Deferred objects that represent asynchronous events.
-     *
-     * @see \`{@link https://api.jquery.com/jQuery.when/ }\`
-     * @since 1.5
-     * @example ​ ````Execute a function after two Ajax requests are successful. (See the jQuery.ajax() documentation for a complete description of success and error cases for an ajax request).
-```javascript
-$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) ).done(function( a1, a2 ) {
-  // a1 and a2 are arguments resolved for the page1 and page2 ajax requests, respectively.
-  // Each argument is an array with the following structure: [ data, statusText, jqXHR ]
-  var data = a1[ 0 ] + a2[ 0 ]; // a1[ 0 ] = "Whip", a2[ 0 ] = " It"
-  if ( /Whip It/.test( data ) ) {
-    alert( "We got what we came for!" );
-  }
-});
-```
-     * @example ​ ````Execute the function myFunc when both ajax requests are successful, or myFailure if either one has an error.
-```javascript
-$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) )
-  .then( myFunc, myFailure );
-```
-     */
-    when<TR1, UR1, VR1,
-        TJ1 = any, UJ1 = any, VJ1 = any>(
-            deferredT: JQuery.Promise<TR1, TJ1> | JQuery.Thenable<TR1> | TR1,
-            deferredU: JQuery.Promise<UR1, UJ1> | JQuery.Thenable<UR1> | UR1,
-            deferredV: JQuery.Promise<VR1, VJ1> | JQuery.Thenable<VR1> | VR1,
-    ): JQuery.Promise3<
-        TR1, TJ1, never,
-        UR1, UJ1, never,
-        VR1, VJ1, never>;
-    /**
-     * Provides a way to execute callback functions based on zero or more Thenable objects, usually
-     * Deferred objects that represent asynchronous events.
-     *
-     * @see \`{@link https://api.jquery.com/jQuery.when/ }\`
-     * @since 1.5
-     * @example ​ ````Execute a function after two Ajax requests are successful. (See the jQuery.ajax() documentation for a complete description of success and error cases for an ajax request).
-```javascript
-$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) ).done(function( a1, a2 ) {
-  // a1 and a2 are arguments resolved for the page1 and page2 ajax requests, respectively.
-  // Each argument is an array with the following structure: [ data, statusText, jqXHR ]
-  var data = a1[ 0 ] + a2[ 0 ]; // a1[ 0 ] = "Whip", a2[ 0 ] = " It"
-  if ( /Whip It/.test( data ) ) {
-    alert( "We got what we came for!" );
-  }
-});
-```
-     * @example ​ ````Execute the function myFunc when both ajax requests are successful, or myFailure if either one has an error.
-```javascript
-$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) )
-  .then( myFunc, myFailure );
-```
-     */
-    when<TR1, UR1,
-        TJ1 = any, UJ1 = any>(
-            deferredT: JQuery.Promise<TR1, TJ1> | JQuery.Thenable<TR1> | TR1,
-            deferredU: JQuery.Promise<UR1, UJ1> | JQuery.Thenable<UR1> | UR1,
-    ): JQuery.Promise2<
-        TR1, TJ1, never,
-        UR1, UJ1, never>;
-    /**
-     * Provides a way to execute callback functions based on zero or more Thenable objects, usually
-     * Deferred objects that represent asynchronous events.
-     *
-     * @see \`{@link https://api.jquery.com/jQuery.when/ }\`
-     * @since 1.5
-     * @example ​ ````Execute a function after two Ajax requests are successful. (See the jQuery.ajax() documentation for a complete description of success and error cases for an ajax request).
-```javascript
-$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) ).done(function( a1, a2 ) {
-  // a1 and a2 are arguments resolved for the page1 and page2 ajax requests, respectively.
-  // Each argument is an array with the following structure: [ data, statusText, jqXHR ]
-  var data = a1[ 0 ] + a2[ 0 ]; // a1[ 0 ] = "Whip", a2[ 0 ] = " It"
-  if ( /Whip It/.test( data ) ) {
-    alert( "We got what we came for!" );
-  }
-});
-```
-     * @example ​ ````Execute the function myFunc when both ajax requests are successful, or myFailure if either one has an error.
-```javascript
-$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) )
-  .then( myFunc, myFailure );
-```
-     */
-    when<TR1, TJ1,
-        TR2, TJ2,
-        TR3 = never, TJ3 = never>(
-            deferredT: JQuery.Promise3<TR1, TJ1, any, TR2, TJ2, any, TR3, TJ3, any> |
-                       JQuery.Promise2<TR1, TJ1, any, TR2, TJ2, any>
-    ): JQuery.Promise3<
-        TR1, TJ1, never,
-        TR2, TJ2, never,
-        TR3, TJ3, never>;
-    /**
-     * Provides a way to execute callback functions based on zero or more Thenable objects, usually
-     * Deferred objects that represent asynchronous events.
-     *
-     * @see \`{@link https://api.jquery.com/jQuery.when/ }\`
-     * @since 1.5
-     * @example ​ ````Execute a function after two Ajax requests are successful. (See the jQuery.ajax() documentation for a complete description of success and error cases for an ajax request).
-```javascript
-$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) ).done(function( a1, a2 ) {
-  // a1 and a2 are arguments resolved for the page1 and page2 ajax requests, respectively.
-  // Each argument is an array with the following structure: [ data, statusText, jqXHR ]
-  var data = a1[ 0 ] + a2[ 0 ]; // a1[ 0 ] = "Whip", a2[ 0 ] = " It"
-  if ( /Whip It/.test( data ) ) {
-    alert( "We got what we came for!" );
-  }
-});
-```
-     * @example ​ ````Execute the function myFunc when both ajax requests are successful, or myFailure if either one has an error.
-```javascript
-$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) )
-  .then( myFunc, myFailure );
-```
-     */
-    when<TR1, TJ1 = any>(deferred: JQuery.Promise<TR1, TJ1> | JQuery.Thenable<TR1> | TR1): JQuery.Promise<TR1, TJ1, never>;
-    /**
-     * Provides a way to execute callback functions based on zero or more Thenable objects, usually
-     * Deferred objects that represent asynchronous events.
-     *
-     * @param deferreds Zero or more Thenable objects.
-     * @see \`{@link https://api.jquery.com/jQuery.when/ }\`
-     * @since 1.5
-     * @example ​ ````Execute a function after two Ajax requests are successful. (See the jQuery.ajax() documentation for a complete description of success and error cases for an ajax request).
-```javascript
-$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) ).done(function( a1, a2 ) {
-  // a1 and a2 are arguments resolved for the page1 and page2 ajax requests, respectively.
-  // Each argument is an array with the following structure: [ data, statusText, jqXHR ]
-  var data = a1[ 0 ] + a2[ 0 ]; // a1[ 0 ] = "Whip", a2[ 0 ] = " It"
-  if ( /Whip It/.test( data ) ) {
-    alert( "We got what we came for!" );
-  }
-});
-```
-     * @example ​ ````Execute the function myFunc when both ajax requests are successful, or myFailure if either one has an error.
-```javascript
-$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) )
-  .then( myFunc, myFailure );
-```
-     */
-    when<TR1 = never, TJ1 = never>(...deferreds: Array<JQuery.Promise<TR1, TJ1> | JQuery.Thenable<TR1> | TR1>): JQuery.Promise<TR1, TJ1, never>;
-    /**
-     * Provides a way to execute callback functions based on zero or more Thenable objects, usually
-     * Deferred objects that represent asynchronous events.
-     *
-     * @param deferreds Zero or more Thenable objects.
-     * @see \`{@link https://api.jquery.com/jQuery.when/ }\`
-     * @since 1.5
-     * @example ​ ````Execute a function after two Ajax requests are successful. (See the jQuery.ajax() documentation for a complete description of success and error cases for an ajax request).
-```javascript
-$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) ).done(function( a1, a2 ) {
-  // a1 and a2 are arguments resolved for the page1 and page2 ajax requests, respectively.
-  // Each argument is an array with the following structure: [ data, statusText, jqXHR ]
-  var data = a1[ 0 ] + a2[ 0 ]; // a1[ 0 ] = "Whip", a2[ 0 ] = " It"
-  if ( /Whip It/.test( data ) ) {
-    alert( "We got what we came for!" );
-  }
-});
-```
-     * @example ​ ````Execute the function myFunc when both ajax requests are successful, or myFailure if either one has an error.
-```javascript
-$.when( $.ajax( "/page1.php" ), $.ajax( "/page2.php" ) )
-  .then( myFunc, myFailure );
-```
-     */
-    when(...deferreds: any[]): JQuery.Promise<any, any, never>;
-}
-
-interface JQuery<TElement = HTMLElement> extends Iterable<TElement> {
-    /**
-     * A string containing the jQuery version number.
-     *
-     * @see \`{@link https://api.jquery.com/jquery-2/#jquery1 }\`
-     * @since 1.0
-     * @example ​ ````Determine if an object is a jQuery object
-```javascript
-var a = { what: "A regular JS object" },
-  b = $( "body" );
-​
-if ( a.jquery ) { // Falsy, since it's undefined
-  alert( "a is a jQuery object!" );
-}
-​
-if ( b.jquery ) { // Truthy, since it's a string
-    alert( "b is a jQuery object!" );
-}
-```
-     * @example ​ ````Get the current version of jQuery running on the page
-```javascript
-alert( "You are running jQuery version: " + $.fn.jquery );
-```
-     */
-    jquery: string;
-    /**
-     * The number of elements in the jQuery object.
-     *
-     * @see \`{@link https://api.jquery.com/length/ }\`
-     * @since 1.0
-     * @example ​ ````Count the divs.  Click to add more.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>length demo</title>
-  <style>
-  body {
-    cursor: pointer;
-  }
-  div {
-    width: 50px;
-    height: 30px;
-    margin: 5px;
-    float: left;
-    background: green;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​<span></span>
-  <div></div>​
-<script>
-$( document.body )
-  .click(function() {
-    $( document.body ).append( $( "<div>" ) );
-    var n = $( "div" ).length;
-    $( "span" ).text( "There are " + n + " divs." +
-      "Click to add more.");
-  })
-  // Trigger the click to start
-  .trigger( "click" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    length: number;
-    /**
-     * Create a new jQuery object with elements added to the set of matched elements.
-     *
-     * @param selector A string representing a selector expression to find additional elements to add to the set of matched elements.
-     * @param context The point in the document at which the selector should begin matching; similar to the context
-     *                argument of the $(selector, context) method.
-     * @see \`{@link https://api.jquery.com/add/ }\`
-     * @since 1.4
-     */
-    add(selector: JQuery.Selector, context: Element): this;
-    /**
-     * Create a new jQuery object with elements added to the set of matched elements.
-     *
-     * @param selector A string representing a selector expression to find additional elements to add to the set of matched elements.
-     *                 One or more elements to add to the set of matched elements.
-     *                 An HTML fragment to add to the set of matched elements.
-     *                 An existing jQuery object to add to the set of matched elements.
-     * @see \`{@link https://api.jquery.com/add/ }\`
-     * @since 1.0
-     * @since 1.3.2
-     * @example ​ ````Finds all divs and makes a border.  Then adds all paragraphs to the jQuery object to set their backgrounds yellow.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>add demo</title>
-  <style>
-  div {
-    width: 60px;
-    height: 60px;
-    margin: 10px;
-    float: left;
-  }
-  p {
-    clear: left;
-    font-weight: bold;
-    font-size: 16px;
-    color: blue;
-    margin: 0 10px;
-    padding: 2px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div></div>
-<div></div>
-<div></div>
-<div></div>
-<div></div>
-<div></div>
-​
-<p>Added this... (notice no border)</p>
-​
-<script>
-$( "div" ).css( "border", "2px solid red" )
-  .add( "p" )
-  .css( "background", "yellow" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Adds more elements, matched by the given expression, to the set of matched elements.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>add demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<span>Hello Again</span>
-​
-<script>
-$( "p" ).add( "span" ).css( "background", "yellow" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Adds more elements, created on the fly, to the set of matched elements.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>add demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-​
-<script>
-$( "p" ).clone().add( "<span>Again</span>" ).appendTo( document.body );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Adds one or more Elements to the set of matched elements.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>add demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<span id="a">Hello Again</span>
-​
-<script>
-$( "p" ).add( document.getElementById( "a" ) ).css( "background", "yellow" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Demonstrates how to add (or push) elements to an existing collection
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>add demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<span id="a">Hello Again</span>
-​
-<script>
-var collection = $( "p" );
-// Capture the new collection
-collection = collection.add( document.getElementById( "a" ) );
-collection.css( "background", "yellow" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    add(selector: JQuery.Selector | JQuery.TypeOrArray<Element> | JQuery.htmlString | JQuery): this;
-    /**
-     * Add the previous set of elements on the stack to the current set, optionally filtered by a selector.
-     *
-     * @param selector A string containing a selector expression to match the current set of elements against.
-     * @see \`{@link https://api.jquery.com/addBack/ }\`
-     * @since 1.8
-     * @example ​ ````The .addBack() method causes the previous set of DOM elements in the traversal stack to be added to the current set. In the first example, the top stack contains the set resulting from .find(&quot;p&quot;). In the second example, .addBack() adds the previous set of elements on the stack — in this case $(&quot;div.after-addback&quot;) — to the current set, selecting both the div and its enclosed paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>addBack demo</title>
-  <style>
-  p, div {
-    margin: 5px;
-    padding: 5px;
-  }
-  .border {
-    border: 2px solid red;
-  }
-  .background {
-    background: yellow;
-  }
-  .left, .right {
-    width: 45%;
-    float: left;
-  }
-  .right {
-    margin-left: 3%;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div class="left">
-  <p><strong>Before <code>addBack()</code></strong></p>
-  <div class="before-addback">
-    <p>First Paragraph</p>
-    <p>Second Paragraph</p>
-  </div>
-</div>
-<div class="right">
-  <p><strong>After <code>addBack()</code></strong></p>
-  <div class="after-addback">
-    <p>First Paragraph</p>
-    <p>Second Paragraph</p>
-  </div>
-</div>
-​
-<script>
-$( "div.left, div.right" ).find( "div, div > p" ).addClass( "border" );
-​
-// First Example
-$( "div.before-addback" ).find( "p" ).addClass( "background" );
-​
-// Second Example
-$( "div.after-addback" ).find( "p" ).addBack().addClass( "background" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    addBack(selector?: JQuery.Selector): this;
-    /**
-     * Adds the specified class(es) to each element in the set of matched elements.
-     *
-     * @param className One or more space-separated classes to be added to the class attribute of each matched element.
-     *                  An array of classes to be added to the class attribute of each matched element.
-     *                  A function returning one or more space-separated class names to be added to the existing class
-     *                  name(s). Receives the index position of the element in the set and the existing class name(s) as
-     *                  arguments. Within the function, this refers to the current element in the set.
-     * @see \`{@link https://api.jquery.com/addClass/ }\`
-     * @since 1.0
-     * @since 1.4
-     * @since 3.3
-     * @example ​ ````Add the class &quot;selected&quot; to the matched elements.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>addClass demo</title>
-  <style>
-  p {
-    margin: 8px;
-    font-size: 16px;
-  }
-  .selected {
-    color: blue;
-  }
-  .highlight {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<p>and</p>
-<p>Goodbye</p>
-​
-<script>
-$( "p" ).last().addClass( "selected" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Add the classes &quot;selected&quot; and &quot;highlight&quot; to the matched elements.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>addClass demo</title>
-  <style>
-  p {
-    margin: 8px;
-    font-size: 16px;
-  }
-  .selected {
-    color: red;
-  }
-  .highlight {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<p>and</p>
-<p>Goodbye</p>
-​
-<script>
-$( "p:last" ).addClass( "selected highlight" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Pass in a function to .addClass() to add the &quot;green&quot; class to a div that already has a &quot;red&quot; class.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>addClass demo</title>
-  <style>
-  div {
-    background: white;
-  }
-  .red {
-    background: red;
-  }
-  .red.green {
-    background: green;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
- <div>This div should be white</div>
- <div class="red">This div will be green because it now has the "green" and "red" classes.
-   It would be red if the addClass function failed.</div>
- <div>This div should be white</div>
- <p>There are zero green divs</p>
-​
-<script>
-$( "div" ).addClass(function( index, currentClass ) {
-  var addedClass;
-​
-  if ( currentClass === "red" ) {
-    addedClass = "green";
-    $( "p" ).text( "There is one green div" );
-  }
-​
-  return addedClass;
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    addClass(className: JQuery.TypeOrArray<string> | ((this: TElement, index: number, currentClassName: string) => string)): this;
-    /**
-     * Insert content, specified by the parameter, after each element in the set of matched elements.
-     *
-     * @param contents One or more additional DOM elements, text nodes, arrays of elements and text nodes, HTML strings, or
-     *                 jQuery objects to insert after each element in the set of matched elements.
-     * @see \`{@link https://api.jquery.com/after/ }\`
-     * @since 1.0
-     * @example ​ ````Inserts some HTML after all paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>after demo</title>
-  <style>
-  p {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>I would like to say: </p>
-​
-<script>
-$( "p" ).after( "<b>Hello</b>" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Inserts a DOM element after all paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>after demo</title>
-  <style>
-  p {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>I would like to say: </p>
-​
-<script>
-$( "p" ).after( document.createTextNode( "Hello" ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Inserts a jQuery object (similar to an Array of DOM Elements) after all paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>after demo</title>
-  <style>
-  p {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<b>Hello</b>
-<p>I would like to say: </p>
-​
-<script>
-$( "p" ).after( $( "b" ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    after(...contents: Array<JQuery.htmlString | JQuery.TypeOrArray<JQuery.Node | JQuery<JQuery.Node>>>): this;
-    /**
-     * Insert content, specified by the parameter, after each element in the set of matched elements.
-     *
-     * @param fn A function that returns an HTML string, DOM element(s), text node(s), or jQuery object to insert
-     *           after each element in the set of matched elements. Receives the index position of the element in the
-     *           set and the old HTML value of the element as arguments. Within the function, this refers to the
-     *           current element in the set.
-     * @see \`{@link https://api.jquery.com/after/ }\`
-     * @since 1.4
-     * @since 1.10
-     */
-    after(fn: (this: TElement, index: number, html: string) => JQuery.htmlString | JQuery.TypeOrArray<JQuery.Node | JQuery<JQuery.Node>>): this;
-    /**
-     * Register a handler to be called when Ajax requests complete. This is an AjaxEvent.
-     *
-     * @param handler The function to be invoked.
-     * @see \`{@link https://api.jquery.com/ajaxComplete/ }\`
-     * @since 1.0
-     * @example ​ ````Show a message when an Ajax request completes.
-```javascript
-$( document ).ajaxComplete(function( event, request, settings ) {
-  $( "#msg" ).append( "<li>Request Complete.</li>" );
-});
-```
-     */
-    ajaxComplete(handler: (this: Document, event: JQuery.Event<Document>, jqXHR: JQuery.jqXHR, ajaxOptions: JQuery.AjaxSettings) => void | false): this;
-    /**
-     * Register a handler to be called when Ajax requests complete with an error. This is an Ajax Event.
-     *
-     * @param handler The function to be invoked.
-     * @see \`{@link https://api.jquery.com/ajaxError/ }\`
-     * @since 1.0
-     * @example ​ ````Show a message when an Ajax request fails.
-```javascript
-$( document ).ajaxError(function( event, request, settings ) {
-  $( "#msg" ).append( "<li>Error requesting page " + settings.url + "</li>" );
-});
-```
-     */
-    ajaxError(handler: (this: Document, event: JQuery.Event<Document>, jqXHR: JQuery.jqXHR, ajaxSettings: JQuery.AjaxSettings, thrownError: string) => void | false): this;
-    /**
-     * Attach a function to be executed before an Ajax request is sent. This is an Ajax Event.
-     *
-     * @param handler The function to be invoked.
-     * @see \`{@link https://api.jquery.com/ajaxSend/ }\`
-     * @since 1.0
-     * @example ​ ````Show a message before an Ajax request is sent.
-```javascript
-$( document ).ajaxSend(function( event, request, settings ) {
-  $( "#msg" ).append( "<li>Starting request at " + settings.url + "</li>" );
-});
-```
-     */
-    ajaxSend(handler: (this: Document, event: JQuery.Event<Document>, jqXHR: JQuery.jqXHR, ajaxOptions: JQuery.AjaxSettings) => void | false): this;
-    /**
-     * Register a handler to be called when the first Ajax request begins. This is an Ajax Event.
-     *
-     * @param handler The function to be invoked.
-     * @see \`{@link https://api.jquery.com/ajaxStart/ }\`
-     * @since 1.0
-     * @example ​ ````Show a loading message whenever an Ajax request starts (and none is already active).
-```javascript
-$( document ).ajaxStart(function() {
-  $( "#loading" ).show();
-});
-```
-     */
-    ajaxStart(handler: (this: Document) => void | false): this;
-    /**
-     * Register a handler to be called when all Ajax requests have completed. This is an Ajax Event.
-     *
-     * @param handler The function to be invoked.
-     * @see \`{@link https://api.jquery.com/ajaxStop/ }\`
-     * @since 1.0
-     * @example ​ ````Hide a loading message after all the Ajax requests have stopped.
-```javascript
-$( document ).ajaxStop(function() {
-  $( "#loading" ).hide();
-});
-```
-     */
-    ajaxStop(handler: (this: Document) => void | false): this;
-    /**
-     * Attach a function to be executed whenever an Ajax request completes successfully. This is an Ajax Event.
-     *
-     * @param handler The function to be invoked.
-     * @see \`{@link https://api.jquery.com/ajaxSuccess/ }\`
-     * @since 1.0
-     * @example ​ ````Show a message when an Ajax request completes successfully.
-```javascript
-$( document ).ajaxSuccess(function( event, request, settings ) {
-  $( "#msg" ).append( "<li>Successful Request!</li>" );
-});
-```
-     */
-    ajaxSuccess(handler: (this: Document, event: JQuery.Event<Document>, jqXHR: JQuery.jqXHR, ajaxOptions: JQuery.AjaxSettings, data: JQuery.PlainObject) => void | false): this;
-    /**
-     * Perform a custom animation of a set of CSS properties.
-     *
-     * @param properties An object of CSS properties and values that the animation will move toward.
-     * @param duration A string or number determining how long the animation will run.
-     * @param easing A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/animate/ }\`
-     * @since 1.0
-     * @example ​ ````An example of using an &#39;easing&#39; function to provide a different style of animation. This will only work if you have a plugin that provides this easing function.  Note, this code will do nothing unless the paragraph element is hidden.
-```javascript
-$( "p" ).animate({
-  opacity: "show"
-}, "slow", "easein" );
-```
-     * @example ​ ````Animate all paragraphs and execute a callback function when the animation is complete.  The first argument is an object of CSS properties, the second specifies that the animation should take 1000 milliseconds to complete, the third states the easing type, and the fourth argument is an anonymous callback function.
-```javascript
-$( "p" ).animate({
-  height: 200,
-  width: 400,
-  opacity: 0.5
-}, 1000, "linear", function() {
-  alert( "all done" );
-});
-```
-     */
-    animate(properties: JQuery.PlainObject,
-            duration: JQuery.Duration,
-            easing: string,
-            complete?: (this: TElement) => void): this;
-    /**
-     * Perform a custom animation of a set of CSS properties.
-     *
-     * @param properties An object of CSS properties and values that the animation will move toward.
-     * @param duration_easing _&#x40;param_ `duration_easing`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `easing` — A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/animate/ }\`
-     * @since 1.0
-     * @example ​ ````Click the button to animate the div with a number of different properties.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>animate demo</title>
-  <style>
-  div {
-    background-color: #bca;
-    width: 100px;
-    border: 1px solid green;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="go">&raquo; Run</button>
-<div id="block">Hello!</div>
-​
-<script>
-// Using multiple unit types within one animation.
-​
-$( "#go" ).click(function() {
-  $( "#block" ).animate({
-    width: "70%",
-    opacity: 0.4,
-    marginLeft: "0.6in",
-    fontSize: "3em",
-    borderWidth: "10px"
-  }, 1500 );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Animates a div&#39;s left property with a relative value. Click several times on the buttons to see the relative animations queued up.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>animate demo</title>
-  <style>
-  div {
-    position: absolute;
-    background-color: #abc;
-    left: 50px;
-    width: 90px;
-    height: 90px;
-    margin: 5px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="left">&laquo;</button>
-<button id="right">&raquo;</button>
-<div class="block"></div>
-​
-<script>
-$( "#right" ).click(function() {
-  $( ".block" ).animate({ "left": "+=50px" }, "slow" );
-});
-​
-$( "#left" ).click(function(){
-  $( ".block" ).animate({ "left": "-=50px" }, "slow" );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Animate all paragraphs to toggle both height and opacity, completing the animation within 600 milliseconds.
-```javascript
-$( "p" ).animate({
-  height: "toggle",
-  opacity: "toggle"
-}, "slow" );
-```
-     * @example ​ ````Animate all paragraphs to a left style of 50 and opacity of 1 (opaque, visible), completing the animation within 500 milliseconds.
-```javascript
-$( "p" ).animate({
-  left: 50,
-  opacity: 1
-}, 500 );
-```
-     */
-    animate(properties: JQuery.PlainObject,
-            duration_easing: JQuery.Duration | string,
-            complete?: (this: TElement) => void): this;
-    /**
-     * Perform a custom animation of a set of CSS properties.
-     *
-     * @param properties An object of CSS properties and values that the animation will move toward.
-     * @param options A map of additional options to pass to the method.
-     * @see \`{@link https://api.jquery.com/animate/ }\`
-     * @since 1.0
-     * @example ​ ````The first button shows how an unqueued animation works.  It expands the div out to 90% width while the font-size is increasing. Once the font-size change is complete, the border animation will begin.
-
-The second button starts a traditional chained animation, where each animation will start once the previous animation on the element has completed.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>animate demo</title>
-  <style>
-  div {
-    background-color: #bca;
-    width: 200px;
-    height: 1.1em;
-    text-align: center;
-    border: 2px solid green;
-    margin: 3px;
-    font-size: 14px;
-  }
-  button {
-    font-size: 14px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="go1">&raquo; Animate Block1</button>
-<button id="go2">&raquo; Animate Block2</button>
-<button id="go3">&raquo; Animate Both</button>
-<button id="go4">&raquo; Reset</button>
-<div id="block1">Block1</div>
-<div id="block2">Block2</div>
-​
-<script>
-$( "#go1" ).click(function() {
-  $( "#block1" )
-    .animate({
-      width: "90%"
-    }, {
-      queue: false,
-      duration: 3000
-    })
-    .animate({ fontSize: "24px" }, 1500 )
-    .animate({ borderRightWidth: "15px" }, 1500 );
-});
-​
-$( "#go2" ).click(function() {
-  $( "#block2" )
-    .animate({ width: "90%" }, 1000 )
-    .animate({ fontSize: "24px" }, 1000 )
-    .animate({ borderLeftWidth: "15px" }, 1000 );
-});
-​
-$( "#go3" ).click(function() {
-  $( "#go1" ).add( "#go2" ).click();
-});
-​
-$( "#go4" ).click(function() {
-  $( "div" ).css({
-    width: "",
-    fontSize: "",
-    borderWidth: ""
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Animates the first div&#39;s left property and synchronizes the remaining divs, using the step function to set their left properties at each stage of the animation.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>animate demo</title>
-  <style>
-  div {
-    position: relative;
-    background-color: #abc;
-    width: 40px;
-    height: 40px;
-    float: left;
-    margin: 5px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button id="go">Run »</button></p>
-<div class="block"></div>
-<div class="block"></div>
-<div class="block"></div>
-<div class="block"></div>
-<div class="block"></div>
-<div class="block"></div>
-​
-<script>
-$( "#go" ).click(function() {
-  $( ".block:first" ).animate({
-    left: 100
-  }, {
-    duration: 1000,
-    step: function( now, fx ){
-      $( ".block:gt(0)" ).css( "left", now );
-    }
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Animate the left and opacity style properties of all paragraphs; run the animation outside the queue, so that it will automatically start without waiting for its turn.
-```javascript
-$( "p" ).animate({
-  left: "50px",
-  opacity: 1
-}, {
-  duration: 500,
-  queue: false
-});
-```
-     * @example ​ ````Animates all paragraphs to toggle both height and opacity, completing the animation within 600 milliseconds.
-```javascript
-$( "p" ).animate({
-  height: "toggle",
-  opacity: "toggle"
-}, {
-  duration: "slow"
-});
-```
-     * @example ​ ````Use an easing function to provide a different style of animation. This will only work if you have a plugin that provides this easing function.
-```javascript
-$( "p" ).animate({
-  opacity: "show"
-}, {
-  duration: "slow",
-  easing: "easein"
-});
-```
-     */
-    animate(properties: JQuery.PlainObject,
-            options: JQuery.EffectsOptions<TElement>): this;
-    /**
-     * Perform a custom animation of a set of CSS properties.
-     *
-     * @param properties An object of CSS properties and values that the animation will move toward.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/animate/ }\`
-     * @since 1.0
-     */
-    animate(properties: JQuery.PlainObject,
-            complete?: (this: TElement) => void): this;
-    /**
-     * Insert content, specified by the parameter, to the end of each element in the set of matched elements.
-     *
-     * @param contents One or more additional DOM elements, text nodes, arrays of elements and text nodes, HTML strings, or
-     *                 jQuery objects to insert at the end of each element in the set of matched elements.
-     * @see \`{@link https://api.jquery.com/append/ }\`
-     * @since 1.0
-     * @example ​ ````Appends some HTML to all paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>append demo</title>
-  <style>
-  p {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>I would like to say: </p>
-​
-<script>
-$( "p" ).append( "<strong>Hello</strong>" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Appends an Element to all paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>append demo</title>
-  <style>
-  p {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>I would like to say: </p>
-​
-<script>
-$( "p" ).append( document.createTextNode( "Hello" ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Appends a jQuery object (similar to an Array of DOM Elements) to all paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>append demo</title>
-  <style>
-  p {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<strong>Hello world!!!</strong>
-<p>I would like to say: </p>
-​
-<script>
-$( "p" ).append( $( "strong" ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    append(...contents: Array<JQuery.htmlString | JQuery.TypeOrArray<JQuery.Node | JQuery<JQuery.Node>>>): this;
-    /**
-     * Insert content, specified by the parameter, to the end of each element in the set of matched elements.
-     *
-     * @param fn A function that returns an HTML string, DOM element(s), text node(s), or jQuery object to insert at
-     *           the end of each element in the set of matched elements. Receives the index position of the element
-     *           in the set and the old HTML value of the element as arguments. Within the function, this refers to
-     *           the current element in the set.
-     * @see \`{@link https://api.jquery.com/append/ }\`
-     * @since 1.4
-     */
-    append(fn: (this: TElement, index: number, html: string) => JQuery.htmlString | JQuery.TypeOrArray<JQuery.Node | JQuery<JQuery.Node>>): this;
-    /**
-     * Insert every element in the set of matched elements to the end of the target.
-     *
-     * @param target A selector, element, HTML string, array of elements, or jQuery object; the matched set of elements
-     *               will be inserted at the end of the element(s) specified by this parameter.
-     * @see \`{@link https://api.jquery.com/appendTo/ }\`
-     * @since 1.0
-     * @example ​ ````Append all spans to the element with the ID &quot;foo&quot; (Check append() documentation for more examples)
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>appendTo demo</title>
-  <style>
-  #foo {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<span>I have nothing more to say... </span>
-​
-<div id="foo">FOO! </div>
-​
-<script>
-$( "span" ).appendTo( "#foo" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    appendTo(target: JQuery.Selector | JQuery.htmlString | JQuery.TypeOrArray<Element | DocumentFragment> | JQuery): this;
-    /**
-     * Set one or more attributes for the set of matched elements.
-     *
-     * @param attributeName The name of the attribute to set.
-     * @param value A value to set for the attribute. If null, the specified attribute will be removed (as in .removeAttr()).
-     *              A function returning the value to set. this is the current element. Receives the index position of
-     *              the element in the set and the old attribute value as arguments.
-     * @see \`{@link https://api.jquery.com/attr/ }\`
-     * @since 1.0
-     * @since 1.1
-     * @example ​ ````Set the id for divs based on the position in the page.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>attr demo</title>
-  <style>
-  div {
-    color: blue;
-  }
-  span {
-    color: red;
-  }
-  b {
-    font-weight: bolder;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>Zero-th <span></span></div>
-<div>First <span></span></div>
-<div>Second <span></span></div>
-​
-<script>
-$( "div" )
-  .attr( "id", function( arr ) {
-    return "div-id" + arr;
-  })
-  .each(function() {
-    $( "span", this ).html( "(id = '<b>" + this.id + "</b>')" );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Set the src attribute from title attribute on the image.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>attr demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<img title="hat.gif">
-​
-<script>
-$( "img" ).attr( "src", function() {
-  return "/resources/" + this.title;
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    attr(attributeName: string,
-         value: string | number | null | ((this: TElement, index: number, attr: string) => string | number | void | undefined)): this;
-    /**
-     * Set one or more attributes for the set of matched elements.
-     *
-     * @param attributes An object of attribute-value pairs to set.
-     * @see \`{@link https://api.jquery.com/attr/ }\`
-     * @since 1.0
-     * @example ​ ````Set some attributes for all &lt;img&gt;s in the page.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>attr demo</title>
-  <style>
-  img {
-    padding: 10px;
-  }
-  div {
-    color: red;
-    font-size: 24px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<img>
-<img>
-<img>
-​
-<div><b>Attribute of Ajax</b></div>
-​
-<script>
-$( "img" ).attr({
-  src: "/resources/hat.gif",
-  title: "jQuery",
-  alt: "jQuery Logo"
-});
-$( "div" ).text( $( "img" ).attr( "alt" ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    attr(attributes: JQuery.PlainObject): this;
-    /**
-     * Get the value of an attribute for the first element in the set of matched elements.
-     *
-     * @param attributeName The name of the attribute to get.
-     * @see \`{@link https://api.jquery.com/attr/ }\`
-     * @since 1.0
-     * @example ​ ````Display the checked attribute and property of a checkbox as it changes.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>attr demo</title>
-  <style>
-  p {
-    margin: 20px 0 0;
-  }
-  b {
-    color: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<input id="check1" type="checkbox" checked="checked">
-<label for="check1">Check me</label>
-<p></p>
-​
-<script>
-$( "input" )
-  .change(function() {
-    var $input = $( this );
-    $( "p" ).html( ".attr( 'checked' ): <b>" + $input.attr( "checked" ) + "</b><br>" +
-      ".prop( 'checked' ): <b>" + $input.prop( "checked" ) + "</b><br>" +
-      ".is( ':checked' ): <b>" + $input.is( ":checked" ) + "</b>" );
-  })
-  .change();
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Find the title attribute of the first &lt;em&gt; in the page.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>attr demo</title>
-  <style>
-  em {
-    color: blue;
-    font-weight: bold;
-  }
-  div {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Once there was a <em title="huge, gigantic">large</em> dinosaur...</p>
-​
-The title of the emphasis is:<div></div>
-​
-<script>
-var title = $( "em" ).attr( "title" );
-$( "div" ).text( title );
-</script>
-​
-</body>
-</html>
-```
-     */
-    attr(attributeName: string): string | undefined;
-    /**
-     * Insert content, specified by the parameter, before each element in the set of matched elements.
-     *
-     * @param contents One or more additional DOM elements, text nodes, arrays of elements and text nodes, HTML strings, or
-     *                 jQuery objects to insert before each element in the set of matched elements.
-     * @see \`{@link https://api.jquery.com/before/ }\`
-     * @since 1.0
-     * @example ​ ````Inserts some HTML before all paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>before demo</title>
-  <style>
-  p {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p> is what I said...</p>
-​
-<script>
-$( "p" ).before( "<b>Hello</b>" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Inserts a DOM element before all paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>before demo</title>
-  <style>
-  p {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p> is what I said...</p>
-​
-<script>
-$( "p" ).before( document.createTextNode( "Hello" ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Inserts a jQuery object (similar to an Array of DOM Elements) before all paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>before demo</title>
-  <style>
-  p {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p> is what I said...</p><b>Hello</b>
-​
-<script>
-$( "p" ).before( $( "b" ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    before(...contents: Array<JQuery.htmlString | JQuery.TypeOrArray<JQuery.Node | JQuery<JQuery.Node>>>): this;
-    /**
-     * Insert content, specified by the parameter, before each element in the set of matched elements.
-     *
-     * @param fn A function that returns an HTML string, DOM element(s), text node(s), or jQuery object to insert
-     *           before each element in the set of matched elements. Receives the index position of the element in
-     *           the set and the old HTML value of the element as arguments. Within the function, this refers to the
-     *           current element in the set.
-     * @see \`{@link https://api.jquery.com/before/ }\`
-     * @since 1.4
-     * @since 1.10
-     */
-    before(fn: (this: TElement, index: number, html: string) => JQuery.htmlString | JQuery.TypeOrArray<JQuery.Node | JQuery<JQuery.Node>>): this;
-    // [bind() overloads] https://github.com/jquery/api.jquery.com/issues/1048
-    /**
-     * Attach a handler to an event for the elements.
-     *
-     * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/bind/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.0. Use \`{@link on }\`.
-     *
-     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
-     *
-     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
-     */
-    bind<TData>(eventType: string,
-                eventData: TData,
-                handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Attach a handler to an event for the elements.
-     *
-     * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
-     * @param handler A function to execute each time the event is triggered.
-     *                Setting the second argument to false will attach a function that prevents the default action from
-     *                occurring and stops the event from bubbling.
-     * @see \`{@link https://api.jquery.com/bind/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.0. Use \`{@link on }\`.
-     *
-     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
-     *
-     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
-     * @example ​ ````Handle click and double-click for the paragraph.  Note: the coordinates are window relative, so in this case relative to the demo iframe.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>bind demo</title>
-  <style>
-  p {
-    background: yellow;
-    font-weight: bold;
-    cursor: pointer;
-    padding: 5px;
-  }
-  p.over {
-     background: #ccc;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Click or double click here.</p>
-<span></span>
-​
-<script>
-$( "p" ).bind( "click", function( event ) {
-  var str = "( " + event.pageX + ", " + event.pageY + " )";
-  $( "span" ).text( "Click happened! " + str );
-});
-$( "p" ).bind( "dblclick", function() {
-  $( "span" ).text( "Double-click happened in " + this.nodeName );
-});
-$( "p" ).bind( "mouseenter mouseleave", function( event ) {
-  $( this ).toggleClass( "over" );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````To display each paragraph&#39;s text in an alert box whenever it is clicked:
-```javascript
-$( "p" ).bind( "click", function() {
-  alert( $( this ).text() );
-});
-```
-     * @example ​ ````Cancel a default action and prevent it from bubbling up by returning false:
-```javascript
-$( "form" ).bind( "submit", function() {
-  return false;
-})
-```
-     * @example ​ ````Cancel only the default action by using the .preventDefault() method.
-```javascript
-$( "form" ).bind( "submit", function( event ) {
-  event.preventDefault();
-});
-```
-     * @example ​ ````Stop an event from bubbling without preventing the default action by using the .stopPropagation() method.
-```javascript
-$( "form" ).bind( "submit", function( event ) {
-  event.stopPropagation();
-});
-```
-     * @example ​ ````Bind custom events.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>bind demo</title>
-  <style>
-  p {
-    color: red;
-  }
-  span {
-    color: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Has an attached custom event.</p>
-<button>Trigger custom event</button>
-<span style="display: none;"></span>
-​
-<script>
-$( "p" ).bind( "myCustomEvent", function( e, myName, myValue ) {
-  $( this ).text( myName + ", hi there!" );
-  $( "span" )
-    .stop()
-    .css( "opacity", 1 )
-    .text( "myName = " + myName )
-    .fadeIn( 30 )
-    .fadeOut( 1000 );
-  });
-$( "button" ).click(function() {
-  $( "p" ).trigger( "myCustomEvent", [ "John" ] );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    bind(eventType: string,
-         handler: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false | null | undefined): this;
-    /**
-     * Attach a handler to an event for the elements.
-     *
-     * @param events An object containing one or more DOM event types and functions to execute for them.
-     * @see \`{@link https://api.jquery.com/bind/ }\`
-     * @since 1.4
-     * @deprecated ​ Deprecated since 3.0. Use \`{@link on }\`.
-     *
-     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
-     *
-     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
-     * @example ​ ````Bind multiple events simultaneously.
-```javascript
-$( "div.test" ).bind({
-  click: function() {
-    $( this ).addClass( "active" );
-  },
-  mouseenter: function() {
-    $( this ).addClass( "inside" );
-  },
-  mouseleave: function() {
-    $( this ).removeClass( "inside" );
-  }
-});
-```
-     */
-    bind(events: JQuery.PlainObject<JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false>): this;
-    /**
-     * Bind an event handler to the "blur" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/blur/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    blur<TData>(eventData: TData,
-                handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "blur" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/blur/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````To trigger the blur event on all paragraphs:
-```javascript
-$( "p" ).blur();
-```
-     */
-    blur(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Bind an event handler to the "change" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/change/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    change<TData>(eventData: TData,
-                  handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "change" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/change/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````Attaches a change event to the select that gets the text for each selected option and writes them in the div.  It then triggers the event for the initial text draw.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>change demo</title>
-  <style>
-  div {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<select name="sweets" multiple="multiple">
-  <option>Chocolate</option>
-  <option selected="selected">Candy</option>
-  <option>Taffy</option>
-  <option selected="selected">Caramel</option>
-  <option>Fudge</option>
-  <option>Cookie</option>
-</select>
-<div></div>
-​
-<script>
-$( "select" )
-  .change(function () {
-    var str = "";
-    $( "select option:selected" ).each(function() {
-      str += $( this ).text() + " ";
-    });
-    $( "div" ).text( str );
-  })
-  .change();
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````To add a validity test to all text input elements:
-```javascript
-$( "input[type='text']" ).change(function() {
-  // Check input( $( this ).val() ) for validity here
-});
-```
-     */
-    change(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Get the children of each element in the set of matched elements, optionally filtered by a selector.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @see \`{@link https://api.jquery.com/children/ }\`
-     * @since 1.0
-     * @example ​ ````Find all children of the clicked element.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>children demo</title>
-  <style>
-  body {
-    font-size: 16px;
-    font-weight: bolder;
-  }
-  div {
-    width: 130px;
-    height: 82px;
-    margin: 10px;
-    float: left;
-    border: 1px solid blue;
-    padding: 4px;
-  }
-  #container {
-    width: auto;
-    height: 105px;
-    margin: 0;
-    float: none;
-    border: none;
-  }
-  .hilite {
-    border-color: red;
-  }
-  #results {
-    display: block;
-    color: red;
-  }
-  p, span, em, a, b, button {
-    border: 1px solid transparent;
-  }
-  p {
-    margin: 10px;
-  }
-  span {
-    color: blue;
-  }
-  input {
-    width: 100px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="container">
-  <div>
-    <p>This <span>is the <em>way</em> we</span>
-      write <em>the</em> demo,</p>
-  </div>
-​
-  <div>
-    <a href="#"><b>w</b>rit<b>e</b></a> the <span>demo,</span> <button>write
-    the</button> demo,
-  </div>
-​
-  <div>
-    This <span>the way we <em>write</em> the <em>demo</em> so</span>
-    <input type="text" value="early"> in
-  </div>
-​
-  <p>
-    <span>t</span>he <span>m</span>orning.
-    <span id="results">Found <span>0</span> children in <span>TAG</span>.</span>
-  </p>
-</div>
-​
-<script>
-$( "#container" ).click(function ( event ) {
-  $( "*" ).removeClass( "hilite" );
-  var kids = $( event.target ).children();
-  var len = kids.addClass( "hilite" ).length;
-​
-  $( "#results span:first" ).text( len );
-  $( "#results span:last" ).text( event.target.tagName );
-​
-  event.preventDefault();
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Find all children of each div.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>children demo</title>
-  <style>
-  body {
-    font-size: 16px;
-    font-weight: bolder;
-  }
-  span {
-    color: blue;
-  }
-  p {
-    margin: 5px 0;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello (this is a paragraph)</p>
-​
-<div><span>Hello Again (this span is a child of the a div)</span></div>
-<p>And <span>Again</span> (in another paragraph)</p>
-​
-<div>And One Last <span>Time</span> (most text directly in a div)</div>
-​
-<script>
-$( "div" ).children().css( "border-bottom", "3px double red" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Find all children with a class &quot;selected&quot; of each div.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>children demo</title>
-  <style>
-  body {
-    font-size: 16px;
-    font-weight: bolder;
-  }
-  p {
-    margin: 5px 0;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>
-  <span>Hello</span>
-  <p class="selected">Hello Again</p>
-  <div class="selected">And Again</div>
-  <p>And One Last Time</p>
-</div>
-​
-<script>
-$( "div" ).children( ".selected" ).css( "color", "blue" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    children(selector?: JQuery.Selector): this;
-    /**
-     * Remove from the queue all items that have not yet been run.
-     *
-     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
-     * @see \`{@link https://api.jquery.com/clearQueue/ }\`
-     * @since 1.4
-     * @example ​ ````Empty the queue.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>clearQueue demo</title>
-  <style>
-  div {
-    margin: 3px;
-    width: 40px;
-    height: 40px;
-    position: absolute;
-    left: 0px;
-    top: 30px;
-    background: green;
-    display: none;
-  }
-  div.newcolor {
-    background: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="start">Start</button>
-<button id="stop">Stop</button>
-<div></div>
-​
-<script>
-$( "#start" ).click(function() {
-  var myDiv = $( "div" );
-  myDiv.show( "slow" );
-  myDiv.animate({
-    left:"+=200"
-  }, 5000 );
-​
-  myDiv.queue(function() {
-    var that = $( this );
-    that.addClass( "newcolor" );
-    that.dequeue();
-  });
-​
-  myDiv.animate({
-    left:"-=200"
-  }, 1500 );
-  myDiv.queue(function() {
-    var that = $( this );
-    that.removeClass( "newcolor" );
-    that.dequeue();
-  });
-  myDiv.slideUp();
-});
-​
-$( "#stop" ).click(function() {
-  var myDiv = $( "div" );
-  myDiv.clearQueue();
-  myDiv.stop();
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    clearQueue(queueName?: string): this;
-    /**
-     * Bind an event handler to the "click" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/click/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    click<TData>(eventData: TData,
-                 handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "click" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/click/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````Hide paragraphs on a page when they are clicked:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>click demo</title>
-  <style>
-  p {
-    color: red;
-    margin: 5px;
-    cursor: pointer;
-  }
-  p:hover {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>First Paragraph</p>
-<p>Second Paragraph</p>
-<p>Yet one more Paragraph</p>
-​
-<script>
-$( "p" ).click(function() {
-  $( this ).slideUp();
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Trigger the click event on all of the paragraphs on the page:
-```javascript
-$( "p" ).click();
-```
-     */
-    click(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Create a deep copy of the set of matched elements.
-     *
-     * @param withDataAndEvents A Boolean indicating whether event handlers and data should be copied along with the elements. The
-     *                          default value is false. *In jQuery 1.5.0 the default value was incorrectly true; it was changed back
-     *                          to false in 1.5.1 and up.
-     * @param deepWithDataAndEvents A Boolean indicating whether event handlers and data for all children of the cloned element should
-     *                              be copied. By default its value matches the first argument's value (which defaults to false).
-     * @see \`{@link https://api.jquery.com/clone/ }\`
-     * @since 1.0
-     * @since 1.5
-     * @example ​ ````Clones all b elements (and selects the clones) and prepends them to all paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>clone demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<b>Hello</b><p>, how are you?</p>
-​
-<script>
-$( "b" ).clone().prependTo( "p" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    clone(withDataAndEvents?: boolean, deepWithDataAndEvents?: boolean): this;
-    /**
-     * For each element in the set, get the first element that matches the selector by testing the element
-     * itself and traversing up through its ancestors in the DOM tree.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @param context A DOM element within which a matching element may be found.
-     * @see \`{@link https://api.jquery.com/closest/ }\`
-     * @since 1.4
-     */
-    closest(selector: JQuery.Selector, context: Element): this;
-    /**
-     * For each element in the set, get the first element that matches the selector by testing the element
-     * itself and traversing up through its ancestors in the DOM tree.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     *                 A jQuery object to match elements against.
-     *                 An element to match elements against.
-     * @see \`{@link https://api.jquery.com/closest/ }\`
-     * @since 1.3
-     * @since 1.6
-     * @example ​ ````Show how event delegation can be done with closest. The closest list element toggles a yellow background when it or its descendent is clicked.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>closest demo</title>
-  <style>
-  li {
-    margin: 3px;
-    padding: 3px;
-    background: #EEEEEE;
-  }
-  li.highlight {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul>
-  <li><b>Click me!</b></li>
-  <li>You can also <b>Click me!</b></li>
-</ul>
-​
-<script>
-$( document ).on( "click", function( event ) {
-  $( event.target ).closest( "li" ).toggleClass( "highlight" );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Pass a jQuery object to closest. The closest list element toggles a yellow background when it or its descendent is clicked.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>closest demo</title>
-  <style>
-  li {
-    margin: 3px;
-    padding: 3px;
-    background: #EEEEEE;
-  }
-  li.highlight {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul>
-  <li><b>Click me!</b></li>
-  <li>You can also <b>Click me!</b></li>
-</ul>
-​
-<script>
-var listElements = $( "li" ).css( "color", "blue" );
-$( document ).on( "click", function( event ) {
-  $( event.target ).closest( listElements ).toggleClass( "highlight" );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    closest(selector: JQuery.Selector | Element | JQuery): this;
-    /**
-     * Get the children of each element in the set of matched elements, including text and comment nodes.
-     *
-     * @see \`{@link https://api.jquery.com/contents/ }\`
-     * @since 1.2
-     * @example ​ ````Find all the text nodes inside a paragraph and wrap them with a bold tag.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>contents demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello <a href="https://johnresig.com/">John</a>, how are you doing?</p>
-​
-<script>
-$( "p" )
-  .contents()
-  .filter(function(){
-    return this.nodeType !== 1;
-  })
-  .wrap( "<b></b>" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the background color of links inside of an iframe.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>contents demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<iframe src="https://api.jquery.com/" width="80%" height="600" id="frameDemo"></iframe>
-​
-<script>
-$( "#frameDemo" ).contents().find( "a" ).css( "background-color", "#BADA55" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    contents(): JQuery<TElement | Text | Comment>;
-    /**
-     * Bind an event handler to the "contextmenu" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/contextmenu/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    contextmenu<TData>(eventData: TData,
-                       handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "contextmenu" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/contextmenu/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````To show a &quot;Hello World!&quot; alert box when the contextmenu event is triggered on a paragraph on the page:
-```javascript
-$( "p" ).contextmenu(function() {
-  alert( "Hello World!" );
-});
-```
-     * @example ​ ````Right click to toggle background color.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>contextmenu demo</title>
-  <style>
-  div {
-    background: blue;
-    color: white;
-    height: 100px;
-    width: 150px;
- }
-  div.contextmenu {
-    background: yellow;
-    color: black;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div></div>
-<span>Right click the block</span>
-​
-<script>
-var div = $( "div:first" );
-div.contextmenu(function() {
-  div.toggleClass( "contextmenu" );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    contextmenu(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Set one or more CSS properties for the set of matched elements.
-     *
-     * @param propertyName A CSS property name.
-     * @param value A value to set for the property.
-     *              A function returning the value to set. this is the current element. Receives the index position of
-     *              the element in the set and the old value as arguments.
-     * @see \`{@link https://api.jquery.com/css/ }\`
-     * @since 1.0
-     * @since 1.4
-     * @example ​ ````Change the color of any paragraph to red on mouseover event.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>css demo</title>
-  <style>
-  p {
-    color: blue;
-    width: 200px;
-    font-size: 14px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-  <p>Just roll the mouse over me.</p>
-​
-  <p>Or me to see a color change.</p>
-​
-<script>
-$( "p" ).on( "mouseover", function() {
-  $( this ).css( "color", "red" );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Increase the width of #box by 200 pixels the first time it is clicked.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>css demo</title>
-  <style>
-  #box {
-    background: black;
-    color: snow;
-    width: 100px;
-    padding: 10px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="box">Click me to grow</div>
-​
-<script>
-$( "#box" ).one( "click", function() {
-  $( this ).css( "width", "+=200" );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Highlight a clicked word in the paragraph.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>css demo</title>
-  <style>
-  p {
-    color: blue;
-    font-weight: bold;
-    cursor: pointer;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>
-  Once upon a time there was a man
-  who lived in a pizza parlor. This
-  man just loved pizza and ate it all
-  the time.  He went on to be the
-  happiest man in the world.  The end.
-</p>
-​
-<script>
-var words = $( "p" ).first().text().split( /\s+/ );
-var text = words.join( "</span> <span>" );
-$( "p" ).first().html( "<span>" + text + "</span>" );
-$( "span" ).on( "click", function() {
-  $( this ).css( "background-color", "yellow" );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    css(propertyName: string,
-        value: string | number | ((this: TElement, index: number, value: string) => string | number | void | undefined)): this;
-    /**
-     * Set one or more CSS properties for the set of matched elements.
-     *
-     * @param properties An object of property-value pairs to set.
-     * @see \`{@link https://api.jquery.com/css/ }\`
-     * @since 1.0
-     * @example ​ ````Change the font weight and background color on mouseenter and mouseleave.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>css demo</title>
-  <style>
-  p {
-    color: green;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Move the mouse over a paragraph.</p>
-<p>Like this one or the one above.</p>
-​
-<script>
-$( "p" )
-  .on( "mouseenter", function() {
-    $( this ).css({
-      "background-color": "yellow",
-      "font-weight": "bolder"
-    });
-  })
-  .on( "mouseleave", function() {
-    var styles = {
-      backgroundColor : "#ddd",
-      fontWeight: ""
-    };
-    $( this ).css( styles );
-  });
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Increase the size of a div when you click it.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>css demo</title>
-  <style>
-  div {
-    width: 20px;
-    height: 15px;
-    background-color: #f33;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>click</div>
-<div>click</div>
-​
-<script>
-$( "div" ).on( "click", function() {
-  $( this ).css({
-    width: function( index, value ) {
-      return parseFloat( value ) * 1.2;
-    },
-    height: function( index, value ) {
-      return parseFloat( value ) * 1.2;
-    }
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    css(properties: JQuery.PlainObject<string | number | ((this: TElement, index: number, value: string) => string | number | void | undefined)>): this;
-    /**
-     * Get the computed style properties for the first element in the set of matched elements.
-     *
-     * @param propertyName A CSS property.
-     *                     An array of one or more CSS properties.
-     * @see \`{@link https://api.jquery.com/css/ }\`
-     * @since 1.0
-     * @example ​ ````Get the background color of a clicked div.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>css demo</title>
-  <style>
-  div {
-    width: 60px;
-    height: 60px;
-    margin: 5px;
-    float: left;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<span id="result">&nbsp;</span>
-<div style="background-color:blue;"></div>
-<div style="background-color:rgb(15,99,30);"></div>
-<div style="background-color:#123456;"></div>
-<div style="background-color:#f11;"></div>
-​
-<script>
-$( "div" ).click(function() {
-  var color = $( this ).css( "background-color" );
-  $( "#result" ).html( "That div is <span style='color:" +
-    color + ";'>" + color + "</span>." );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    css(propertyName: string): string;
-    /**
-     * Get the computed style properties for the first element in the set of matched elements.
-     *
-     * @param propertyNames An array of one or more CSS properties.
-     * @see \`{@link https://api.jquery.com/css/ }\`
-     * @since 1.9
-     * @example ​ ````Get the width, height, text color, and background color of a clicked div.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>css demo</title>
-  <style>
-  div {
-    height: 50px;
-    margin: 5px;
-    padding: 5px;
-    float: left;
-  }
-  #box1 {
-    width: 50px;
-    color: yellow;
-    background-color: blue;
-  }
-  #box2 {
-    width: 80px;
-    color: rgb(255, 255, 255);
-    background-color: rgb(15, 99, 30);
-  }
-  #box3 {
-    width: 40px;
-    color: #fcc;
-    background-color: #123456;
-  }
-  #box4 {
-    width: 70px;
-    background-color: #f11;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p id="result">&nbsp;</p>
-<div id="box1">1</div>
-<div id="box2">2</div>
-<div id="box3">3</div>
-<div id="box4">4</div>
-​
-<script>
-$( "div" ).click(function() {
-  var html = [ "The clicked div has the following styles:" ];
-​
-  var styleProps = $( this ).css([
-    "width", "height", "color", "background-color"
-  ]);
-  $.each( styleProps, function( prop, value ) {
-    html.push( prop + ": " + value );
-  });
-​
-  $( "#result" ).html( html.join( "<br>" ) );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    css(propertyNames: string[]): JQuery.PlainObject<string>;
-    /**
-     * Store arbitrary data associated with the matched elements.
-     *
-     * @param key A string naming the piece of data to set.
-     * @param value The new data value; this can be any Javascript type except `undefined`.
-     * @see \`{@link https://api.jquery.com/data/ }\`
-     * @since 1.2.3
-     * @example ​ ````Store then retrieve a value from the div element.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>data demo</title>
-  <style>
-  div {
-    color: blue;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>
-  The values stored were
-  <span></span>
-  and
-  <span></span>
-</div>
-​
-<script>
-$( "div" ).data( "test", { first: 16, last: "pizza!" } );
-$( "span:first" ).text( $( "div" ).data( "test" ).first );
-$( "span:last" ).text( $( "div" ).data( "test" ).last );
-</script>
-​
-</body>
-</html>
-```
-     */
-    data(key: string, value: string | number | boolean | symbol | object | null): this;
-    /**
-     * Store arbitrary data associated with the matched elements.
-     *
-     * @param obj An object of key-value pairs of data to update.
-     * @see \`{@link https://api.jquery.com/data/ }\`
-     * @since 1.4.3
-     */
-    data(obj: JQuery.PlainObject): this;
-    /**
-     * Return the value at the named data store for the first element in the jQuery collection, as set by
-     * data(name, value) or by an HTML5 data-* attribute.
-     *
-     * @param key Name of the data stored.
-     * @param value `undefined` is not recognized as a data value. Calls such as `.data( "name", undefined )`
-     *              will return the jQuery object that it was called on, allowing for chaining.
-     * @see \`{@link https://api.jquery.com/data/ }\`
-     * @since 1.2.3
-     */
-    // `unified-signatures` is disabled so that behavior when passing `undefined` to `value` can be documented. Unifying the signatures
-    // results in potential confusion for users from an unexpected parameter.
-    // tslint:disable-next-line:unified-signatures
-    data(key: string, value: undefined): any;
-    /**
-     * Return the value at the named data store for the first element in the jQuery collection, as set by
-     * data(name, value) or by an HTML5 data-* attribute.
-     *
-     * @param key Name of the data stored.
-     * @see \`{@link https://api.jquery.com/data/ }\`
-     * @since 1.2.3
-     * @example ​ ````Get the data named &quot;blah&quot; stored at for an element.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>data demo</title>
-  <style>
-  div {
-    margin: 5px;
-    background: yellow;
-  }
-  button {
-    margin: 5px;
-    font-size: 14px;
-  }
-  p {
-    margin: 5px;
-    color: blue;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>A div</div>
-<button>Get "blah" from the div</button>
-<button>Set "blah" to "hello"</button>
-<button>Set "blah" to 86</button>
-<button>Remove "blah" from the div</button>
-<p>The "blah" value of this div is <span>?</span></p>
-​
-<script>
-$( "button" ).click(function() {
-  var value;
-​
-  switch ( $( "button" ).index( this ) ) {
-    case 0 :
-      value = $( "div" ).data( "blah" );
-      break;
-    case 1 :
-      $( "div" ).data( "blah", "hello" );
-      value = "Stored!";
-      break;
-    case 2 :
-      $( "div" ).data( "blah", 86 );
-      value = "Stored!";
-      break;
-    case 3 :
-      $( "div" ).removeData( "blah" );
-      value = "Removed!";
-      break;
-  }
-​
-  $( "span" ).text( "" + value );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    data(key: string): any;
-    /**
-     * Return the value at the named data store for the first element in the jQuery collection, as set by
-     * data(name, value) or by an HTML5 data-* attribute.
-     *
-     * @see \`{@link https://api.jquery.com/data/ }\`
-     * @since 1.4
-     */
-    data(): JQuery.PlainObject;
-    /**
-     * Bind an event handler to the "dblclick" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/dblclick/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    dblclick<TData>(eventData: TData,
-                    handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "dblclick" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/dblclick/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````To bind a &quot;Hello World!&quot; alert box to the dblclick event on every paragraph on the page:
-```javascript
-$( "p" ).dblclick(function() {
-  alert( "Hello World!" );
-});
-```
-     * @example ​ ````Double click to toggle background color.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>dblclick demo</title>
-  <style>
-  div {
-    background: blue;
-    color: white;
-    height: 100px;
-    width: 150px;
- }
-  div.dbl {
-    background: yellow;
-    color: black;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div></div>
-<span>Double click the block</span>
-​
-<script>
-var divdbl = $( "div:first" );
-divdbl.dblclick(function() {
-  divdbl.toggleClass( "dbl" );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    dblclick(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Set a timer to delay execution of subsequent items in the queue.
-     *
-     * @param duration An integer indicating the number of milliseconds to delay execution of the next item in the queue.
-     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
-     * @see \`{@link https://api.jquery.com/delay/ }\`
-     * @since 1.4
-     * @example ​ ````Animate the hiding and showing of two divs, delaying the first before showing it.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>delay demo</title>
-  <style>
-  div {
-    position: absolute;
-    width: 60px;
-    height: 60px;
-    float: left;
-  }
-  .first {
-    background-color: #3f3;
-    left: 0;
-  }
-  .second {
-    background-color: #33f;
-    left: 80px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button>Run</button></p>
-<div class="first"></div>
-<div class="second"></div>
-​
-<script>
-$( "button" ).click(function() {
-  $( "div.first" ).slideUp( 300 ).delay( 800 ).fadeIn( 400 );
-  $( "div.second" ).slideUp( 300 ).fadeIn( 400 );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    delay(duration: JQuery.Duration, queueName?: string): this;
-    /**
-     * Attach a handler to one or more events for all elements that match the selector, now or in the
-     * future, based on a specific set of root elements.
-     *
-     * @param selector A selector to filter the elements that trigger the event.
-     * @param eventType A string containing one or more space-separated JavaScript event types, such as "click" or
-     *                  "keydown," or custom event names.
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/delegate/ }\`
-     * @since 1.4.2
-     * @deprecated ​ Deprecated since 3.0. Use \`{@link on }\`.
-     *
-     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
-     *
-     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
-     */
-    delegate<TData>(selector: JQuery.Selector,
-                    eventType: string,
-                    eventData: TData,
-                    handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Attach a handler to one or more events for all elements that match the selector, now or in the
-     * future, based on a specific set of root elements.
-     *
-     * @param selector A selector to filter the elements that trigger the event.
-     * @param eventType A string containing one or more space-separated JavaScript event types, such as "click" or
-     *                  "keydown," or custom event names.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/delegate/ }\`
-     * @since 1.4.2
-     * @deprecated ​ Deprecated since 3.0. Use \`{@link on }\`.
-     *
-     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
-     *
-     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
-     * @example ​ ````Click a paragraph to add another. Note that .delegate() attaches a click event handler to all paragraphs - even new ones.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>delegate demo</title>
-  <style>
-  p {
-    background: yellow;
-    font-weight: bold;
-    cursor: pointer;
-    padding: 5px;
-  }
-  p.over {
-    background: #ccc;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Click me!</p>
-​
-<span></span>
-​
-<script>
-$( "body" ).delegate( "p", "click", function() {
-  $( this ).after( "<p>Another paragraph!</p>" );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````To display each paragraph&#39;s text in an alert box whenever it is clicked:
-```javascript
-$( "body" ).delegate( "p", "click", function() {
-  alert( $( this ).text() );
-});
-```
-     * @example ​ ````To cancel a default action and prevent it from bubbling up, return false:
-```javascript
-$( "body" ).delegate( "a", "click", function() {
-  return false;
-});
-```
-     * @example ​ ````To cancel only the default action by using the preventDefault method.
-```javascript
-$( "body" ).delegate( "a", "click", function( event ) {
-  event.preventDefault();
-});
-```
-     * @example ​ ````Can bind custom events too.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>delegate demo</title>
-  <style>
-  p {
-    color: red;
-  }
-  span {
-    color: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Has an attached custom event.</p>
-<button>Trigger custom event</button>
-<span style="display:none;"></span>
-​
-<script>
-$( "body" ).delegate( "p", "myCustomEvent", function( e, myName, myValue ) {
-  $( this ).text( "Hi there!" );
-  $( "span" )
-    .stop()
-    .css( "opacity", 1 )
-    .text( "myName = " + myName )
-    .fadeIn( 30 )
-    .fadeOut( 1000 );
-});
-$( "button" ).click(function() {
-  $( "p" ).trigger( "myCustomEvent" );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    delegate(selector: JQuery.Selector,
-             eventType: string,
-             handler: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Attach a handler to one or more events for all elements that match the selector, now or in the
-     * future, based on a specific set of root elements.
-     *
-     * @param selector A selector to filter the elements that trigger the event.
-     * @param events A plain object of one or more event types and functions to execute for them.
-     * @see \`{@link https://api.jquery.com/delegate/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.0. Use \`{@link on }\`.
-     *
-     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
-     *
-     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
-     */
-    delegate(selector: JQuery.Selector,
-             events: JQuery.PlainObject<JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false>): this;
-    /**
-     * Execute the next function on the queue for the matched elements.
-     *
-     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
-     * @see \`{@link https://api.jquery.com/dequeue/ }\`
-     * @since 1.2
-     * @example ​ ````Use dequeue to end a custom queue function which allows the queue to keep going.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>dequeue demo</title>
-  <style>
-  div {
-    margin: 3px;
-    width: 50px;
-    position: absolute;
-    height: 50px;
-    left: 10px;
-    top: 30px;
-    background-color: yellow;
-  }
-  div.red {
-    background-color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Start</button>
-<div></div>
-​
-<script>
-$( "button" ).click(function() {
-  $( "div" )
-    .animate({ left:"+=200px" }, 2000 )
-    .animate({ top:"0px" }, 600 )
-    .queue(function() {
-      $( this ).toggleClass( "red" ).dequeue();
-    })
-    .animate({ left:"10px", top:"30px" }, 700 );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    dequeue(queueName?: string): this;
-    /**
-     * Remove the set of matched elements from the DOM.
-     *
-     * @param selector A selector expression that filters the set of matched elements to be removed.
-     * @see \`{@link https://api.jquery.com/detach/ }\`
-     * @since 1.4
-     * @example ​ ````Detach all paragraphs from the DOM
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>detach demo</title>
-  <style>
-  p {
-    background: yellow;
-    margin: 6px 0;
-  }
-  p.off {
-    background: black;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-how are
-<p>you?</p>
-<button>Attach/detach paragraphs</button>
-​
-<script>
-$( "p" ).click(function() {
-  $( this ).toggleClass( "off" );
-});
-var p;
-$( "button" ).click(function() {
-  if ( p ) {
-    p.appendTo( "body" );
-    p = null;
-  } else {
-    p = $( "p" ).detach();
-  }
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    detach(selector?: JQuery.Selector): this;
-    /**
-     * Iterate over a jQuery object, executing a function for each matched element.
-     *
-     * @param fn A function to execute for each matched element.
-     * @see \`{@link https://api.jquery.com/each/ }\`
-     * @since 1.0
-     * @example ​ ````Iterate over three divs and sets their color property.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>each demo</title>
-  <style>
-  div {
-    color: red;
-    text-align: center;
-    cursor: pointer;
-    font-weight: bolder;
-    width: 300px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>Click here</div>
-<div>to iterate through</div>
-<div>these divs.</div>
-​
-<script>
-$( document.body ).click(function() {
-  $( "div" ).each(function( i ) {
-    if ( this.style.color !== "blue" ) {
-      this.style.color = "blue";
-    } else {
-      this.style.color = "";
-    }
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````To access a jQuery object instead of the regular DOM element, use $( this ). For example:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>each demo</title>
-  <style>
-  ul {
-    font-size: 18px;
-    margin: 0;
-  }
-  span {
-    color: blue;
-    text-decoration: underline;
-    cursor: pointer;
-  }
-  .example {
-    font-style: italic;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-To do list: <span>(click here to change)</span>
-<ul>
-  <li>Eat</li>
-  <li>Sleep</li>
-  <li>Be merry</li>
-</ul>
-​
-<script>
-$( "span" ).click(function() {
-  $( "li" ).each(function() {
-    $( this ).toggleClass( "example" );
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Use return false to break out of each() loops early.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>each demo</title>
-  <style>
-  div {
-    width: 40px;
-    height: 40px;
-    margin: 5px;
-    float: left;
-    border: 2px blue solid;
-    text-align: center;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Change colors</button>
-<span></span>
-<div></div>
-<div></div>
-<div></div>
-<div></div>
-<div id="stop">Stop here</div>
-<div></div>
-<div></div>
-<div></div>
-​
-<script>
-$( "button" ).click(function() {
-  $( "div" ).each(function( index, element ) {
-    // element == this
-    $( element ).css( "backgroundColor", "yellow" );
-    if ( $( this ).is( "#stop" ) ) {
-      $( "span" ).text( "Stopped at div index #" + index );
-      return false;
-    }
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    each(fn: (this: TElement, index: number, element: TElement) => void | false): this;
-    /**
-     * Remove all child nodes of the set of matched elements from the DOM.
-     *
-     * @see \`{@link https://api.jquery.com/empty/ }\`
-     * @since 1.0
-     * @example ​ ````Removes all child nodes (including text nodes) from all paragraphs
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>empty demo</title>
-  <style>
-  p {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>
-  Hello, <span>Person</span> <em>and person</em>.
-</p>
-​
-<button>Call empty() on above paragraph</button>
-​
-<script>
-$( "button" ).click(function() {
-  $( "p" ).empty();
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    empty(): this;
-    /**
-     * End the most recent filtering operation in the current chain and return the set of matched elements
-     * to its previous state.
-     *
-     * @see \`{@link https://api.jquery.com/end/ }\`
-     * @since 1.0
-     * @example ​ ````Selects all paragraphs, finds span elements inside these, and reverts the selection back to the paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>end demo</title>
-  <style>
-  p, div {
-    margin: 1px;
-    padding: 1px;
-    font-weight: bold;
-    font-size: 16px;
-  }
-  div {
-    color: blue;
-  }
-  b {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>
-  Hi there <span>how</span> are you <span>doing</span>?
-</p>
-​
-<p>
-  This <span>span</span> is one of
-  several <span>spans</span> in this
-  <span>sentence</span>.
-</p>
-​
-<div>
-  Tags in jQuery object initially: <b></b>
-</div>
-​
-<div>
-  Tags in jQuery object after find: <b></b>
-</div>
-​
-<div>
-  Tags in jQuery object after end: <b></b>
-</div>
-​
-<script>
-jQuery.fn.showTags = function( n ) {
-  var tags = this.map(function() {
-    return this.tagName;
-  })
-  .get()
-  .join( ", " );
-  $( "b:eq( " + n + " )" ).text( tags );
-  return this;
-};
-​
-$( "p" )
-  .showTags( 0 )
-  .find( "span" )
-    .showTags( 1 )
-    .css( "background", "yellow" )
-  .end()
-  .showTags( 2 )
-  .css( "font-style", "italic" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Selects all paragraphs, finds span elements inside these, and reverts the selection back to the paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>end demo</title>
-  <style>
-  p {
-    margin: 10px;
-    padding: 10px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><span>Hello</span>, how are you?</p>
-​
-<script>
-$( "p" )
-  .find( "span" )
-  .end()
-  .css( "border", "2px red solid" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    end(): this;
-    /**
-     * Reduce the set of matched elements to the one at the specified index.
-     *
-     * @param index An integer indicating the 0-based position of the element.
-     *              An integer indicating the position of the element, counting backwards from the last element in the set.
-     * @see \`{@link https://api.jquery.com/eq/ }\`
-     * @since 1.1.2
-     * @since 1.4
-     * @example ​ ````Turn the div with index 2 blue by adding an appropriate class.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>eq demo</title>
-  <style>
-  div {
-    width: 60px;
-    height: 60px;
-    margin: 10px;
-    float: left;
-    border: 2px solid blue;
-  }
-  .blue {
-    background: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div></div>
-<div></div>
-<div></div>
-<div></div>
-<div></div>
-<div></div>
-​
-<script>
-$( "body" ).find( "div" ).eq( 2 ).addClass( "blue" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    eq(index: number): this;
-    /**
-     * Merge the contents of an object onto the jQuery prototype to provide new jQuery instance methods.
-     *
-     * @param obj An object to merge onto the jQuery prototype.
-     * @see \`{@link https://api.jquery.com/jQuery.fn.extend/ }\`
-     * @since 1.0
-     * @example ​ ````Add two methods to the jQuery prototype ($.fn) object and then use one of them.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.fn.extend demo</title>
-  <style>
-  label {
-    display: block;
-    margin: .5em;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<label><input type="checkbox" name="foo"> Foo</label>
-<label><input type="checkbox" name="bar"> Bar</label>
-​
-<script>
-jQuery.fn.extend({
-  check: function() {
-    return this.each(function() {
-      this.checked = true;
-    });
-  },
-  uncheck: function() {
-    return this.each(function() {
-      this.checked = false;
-    });
-  }
-});
-​
-// Use the newly created .check() method
-$( "input[type='checkbox']" ).check();
-</script>
-​
-</body>
-</html>
-```
-     */
-    extend(obj: object): this;
-    /**
-     * Display the matched elements by fading them to opaque.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param easing A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/fadeIn/ }\`
-     * @since 1.4.3
-     */
-    fadeIn(duration: JQuery.Duration, easing: string, complete?: (this: TElement) => void): this;
-    /**
-     * Display the matched elements by fading them to opaque.
-     *
-     * @param duration_easing _&#x40;param_ `duration_easing`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `easing` — A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/fadeIn/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     * @example ​ ````Fades a red block in over the text. Once the animation is done, it quickly fades in more text on top.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>fadeIn demo</title>
-  <style>
-  p {
-    position: relative;
-    width: 400px;
-    height: 90px;
-  }
-  div {
-    position: absolute;
-    width: 400px;
-    height: 65px;
-    font-size: 36px;
-    text-align: center;
-    color: yellow;
-    background: red;
-    padding-top: 25px;
-    top: 0;
-    left: 0;
-    display: none;
-  }
-  span {
-    display: none;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>
-  Let it be known that the party of the first part
-  and the party of the second part are henceforth
-  and hereto directed to assess the allegations
-  for factual correctness... (<a href="#">click!</a>)
-  <div><span>CENSORED!</span></div>
-</p>
-​
-<script>
-$( "a" ).click(function() {
-  $( "div" ).fadeIn( 3000, function() {
-    $( "span" ).fadeIn( 100 );
-  });
-  return false;
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    fadeIn(duration_easing: JQuery.Duration | string, complete: (this: TElement) => void): this;
-    /**
-     * Display the matched elements by fading them to opaque.
-     *
-     * @param duration_easing_complete_options _&#x40;param_ `duration_easing_complete_options`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `easing` — A string indicating which easing function to use for the transition. <br>
-     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
-     * * `options` — A map of additional options to pass to the method.
-     * @see \`{@link https://api.jquery.com/fadeIn/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     * @example ​ ````Animates hidden divs to fade in one by one, completing each animation within 600 milliseconds.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>fadeIn demo</title>
-  <style>
-  span {
-    color: red;
-    cursor: pointer;
-  }
-  div {
-    margin: 3px;
-    width: 80px;
-    display: none;
-    height: 80px;
-    float: left;
-  }
-  #one {
-    background: #f00;
-  }
-  #two {
-    background: #0f0;
-  }
-  #three {
-    background: #00f;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<span>Click here...</span>
-<div id="one"></div>
-<div id="two"></div>
-<div id="three"></div>
-​
-<script>
-$( document.body ).click(function() {
-  $( "div:hidden:first" ).fadeIn( "slow" );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    fadeIn(duration_easing_complete_options?: JQuery.Duration | string | ((this: TElement) => void) | JQuery.EffectsOptions<TElement>): this;
-    /**
-     * Hide the matched elements by fading them to transparent.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param easing A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/fadeOut/ }\`
-     * @since 1.4.3
-     * @example ​ ````Fades out two divs, one with a &quot;linear&quot; easing and one with the default, &quot;swing,&quot; easing.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>fadeOut demo</title>
-  <style>
-  .box,
-  button {
-    float: left;
-    margin: 5px 10px 5px 0;
-  }
-  .box {
-    height: 80px;
-    width: 80px;
-    background: #090;
-  }
-  #log {
-    clear: left;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="btn1">fade out</button>
-<button id="btn2">show</button>
-​
-<div id="log"></div>
-​
-<div id="box1" class="box">linear</div>
-<div id="box2" class="box">swing</div>
-​
-<script>
-$( "#btn1" ).click(function() {
-  function complete() {
-    $( "<div>" ).text( this.id ).appendTo( "#log" );
-  }
-  $( "#box1" ).fadeOut( 1600, "linear", complete );
-  $( "#box2" ).fadeOut( 1600, complete );
-});
-​
-$( "#btn2" ).click(function() {
-  $( "div" ).show();
-  $( "#log" ).empty();
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    fadeOut(duration: JQuery.Duration, easing: string, complete?: (this: TElement) => void): this;
-    /**
-     * Hide the matched elements by fading them to transparent.
-     *
-     * @param duration_easing _&#x40;param_ `duration_easing`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `easing` — A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/fadeOut/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     * @example ​ ````Fades out spans in one section that you click on.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>fadeOut demo</title>
-  <style>
-  span {
-    cursor: pointer;
-  }
-  span.hilite {
-    background: yellow;
-  }
-  div {
-    display: inline;
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<h3>Find the modifiers - <div></div></h3>
-<p>
-  If you <span>really</span> want to go outside
-  <span>in the cold</span> then make sure to wear
-  your <span>warm</span> jacket given to you by
-  your <span>favorite</span> teacher.
-</p>
-​
-<script>
-$( "span" ).click(function() {
-  $( this ).fadeOut( 1000, function() {
-    $( "div" ).text( "'" + $( this ).text() + "' has faded!" );
-    $( this ).remove();
-  });
-});
-$( "span" ).hover(function() {
-  $( this ).addClass( "hilite" );
-}, function() {
-  $( this ).removeClass( "hilite" );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    fadeOut(duration_easing: JQuery.Duration | string, complete: (this: TElement) => void): this;
-    /**
-     * Hide the matched elements by fading them to transparent.
-     *
-     * @param duration_easing_complete_options _&#x40;param_ `duration_easing_complete_options`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `easing` — A string indicating which easing function to use for the transition. <br>
-     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
-     * * `options` — A map of additional options to pass to the method.
-     * @see \`{@link https://api.jquery.com/fadeOut/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     * @example ​ ````Animates all paragraphs to fade out, completing the animation within 600 milliseconds.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>fadeOut demo</title>
-  <style>
-  p {
-    font-size: 150%;
-    cursor: pointer;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>
-  If you click on this paragraph
-  you'll see it just fade away.
-</p>
-​
-<script>
-$( "p" ).click(function() {
-  $( "p" ).fadeOut( "slow" );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    fadeOut(duration_easing_complete_options?: JQuery.Duration | string | ((this: TElement) => void) | JQuery.EffectsOptions<TElement>): this;
-    /**
-     * Adjust the opacity of the matched elements.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param opacity A number between 0 and 1 denoting the target opacity.
-     * @param easing A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/fadeTo/ }\`
-     * @since 1.4.3
-     */
-    fadeTo(duration: JQuery.Duration, opacity: number, easing: string, complete?: (this: TElement) => void): this;
-    /**
-     * Adjust the opacity of the matched elements.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param opacity A number between 0 and 1 denoting the target opacity.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/fadeTo/ }\`
-     * @since 1.0
-     * @example ​ ````Animates first paragraph to fade to an opacity of 0.33 (33%, about one third visible), completing the animation within 600 milliseconds.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>fadeTo demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>
-Click this paragraph to see it fade.
-</p>
-​
-<p>
-Compare to this one that won't fade.
-</p>
-​
-<script>
-$( "p:first" ).click(function() {
-  $( this ).fadeTo( "slow", 0.33 );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Fade div to a random opacity on each click, completing the animation within 200 milliseconds.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>fadeTo demo</title>
-  <style>
-  p {
-    width: 80px;
-    margin: 0;
-    padding: 5px;
-  }
-  div {
-    width: 40px;
-    height: 40px;
-    position: absolute;
-  }
-  #one {
-    top: 0;
-    left: 0;
-    background: #f00;
-  }
-  #two {
-    top: 20px;
-    left: 20px;
-    background: #0f0;
-  }
-  #three {
-    top: 40px;
-    left:40px;
-    background:#00f;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>And this is the library that John built...</p>
-​
-<div id="one"></div>
-<div id="two"></div>
-<div id="three"></div>
-​
-<script>
-$( "div" ).click(function() {
-  $( this ).fadeTo( "fast", Math.random() );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Find the right answer! The fade will take 250 milliseconds and change various styles when it completes.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>fadeTo demo</title>
-  <style>
-  div, p {
-    width: 80px;
-    height: 40px;
-    top: 0;
-    margin: 0;
-    position: absolute;
-    padding-top: 8px;
-  }
-  p {
-    background: #fcc;
-    text-align: center;
-  }
-  div {
-    background: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Wrong</p>
-<div></div>
-<p>Wrong</p>
-<div></div>
-<p>Right!</p>
-<div></div>
-​
-<script>
-var getPos = function( n ) {
-  return (Math.floor( n ) * 90) + "px";
-};
-$( "p" ).each(function( n ) {
-  var r = Math.floor( Math.random() * 3 );
-  var tmp = $( this ).text();
-  $( this ).text( $( "p:eq(" + r + ")" ).text() );
-  $( "p:eq(" + r + ")" ).text( tmp );
-  $( this ).css( "left", getPos( n ) );
-});
-$( "div" )
-  .each(function( n ) {
-    $( this ).css( "left", getPos( n ) );
-  })
-  .css( "cursor", "pointer" )
-  .click( function() {
-    $( this ).fadeTo( 250, 0.25, function() {
-      $( this )
-        .css( "cursor", "" )
-        .prev()
-          .css({
-            "font-weight": "bolder",
-            "font-style": "italic"
-          });
-    });
-  });
-</script>
-​
-</body>
-</html>
-```
-     */
-    fadeTo(duration: JQuery.Duration, opacity: number, complete?: (this: TElement) => void): this;
-    /**
-     * Display or hide the matched elements by animating their opacity.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param easing A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/fadeToggle/ }\`
-     * @since 1.4.4
-     * @example ​ ````Fades first paragraph in or out, completing the animation within 600 milliseconds and using a linear easing. Fades last paragraph in or out for 200 milliseconds, inserting a &quot;finished&quot; message upon completion.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>fadeToggle demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>fadeToggle p1</button>
-<button>fadeToggle p2</button>
-<p>This paragraph has a slow, linear fade.</p>
-<p>This paragraph has a fast animation.</p>
-<div id="log"></div>
-​
-<script>
-$( "button:first" ).click(function() {
-  $( "p:first" ).fadeToggle( "slow", "linear" );
-});
-$( "button:last" ).click(function() {
-  $( "p:last" ).fadeToggle( "fast", function() {
-    $( "#log" ).append( "<div>finished</div>" );
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    fadeToggle(duration: JQuery.Duration, easing: string, complete?: (this: TElement) => void): this;
-    /**
-     * Display or hide the matched elements by animating their opacity.
-     *
-     * @param duration_easing _&#x40;param_ `duration_easing`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `easing` — A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/fadeToggle/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     * @example ​ ````Fades first paragraph in or out, completing the animation within 600 milliseconds and using a linear easing. Fades last paragraph in or out for 200 milliseconds, inserting a &quot;finished&quot; message upon completion.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>fadeToggle demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>fadeToggle p1</button>
-<button>fadeToggle p2</button>
-<p>This paragraph has a slow, linear fade.</p>
-<p>This paragraph has a fast animation.</p>
-<div id="log"></div>
-​
-<script>
-$( "button:first" ).click(function() {
-  $( "p:first" ).fadeToggle( "slow", "linear" );
-});
-$( "button:last" ).click(function() {
-  $( "p:last" ).fadeToggle( "fast", function() {
-    $( "#log" ).append( "<div>finished</div>" );
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    fadeToggle(duration_easing: JQuery.Duration | string, complete: (this: TElement) => void): this;
-    /**
-     * Display or hide the matched elements by animating their opacity.
-     *
-     * @param duration_easing_complete_options _&#x40;param_ `duration_easing_complete_options`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `easing` — A string indicating which easing function to use for the transition. <br>
-     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
-     * * `options` — A map of additional options to pass to the method.
-     * @see \`{@link https://api.jquery.com/fadeToggle/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     */
-    fadeToggle(duration_easing_complete_options?: JQuery.Duration | string | ((this: TElement) => void) | JQuery.EffectsOptions<TElement>): this;
-    /**
-     * Reduce the set of matched elements to those that match the selector or pass the function's test.
-     *
-     * @param selector A string containing a selector expression to match the current set of elements against.
-     *                 One or more DOM elements to match the current set of elements against.
-     *                 An existing jQuery object to match the current set of elements against.
-     *                 A function used as a test for each element in the set. this is the current DOM element.
-     * @see \`{@link https://api.jquery.com/filter/ }\`
-     * @since 1.0
-     * @since 1.4
-     * @example ​ ````Change the color of all divs; then add a border to those with a &quot;middle&quot; class.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>filter demo</title>
-  <style>
-  div {
-    width: 60px;
-    height: 60px;
-    margin: 5px;
-    float: left;
-    border: 2px white solid;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div></div>
-<div class="middle"></div>
-<div class="middle"></div>
-<div class="middle"></div>
-<div class="middle"></div>
-<div></div>
-​
-<script>
-$( "div" )
-  .css( "background", "#c8ebcc" )
-  .filter( ".middle" )
-    .css( "border-color", "red" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Change the color of all divs; then add a border to the second one (index == 1) and the div with an id of &quot;fourth.&quot;
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>filter demo</title>
-  <style>
-  div {
-    width: 60px;
-    height: 60px;
-    margin: 5px;
-    float: left;
-    border: 3px white solid;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="first"></div>
-<div id="second"></div>
-<div id="third"></div>
-<div id="fourth"></div>
-<div id="fifth"></div>
-<div id="sixth"></div>
-​
-<script>
-$( "div" )
-  .css( "background", "#b4b0da" )
-  .filter(function( index ) {
-    return index === 1 || $( this ).attr( "id" ) === "fourth";
-  })
-    .css( "border", "3px double red" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Select all divs and filter the selection with a DOM element, keeping only the one with an id of &quot;unique&quot;.
-```javascript
-$( "div" ).filter( document.getElementById( "unique" ) );
-```
-     * @example ​ ````Select all divs and filter the selection with a jQuery object, keeping only the one with an id of &quot;unique&quot;.
-```javascript
-$( "div" ).filter( $( "#unique" ) );
-```
-     */
-    filter(selector: JQuery.Selector | JQuery.TypeOrArray<Element> | JQuery | ((this: TElement, index: number, element: TElement) => boolean)): this;
-    /**
-     * Get the descendants of each element in the current set of matched elements, filtered by a selector,
-     * jQuery object, or element.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     *                 An element or a jQuery object to match elements against.
-     * @see \`{@link https://api.jquery.com/find/ }\`
-     * @since 1.0
-     * @since 1.6
-     * @example ​ ````Starts with all paragraphs and searches for descendant span elements, same as $( &quot;p span&quot; )
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>find demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><span>Hello</span>, how are you?</p>
-<p>Me? I'm <span>good</span>.</p>
-​
-<script>
-$( "p" ).find( "span" ).css( "color", "red" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````A selection using a jQuery collection of all span tags. Only spans within p tags are changed to red while others are left blue.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>find demo</title>
-  <style>
-  span {
-    color: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><span>Hello</span>, how are you?</p>
-<p>Me? I'm <span>good</span>.</p>
-<div>Did you <span>eat</span> yet?</div>
-​
-<script>
-var spans = $( "span" );
-$( "p" ).find( spans ).css( "color", "red" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Add spans around each word then add a hover and italicize words with the letter t.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>find demo</title>
-  <style>
-  p {
-    font-size: 20px;
-    width: 200px;
-    color: blue;
-    font-weight: bold;
-    margin: 0 10px;
-  }
-  .hilite {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>
-  When the day is short
-  find that which matters to you
-  or stop believing
-</p>
-​
-<script>
-var newText = $( "p" ).text().split( " " ).join( "</span> <span>" );
-newText = "<span>" + newText + "</span>";
-​
-$( "p" )
-  .html( newText )
-  .find( "span" )
-    .hover(function() {
-      $( this ).addClass( "hilite" );
-    }, function() {
-      $( this ).removeClass( "hilite" );
-    })
-  .end()
-  .find( ":contains('t')" )
-    .css({
-      "font-style": "italic",
-      "font-weight": "bolder"
-    });
-</script>
-​
-</body>
-</html>
-```
-     */
-    find(selector: JQuery.Selector | Element | JQuery): this;
-    /**
-     * Stop the currently-running animation, remove all queued animations, and complete all animations for
-     * the matched elements.
-     *
-     * @param queue The name of the queue in which to stop animations.
-     * @see \`{@link https://api.jquery.com/finish/ }\`
-     * @since 1.9
-     * @example ​ ````Click the Go button once to start the animation, and then click the other buttons to see how they affect the current and queued animations.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>finish demo</title>
-  <style>
-  .box {
-    position: absolute;
-    top: 10px;
-    left: 10px;
-    width: 15px;
-    height: 15px;
-    background: black;
-  }
-  #path {
-    height: 244px;
-    font-size: 70%;
-    border-left: 2px dashed red;
-    border-bottom: 2px dashed green;
-    border-right: 2px dashed blue;
-  }
-  button {
-    width: 12em;
-    display: block;
-    text-align: left;
-    margin: 0 auto;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div class="box"></div>
-<div id="path">
-  <button id="go">Go</button>
-  <br>
-  <button id="bstt" class="b">.stop( true,true )</button>
-  <button id="bcf" class="b">.clearQueue().finish()</button>
-  <br>
-  <button id="bstf" class="b">.stop( true, false )</button>
-  <button id="bcs" class="b">.clearQueue().stop()</button>
-  <br>
-  <button id="bsff" class="b">.stop( false, false )</button>
-  <button id="bs" class="b">.stop()</button>
-  <br>
-  <button id="bsft" class="b">.stop( false, true )</button>
-  <br>
-  <button id="bf" class="b">.finish()</button>
-</div>
-​
-<script>
-var horiz = $( "#path" ).width() - 20,
-  vert = $( "#path" ).height() - 20;
-​
-var btns = {
-  bstt: function() {
-    $( "div.box" ).stop( true, true );
-  },
-  bs: function() {
-    $( "div.box" ).stop();
-  },
-  bsft: function() {
-    $( "div.box" ).stop( false, true );
-  },
-  bf: function() {
-    $( "div.box" ).finish();
-  },
-  bcf: function() {
-    $( "div.box" ).clearQueue().finish();
-  },
-  bsff: function() {
-    $( "div.box" ).stop( false, false );
-  },
-  bstf: function() {
-    $( "div.box" ).stop( true, false );
-  },
-  bcs: function() {
-    $( "div.box" ).clearQueue().stop();
-  }
-};
-​
-$( "button.b" ).on( "click", function() {
-  btns[ this.id ]();
-});
-​
-$( "#go" ).on( "click", function() {
-  $( ".box" )
-    .clearQueue()
-    .stop()
-    .css({
-      left: 10,
-      top: 10
-    })
-    .animate({
-      top: vert
-    }, 3000 )
-    .animate({
-      left: horiz
-    }, 3000 )
-    .animate({
-      top: 10
-    }, 3000 );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    finish(queue?: string): this;
-    /**
-     * Reduce the set of matched elements to the first in the set.
-     *
-     * @see \`{@link https://api.jquery.com/first/ }\`
-     * @since 1.4
-     * @example ​ ````Highlight the first span in a paragraph.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>first demo</title>
-  <style>
-  .highlight{
-    background-color: yellow
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>
-  <span>Look:</span>
-  <span>This is some text in a paragraph.</span>
-  <span>This is a note about it.</span>
-</p>
-​
-<script>
-$( "p span" ).first().addClass( "highlight" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    first(): this;
-    /**
-     * Bind an event handler to the "focus" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/focus/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    focus<TData>(eventData: TData,
-                 handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "focus" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/focus/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````Fire focus.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>focus demo</title>
-  <style>
-  span {
-    display: none;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><input type="text"> <span>focus fire</span></p>
-<p><input type="password"> <span>focus fire</span></p>
-​
-<script>
-$( "input" ).focus(function() {
-  $( this ).next( "span" ).css( "display", "inline" ).fadeOut( 1000 );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````To stop people from writing in text input boxes, try:
-```javascript
-$( "input[type=text]" ).focus(function() {
-  $( this ).blur();
-});
-```
-     * @example ​ ````To focus on a login input box with id &#39;login&#39; on page startup, try:
-```javascript
-$( document ).ready(function() {
-  $( "#login" ).focus();
-});
-```
-     */
-    focus(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Bind an event handler to the "focusin" event.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/focusin/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    focusin<TData>(eventData: TData,
-                   handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "focusin" event.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/focusin/ }\`
-     * @since 1.4
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````Watch for a focus to occur within the paragraphs on the page.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>focusin demo</title>
-  <style>
-  span {
-    display: none;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><input type="text"> <span>focusin fire</span></p>
-<p><input type="password"> <span>focusin fire</span></p>
-​
-<script>
-$( "p" ).focusin(function() {
-  $( this ).find( "span" ).css( "display", "inline" ).fadeOut( 1000 );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    focusin(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Bind an event handler to the "focusout" JavaScript event.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/focusout/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    focusout<TData>(eventData: TData,
-                    handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "focusout" JavaScript event.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/focusout/ }\`
-     * @since 1.4
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````Watch for a loss of focus to occur inside paragraphs and note the difference between the focusout count and the blur count. (The blur count does not change because those events do not bubble.)
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>focusout demo</title>
-  <style>
-  .inputs {
-    float: left;
-    margin-right: 1em;
-  }
-  .inputs p {
-    margin-top: 0;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div class="inputs">
-  <p>
-    <input type="text"><br>
-    <input type="text">
-  </p>
-  <p>
-    <input type="password">
-  </p>
-</div>
-<div id="focus-count">focusout fire</div>
-<div id="blur-count">blur fire</div>
-​
-<script>
-var focus = 0,
-  blur = 0;
-$( "p" )
-  .focusout(function() {
-    focus++;
-    $( "#focus-count" ).text( "focusout fired: " + focus + "x" );
-  })
-  .blur(function() {
-    blur++;
-    $( "#blur-count" ).text( "blur fired: " + blur + "x" );
-  });
-</script>
-​
-</body>
-</html>
-```
-     */
-    focusout(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Retrieve one of the elements matched by the jQuery object.
-     *
-     * @param index A zero-based integer indicating which element to retrieve.
-     * @see \`{@link https://api.jquery.com/get/ }\`
-     * @since 1.0
-     * @example ​ ````Display the tag name of the click element.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>get demo</title>
-  <style>
-  span {
-    color: red;
-  }
-  div {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<span>&nbsp;</span>
-<p>In this paragraph is an <span>important</span> section</p>
-<div><input type="text"></div>
-​
-<script>
-$( "*", document.body ).click(function( event ) {
-  event.stopPropagation();
-  var domElement = $( this ).get( 0 );
-  $( "span:first" ).text( "Clicked on - " + domElement.nodeName );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    get(index: number): TElement;
-    /**
-     * Retrieve the elements matched by the jQuery object.
-     *
-     * @see \`{@link https://api.jquery.com/get/ }\`
-     * @since 1.0
-     * @example ​ ````Select all divs in the document and return the DOM Elements as an Array; then use the built-in reverse() method to reverse that array.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>get demo</title>
-  <style>
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-Reversed - <span></span>
-​
-<div>One</div>
-<div>Two</div>
-<div>Three</div>
-​
-<script>
-function display( divs ) {
-  var a = [];
-  for ( var i = 0; i < divs.length; i++ ) {
-    a.push( divs[ i ].innerHTML );
-  }
-  $( "span" ).text( a.join(" ") );
-}
-display( $( "div" ).get().reverse() );
-</script>
-​
-</body>
-</html>
-```
-     */
-    get(): TElement[];
-    /**
-     * Reduce the set of matched elements to those that have a descendant that matches the selector or DOM element.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     *                 A DOM element to match elements against.
-     * @see \`{@link https://api.jquery.com/has/ }\`
-     * @since 1.4
-     * @example ​ ````Check if an element is inside another.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>has demo</title>
-  <style>
-  .full {
-    border: 1px solid red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul><li>Does the UL contain an LI?</li></ul>
-​
-<script>
-$( "ul" ).append( "<li>" +
-  ( $( "ul" ).has( "li" ).length ? "Yes" : "No" ) +
-  "</li>" );
-$( "ul" ).has( "li" ).addClass( "full" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    has(selector: string | Element): this;
-    /**
-     * Determine whether any of the matched elements are assigned the given class.
-     *
-     * @param className The class name to search for.
-     * @see \`{@link https://api.jquery.com/hasClass/ }\`
-     * @since 1.2
-     * @example ​ ````Looks for the paragraph that contains &#39;selected&#39; as a class.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>hasClass demo</title>
-  <style>
-  p {
-    margin: 8px;
-    font-size: 16px;
-  }
-  .selected {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>This paragraph is black and is the first paragraph.</p>
-<p class="selected">This paragraph is red and is the second paragraph.</p>
-<div id="result1">First paragraph has selected class: </div>
-<div id="result2">Second paragraph has selected class: </div>
-<div id="result3">At least one paragraph has selected class: </div>
-​
-<script>
-$( "#result1" ).append( $( "p:first" ).hasClass( "selected" ).toString() );
-$( "#result2" ).append( $( "p:last" ).hasClass( "selected" ).toString() );
-$( "#result3" ).append( $( "p" ).hasClass( "selected" ).toString() ) ;
-</script>
-​
-</body>
-</html>
-```
-     */
-    hasClass(className: string): boolean;
-    /**
-     * Set the CSS height of every matched element.
-     *
-     * @param value An integer representing the number of pixels, or an integer with an optional unit of measure
-     *              appended (as a string).
-     *              A function returning the height to set. Receives the index position of the element in the set and
-     *              the old height as arguments. Within the function, this refers to the current element in the set.
-     * @see \`{@link https://api.jquery.com/height/ }\`
-     * @since 1.0
-     * @since 1.4.1
-     * @example ​ ````To set the height of each div on click to 30px plus a color change.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>height demo</title>
-  <style>
-  div {
-    width: 50px;
-    height: 70px;
-    float: left;
-    margin: 5px;
-    background: rgb(255,140,0);
-    cursor: pointer;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div></div>
-<div></div>
-<div></div>
-<div></div>
-<div></div>
-​
-<script>
-$( "div" ).one( "click", function() {
-  $( this ).height( 30 ).css({
-    cursor: "auto",
-    backgroundColor: "green"
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    height(value: string | number | ((this: TElement, index: number, height: number) => string | number)): this;
-    /**
-     * Get the current computed height for the first element in the set of matched elements.
-     *
-     * @see \`{@link https://api.jquery.com/height/ }\`
-     * @since 1.0
-     * @example ​ ````Show various heights.  Note the values are from the iframe so might be smaller than you expected.  The yellow highlight shows the iframe body.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>height demo</title>
-  <style>
-  body {
-    background: yellow;
-  }
-  button {
-    font-size: 12px;
-    margin: 2px;
-  }
-  p {
-    width: 150px;
-    border: 1px red solid;
-  }
-  div {
-    color: red;
-    font-weight: bold;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="getp">Get Paragraph Height</button>
-<button id="getd">Get Document Height</button>
-<button id="getw">Get Window Height</button>
-​
-<div>&nbsp;</div>
-<p>
-  Sample paragraph to test height
-</p>
-​
-<script>
-function showHeight( element, height ) {
-  $( "div" ).text( "The height for the " + element + " is " + height + "px." );
-}
-$( "#getp" ).click(function() {
-  showHeight( "paragraph", $( "p" ).height() );
-});
-$( "#getd" ).click(function() {
-  showHeight( "document", $( document ).height() );
-});
-$( "#getw" ).click(function() {
-  showHeight( "window", $( window ).height() );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    height(): number | undefined;
-    /**
-     * Hide the matched elements.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param easing A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/hide/ }\`
-     * @since 1.4.3
-     */
-    hide(duration: JQuery.Duration, easing: string, complete: (this: TElement) => void): this;
-    /**
-     * Hide the matched elements.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param easing_complete _&#x40;param_ `easing_complete`
-     * <br>
-     * * `easing` — A string indicating which easing function to use for the transition. <br>
-     * * `complete` — A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/hide/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     * @example ​ ````Animates all spans (words in this case) to hide fastly, completing each animation within 200 milliseconds. Once each animation is done, it starts the next one.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>hide demo</title>
-  <style>
-  span {
-    background: #def3ca;
-    padding: 3px;
-    float: left;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="hider">Hide</button>
-<button id="shower">Show</button>
-<div>
-  <span>Once</span> <span>upon</span> <span>a</span>
-  <span>time</span> <span>there</span> <span>were</span>
-  <span>three</span> <span>programmers...</span>
-</div>
-​
-<script>
-$( "#hider" ).click(function() {
-  $( "span:last-child" ).hide( "fast", function() {
-    // Use arguments.callee so we don't need a named function
-    $( this ).prev().hide( "fast", arguments.callee );
-  });
-});
-$( "#shower" ).click(function() {
-  $( "span" ).show( 2000 );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Hides the divs when clicked over 2 seconds, then removes the div element when its hidden.  Try clicking on more than one box at a time.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>hide demo</title>
-  <style>
-  div {
-    background: #ece023;
-    width: 30px;
-    height: 40px;
-    margin: 2px;
-    float: left;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div></div>
-​
-<script>
-for ( var i = 0; i < 5; i++ ) {
-  $( "<div>" ).appendTo( document.body );
-}
-$( "div" ).click(function() {
-  $( this ).hide( 2000, function() {
-    $( this ).remove();
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    hide(duration: JQuery.Duration, easing_complete: string | ((this: TElement) => void)): this;
-    /**
-     * Hide the matched elements.
-     *
-     * @param duration_complete_options _&#x40;param_ `duration_complete_options`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
-     * * `options` — A map of additional options to pass to the method.
-     * @see \`{@link https://api.jquery.com/hide/ }\`
-     * @since 1.0
-     * @example ​ ````Hides all paragraphs then the link on click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>hide demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<a href="#">Click to hide me too</a>
-<p>Here is another paragraph</p>
-​
-<script>
-$( "p" ).hide();
-$( "a" ).click(function( event ) {
-  event.preventDefault();
-  $( this ).hide();
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Animates all shown paragraphs to hide slowly, completing the animation within 600 milliseconds.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>hide demo</title>
-  <style>
-  p {
-    background: #dad;
-    font-weight: bold;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Hide 'em</button>
-<p>Hiya</p>
-<p>Such interesting text, eh?</p>
-​
-<script>
-$( "button" ).click(function() {
-  $( "p" ).hide( "slow" );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    hide(duration_complete_options?: JQuery.Duration | ((this: TElement) => void) | JQuery.EffectsOptions<TElement>): this;
-    /**
-     * Bind one or two handlers to the matched elements, to be executed when the mouse pointer enters and
-     * leaves the elements.
-     *
-     * @param handlerInOut A function to execute when the mouse pointer enters or leaves the element.
-     * @param handlerOut A function to execute when the mouse pointer leaves the element.
-     * @see \`{@link https://api.jquery.com/hover/ }\`
-     * @since 1.0
-     * @since 1.4
-     * @deprecated ​ Deprecated.
-     *
-     * **Cause**: The `.hover()` method is a shorthand for the use of the `mouseover`/`mouseout` events. It is often a poor user interface choice because it does not allow for any small amounts of delay between when the mouse enters or exits an area and when the event fires. This can make it quite difficult to use with UI widgets such as drop-down menus. For more information on the problems of hovering, see the \`{@link http://cherne.net/brian/resources/jquery.hoverIntent.html hoverIntent plugin}\`.
-     *
-     * **Solution**: Review uses of `.hover()` to determine if they are appropriate, and consider use of plugins such as `hoverIntent` as an alternative. The direct replacement for `.hover(fn1, fn2)`, is `.on("mouseenter", fn1).on("mouseleave", fn2)`.
-     * @example ​ ````To add a special style to list items that are being hovered over, try:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>hover demo</title>
-  <style>
-  ul {
-    margin-left: 20px;
-    color: blue;
-  }
-  li {
-    cursor: default;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul>
-  <li>Milk</li>
-  <li>Bread</li>
-  <li class="fade">Chips</li>
-  <li class="fade">Socks</li>
-</ul>
-​
-<script>
-$( "li" ).hover(
-  function() {
-    $( this ).append( $( "<span> ***</span>" ) );
-  }, function() {
-    $( this ).find( "span:last" ).remove();
-  }
-);
-​
-$( "li.fade" ).hover(function() {
-  $( this ).fadeOut( 100 );
-  $( this ).fadeIn( 500 );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````To add a special style to table cells that are being hovered over, try:
-```javascript
-$( "td" ).hover(
-  function() {
-    $( this ).addClass( "hover" );
-  }, function() {
-    $( this ).removeClass( "hover" );
-  }
-);
-```
-     * @example ​ ````To unbind the above example use:
-```javascript
-$( "td" ).off( "mouseenter mouseleave" );
-```
-     * @example ​ ````Slide the next sibling LI up or down on hover, and toggle a class.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>hover demo</title>
-  <style>
-  ul {
-    margin-left: 20px;
-    color: blue;
-  }
-  li {
-    cursor: default;
-  }
-  li.active {
-    background: black;
-    color: white;
-  }
-  span {
-    color:red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul>
-  <li>Milk</li>
-  <li>White</li>
-  <li>Carrots</li>
-  <li>Orange</li>
-  <li>Broccoli</li>
-  <li>Green</li>
-</ul>
-​
-<script>
-$( "li" )
-  .filter( ":odd" )
-    .hide()
-  .end()
-  .filter( ":even" )
-    .hover(function() {
-      $( this )
-        .toggleClass( "active" )
-        .next()
-          .stop( true, true )
-          .slideToggle();
-    });
-</script>
-​
-</body>
-</html>
-```
-     */
-    // HACK: The type parameter T is not used but ensures the 'event' callback parameter is typed correctly.
-    // tslint:disable-next-line:no-unnecessary-generics
-    hover<T>(handlerInOut: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false,
-             handlerOut?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Set the HTML contents of each element in the set of matched elements.
-     *
-     * @param htmlString A string of HTML to set as the content of each matched element.
-     *                   A function returning the HTML content to set. Receives the index position of the element in the set
-     *                   and the old HTML value as arguments. jQuery empties the element before calling the function; use the
-     *                   oldhtml argument to reference the previous content. Within the function, this refers to the current element in the set.
-     * @see \`{@link https://api.jquery.com/html/ }\`
-     * @since 1.0
-     * @since 1.4
-     * @example ​ ````Add some html to each div.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>html demo</title>
-  <style>
-  .red {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<span>Hello</span>
-<div></div>
-<div></div>
-<div></div>
-​
-<script>
-$( "div" ).html( "<span class='red'>Hello <b>Again</b></span>" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Add some html to each div then immediately do further manipulations to the inserted html.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>html demo</title>
-  <style>
-  div {
-    color: blue;
-    font-size: 18px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div></div>
-<div></div>
-<div></div>
-​
-<script>
-$( "div" ).html( "<b>Wow!</b> Such excitement..." );
-$( "div b" )
-  .append( document.createTextNode( "!!!" ) )
-  .css( "color", "red" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    html(htmlString: JQuery.htmlString | ((this: TElement, index: number, oldhtml: JQuery.htmlString) => JQuery.htmlString)): this;
-    /**
-     * Get the HTML contents of the first element in the set of matched elements.
-     *
-     * @see \`{@link https://api.jquery.com/html/ }\`
-     * @since 1.0
-     * @example ​ ````Click a paragraph to convert it from html to text.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>html demo</title>
-  <style>
-  p {
-    margin: 8px;
-    font-size: 20px;
-    color: blue;
-    cursor: pointer;
-  }
-  b {
-    text-decoration: underline;
-  }
-  button {
-    cursor: pointer;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>
-  <b>Click</b> to change the <span id="tag">html</span>
-</p>
-<p>
-  to a <span id="text">text</span> node.
-</p>
-<p>
-  This <button name="nada">button</button> does nothing.
-</p>
-​
-<script>
-$( "p" ).click(function() {
-  var htmlString = $( this ).html();
-  $( this ).text( htmlString );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    html(): string;
-    /**
-     * Search for a given element from among the matched elements.
-     *
-     * @param element The DOM element or first element within the jQuery object to look for.
-     *                A selector representing a jQuery collection in which to look for an element.
-     * @see \`{@link https://api.jquery.com/index/ }\`
-     * @since 1.0
-     * @since 1.4
-     * @example ​ ````On click, returns the index (zero-based) of that div in the page.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>index demo</title>
-  <style>
-  div {
-    background: yellow;
-    margin: 5px;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<span>Click a div!</span>
-<div>First div</div>
-<div>Second div</div>
-<div>Third div</div>
-​
-<script>
-$( "div" ).click(function() {
-  // `this` is the DOM element that was clicked
-  var index = $( "div" ).index( this );
-  $( "span" ).text( "That was div index #" + index );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Returns the index for the element with ID bar.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>index demo</title>
-  <style>
-  div {
-    font-weight: bold;
-    color: #090;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul>
-  <li id="foo">foo</li>
-  <li id="bar">bar</li>
-  <li id="baz">baz</li>
-</ul>
-<div></div>
-​
-<script>
-var listItem = $( "#bar" );
-$( "div" ).html( "Index: " + $( "li" ).index( listItem ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Returns the index for the first item in the jQuery collection.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>index demo</title>
-  <style>
-  div {
-    font-weight: bold;
-    color: #090;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul>
-  <li id="foo">foo</li>
-  <li id="bar">bar</li>
-  <li id="baz">baz</li>
-</ul>
-<div></div>
-​
-<script>
-var listItems = $( "li:gt(0)" );
-$( "div" ).html( "Index: " + $( "li" ).index( listItems ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Returns the index for the element with ID bar in relation to all &lt;li&gt; elements.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>index demo</title>
-  <style>
-  div {
-    font-weight: bold;
-    color: #090;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul>
-  <li id="foo">foo</li>
-  <li id="bar">bar</li>
-  <li id="baz">baz</li>
-</ul>
-<div></div>
-​
-<script>
-$( "div" ).html( "Index: " +  $( "#bar" ).index( "li" ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Returns the index for the element with ID bar in relation to its siblings.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>index demo</title>
-  <style>
-  div {
-    font-weight: bold;
-    color: #090;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul>
-  <li id="foo">foo</li>
-  <li id="bar">bar</li>
-  <li id="baz">baz</li>
-</ul>
-<div></div>
-​
-<script>
-var barIndex = $( "#bar" ).index();
-$( "div" ).html( "Index: " +  barIndex );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Returns -1, as there is no element with ID foobar.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>index demo</title>
-  <style>
-  div {
-    font-weight: bold;
-    color: #090;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul>
-  <li id="foo">foo</li>
-  <li id="bar">bar</li>
-  <li id="baz">baz</li>
-</ul>
-<div></div>
-​
-<script>
-var foobar = $( "li" ).index( $( "#foobar" ) );
-$( "div" ).html( "Index: " + foobar );
-</script>
-​
-</body>
-</html>
-```
-     */
-    index(element?: JQuery.Selector | Element | JQuery): number;
-    /**
-     * Set the CSS inner height of each element in the set of matched elements.
-     *
-     * @param value A number representing the number of pixels, or a number along with an optional unit of measure
-     *              appended (as a string).
-     *              A function returning the inner height (including padding but not border) to set. Receives the index
-     *              position of the element in the set and the old inner height as arguments. Within the function, this
-     *              refers to the current element in the set.
-     * @see \`{@link https://api.jquery.com/innerHeight/ }\`
-     * @since 1.8.0
-     * @example ​ ````Change the inner height of each div the first time it is clicked (and change its color).
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>innerHeight demo</title>
-  <style>
-div {
-  width: 60px;
-  padding: 10px;
-  height: 70px;
-  float: left;
-  margin: 5px;
-  background: red;
-  cursor: pointer;
-}
-.mod {
-  background: blue;
-  cursor: default;
-}
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>d</div>
-<div>d</div>
-<div>d</div>
-<div>d</div>
-<div>d</div>
-​
-<script>
-var modHeight = 70;
-$( "div" ).one( "click", function() {
-  $( this ).innerHeight( modHeight ).addClass( "mod" );
-  modHeight -= 8;
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    innerHeight(value: string | number | ((this: TElement, index: number, height: number) => string | number)): this;
-    /**
-     * Get the current computed height for the first element in the set of matched elements, including
-     * padding but not border.
-     *
-     * @see \`{@link https://api.jquery.com/innerHeight/ }\`
-     * @since 1.2.6
-     * @example ​ ````Get the innerHeight of a paragraph.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>innerHeight demo</title>
-  <style>
-  p {
-    margin: 10px;
-    padding: 5px;
-    border: 2px solid #666;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<p></p>
-​
-<script>
-var p = $( "p:first" );
-$( "p:last" ).text( "innerHeight:" + p.innerHeight() );
-</script>
-​
-</body>
-</html>
-```
-     */
-    innerHeight(): number | undefined;
-    /**
-     * Set the CSS inner width of each element in the set of matched elements.
-     *
-     * @param value A number representing the number of pixels, or a number along with an optional unit of measure
-     *              appended (as a string).
-     *              A function returning the inner width (including padding but not border) to set. Receives the index
-     *              position of the element in the set and the old inner width as arguments. Within the function, this
-     *              refers to the current element in the set.
-     * @see \`{@link https://api.jquery.com/innerWidth/ }\`
-     * @since 1.8.0
-     * @example ​ ````Change the inner width of each div the first time it is clicked (and change its color).
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>innerWidth demo</title>
-  <style>
-div {
-width: 60px;
-padding: 10px;
-height: 50px;
-float: left;
-margin: 5px;
-background: red;
-cursor: pointer;
-}
-.mod {
-background: blue;
-cursor: default;
-}
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>d</div>
-<div>d</div>
-<div>d</div>
-<div>d</div>
-<div>d</div>
-​
-<script>
-var modWidth = 60;
-$( "div" ).one( "click", function() {
-$( this ).innerWidth( modWidth ).addClass( "mod" );
-modWidth -= 8;
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    innerWidth(value: string | number | ((this: TElement, index: number, width: number) => string | number)): this;
-    /**
-     * Get the current computed inner width for the first element in the set of matched elements, including
-     * padding but not border.
-     *
-     * @see \`{@link https://api.jquery.com/innerWidth/ }\`
-     * @since 1.2.6
-     * @example ​ ````Get the innerWidth of a paragraph.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>innerWidth demo</title>
-  <style>
-  p {
-    margin: 10px;
-    padding: 5px;
-    border: 2px solid #666;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<p></p>
-​
-<script>
-var p = $( "p:first" );
-$( "p:last" ).text( "innerWidth:" + p.innerWidth() );
-</script>
-​
-</body>
-</html>
-```
-     */
-    innerWidth(): number | undefined;
-    /**
-     * Insert every element in the set of matched elements after the target.
-     *
-     * @param target A selector, element, array of elements, HTML string, or jQuery object; the matched set of elements
-     *               will be inserted after the element(s) specified by this parameter.
-     * @see \`{@link https://api.jquery.com/insertAfter/ }\`
-     * @since 1.0
-     * @example ​ ````Insert all paragraphs after an element with id of &quot;foo&quot;. Same as $( &quot;#foo&quot; ).after( &quot;p&quot; )
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>insertAfter demo</title>
-  <style>
-  #foo {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p> is what I said... </p>
-<div id="foo">FOO!</div>
-​
-<script>
-$( "p" ).insertAfter( "#foo" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    insertAfter(target: JQuery.Selector | JQuery.htmlString | JQuery.TypeOrArray<Node> | JQuery<Node>): this;
-    /**
-     * Insert every element in the set of matched elements before the target.
-     *
-     * @param target A selector, element, array of elements, HTML string, or jQuery object; the matched set of elements
-     *               will be inserted before the element(s) specified by this parameter.
-     * @see \`{@link https://api.jquery.com/insertBefore/ }\`
-     * @since 1.0
-     * @example ​ ````Insert all paragraphs before an element with id of &quot;foo&quot;. Same as $( &quot;#foo&quot; ).before( &quot;p&quot; )
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>insertBefore demo</title>
-  <style>
-  #foo {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="foo">FOO!</div>
-<p>I would like to say: </p>
-​
-<script>
-$( "p" ).insertBefore( "#foo" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    insertBefore(target: JQuery.Selector | JQuery.htmlString | JQuery.TypeOrArray<Node> | JQuery<Node>): this;
-    /**
-     * Check the current matched set of elements against a selector, element, or jQuery object and return
-     * true if at least one of these elements matches the given arguments.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     *                 A function used as a test for every element in the set. It accepts two arguments, index, which is
-     *                 the element's index in the jQuery collection, and element, which is the DOM element. Within the
-     *                 function, this refers to the current DOM element.
-     *                 An existing jQuery object to match the current set of elements against.
-     *                 One or more elements to match the current set of elements against.
-     * @see \`{@link https://api.jquery.com/is/ }\`
-     * @since 1.0
-     * @since 1.6
-     * @example ​ ````Shows a few ways is() can be used inside an event handler.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>is demo</title>
-  <style>
-  div {
-    width: 60px;
-    height: 60px;
-    margin: 5px;
-    float: left;
-    border: 4px outset;
-    background: green;
-    text-align: center;
-    font-weight: bolder;
-    cursor: pointer;
-  }
-  .blue {
-    background: blue;
-  }
-  .red {
-    background: red;
-  }
-  span {
-    color: white;
-    font-size: 16px;
-  }
-  p {
-    color: red;
-    font-weight: bolder;
-    background: yellow;
-    margin: 3px;
-    clear: left;
-    display: none;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div></div>
-<div class="blue"></div>
-<div></div>
-<div class="red"></div>
-<div><br/><span>Peter</span></div>
-<div class="blue"></div>
-<p>&nbsp;</p>
-​
-<script>
-$( "div" ).one( "click", function() {
-  if ( $( this ).is( ":first-child" ) ) {
-    $( "p" ).text( "It's the first div." );
-  } else if ( $( this ).is( ".blue,.red" ) ) {
-    $( "p" ).text( "It's a blue or red div." );
-  } else if ( $( this ).is( ":contains('Peter')" ) ) {
-    $( "p" ).text( "It's Peter!" );
-  } else {
-    $( "p" ).html( "It's nothing <em>special</em>." );
-  }
-  $( "p" ).hide().slideDown( "slow" );
-  $( this ).css({
-    "border-style": "inset",
-    cursor: "default"
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Returns true, because the parent of the input is a form element.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>is demo</title>
-  <style>
-  div {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<form>
-  <input type="checkbox">
-</form>
-<div></div>
-​
-<script>
-var isFormParent = $( "input[type='checkbox']" ).parent().is( "form" );
-$( "div" ).text( "isFormParent = " + isFormParent );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Returns false, because the parent of the input is a p element.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>is demo</title>
-  <style>
-  div {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<form>
-  <p><input type="checkbox"></p>
-</form>
-<div></div>
-​
-<script>
-var isFormParent = $( "input[type='checkbox']" ).parent().is( "form" );
-$( "div" ).text( "isFormParent = " + isFormParent );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Checks against an existing collection of alternating list elements. Blue, alternating list elements slide up while others turn red.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>is demo</title>
-  <style>
-  li {
-    cursor: pointer;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul id="browsers">
-  <li>Chrome</li>
-  <li>Safari</li>
-  <li>Firefox</li>
-  <li>Opera</li>
-</ul>
-​
-<script>
-var alt = $( "#browsers li:nth-child(2n)" ).css( "background", "#0ff" );
-$( "li" ).click(function() {
-  var li = $( this );
-  if ( li.is( alt ) ) {
-    li.slideUp();
-  } else {
-    li.css( "background", "red" );
-  }
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````An alternate way to achieve the above example using an element rather than a jQuery object. Checks against an existing collection of alternating list elements. Blue, alternating list elements slide up while others turn red.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>is demo</title>
-  <style>
-  li {
-    cursor: pointer;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul id="browsers">
-  <li>Chrome</li>
-  <li>Safari</li>
-  <li>Firefox</li>
-  <li>Opera</li>
-</ul>
-​
-<script>
-var alt = $( "#browsers li:nth-child(2n)" ).css( "background", "#0ff" );
-$( "li" ).click(function() {
-  if ( alt.is( this ) ) {
-    $( this ).slideUp();
-  } else {
-    $( this ).css( "background", "red" );
-  }
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    is(selector: JQuery.Selector | JQuery.TypeOrArray<Element> | JQuery | ((this: TElement, index: number, element: TElement) => boolean)): boolean;
-    /**
-     * Bind an event handler to the "keydown" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/keydown/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    keydown<TData>(eventData: TData,
-                   handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "keydown" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/keydown/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````Show the event object for the keydown handler when a key is pressed in the input.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>keydown demo</title>
-  <style>
-  fieldset {
-    margin-bottom: 1em;
-  }
-  input {
-    display: block;
-    margin-bottom: .25em;
-  }
-  #print-output {
-    width: 100%;
-  }
-  .print-output-line {
-    white-space: pre;
-    padding: 5px;
-    font-family: monaco, monospace;
-    font-size: .7em;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<form>
-  <fieldset>
-    <label for="target">Type Something:</label>
-    <input id="target" type="text">
-  </fieldset>
-</form>
-<button id="other">
-  Trigger the handler
-</button>
-<script type="text/javascript" src="/resources/events.js"></script>
-​
-<script>
-var xTriggered = 0;
-$( "#target" ).keydown(function( event ) {
-  if ( event.which == 13 ) {
-   event.preventDefault();
-  }
-  xTriggered++;
-  var msg = "Handler for .keydown() called " + xTriggered + " time(s).";
-  $.print( msg, "html" );
-  $.print( event );
-});
-​
-$( "#other" ).click(function() {
-  $( "#target" ).keydown();
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    keydown(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Bind an event handler to the "keypress" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/keypress/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    keypress<TData>(eventData: TData,
-                    handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "keypress" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/keypress/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````Show the event object when a key is pressed in the input. Note: This demo relies on a simple $.print() plugin (https://api.jquery.com/resources/events.js) for the event object&#39;s output.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>keypress demo</title>
-  <style>
-  fieldset {
-    margin-bottom: 1em;
-  }
-  input {
-    display: block;
-    margin-bottom: .25em;
-  }
-  #print-output {
-    width: 100%;
-  }
-  .print-output-line {
-    white-space: pre;
-    padding: 5px;
-    font-family: monaco, monospace;
-    font-size: .7em;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<form>
-  <fieldset>
-    <label for="target">Type Something:</label>
-    <input id="target" type="text">
-  </fieldset>
-</form>
-<button id="other">
-  Trigger the handler
-</button>
-<script src="/resources/events.js"></script>
-​
-<script>
-var xTriggered = 0;
-$( "#target" ).keypress(function( event ) {
-  if ( event.which == 13 ) {
-     event.preventDefault();
-  }
-  xTriggered++;
-  var msg = "Handler for .keypress() called " + xTriggered + " time(s).";
-  $.print( msg, "html" );
-  $.print( event );
-});
-​
-$( "#other" ).click(function() {
-  $( "#target" ).keypress();
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    keypress(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Bind an event handler to the "keyup" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/keyup/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    keyup<TData>(eventData: TData,
-                 handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "keyup" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/keyup/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````Show the event object for the keyup handler (using a simple $.print plugin) when a key is released in the input.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>keyup demo</title>
-  <style>
-  fieldset {
-    margin-bottom: 1em;
-  }
-  input {
-    display: block;
-    margin-bottom: .25em;
-  }
-  #print-output {
-    width: 100%;
-  }
-  .print-output-line {
-    white-space: pre;
-    padding: 5px;
-    font-family: monaco, monospace;
-    font-size: .7em;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<form>
-  <fieldset>
-    <label for="target">Type Something:</label>
-    <input id="target" type="text">
-  </fieldset>
-</form>
-<button id="other">
-  Trigger the handler
-</button>
-<script type="text/javascript" src="/resources/events.js"></script>
-​
-<script>
-var xTriggered = 0;
-$( "#target" ).keyup(function( event ) {
-  xTriggered++;
-  var msg = "Handler for .keyup() called " + xTriggered + " time(s).";
-  $.print( msg, "html" );
-  $.print( event );
-}).keydown(function( event ) {
-  if ( event.which == 13 ) {
-    event.preventDefault();
-  }
-});
-​
-$( "#other").click(function() {
-  $( "#target" ).keyup();
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    keyup(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Reduce the set of matched elements to the final one in the set.
-     *
-     * @see \`{@link https://api.jquery.com/last/ }\`
-     * @since 1.4
-     * @example ​ ````Highlight the last span in a paragraph.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>last demo</title>
-  <style>
-  .highlight {
-    background-color: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><span>Look:</span> <span>This is some text in a paragraph.</span> <span>This is a note about it.</span></p>
-​
-<script>
-$( "p span" ).last().addClass( "highlight" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    last(): this;
-    /**
-     * Load data from the server and place the returned HTML into the matched element.
-     *
-     * @param url A string containing the URL to which the request is sent.
-     * @param data A plain object or string that is sent to the server with the request.
-     * @param complete A callback function that is executed when the request completes.
-     * @see \`{@link https://api.jquery.com/load/ }\`
-     * @since 1.0
-     * @example ​ ````Same as above, but will POST the additional parameters to the server and a callback that is executed when the server is finished responding.
-```javascript
-$( "#feeds" ).load( "feeds.php", { limit: 25 }, function() {
-  alert( "The last 25 entries in the feed have been loaded" );
-});
-```
-     */
-    load(url: string,
-         data: string | JQuery.PlainObject,
-         complete: (this: TElement, responseText: string, textStatus: JQuery.Ajax.TextStatus, jqXHR: JQuery.jqXHR) => void): this;
-    /**
-     * Load data from the server and place the returned HTML into the matched element.
-     *
-     * @param url A string containing the URL to which the request is sent.
-     * @param complete_data _&#x40;param_ `complete_data`
-     * <br>
-     * * `complete` — A callback function that is executed when the request completes. <br>
-     * * `data` — A plain object or string that is sent to the server with the request.
-     * @see \`{@link https://api.jquery.com/load/ }\`
-     * @since 1.0
-     * @example ​ ````Load another page&#39;s list items into an ordered list.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>load demo</title>
-  <style>
-  body {
-    font-size: 12px;
-    font-family: Arial;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<b>Projects:</b>
-<ol id="new-projects"></ol>
-​
-<script>
-$( "#new-projects" ).load( "/resources/load.html #projects li" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Display a notice if the Ajax request encounters an error.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>load demo</title>
-  <style>
-  body {
-    font-size: 12px;
-    font-family: Arial;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<b>Successful Response (should be blank):</b>
-<div id="success"></div>
-<b>Error Response:</b>
-<div id="error"></div>
-​
-<script>
-$( "#success" ).load( "/not-here.php", function( response, status, xhr ) {
-  if ( status == "error" ) {
-    var msg = "Sorry but there was an error: ";
-    $( "#error" ).html( msg + xhr.status + " " + xhr.statusText );
-  }
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Load the feeds.html file into the div with the ID of feeds.
-```javascript
-$( "#feeds" ).load( "feeds.html" );
-```
-     * @example ​ ````pass arrays of data to the server.
-```javascript
-$( "#objectID" ).load( "test.php", { "choices[]": [ "Jon", "Susan" ] } );
-```
-     */
-    load(url: string,
-         complete_data?: ((this: TElement, responseText: string, textStatus: JQuery.Ajax.TextStatus, jqXHR: JQuery.jqXHR) => void) | string | JQuery.PlainObject): this;
-    /**
-     * Pass each element in the current matched set through a function, producing a new jQuery object
-     * containing the return values.
-     *
-     * @param callback A function object that will be invoked for each element in the current set.
-     * @see \`{@link https://api.jquery.com/map/ }\`
-     * @since 1.2
-     * @example ​ ````Build a list of all the values within a form.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>map demo</title>
-  <style>
-  p {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><b>Values: </b></p>
-<form>
-  <input type="text" name="name" value="John">
-  <input type="text" name="password" value="password">
-  <input type="text" name="url" value="https://johnresig.com/">
-</form>
-​
-<script>
-$( "p" )
-  .append( $( "input" ).map(function() {
-    return $( this ).val();
-  })
-  .get()
-  .join( ", " ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````A contrived example to show some functionality.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>map demo</title>
-  <style>
-  body {
-    font-size: 16px;
-  }
-  ul {
-    float: left;
-    margin: 0 30px;
-    color: blue;
-  }
-  #results {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul>
-  <li>First</li>
-  <li>Second</li>
-  <li>Third</li>
-  <li>Fourth</li>
-  <li>Fifth</li>
-</ul>
-<ul id="results">
-</ul>
-​
-<script>
-var mappedItems = $( "li" ).map(function( index ) {
-  var replacement = $( "<li>" ).text( $( this ).text() ).get( 0 );
-  if ( index === 0 ) {
-​
-    // Make the first item all caps
-    $( replacement ).text( $( replacement ).text().toUpperCase() );
-  } else if ( index === 1 || index === 3 ) {
-​
-    // Delete the second and fourth items
-    replacement = null;
-  } else if ( index === 2 ) {
-​
-    // Make two of the third item and add some text
-    replacement = [ replacement, $( "<li>" ).get( 0 ) ];
-    $( replacement[ 0 ] ).append( "<b> - A</b>" );
-    $( replacement[ 1 ] ).append( "Extra <b> - B</b>" );
-  }
-​
-  // Replacement will be a dom element, null,
-  // or an array of dom elements
-  return replacement;
-});
-$( "#results" ).append( mappedItems );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Equalize the heights of the divs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>map demo</title>
-  <style>
-  div {
-    width: 40px;
-    float: left;
-  }
-  input {
-    clear: left;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<input type="button" value="equalize div heights">
-<div style="background: red; height: 40px; "></div>
-<div style="background: green; height: 70px;"></div>
-<div style="background: blue; height: 50px; "></div>
-​
-<script>
-$.fn.equalizeHeights = function() {
-  var maxHeight = this.map(function( i, e ) {
-    return $( e ).height();
-  }).get();
-  return this.height( Math.max.apply( this, maxHeight ) );
-};
-​
-$( "input" ).click(function() {
-  $( "div" ).equalizeHeights();
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    map<TReturn>(callback: (this: TElement, index: number, domElement: TElement) => JQuery.TypeOrArray<TReturn> | null | undefined): JQuery<TReturn>;
-    /**
-     * Bind an event handler to the "mousedown" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/mousedown/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    mousedown<TData>(eventData: TData,
-                     handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "mousedown" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/mousedown/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````Show texts when mouseup and mousedown event triggering.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>mousedown demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Press mouse and release here.</p>
-​
-<script>
-$( "p" )
-  .mouseup(function() {
-    $( this ).append( "<span style='color:#f00;'>Mouse up.</span>" );
-  })
-  .mousedown(function() {
-    $( this ).append( "<span style='color:#00f;'>Mouse down.</span>" );
-  });
-</script>
-​
-</body>
-</html>
-```
-     */
-    mousedown(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Bind an event handler to be fired when the mouse enters an element, or trigger that handler on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/mouseenter/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    mouseenter<TData>(eventData: TData,
-                      handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to be fired when the mouse enters an element, or trigger that handler on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/mouseenter/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````Show texts when mouseenter and mouseout event triggering.
-    mouseover fires when the pointer moves into the child element as well, while mouseenter fires only when the pointer moves into the bound element.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>mouseenter demo</title>
-  <style>
-  div.out {
-    width: 40%;
-    height: 120px;
-    margin: 0 15px;
-    background-color: #d6edfc;
-    float: left;
-  }
-  div.in {
-    width: 60%;
-    height: 60%;
-    background-color: #fc0;
-    margin: 10px auto;
-  }
-  p {
-    line-height: 1em;
-    margin: 0;
-    padding: 0;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div class="out overout">
-  <p>move your mouse</p>
-  <div class="in overout"><p>move your mouse</p><p>0</p></div>
-  <p>0</p>
-</div>
-​
-<div class="out enterleave">
-  <p>move your mouse</p>
-  <div class="in enterleave"><p>move your mouse</p><p>0</p></div>
-  <p>0</p>
-</div>
-​
-<script>
-var i = 0;
-$( "div.overout" )
-  .mouseover(function() {
-    $( "p:first", this ).text( "mouse over" );
-    $( "p:last", this ).text( ++i );
-  })
-  .mouseout(function() {
-    $( "p:first", this ).text( "mouse out" );
-  });
-​
-var n = 0;
-$( "div.enterleave" )
-  .mouseenter(function() {
-    $( "p:first", this ).text( "mouse enter" );
-    $( "p:last", this ).text( ++n );
-  })
-  .mouseleave(function() {
-    $( "p:first", this ).text( "mouse leave" );
-  });
-</script>
-​
-</body>
-</html>
-```
-     */
-    mouseenter(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Bind an event handler to be fired when the mouse leaves an element, or trigger that handler on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/mouseleave/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    mouseleave<TData>(eventData: TData,
-                      handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to be fired when the mouse leaves an element, or trigger that handler on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/mouseleave/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````Show number of times mouseout and mouseleave events are triggered. mouseout fires when the pointer moves out of child element as well, while mouseleave fires only when the pointer moves out of the bound element.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>mouseleave demo</title>
-  <style>
-  div.out {
-    width: 40%;
-    height: 120px;
-    margin: 0 15px;
-    background-color: #d6edfc;
-    float: left;
-  }
-  div.in {
-    width: 60%;
-    height: 60%;
-    background-color: #fc0;
-    margin: 10px auto;
-  }
-  p {
-    line-height: 1em;
-    margin: 0;
-    padding: 0;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div class="out overout">
-  <p>move your mouse</p>
-  <div class="in overout"><p>move your mouse</p><p>0</p></div>
-  <p>0</p>
-</div>
-<div class="out enterleave">
-  <p>move your mouse</p>
-  <div class="in enterleave"><p>move your mouse</p><p>0</p></div>
-  <p>0</p>
-</div>
-​
-<script>
-var i = 0;
-$( "div.overout" )
-  .mouseover(function() {
-    $( "p:first", this ).text( "mouse over" );
-  })
-  .mouseout(function() {
-    $( "p:first", this ).text( "mouse out" );
-    $( "p:last", this ).text( ++i );
-  });
-​
-var n = 0;
-$( "div.enterleave" )
-  .mouseenter(function() {
-    $( "p:first", this ).text( "mouse enter" );
-  })
-  .mouseleave(function() {
-    $( "p:first", this ).text( "mouse leave" );
-    $( "p:last", this ).text( ++n );
-  });
-</script>
-​
-</body>
-</html>
-```
-     */
-    mouseleave(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Bind an event handler to the "mousemove" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/mousemove/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    mousemove<TData>(eventData: TData,
-                     handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "mousemove" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/mousemove/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````Show the mouse coordinates when the mouse is moved over the yellow div.  Coordinates are relative to the window, which in this case is the iframe.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>mousemove demo</title>
-  <style>
-  div {
-    width: 220px;
-    height: 170px;
-    margin: 10px 50px 10px 10px;
-    background: yellow;
-    border: 2px groove;
-    float: right;
-  }
-  p {
-    margin: 0;
-    margin-left: 10px;
-    color: red;
-    width: 220px;
-    height: 120px;
-    padding-top: 70px;
-    float: left;
-    font-size: 14px;
-  }
-  span {
-    display: block;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>
-  <span>Move the mouse over the div.</span>
-  <span>&nbsp;</span>
-</p>
-<div></div>
-​
-<script>
-$( "div" ).mousemove(function( event ) {
-  var pageCoords = "( " + event.pageX + ", " + event.pageY + " )";
-  var clientCoords = "( " + event.clientX + ", " + event.clientY + " )";
-  $( "span:first" ).text( "( event.pageX, event.pageY ) : " + pageCoords );
-  $( "span:last" ).text( "( event.clientX, event.clientY ) : " + clientCoords );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    mousemove(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Bind an event handler to the "mouseout" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/mouseout/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    mouseout<TData>(eventData: TData,
-                    handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "mouseout" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/mouseout/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````Show the number of times mouseout and mouseleave events are triggered.
-  mouseout fires when the pointer moves out of the child element as well, while mouseleave fires only when the pointer moves out of the bound element.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>mouseout demo</title>
-  <style>
-  div.out {
-    width: 40%;
-    height: 120px;
-    margin: 0 15px;
-    background-color: #d6edfc;
-    float: left;
-  }
-  div.in {
-    width: 60%;
-    height: 60%;
-    background-color: #fc0;
-    margin: 10px auto;
-  }
-  p {
-    line-height: 1em;
-    margin: 0;
-    padding: 0;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div class="out overout">
-  <p>move your mouse</p>
-  <div class="in overout"><p>move your mouse</p><p>0</p></div>
-  <p>0</p>
-</div>
-​
-<div class="out enterleave">
-  <p>move your mouse</p>
-  <div class="in enterleave"><p>move your mouse</p><p>0</p></div>
-  <p>0</p>
-</div>
-​
-<script>
-var i = 0;
-$( "div.overout" )
-  .mouseout(function() {
-    $( "p:first", this ).text( "mouse out" );
-    $( "p:last", this ).text( ++i );
-  })
-  .mouseover(function() {
-    $( "p:first", this ).text( "mouse over" );
-  });
-​
-var n = 0;
-$( "div.enterleave" )
-  .on( "mouseenter", function() {
-    $( "p:first", this ).text( "mouse enter" );
-  })
-  .on( "mouseleave", function() {
-    $( "p:first", this ).text( "mouse leave" );
-    $( "p:last", this ).text( ++n );
-  });
-</script>
-​
-</body>
-</html>
-```
-     */
-    mouseout(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Bind an event handler to the "mouseover" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/mouseover/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    mouseover<TData>(eventData: TData,
-                     handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "mouseover" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/mouseover/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````Show the number of times mouseover and mouseenter events are triggered.
-mouseover fires when the pointer moves into the child element as well, while mouseenter fires only when the pointer moves into the bound element.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>mouseover demo</title>
-  <style>
-  div.out {
-    width: 40%;
-    height: 120px;
-    margin: 0 15px;
-    background-color: #d6edfc;
-    float: left;
-  }
-  div.in {
-    width: 60%;
-    height: 60%;
-    background-color: #fc0;
-    margin: 10px auto;
-  }
-  p {
-    line-height: 1em;
-    margin: 0;
-    padding: 0;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div class="out overout">
-  <span>move your mouse</span>
-  <div class="in">
-  </div>
-</div>
-​
-<div class="out enterleave">
-  <span>move your mouse</span>
-  <div class="in">
-  </div>
-</div>
-​
-<script>
-var i = 0;
-$( "div.overout" )
-  .mouseover(function() {
-    i += 1;
-    $( this ).find( "span" ).text( "mouse over x " + i );
-  })
-  .mouseout(function() {
-    $( this ).find( "span" ).text( "mouse out " );
-  });
-​
-var n = 0;
-$( "div.enterleave" )
-  .mouseenter(function() {
-    n += 1;
-    $( this ).find( "span" ).text( "mouse enter x " + n );
-  })
-  .mouseleave(function() {
-    $( this ).find( "span" ).text( "mouse leave" );
-  });
-</script>
-​
-</body>
-</html>
-```
-     */
-    mouseover(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Bind an event handler to the "mouseup" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/mouseup/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    mouseup<TData>(eventData: TData,
-                   handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "mouseup" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/mouseup/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````Show texts when mouseup and mousedown event triggering.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>mouseup demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Press mouse and release here.</p>
-​
-<script>
-$( "p" )
-  .mouseup(function() {
-    $( this ).append( "<span style='color:#f00;'>Mouse up.</span>" );
-  })
-  .mousedown(function() {
-    $( this ).append( "<span style='color:#00f;'>Mouse down.</span>" );
-  });
-</script>
-​
-</body>
-</html>
-```
-     */
-    mouseup(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Get the immediately following sibling of each element in the set of matched elements. If a selector
-     * is provided, it retrieves the next sibling only if it matches that selector.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @see \`{@link https://api.jquery.com/next/ }\`
-     * @since 1.0
-     * @example ​ ````Find the very next sibling of each disabled button and change its text &quot;this button is disabled&quot;.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>next demo</title>
-  <style>
-  span {
-    color: blue;
-    font-weight: bold;
-  }
-  button {
-    width: 100px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div><button disabled="disabled">First</button> - <span></span></div>
-<div><button>Second</button> - <span></span></div>
-<div><button disabled="disabled">Third</button> - <span></span></div>
-​
-<script>
-$( "button[disabled]" ).next().text( "this button is disabled" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Find the very next sibling of each paragraph. Keep only the ones with a class &quot;selected&quot;.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>next demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<p class="selected">Hello Again</p>
-<div><span>And Again</span></div>
-​
-<script>
-$( "p" ).next( ".selected" ).css( "background", "yellow" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    next(selector?: JQuery.Selector): this;
-    /**
-     * Get all following siblings of each element in the set of matched elements, optionally filtered by a selector.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @see \`{@link https://api.jquery.com/nextAll/ }\`
-     * @since 1.2
-     * @example ​ ````Locate all the divs after the first and give them a class.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>nextAll demo</title>
-  <style>
-  div {
-    width: 80px;
-    height: 80px;
-    background: #abc;
-    border: 2px solid black;
-    margin: 10px;
-    float: left;
-  }
-  div.after {
-    border-color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>first</div>
-<div>sibling<div>child</div></div>
-<div>sibling</div>
-<div>sibling</div>​
-<script>
-$( "div:first" ).nextAll().addClass( "after" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Locate all the paragraphs after the second child in the body and give them a class.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>nextAll demo</title>
-  <style>
-  div, p {
-    width: 60px;
-    height: 60px;
-    background: #abc;
-    border: 2px solid black;
-    margin: 10px;
-    float: left;
-  }
-  .after {
-    border-color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>p</p>
-<div>div</div>
-<p>p</p>
-<p>p</p>
-<div>div</div>
-<p>p</p>
-<div>div</div>
-​
-<script>
-$( ":nth-child(1)" ).nextAll( "p" ).addClass( "after" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    nextAll(selector?: string): this;
-    /**
-     * Get all following siblings of each element up to but not including the element matched by the
-     * selector, DOM node, or jQuery object passed.
-     *
-     * @param selector A string containing a selector expression to indicate where to stop matching following sibling elements.
-     *                 A DOM node or jQuery object indicating where to stop matching following sibling elements.
-     * @param filter A string containing a selector expression to match elements against.
-     * @see \`{@link https://api.jquery.com/nextUntil/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @example ​ ````Find the siblings that follow &lt;dt id=&quot;term-2&quot;&gt; up to the next &lt;dt&gt; and give them a red background color. Also, find &lt;dd&gt; siblings that follow &lt;dt id=&quot;term-1&quot;&gt; up to &lt;dt id=&quot;term-3&quot;&gt; and give them a green text color.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>nextUntil demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<dl>
-  <dt id="term-1">term 1</dt>
-  <dd>definition 1-a</dd>
-  <dd>definition 1-b</dd>
-  <dd>definition 1-c</dd>
-  <dd>definition 1-d</dd>
-  <dt id="term-2">term 2</dt>
-  <dd>definition 2-a</dd>
-  <dd>definition 2-b</dd>
-  <dd>definition 2-c</dd>
-  <dt id="term-3">term 3</dt>
-  <dd>definition 3-a</dd>
-  <dd>definition 3-b</dd>
-</dl>
-​
-<script>
-$( "#term-2" )
-  .nextUntil( "dt" )
-    .css( "background-color", "red" );
-var term3 = document.getElementById( "term-3" );
-$( "#term-1" )
-  .nextUntil( term3, "dd" )
-    .css( "color", "green" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    nextUntil(selector?: JQuery.Selector | Element | JQuery, filter?: JQuery.Selector): this;
-    /**
-     * Remove elements from the set of matched elements.
-     *
-     * @param selector A string containing a selector expression, a DOM element, or an array of elements to match against the set.
-     *                 A function used as a test for each element in the set. It accepts two arguments, index, which is the
-     *                 element's index in the jQuery collection, and element, which is the DOM element. Within the
-     *                 function, this refers to the current DOM element.
-     *                 An existing jQuery object to match the current set of elements against.
-     * @see \`{@link https://api.jquery.com/not/ }\`
-     * @since 1.0
-     * @since 1.4
-     * @example ​ ````Adds a border to divs that are not green or blue.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>not demo</title>
-  <style>
-  div {
-    width: 50px;
-    height: 50px;
-    margin: 10px;
-    float: left;
-    background: yellow;
-    border: 2px solid white;
-  }
-  .green {
-    background: #8f8;
-  }
-  .gray {
-    background: #ccc;
-  }
-  #blueone {
-    background: #99f;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div></div>
-<div id="blueone"></div>
-<div></div>
-<div class="green"></div>
-<div class="green"></div>
-<div class="gray"></div>
-<div></div>
-​
-<script>
-$( "div" ).not( ".green, #blueone" )
-  .css( "border-color", "red" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Removes the element with the ID &quot;selected&quot; from the set of all paragraphs.
-```javascript
-$( "p" ).not( $( "#selected" )[ 0 ] );
-```
-     * @example ​ ````Removes the element with the ID &quot;selected&quot; from the set of all paragraphs.
-```javascript
-$( "p" ).not( "#selected" );
-```
-     * @example ​ ````Removes all elements that match &quot;div p.selected&quot; from the total set of all paragraphs.
-```javascript
-$( "p" ).not( $( "div p.selected" ) );
-```
-     */
-    not(selector: JQuery.Selector | JQuery.TypeOrArray<Element> | JQuery | ((this: TElement, index: number, element: TElement) => boolean)): this;
-    /**
-     * Remove an event handler.
-     *
-     * @param events One or more space-separated event types and optional namespaces, or just namespaces, such as
-     *               "click", "keydown.myPlugin", or ".myPlugin".
-     * @param selector A selector which should match the one originally passed to .on() when attaching event handlers.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/off/ }\`
-     * @since 1.7
-     * @example ​ ````Add and remove event handlers on the colored button.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>off demo</title>
-  <style>
-  button {
-    margin: 5px;
-  }
-  button#theone {
-    color: red;
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="theone">Does nothing...</button>
-<button id="bind">Add Click</button>
-<button id="unbind">Remove Click</button>
-<div style="display:none;">Click!</div>
-​
-<script>
-function flash() {
-  $( "div" ).show().fadeOut( "slow" );
-}
-$( "#bind" ).click(function() {
-  $( "body" )
-    .on( "click", "#theone", flash )
-    .find( "#theone" )
-      .text( "Can Click!" );
-});
-$( "#unbind" ).click(function() {
-  $( "body" )
-    .off( "click", "#theone", flash )
-    .find( "#theone" )
-      .text( "Does nothing..." );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Remove just one previously bound handler by passing it as the third argument:
-```javascript
-var foo = function() {
-  // Code to handle some kind of event
-};
-​
-// ... Now foo will be called when paragraphs are clicked ...
-$( "body" ).on( "click", "p", foo );
-​
-// ... Foo will no longer be called.
-$( "body" ).off( "click", "p", foo );
-```
-     */
-    off(events: string, selector: JQuery.Selector, handler: JQuery.EventHandlerBase<any, JQuery.Event<TElement, any>> | false): this;
-    /**
-     * Remove an event handler.
-     *
-     * @param events One or more space-separated event types and optional namespaces, or just namespaces, such as
-     *               "click", "keydown.myPlugin", or ".myPlugin".
-     * @param selector_handler _&#x40;param_ `selector_handler`
-     * <br>
-     * * `selector` — A selector which should match the one originally passed to `.on()` when attaching event handlers. <br>
-     * * `handler` — A handler function previously attached for the event(s), or the special value `false`.
-     * @see \`{@link https://api.jquery.com/off/ }\`
-     * @since 1.7
-     * @example ​ ````Remove all delegated click handlers from all paragraphs:
-```javascript
-$( "p" ).off( "click", "**" );
-```
-     * @example ​ ````Unbind all delegated event handlers by their namespace:
-```javascript
-var validate = function() {
-  // Code to validate form entries
-};
-​
-// Delegate events under the ".validator" namespace
-$( "form" ).on( "click.validator", "button", validate );
-​
-$( "form" ).on( "keypress.validator", "input[type='text']", validate );
-​
-// Remove event handlers in the ".validator" namespace
-$( "form" ).off( ".validator" );
-```
-     */
-    off(events: string, selector_handler?: JQuery.Selector | JQuery.EventHandlerBase<any, JQuery.Event<TElement, any>> | false): this;
-    /**
-     * Remove an event handler.
-     *
-     * @param events An object where the string keys represent one or more space-separated event types and optional
-     *               namespaces, and the values represent handler functions previously attached for the event(s).
-     * @param selector A selector which should match the one originally passed to .on() when attaching event handlers.
-     * @see \`{@link https://api.jquery.com/off/ }\`
-     * @since 1.7
-     */
-    off(events: JQuery.PlainObject<JQuery.EventHandlerBase<any, JQuery.Event<TElement, any>> | false>, selector?: JQuery.Selector): this;
-    /**
-     * Remove an event handler.
-     *
-     * @param event A jQuery.Event object.
-     * @see \`{@link https://api.jquery.com/off/ }\`
-     * @since 1.7
-     * @example ​ ````Remove all event handlers from all paragraphs:
-```javascript
-$( "p" ).off();
-```
-     */
-    off(event?: JQuery.Event<TElement>): this;
-    /**
-     * Set the current coordinates of every element in the set of matched elements, relative to the document.
-     *
-     * @param coordinates An object containing the properties top and left, which are numbers indicating the new top and left
-     *                    coordinates for the elements.
-     *                    A function to return the coordinates to set. Receives the index of the element in the collection as
-     *                    the first argument and the current coordinates as the second argument. The function should return an
-     *                    object with the new top and left properties.
-     * @see \`{@link https://api.jquery.com/offset/ }\`
-     * @since 1.4
-     * @example ​ ````Set the offset of the second paragraph:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>offset demo</title>
-  <style>
-  p {
-    margin-left: 10px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p><p>2nd Paragraph</p>
-​
-<script>
-$( "p:last" ).offset({ top: 10, left: 30 });
-</script>
-​
-</body>
-</html>
-```
-     */
-    offset(coordinates: JQuery.CoordinatesPartial | ((this: TElement, index: number, coords: JQuery.Coordinates) => JQuery.CoordinatesPartial)): this;
-    /**
-     * Get the current coordinates of the first element in the set of matched elements, relative to the document.
-     *
-     * @see \`{@link https://api.jquery.com/offset/ }\`
-     * @since 1.2
-     * @example ​ ````Access the offset of the second paragraph:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>offset demo</title>
-  <style>
-  p {
-    margin-left: 10px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p><p>2nd Paragraph</p>
-​
-<script>
-var p = $( "p:last" );
-var offset = p.offset();
-p.html( "left: " + offset.left + ", top: " + offset.top );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Click to see the offset.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>offset demo</title>
-  <style>
-  p {
-    margin-left: 10px;
-    color: blue;
-    width: 200px;
-    cursor: pointer;
-  }
-  span {
-    color: red;
-    cursor: pointer;
-  }
-  div.abs {
-    width: 50px;
-    height: 50px;
-    position: absolute;
-    left: 220px;
-    top: 35px;
-    background-color: green;
-    cursor: pointer;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="result">Click an element.</div>
-<p>
-  This is the best way to <span>find</span> an offset.
-</p>
-<div class="abs">
-</div>
-​
-<script>
-$( "*", document.body ).click(function( event ) {
-  var offset = $( this ).offset();
-  event.stopPropagation();
-  $( "#result" ).text( this.tagName +
-    " coords ( " + offset.left + ", " + offset.top + " )" );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    offset(): JQuery.Coordinates | undefined;
-    /**
-     * Get the closest ancestor element that is positioned.
-     *
-     * @see \`{@link https://api.jquery.com/offsetParent/ }\`
-     * @since 1.2.6
-     * @example ​ ````Find the offsetParent of item &quot;A.&quot;
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>offsetParent demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul class="level-1">
-  <li class="item-i">I</li>
-  <li class="item-ii" style="position: relative;">II
-    <ul class="level-2">
-      <li class="item-a">A</li>
-      <li class="item-b">B
-        <ul class="level-3">
-          <li class="item-1">1</li>
-          <li class="item-2">2</li>
-          <li class="item-3">3</li>
-        </ul>
-      </li>
-      <li class="item-c">C</li>
-    </ul>
-  </li>
-  <li class="item-iii">III</li>
-</ul>
-​
-<script>$( "li.item-a" ).offsetParent().css( "background-color", "red" );</script>
-​
-</body>
-</html>
-```
-     */
-    offsetParent(): this;
-    /**
-     * Attach an event handler function for one or more events to the selected elements.
-     *
-     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
-     * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the
-     *                 selector is null or omitted, the event is always triggered when it reaches the selected element.
-     * @param data Data to be passed to the handler in event.data when an event is triggered.
-     * @param handler A function to execute when the event is triggered.
-     * @see \`{@link https://api.jquery.com/on/ }\`
-     * @since 1.7
-     */
-    on<TData>(events: string,
-              selector: JQuery.Selector | null,
-              data: TData,
-              handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Attach an event handler function for one or more events to the selected elements.
-     *
-     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
-     * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the
-     *                 selector is null or omitted, the event is always triggered when it reaches the selected element.
-     * @param data Data to be passed to the handler in event.data when an event is triggered.
-     * @param handler A function to execute when the event is triggered.
-     * @see \`{@link https://api.jquery.com/on/ }\`
-     * @since 1.7
-     */
-    on(events: string,
-       selector: JQuery.Selector | null,
-       data: any,
-       handler: ((event: JQueryEventObject) => void)): this; // tslint:disable-line:unified-signatures
-    /**
-     * Attach an event handler function for one or more events to the selected elements.
-     *
-     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
-     * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the
-     *                 selector is null or omitted, the event is always triggered when it reaches the selected element.
-     * @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand
-     *                for a function that simply does return false.
-     * @see \`{@link https://api.jquery.com/on/ }\`
-     * @since 1.7
-     * @example ​ ````Click any paragraph to add another after it. Note that .on() allows a click event on any paragraph--even new ones--since the event is handled by the ever-present body element after it bubbles to there.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>on demo</title>
-  <style>
-  p {
-    background: yellow;
-    font-weight: bold;
-    cursor: pointer;
-    padding: 5px;
-  }
-  p.over {
-    background: #ccc;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Click me!</p>
-<span></span>
-​
-<script>
-var count = 0;
-$( "body" ).on( "click", "p", function() {
-  $( this ).after( "<p>Another paragraph! " + (++count) + "</p>" );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Display each paragraph&#39;s text in an alert box whenever it is clicked:
-```javascript
-$( "body" ).on( "click", "p", function() {
-  alert( $( this ).text() );
-});
-```
-     * @example ​ ````Cancel a link&#39;s default action using the .preventDefault() method:
-```javascript
-$( "body" ).on( "click", "a", function( event ) {
-  event.preventDefault();
-});
-```
-     */
-    on(events: string,
-       selector: JQuery.Selector,
-       handler: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Attach an event handler function for one or more events to the selected elements.
-     *
-     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
-     * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the
-     *                 selector is null or omitted, the event is always triggered when it reaches the selected element.
-     * @param handler A function to execute when the event is triggered.
-     * @see \`{@link https://api.jquery.com/on/ }\`
-     * @since 1.7
-     * @example ​ ````Click any paragraph to add another after it. Note that .on() allows a click event on any paragraph--even new ones--since the event is handled by the ever-present body element after it bubbles to there.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>on demo</title>
-  <style>
-  p {
-    background: yellow;
-    font-weight: bold;
-    cursor: pointer;
-    padding: 5px;
-  }
-  p.over {
-    background: #ccc;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Click me!</p>
-<span></span>
-​
-<script>
-var count = 0;
-$( "body" ).on( "click", "p", function() {
-  $( this ).after( "<p>Another paragraph! " + (++count) + "</p>" );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Display each paragraph&#39;s text in an alert box whenever it is clicked:
-```javascript
-$( "body" ).on( "click", "p", function() {
-  alert( $( this ).text() );
-});
-```
-     * @example ​ ````Cancel a link&#39;s default action using the .preventDefault() method:
-```javascript
-$( "body" ).on( "click", "a", function( event ) {
-  event.preventDefault();
-});
-```
-     */
-    on(events: string,
-       selector: JQuery.Selector,
-       handler: ((event: JQueryEventObject) => void)): this; // tslint:disable-line:unified-signatures
-    /**
-     * Attach an event handler function for one or more events to the selected elements.
-     *
-     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
-     * @param data Data to be passed to the handler in event.data when an event is triggered.
-     * @param handler A function to execute when the event is triggered.
-     * @see \`{@link https://api.jquery.com/on/ }\`
-     * @since 1.7
-     * @example ​ ````Pass data to the event handler, which is specified here by name:
-```javascript
-function myHandler( event ) {
-  alert( event.data.foo );
-}
-$( "p" ).on( "click", { foo: "bar" }, myHandler );
-```
-     */
-    on<TData>(events: string,
-              data: TData,
-              handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Attach an event handler function for one or more events to the selected elements.
-     *
-     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
-     * @param data Data to be passed to the handler in event.data when an event is triggered.
-     * @param handler A function to execute when the event is triggered.
-     * @see \`{@link https://api.jquery.com/on/ }\`
-     * @since 1.7
-     * @example ​ ````Pass data to the event handler, which is specified here by name:
-```javascript
-function myHandler( event ) {
-  alert( event.data.foo );
-}
-$( "p" ).on( "click", { foo: "bar" }, myHandler );
-```
-     */
-    on(events: string,
-       data: any, // tslint:disable-line:unified-signatures
-       handler: ((event: JQueryEventObject) => void)): this;
-    /**
-     * Attach an event handler function for one or more events to the selected elements.
-     *
-     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
-     * @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand
-     *                for a function that simply does return false.
-     * @see \`{@link https://api.jquery.com/on/ }\`
-     * @since 1.7
-     * @example ​ ````Display a paragraph&#39;s text in an alert when it is clicked:
-```javascript
-$( "p" ).on( "click", function() {
-  alert( $( this ).text() );
-});
-```
-     * @example ​ ````Cancel a form submit action and prevent the event from bubbling up by returning false:
-```javascript
-$( "form" ).on( "submit", false );
-```
-     * @example ​ ````Cancel only the default action by using .preventDefault().
-```javascript
-$( "form" ).on( "submit", function( event ) {
-  event.preventDefault();
-});
-```
-     * @example ​ ````Stop submit events from bubbling without preventing form submit, using .stopPropagation().
-```javascript
-$( "form" ).on( "submit", function( event ) {
-  event.stopPropagation();
-});
-```
-     * @example ​ ````Pass data to the event handler using the second argument to .trigger()
-```javascript
-$( "div" ).on( "click", function( event, person ) {
-  alert( "Hello, " + person.name );
-});
-$( "div" ).trigger( "click", { name: "Jim" } );
-```
-     * @example ​ ````Use the the second argument of .trigger() to pass an array of data to the event handler
-```javascript
-$( "div" ).on( "click", function( event, salutation, name ) {
-  alert( salutation + ", " + name );
-});
-$( "div" ).trigger( "click", [ "Goodbye", "Jim" ] );
-```
-     * @example ​ ````Attach and trigger custom (non-browser) events.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>on demo</title>
-  <style>
-  p {
-    color: red;
-  }
-  span {
-    color: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Has an attached custom event.</p>
-<button>Trigger custom event</button>
-<span style="display:none;"></span>
-​
-<script>
-$( "p" ).on( "myCustomEvent", function( event, myName ) {
-  $( this ).text( myName + ", hi there!" );
-  $( "span" )
-    .stop()
-    .css( "opacity", 1 )
-    .text( "myName = " + myName )
-    .fadeIn( 30 )
-    .fadeOut( 1000 );
-});
-$( "button" ).click(function () {
-  $( "p" ).trigger( "myCustomEvent", [ "John" ] );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Attach multiple events—one on mouseenter and one on mouseleave to the same element:
-```javascript
-$( "#cart" ).on( "mouseenter mouseleave", function( event ) {
-  $( this ).toggleClass( "active" );
-});
-```
-     */
-    on(events: string,
-       handler: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Attach an event handler function for one or more events to the selected elements.
-     *
-     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
-     * @param handler A function to execute when the event is triggered.
-     * @see \`{@link https://api.jquery.com/on/ }\`
-     * @since 1.7
-     * @example ​ ````Display a paragraph&#39;s text in an alert when it is clicked:
-```javascript
-$( "p" ).on( "click", function() {
-  alert( $( this ).text() );
-});
-```
-     * @example ​ ````Cancel a form submit action and prevent the event from bubbling up by returning false:
-```javascript
-$( "form" ).on( "submit", false );
-```
-     * @example ​ ````Cancel only the default action by using .preventDefault().
-```javascript
-$( "form" ).on( "submit", function( event ) {
-  event.preventDefault();
-});
-```
-     * @example ​ ````Stop submit events from bubbling without preventing form submit, using .stopPropagation().
-```javascript
-$( "form" ).on( "submit", function( event ) {
-  event.stopPropagation();
-});
-```
-     * @example ​ ````Pass data to the event handler using the second argument to .trigger()
-```javascript
-$( "div" ).on( "click", function( event, person ) {
-  alert( "Hello, " + person.name );
-});
-$( "div" ).trigger( "click", { name: "Jim" } );
-```
-     * @example ​ ````Use the the second argument of .trigger() to pass an array of data to the event handler
-```javascript
-$( "div" ).on( "click", function( event, salutation, name ) {
-  alert( salutation + ", " + name );
-});
-$( "div" ).trigger( "click", [ "Goodbye", "Jim" ] );
-```
-     * @example ​ ````Attach and trigger custom (non-browser) events.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>on demo</title>
-  <style>
-  p {
-    color: red;
-  }
-  span {
-    color: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Has an attached custom event.</p>
-<button>Trigger custom event</button>
-<span style="display:none;"></span>
-​
-<script>
-$( "p" ).on( "myCustomEvent", function( event, myName ) {
-  $( this ).text( myName + ", hi there!" );
-  $( "span" )
-    .stop()
-    .css( "opacity", 1 )
-    .text( "myName = " + myName )
-    .fadeIn( 30 )
-    .fadeOut( 1000 );
-});
-$( "button" ).click(function () {
-  $( "p" ).trigger( "myCustomEvent", [ "John" ] );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Attach multiple events—one on mouseenter and one on mouseleave to the same element:
-```javascript
-$( "#cart" ).on( "mouseenter mouseleave", function( event ) {
-  $( this ).toggleClass( "active" );
-});
-```
-     */
-    on(events: string,
-       handler: ((event: JQueryEventObject) => void)): this; // tslint:disable-line:unified-signatures
-    /**
-     * Attach an event handler function for one or more events to the selected elements.
-     *
-     * @param events An object in which the string keys represent one or more space-separated event types and optional
-     *               namespaces, and the values represent a handler function to be called for the event(s).
-     * @param selector A selector string to filter the descendants of the selected elements that will call the handler. If
-     *                 the selector is null or omitted, the handler is always called when it reaches the selected element.
-     * @param data Data to be passed to the handler in event.data when an event occurs.
-     * @see \`{@link https://api.jquery.com/on/ }\`
-     * @since 1.7
-     */
-    on<TData>(events: JQuery.PlainObject<JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>> | false>,
-              selector: JQuery.Selector | null,
-              data: TData): this;
-    /**
-     * Attach an event handler function for one or more events to the selected elements.
-     *
-     * @param events An object in which the string keys represent one or more space-separated event types and optional
-     *               namespaces, and the values represent a handler function to be called for the event(s).
-     * @param selector A selector string to filter the descendants of the selected elements that will call the handler. If
-     *                 the selector is null or omitted, the handler is always called when it reaches the selected element.
-     * @see \`{@link https://api.jquery.com/on/ }\`
-     * @since 1.7
-     */
-    on(events: JQuery.PlainObject<JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false>,
-       selector: JQuery.Selector): this; // tslint:disable-line:unified-signatures
-    /**
-     * Attach an event handler function for one or more events to the selected elements.
-     *
-     * @param events An object in which the string keys represent one or more space-separated event types and optional
-     *               namespaces, and the values represent a handler function to be called for the event(s).
-     * @param data Data to be passed to the handler in event.data when an event occurs.
-     * @see \`{@link https://api.jquery.com/on/ }\`
-     * @since 1.7
-     */
-    on<TData>(events: JQuery.PlainObject<JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>> | false>,
-              data: TData): this;
-    /**
-     * Attach an event handler function for one or more events to the selected elements.
-     *
-     * @param events An object in which the string keys represent one or more space-separated event types and optional
-     *               namespaces, and the values represent a handler function to be called for the event(s).
-     * @see \`{@link https://api.jquery.com/on/ }\`
-     * @since 1.7
-     * @example ​ ````Attach multiple event handlers simultaneously using a plain object.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>on demo</title>
-  <style>
-  .test {
-    color: #000;
-    padding: .5em;
-    border: 1px solid #444;
-  }
-  .active {
-    color: #900;
-  }
-  .inside {
-    background-color: aqua;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div class="test">test div</div>
-​
-<script>
-$( "div.test" ).on({
-  click: function() {
-    $( this ).toggleClass( "active" );
-  }, mouseenter: function() {
-    $( this ).addClass( "inside" );
-  }, mouseleave: function() {
-    $( this ).removeClass( "inside" );
-  }
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    on(events: JQuery.PlainObject<JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false>): this;
-    /**
-     * Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
-     *
-     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
-     * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the
-     *                 selector is null or omitted, the event is always triggered when it reaches the selected element.
-     * @param data Data to be passed to the handler in event.data when an event is triggered.
-     * @param handler A function to execute when the event is triggered.
-     * @see \`{@link https://api.jquery.com/one/ }\`
-     * @since 1.7
-     */
-    one<TData>(events: string,
-               selector: JQuery.Selector | null,
-               data: TData,
-               handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
-     *
-     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
-     * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the
-     *                 selector is null or omitted, the event is always triggered when it reaches the selected element.
-     * @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand
-     *                for a function that simply does return false.
-     * @see \`{@link https://api.jquery.com/one/ }\`
-     * @since 1.7
-     */
-    one(events: string,
-        selector: JQuery.Selector,
-        handler: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
-     *
-     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
-     * @param data Data to be passed to the handler in event.data when an event is triggered.
-     * @param handler A function to execute when the event is triggered.
-     * @see \`{@link https://api.jquery.com/one/ }\`
-     * @since 1.7
-     */
-    one<TData>(events: string,
-               data: TData,
-               handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
-     *
-     * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin".
-     * @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand
-     *                for a function that simply does return false.
-     * @see \`{@link https://api.jquery.com/one/ }\`
-     * @since 1.7
-     * @example ​ ````Tie a one-time click to each div.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>one demo</title>
-  <style>
-  div {
-    width: 60px;
-    height: 60px;
-    margin: 5px;
-    float: left;
-    background: green;
-    border: 10px outset;
-    cursor:pointer;
-  }
-  p {
-    color: red;
-    margin: 0;
-    clear: left;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div></div>
-<div></div>
-<div></div>
-<div></div>
-<div></div>
-<p>Click a green square...</p>
-​
-<script>
-var n = 0;
-$( "div" ).one( "click", function() {
-  var index = $( "div" ).index( this );
-  $( this ).css({
-    borderStyle: "inset",
-    cursor: "auto"
-  });
-  $( "p" ).text( "Div at index #" + index + " clicked." +
-    " That's " + (++n) + " total clicks." );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````To display the text of all paragraphs in an alert box the first time each of them is clicked:
-```javascript
-$( "p" ).one( "click", function() {
-  alert( $( this ).text() );
-});
-```
-     * @example ​ ````Event handlers will trigger once per element per event type
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>one demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div class="count">0</div>
-<div class="target">Hover/click me</div>
-​
-<script>
-var n = 0;
-$(".target").one("click mouseenter", function() {
-  $(".count").html(++n);
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    one(events: string,
-        handler: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
-     *
-     * @param events An object in which the string keys represent one or more space-separated event types and optional
-     *               namespaces, and the values represent a handler function to be called for the event(s).
-     * @param selector A selector string to filter the descendants of the selected elements that will call the handler. If
-     *                 the selector is null or omitted, the handler is always called when it reaches the selected element.
-     * @param data Data to be passed to the handler in event.data when an event occurs.
-     * @see \`{@link https://api.jquery.com/one/ }\`
-     * @since 1.7
-     */
-    one<TData>(events: JQuery.PlainObject<JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>> | false>,
-               selector: JQuery.Selector | null,
-               data: TData): this;
-    /**
-     * Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
-     *
-     * @param events An object in which the string keys represent one or more space-separated event types and optional
-     *               namespaces, and the values represent a handler function to be called for the event(s).
-     * @param selector A selector string to filter the descendants of the selected elements that will call the handler. If
-     *                 the selector is null or omitted, the handler is always called when it reaches the selected element.
-     * @see \`{@link https://api.jquery.com/one/ }\`
-     * @since 1.7
-     */
-    one(events: JQuery.PlainObject<JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false>,
-        selector: JQuery.Selector): this; // tslint:disable-line:unified-signatures
-    /**
-     * Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
-     *
-     * @param events An object in which the string keys represent one or more space-separated event types and optional
-     *               namespaces, and the values represent a handler function to be called for the event(s).
-     * @param data Data to be passed to the handler in event.data when an event occurs.
-     * @see \`{@link https://api.jquery.com/one/ }\`
-     * @since 1.7
-     */
-    one<TData>(events: JQuery.PlainObject<JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>> | false>,
-               data: TData): this;
-    /**
-     * Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
-     *
-     * @param events An object in which the string keys represent one or more space-separated event types and optional
-     *               namespaces, and the values represent a handler function to be called for the event(s).
-     * @see \`{@link https://api.jquery.com/one/ }\`
-     * @since 1.7
-     */
-    one(events: JQuery.PlainObject<JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false>): this;
-    /**
-     * Set the CSS outer height of each element in the set of matched elements.
-     *
-     * @param value A number representing the number of pixels, or a number along with an optional unit of measure
-     *              appended (as a string).
-     * @see \`{@link https://api.jquery.com/outerHeight/ }\`
-     * @since 1.8.0
-     * @example ​ ````Change the outer height of each div the first time it is clicked (and change its color).
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>outerHeight demo</title>
-  <style>
-  div {
-    width: 50px;
-    padding: 10px;
-    height: 60px;
-    float: left;
-    margin: 5px;
-    background: red;
-    cursor: pointer;
-  }
-  .mod {
-    background: blue;
-    cursor: default;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>d</div>
-<div>d</div>
-<div>d</div>
-<div>d</div>
-<div>d</div>
-​
-<script>
-var modHeight = 60;
-$( "div" ).one( "click", function() {
-  $( this ).outerHeight( modHeight ).addClass( "mod" );
-  modHeight -= 8;
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    outerHeight(value: string | number | ((this: TElement, index: number, height: number) => string | number)): this;
-    /**
-     * Get the current computed outer height (including padding, border, and optionally margin) for the
-     * first element in the set of matched elements.
-     *
-     * @param includeMargin A Boolean indicating whether to include the element's margin in the calculation.
-     * @see \`{@link https://api.jquery.com/outerHeight/ }\`
-     * @since 1.2.6
-     * @example ​ ````Get the outerHeight of a paragraph.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>outerHeight demo</title>
-  <style>
-  p {
-    margin: 10px;
-    padding: 5px;
-    border: 2px solid #666;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p><p></p>
-​
-<script>
-var p = $( "p:first" );
-$( "p:last" ).text(
-  "outerHeight:" + p.outerHeight() +
-  " , outerHeight( true ):" + p.outerHeight( true ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    outerHeight(includeMargin?: boolean): number | undefined;
-    /**
-     * Set the CSS outer width of each element in the set of matched elements.
-     *
-     * @param value A number representing the number of pixels, or a number along with an optional unit of measure
-     *              appended (as a string).
-     *              A function returning the outer width to set. Receives the index position of the element in the set
-     *              and the old outer width as arguments. Within the function, this refers to the current element in the set.
-     * @see \`{@link https://api.jquery.com/outerWidth/ }\`
-     * @since 1.8.0
-     * @example ​ ````Change the outer width of each div the first time it is clicked (and change its color).
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>outerWidth demo</title>
-  <style>
-  div {
-    width: 60px;
-    padding: 10px;
-    height: 50px;
-    float: left;
-    margin: 5px;
-    background: red;
-    cursor: pointer;
-  }
-  .mod {
-    background: blue;
-    cursor: default;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>d</div>
-<div>d</div>
-<div>d</div>
-<div>d</div>
-<div>d</div>
-​
-<script>
-var modWidth = 60;
-$( "div" ).one( "click", function() {
-  $( this ).outerWidth( modWidth ).addClass( "mod" );
-  modWidth -= 8;
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    outerWidth(value: string | number | ((this: TElement, index: number, width: number) => string | number)): this;
-    /**
-     * Get the current computed outer width (including padding, border, and optionally margin) for the
-     * first element in the set of matched elements.
-     *
-     * @param includeMargin A Boolean indicating whether to include the element's margin in the calculation.
-     * @see \`{@link https://api.jquery.com/outerWidth/ }\`
-     * @since 1.2.6
-     * @example ​ ````Get the outerWidth of a paragraph.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>outerWidth demo</title>
-  <style>
-  p {
-    margin: 10px;
-    padding: 5px;
-    border: 2px solid #666;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p><p></p>
-​
-<script>
-var p = $( "p:first" );
-$( "p:last" ).text(
-  "outerWidth:" + p.outerWidth() +
-  " , outerWidth( true ):" + p.outerWidth( true ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    outerWidth(includeMargin?: boolean): number | undefined;
-    /**
-     * Get the parent of each element in the current set of matched elements, optionally filtered by a selector.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @see \`{@link https://api.jquery.com/parent/ }\`
-     * @since 1.0
-     * @example ​ ````Shows the parent of each element as (parent &gt; child).  Check the View Source to see the raw html.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>parent demo</title>
-  <style>
-  div, p {
-    margin: 10px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>div,
-  <span>span, </span>
-  <b>b </b>
-</div>
-​
-<p>p,
-  <span>span,
-    <em>em </em>
-  </span>
-</p>
-​
-<div>div,
-  <strong>strong,
-    <span>span, </span>
-    <em>em,
-      <b>b, </b>
-    </em>
-  </strong>
-  <b>b </b>
-</div>
-​
-<script>
-$( "*", document.body ).each(function() {
-  var parentTag = $( this ).parent().get( 0 ).tagName;
-  $( this ).prepend( document.createTextNode( parentTag + " > " ) );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Find the parent element of each paragraph with a class &quot;selected&quot;.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>parent demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div><p>Hello</p></div>
-<div class="selected"><p>Hello Again</p></div>
-​
-<script>
-$( "p" ).parent( ".selected" ).css( "background", "yellow" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    parent(selector?: JQuery.Selector): this;
-    /**
-     * Get the ancestors of each element in the current set of matched elements, optionally filtered by a selector.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @see \`{@link https://api.jquery.com/parents/ }\`
-     * @since 1.0
-     * @example ​ ````Find all parent elements of each b.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>parents demo</title>
-  <style>
-  b, span, p, html body {
-    padding: .5em;
-    border: 1px solid;
-  }
-  b {
-    color: blue;
-  }
-  strong {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>
-  <p>
-    <span>
-      <b>My parents are: </b>
-    </span>
-  </p>
-</div>
-​
-<script>
-var parentEls = $( "b" ).parents()
-  .map(function() {
-    return this.tagName;
-  })
-  .get()
-  .join( ", " );
-$( "b" ).append( "<strong>" + parentEls + "</strong>" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Click to find all unique div parent elements of each span.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>parents demo</title>
-  <style>
-  p, div, span {
-    margin: 2px;
-    padding: 1px;
-  }
-  div {
-    border: 2px white solid;
-  }
-  span {
-    cursor: pointer;
-    font-size: 12px;
-  }
-  .selected {
-    color: blue;
-  }
-  b {
-    color: red;
-    display: block;
-    font-size: 14px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>
-  <div>
-    <div><span>Hello</span></div>
-      <span>Hello Again</span>
-    </div>
-    <div>
-      <span>And Hello Again</span>
-    </div>
-  </p>
-  <b>Click Hellos to toggle their parents.</b>
-​
-<script>
-function showParents() {
-  $( "div" ).css( "border-color", "white" );
-  var len = $( "span.selected" )
-    .parents( "div" )
-      .css( "border", "2px red solid" )
-      .length;
-  $( "b" ).text( "Unique div parents: " + len );
-}
-$( "span" ).click(function() {
-  $( this ).toggleClass( "selected" );
-  showParents();
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    parents(selector?: JQuery.Selector): this;
-    /**
-     * Get the ancestors of each element in the current set of matched elements, up to but not including
-     * the element matched by the selector, DOM node, or jQuery object.
-     *
-     * @param selector A string containing a selector expression to indicate where to stop matching ancestor elements.
-     *                 A DOM node or jQuery object indicating where to stop matching ancestor elements.
-     * @param filter A string containing a selector expression to match elements against.
-     * @see \`{@link https://api.jquery.com/parentsUntil/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @example ​ ````Find the ancestors of &lt;li class=&quot;item-a&quot;&gt; up to &lt;ul class=&quot;level-1&quot;&gt; and give them a red background color. Also, find ancestors of &lt;li class=&quot;item-2&quot;&gt; that have a class of &quot;yes&quot; up to &lt;ul class=&quot;level-1&quot;&gt; and give them a green border.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>parentsUntil demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul class="level-1 yes">
-  <li class="item-i">I</li>
-  <li class="item-ii">II
-    <ul class="level-2 yes">
-      <li class="item-a">A</li>
-      <li class="item-b">B
-        <ul class="level-3">
-          <li class="item-1">1</li>
-          <li class="item-2">2</li>
-          <li class="item-3">3</li>
-        </ul>
-      </li>
-      <li class="item-c">C</li>
-    </ul>
-  </li>
-  <li class="item-iii">III</li>
-</ul>
-​
-<script>
-$( "li.item-a" )
-  .parentsUntil( ".level-1" )
-    .css( "background-color", "red" );
-​
-$( "li.item-2" )
-  .parentsUntil( $( "ul.level-1" ), ".yes" )
-    .css( "border", "3px solid green" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    parentsUntil(selector?: JQuery.Selector | Element | JQuery, filter?: JQuery.Selector): this;
-    /**
-     * Get the current coordinates of the first element in the set of matched elements, relative to the offset parent.
-     *
-     * @see \`{@link https://api.jquery.com/position/ }\`
-     * @since 1.2
-     * @example ​ ````Access the position of the second paragraph:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>position demo</title>
-  <style>
-  div {
-    padding: 15px;
-  }
-  p {
-    margin-left: 10px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>
-  <p>Hello</p>
-</div>
-<p></p>
-​
-<script>
-var p = $( "p:first" );
-var position = p.position();
-$( "p:last" ).text( "left: " + position.left + ", top: " + position.top );
-</script>
-​
-</body>
-</html>
-```
-     */
-    position(): JQuery.Coordinates;
-    /**
-     * Insert content, specified by the parameter, to the beginning of each element in the set of matched elements.
-     *
-     * @param contents One or more additional DOM elements, text nodes, arrays of elements and text nodes, HTML strings, or
-     *                 jQuery objects to insert at the beginning of each element in the set of matched elements.
-     * @see \`{@link https://api.jquery.com/prepend/ }\`
-     * @since 1.0
-     * @example ​ ````Prepends some HTML to all paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>prepend demo</title>
-  <style>
-  p {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>there, friend!</p>
-<p>amigo!</p>
-​
-<script>
-$( "p" ).prepend( "<b>Hello </b>" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Prepends a DOM Element to all paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>prepend demo</title>
-  <style>
-  p {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>is what I'd say</p>
-<p>is what I said</p>
-​
-<script>
-$( "p" ).prepend( document.createTextNode( "Hello " ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Prepends a jQuery object (similar to an Array of DOM Elements) to all paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>prepend demo</title>
-  <style>
-  p {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p> is what was said.</p><b>Hello</b>
-​
-<script>
-$( "p" ).prepend( $( "b" ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    prepend(...contents: Array<JQuery.htmlString | JQuery.TypeOrArray<JQuery.Node | JQuery<JQuery.Node>>>): this;
-    /**
-     * Insert content, specified by the parameter, to the beginning of each element in the set of matched elements.
-     *
-     * @param fn A function that returns an HTML string, DOM element(s), text node(s), or jQuery object to insert at
-     *           the beginning of each element in the set of matched elements. Receives the index position of the
-     *           element in the set and the old HTML value of the element as arguments. Within the function, this
-     *           refers to the current element in the set.
-     * @see \`{@link https://api.jquery.com/prepend/ }\`
-     * @since 1.4
-     */
-    prepend(fn: (this: TElement, index: number, html: string) => JQuery.htmlString | JQuery.TypeOrArray<JQuery.Node | JQuery<JQuery.Node>>): this;
-    /**
-     * Insert every element in the set of matched elements to the beginning of the target.
-     *
-     * @param target A selector, element, HTML string, array of elements, or jQuery object; the matched set of elements
-     *               will be inserted at the beginning of the element(s) specified by this parameter.
-     * @see \`{@link https://api.jquery.com/prependTo/ }\`
-     * @since 1.0
-     * @example ​ ````Prepend all spans to the element with the ID &quot;foo&quot; (Check .prepend() documentation for more examples)
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>prependTo demo</title>
-  <style>
-  div {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="foo">FOO!</div>
-<span>I have something to say... </span>
-​
-<script>
-$( "span" ).prependTo( "#foo" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    prependTo(target: JQuery.Selector | JQuery.htmlString | JQuery.TypeOrArray<Element | DocumentFragment> | JQuery): this;
-    /**
-     * Get the immediately preceding sibling of each element in the set of matched elements. If a selector
-     * is provided, it retrieves the previous sibling only if it matches that selector.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @see \`{@link https://api.jquery.com/prev/ }\`
-     * @since 1.0
-     * @example ​ ````Find the very previous sibling of each div.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>prev demo</title>
-  <style>
-  div {
-    width: 40px;
-    height: 40px;
-    margin: 10px;
-    float: left;
-    border: 2px blue solid;
-    padding: 2px;
-  }
-  span {
-    font-size: 14px;
-  }
-  p {
-    clear: left;
-    margin: 10px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div></div>
-<div></div>
-<div><span>has child</span></div>
-<div></div>
-<div></div>
-<div></div>
-<div id="start"></div>
-<div></div>
-<p><button>Go to Prev</button></p>
-​
-<script>
-var $curr = $( "#start" );
-$curr.css( "background", "#f99" );
-$( "button" ).click(function() {
-  $curr = $curr.prev();
-  $( "div" ).css( "background", "" );
-  $curr.css( "background", "#f99" );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````For each paragraph, find the very previous sibling that has a class &quot;selected&quot;.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>prev demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div><span>Hello</span></div>
-<p class="selected">Hello Again</p>
-<p>And Again</p>
-​
-<script>
-$( "p" ).prev( ".selected" ).css( "background", "yellow" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    prev(selector?: JQuery.Selector): this;
-    /**
-     * Get all preceding siblings of each element in the set of matched elements, optionally filtered by a selector.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @see \`{@link https://api.jquery.com/prevAll/ }\`
-     * @since 1.2
-     * @example ​ ````Locate all the divs preceding the last div and give them a class.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>prevAll demo</title>
-  <style>
-  div {
-    width: 70px;
-    height: 70px;
-    background: #abc;
-    border: 2px solid black;
-    margin: 10px;
-    float: left;
-  }
-  div.before {
-    border-color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div></div>
-<div></div>
-<div></div>
-<div></div>
-​
-<script>
-$( "div:last" ).prevAll().addClass( "before" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    prevAll(selector?: JQuery.Selector): this;
-    /**
-     * Get all preceding siblings of each element up to but not including the element matched by the
-     * selector, DOM node, or jQuery object.
-     *
-     * @param selector A string containing a selector expression to indicate where to stop matching preceding sibling elements.
-     *                 A DOM node or jQuery object indicating where to stop matching preceding sibling elements.
-     * @param filter A string containing a selector expression to match elements against.
-     * @see \`{@link https://api.jquery.com/prevUntil/ }\`
-     * @since 1.4
-     * @since 1.6
-     * @example ​ ````Find the siblings that precede &lt;dt id=&quot;term-2&quot;&gt; up to the preceding &lt;dt&gt; and give them a red background color. Also, find previous &lt;dd&gt; siblings of &lt;dt id=&quot;term-3&quot;&gt; up to &lt;dt id=&quot;term-1&quot;&gt; and give them a green text color.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>prevUntil demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<dl>
-  <dt id="term-1">term 1</dt>
-  <dd>definition 1-a</dd>
-  <dd>definition 1-b</dd>
-  <dd>definition 1-c</dd>
-  <dd>definition 1-d</dd>
-​
-  <dt id="term-2">term 2</dt>
-  <dd>definition 2-a</dd>
-  <dd>definition 2-b</dd>
-  <dd>definition 2-c</dd>
-​
-  <dt id="term-3">term 3</dt>
-  <dd>definition 3-a</dd>
-  <dd>definition 3-b</dd>
-</dl>
-​
-<script>
-$( "#term-2" ).prevUntil( "dt" )
-  .css( "background-color", "red" );
-​
-var term1 = document.getElementById( "term-1" );
-$( "#term-3" ).prevUntil( term1, "dd" )
-  .css( "color", "green" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    prevUntil(selector?: JQuery.Selector | Element | JQuery, filter?: JQuery.Selector): this;
-    /**
-     * Return a Promise object to observe when all actions of a certain type bound to the collection,
-     * queued or not, have finished.
-     *
-     * @param type The type of queue that needs to be observed.
-     * @param target Object onto which the promise methods have to be attached
-     * @see \`{@link https://api.jquery.com/promise/ }\`
-     * @since 1.6
-     */
-    promise<T extends object>(type: string, target: T): T & JQuery.Promise<this>;
-    /**
-     * Return a Promise object to observe when all actions of a certain type bound to the collection,
-     * queued or not, have finished.
-     *
-     * @param target Object onto which the promise methods have to be attached
-     * @see \`{@link https://api.jquery.com/promise/ }\`
-     * @since 1.6
-     */
-    promise<T extends object>(target: T): T & JQuery.Promise<this>;
-    /**
-     * Return a Promise object to observe when all actions of a certain type bound to the collection,
-     * queued or not, have finished.
-     *
-     * @param type The type of queue that needs to be observed.
-     * @see \`{@link https://api.jquery.com/promise/ }\`
-     * @since 1.6
-     * @example ​ ````Using .promise() on a collection with no active animation returns a resolved Promise:
-```javascript
-var div = $( "<div>" );
-​
-div.promise().done(function( arg1 ) {
-  // Will fire right away and alert "true"
-  alert( this === div && arg1 === div );
-});
-```
-     * @example ​ ````Resolve the returned Promise when all animations have ended (including those initiated in the animation callback or added later on):
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>promise demo</title>
-  <style>
-  div {
-    height: 50px;
-    width: 50px;
-    float: left;
-    margin-right: 10px;
-    display: none;
-    background-color: #090;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Go</button>
-<p>Ready...</p>
-<div></div>
-<div></div>
-<div></div>
-<div></div>
-​
-<script>
-$( "button" ).on( "click", function() {
-  $( "p" ).append( "Started..." );
-​
-  $( "div" ).each(function( i ) {
-    $( this ).fadeIn().fadeOut( 1000 * ( i + 1 ) );
-  });
-​
-  $( "div" ).promise().done(function() {
-    $( "p" ).append( " Finished! " );
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Resolve the returned Promise using a $.when() statement (the .promise() method makes it possible to do this with jQuery collections):
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>promise demo</title>
-  <style>
-  div {
-    height: 50px;
-    width: 50px;
-    float: left;
-    margin-right: 10px;
-    display: none;
-    background-color: #090;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Go</button>
-<p>Ready...</p>
-<div></div>
-<div></div>
-<div></div>
-<div></div>
-​
-<script>
-var effect = function() {
-  return $( "div" ).fadeIn( 800 ).delay( 1200 ).fadeOut();
-};
-​
-$( "button" ).on( "click", function() {
-  $( "p" ).append( " Started... " );
-​
-  $.when( effect() ).done(function() {
-    $( "p" ).append( " Finished! " );
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    promise(type?: string): JQuery.Promise<this>;
-    /**
-     * Set one or more properties for the set of matched elements.
-     *
-     * @param propertyName The name of the property to set.
-     * @param value A function returning the value to set. Receives the index position of the element in the set and the
-     *              old property value as arguments. Within the function, the keyword this refers to the current element.
-     * @see \`{@link https://api.jquery.com/prop/ }\`
-     * @since 1.6
-     */
-    prop(propertyName: string, value: (this: TElement, index: number, oldPropertyValue: any) => any): this;
-    /**
-     * Set one or more properties for the set of matched elements.
-     *
-     * @param propertyName The name of the property to set.
-     * @param value A value to set for the property.
-     * @see \`{@link https://api.jquery.com/prop/ }\`
-     * @since 1.6
-     */
-    prop(propertyName: string, value: any): this; // tslint:disable-line:unified-signatures
-    /**
-     * Set one or more properties for the set of matched elements.
-     *
-     * @param properties An object of property-value pairs to set.
-     * @see \`{@link https://api.jquery.com/prop/ }\`
-     * @since 1.6
-     * @example ​ ````Disable all checkboxes on the page.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>prop demo</title>
-  <style>
-  img {
-    padding: 10px;
-  }
-  div {
-    color: red;
-    font-size: 24px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-  <input type="checkbox" checked="checked">
-  <input type="checkbox">
-  <input type="checkbox">
-  <input type="checkbox" checked="checked">
-​
-<script>
-$( "input[type='checkbox']" ).prop({
-  disabled: true
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    prop(properties: JQuery.PlainObject): this;
-    /**
-     * Get the value of a property for the first element in the set of matched elements.
-     *
-     * @param propertyName The name of the property to get.
-     * @see \`{@link https://api.jquery.com/prop/ }\`
-     * @since 1.6
-     * @example ​ ````Display the checked property and attribute of a checkbox as it changes.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>prop demo</title>
-  <style>
-  p {
-    margin: 20px 0 0;
-  }
-  b {
-    color: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<input id="check1" type="checkbox" checked="checked">
-<label for="check1">Check me</label>
-<p></p>
-​
-<script>
-$( "input" ).change(function() {
-  var $input = $( this );
-  $( "p" ).html(
-    ".attr( \"checked\" ): <b>" + $input.attr( "checked" ) + "</b><br>" +
-    ".prop( \"checked\" ): <b>" + $input.prop( "checked" ) + "</b><br>" +
-    ".is( \":checked\" ): <b>" + $input.is( ":checked" ) + "</b>" );
-}).change();
-</script>
-​
-</body>
-</html>
-```
-     */
-    prop(propertyName: string): any | undefined;
-    /**
-     * Add a collection of DOM elements onto the jQuery stack.
-     *
-     * @param elements An array of elements to push onto the stack and make into a new jQuery object.
-     * @param name The name of a jQuery method that generated the array of elements.
-     * @param args The arguments that were passed in to the jQuery method (for serialization).
-     * @see \`{@link https://api.jquery.com/pushStack/ }\`
-     * @since 1.3
-     */
-    pushStack(elements: ArrayLike<Element>, name: string, args: any[]): this;
-    /**
-     * Add a collection of DOM elements onto the jQuery stack.
-     *
-     * @param elements An array of elements to push onto the stack and make into a new jQuery object.
-     * @see \`{@link https://api.jquery.com/pushStack/ }\`
-     * @since 1.0
-     * @example ​ ````Add some elements onto the jQuery stack, then pop back off again.
-```javascript
-jQuery([])
-  .pushStack( document.getElementsByTagName( "div" ) )
-  .remove()
-  .end();
-```
-     */
-    pushStack(elements: ArrayLike<Element>): this;
-    /**
-     * Manipulate the queue of functions to be executed, once for each matched element.
-     *
-     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
-     * @param newQueue The new function to add to the queue, with a function to call that will dequeue the next item.
-     *                 An array of functions to replace the current queue contents.
-     * @see \`{@link https://api.jquery.com/queue/ }\`
-     * @since 1.2
-     * @example ​ ````Set a queue array to delete the queue.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>queue demo</title>
-  <style>
-  div {
-    margin: 3px;
-    width: 40px;
-    height: 40px;
-    position: absolute;
-    left: 0px;
-    top: 30px;
-    background: green;
-    display: none;
-  }
-  div.newcolor {
-    background: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="start">Start</button>
-<button id="stop">Stop</button>
-<div></div>
-​
-<script>
-$( "#start" ).click(function() {
-  $( "div" )
-    .show( "slow" )
-    .animate({ left: "+=200" }, 5000 )
-    .queue(function() {
-      $( this ).addClass( "newcolor" ).dequeue();
-    })
-    .animate({ left: '-=200' }, 1500 )
-    .queue(function() {
-      $( this ).removeClass( "newcolor" ).dequeue();
-    })
-    .slideUp();
-});
-$( "#stop" ).click(function() {
-  $( "div" )
-    .queue( "fx", [] )
-    .stop();
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    queue(queueName: string, newQueue: JQuery.TypeOrArray<JQuery.QueueFunction<TElement>>): this;
-    /**
-     * Manipulate the queue of functions to be executed, once for each matched element.
-     *
-     * @param newQueue The new function to add to the queue, with a function to call that will dequeue the next item.
-     *                 An array of functions to replace the current queue contents.
-     * @see \`{@link https://api.jquery.com/queue/ }\`
-     * @since 1.2
-     * @example ​ ````Queue a custom function.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>queue demo</title>
-  <style>
-  div {
-    margin: 3px;
-    width: 40px;
-    height: 40px;
-    position: absolute;
-    left: 0px;
-    top: 30px;
-    background: green;
-    display: none;
-  }
-  div.newcolor {
-    background: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-Click here...
-<div></div>
-​
-<script>
-$( document.body ).click(function() {
-  $( "div" )
-    .show( "slow" )
-    .animate({ left: "+=200" }, 2000 )
-    .queue(function() {
-      $( this ).addClass( "newcolor" ).dequeue();
-    })
-    .animate({ left: "-=200" }, 500 )
-    .queue(function() {
-      $( this ).removeClass( "newcolor" ).dequeue();
-    })
-    .slideUp();
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    queue(newQueue: JQuery.TypeOrArray<JQuery.QueueFunction<TElement>>): this;
-    /**
-     * Show the queue of functions to be executed on the matched elements.
-     *
-     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
-     * @see \`{@link https://api.jquery.com/queue/ }\`
-     * @since 1.2
-     * @example ​ ````Show the length of the queue.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>queue demo</title>
-  <style>
-  div {
-    margin: 3px;
-    width: 40px;
-    height: 40px;
-    position: absolute;
-    left: 0px;
-    top: 60px;
-    background: green;
-    display: none;
-  }
-  div.newcolor {
-    background: blue;
-  }
-  p {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>The queue length is: <span></span></p>
-<div></div>
-​
-<script>
-var div = $( "div" );
-​
-function runIt() {
-  div
-    .show( "slow" )
-    .animate({ left: "+=200" }, 2000 )
-    .slideToggle( 1000 )
-    .slideToggle( "fast" )
-    .animate({ left: "-=200" }, 1500 )
-    .hide( "slow" )
-    .show( 1200 )
-    .slideUp( "normal", runIt );
-}
-​
-function showIt() {
-  var n = div.queue( "fx" );
-  $( "span" ).text( n.length );
-  setTimeout( showIt, 100 );
-}
-​
-runIt();
-showIt();
-</script>
-​
-</body>
-</html>
-```
-     */
-    queue(queueName?: string): JQuery.Queue<Node>;
-    /**
-     * Specify a function to execute when the DOM is fully loaded.
-     *
-     * @param handler A function to execute after the DOM is ready.
-     * @see \`{@link https://api.jquery.com/ready/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.0. Use `jQuery(function() { })`.
-     * @example ​ ````Display a message when the DOM is loaded.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>ready demo</title>
-  <style>
-  p {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-  <script>
-​
-  $(function() {
-    $( "p" ).text( "The DOM is now loaded and can be manipulated." );
-  });
-​
-  </script>
-</head>
-<body>
-​
-<p>Not loaded yet.</p>
-​
-</body>
-</html>
-```
-     */
-    ready(handler: ($: JQueryStatic) => void): this;
-    /**
-     * Remove the set of matched elements from the DOM.
-     *
-     * @param selector A selector expression that filters the set of matched elements to be removed.
-     * @see \`{@link https://api.jquery.com/remove/ }\`
-     * @since 1.0
-     * @example ​ ````Removes all paragraphs from the DOM
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>remove demo</title>
-  <style>
-  p {
-    background: yellow;
-    margin: 6px 0;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-how are
-<p>you?</p>
-<button>Call remove() on paragraphs</button>
-​
-<script>
-$( "button" ).click(function() {
-  $( "p" ).remove();
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Removes all paragraphs that contain &quot;Hello&quot; from the DOM.  Analogous to doing $(&quot;p&quot;).filter(&quot;:contains(&#39;Hello&#39;)&quot;).remove().
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>remove demo</title>
-  <style>
-  p {
-    background: yellow;
-    margin: 6px 0;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p class="hello">Hello</p>
-how are
-<p>you?</p>
-<button>Call remove( ":contains('Hello')" ) on paragraphs</button>
-​
-<script>
-$( "button" ).click(function() {
-  $( "p" ).remove( ":contains('Hello')" );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    remove(selector?: string): this;
-    /**
-     * Remove an attribute from each element in the set of matched elements.
-     *
-     * @param attributeName An attribute to remove; as of version 1.7, it can be a space-separated list of attributes.
-     * @see \`{@link https://api.jquery.com/removeAttr/ }\`
-     * @since 1.0
-     * @example ​ ````Clicking the button changes the title of the input next to it. Move the mouse pointer over the text input to see the effect of adding and removing the title attribute.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>removeAttr demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Change title</button>
-<input type="text" title="hello there">
-<div id="log"></div>
-​
-<script>
-(function() {
-  var inputTitle = $( "input" ).attr( "title" );
-  $( "button" ).click(function() {
-    var input = $( this ).next();
-​
-    if ( input.attr( "title" ) === inputTitle ) {
-      input.removeAttr( "title" )
-    } else {
-      input.attr( "title", inputTitle );
-    }
-​
-    $( "#log" ).html( "input title is now " + input.attr( "title" ) );
-  });
-})();
-</script>
-​
-</body>
-</html>
-```
-     */
-    removeAttr(attributeName: string): this;
-    /**
-     * Remove a single class, multiple classes, or all classes from each element in the set of matched elements.
-     *
-     * @param className One or more space-separated classes to be removed from the class attribute of each matched element.
-     *                  An array of classes to be removed from the class attribute of each matched element.
-     *                  A function returning one or more space-separated class names to be removed. Receives the index
-     *                  position of the element in the set and the old class value as arguments.
-     * @see \`{@link https://api.jquery.com/removeClass/ }\`
-     * @since 1.0
-     * @since 1.4
-     * @since 3.3
-     * @example ​ ````Remove the class &#39;blue&#39; from the matched elements.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>removeClass demo</title>
-  <style>
-  p {
-    margin: 4px;
-    font-size: 16px;
-    font-weight: bolder;
-  }
-  .blue {
-    color: blue;
-  }
-  .under {
-    text-decoration: underline;
-  }
-  .highlight {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p class="blue under">Hello</p>
-<p class="blue under highlight">and</p>
-<p class="blue under">then</p>
-<p class="blue under">Goodbye</p>
-​
-<script>
-$( "p:even" ).removeClass( "blue" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Remove the class &#39;blue&#39; and &#39;under&#39; from the matched elements.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>removeClass demo</title>
-  <style>
-  p {
-    margin: 4px;
-    font-size: 16px;
-    font-weight: bolder;
-  }
-  .blue {
-    color: blue;
-  }
-  .under {
-    text-decoration: underline;
-  }
-  .highlight {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p class="blue under">Hello</p>
-<p class="blue under highlight">and</p>
-<p class="blue under">then</p>
-<p class="blue under">Goodbye</p>
-​
-<script>
-$( "p:odd" ).removeClass( "blue under" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Remove all the classes from the matched elements.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>removeClass demo</title>
-  <style>
-  p {
-    margin: 4px;
-    font-size: 16px;
-    font-weight: bolder;
-  }
-  .blue {
-    color: blue;
-  }
-  .under {
-    text-decoration: underline;
-  }
-  .highlight {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p class="blue under">Hello</p>
-<p class="blue under highlight">and</p>
-<p class="blue under">then</p>
-<p class="blue under">Goodbye</p>
-​
-<script>
-$( "p:eq(1)" ).removeClass();
-</script>
-​
-</body>
-</html>
-```
-     */
-    removeClass(className?: JQuery.TypeOrArray<string> | ((this: TElement, index: number, className: string) => string)): this;
-    /**
-     * Remove a previously-stored piece of data.
-     *
-     * @param name A string naming the piece of data to delete.
-     *             An array or space-separated string naming the pieces of data to delete.
-     * @see \`{@link https://api.jquery.com/removeData/ }\`
-     * @since 1.2.3
-     * @since 1.7
-     * @example ​ ````Set a data store for 2 names then remove one of them.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>removeData demo</title>
-  <style>
-  div {
-    margin: 2px;
-    color: blue;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>value1 before creation: <span></span></div>
-<div>value1 after creation: <span></span></div>
-<div>value1 after removal: <span></span></div>
-<div>value2 after removal: <span></span></div>
-​
-<script>
-$( "span:eq(0)" ).text( "" + $( "div" ).data( "test1" ) );
-$( "div" ).data( "test1", "VALUE-1" );
-$( "div" ).data( "test2", "VALUE-2" );
-$( "span:eq(1)" ).text( "" + $( "div").data( "test1" ) );
-$( "div" ).removeData( "test1" );
-$( "span:eq(2)" ).text( "" + $( "div" ).data( "test1" ) );
-$( "span:eq(3)" ).text( "" + $( "div" ).data( "test2" ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    removeData(name?: JQuery.TypeOrArray<string>): this;
-    /**
-     * Remove a property for the set of matched elements.
-     *
-     * @param propertyName The name of the property to remove.
-     * @see \`{@link https://api.jquery.com/removeProp/ }\`
-     * @since 1.6
-     * @example ​ ````Set a numeric property on a paragraph and then remove it.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>removeProp demo</title>
-  <style>
-  img {
-    padding: 10px;
-  }
-  div {
-    color: red;
-    font-size: 24px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-  <p></p>
-​
-<script>
-para = $( "p" );
-para
-  .prop( "luggageCode", 1234 )
-  .append( "The secret luggage code is: ", String( para.prop( "luggageCode" ) ), ". " )
-  .removeProp( "luggageCode" )
-  .append( "Now the secret luggage code is: ", String( para.prop( "luggageCode" ) ), ". " );
-</script>
-​
-</body>
-</html>
-```
-     */
-    removeProp(propertyName: string): this;
-    /**
-     * Replace each target element with the set of matched elements.
-     *
-     * @param target A selector string, jQuery object, DOM element, or array of elements indicating which element(s) to replace.
-     * @see \`{@link https://api.jquery.com/replaceAll/ }\`
-     * @since 1.2
-     * @example ​ ````Replace all the paragraphs with bold words.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>replaceAll demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<p>cruel</p>
-<p>World</p>
-​
-<script>
-$( "<b>Paragraph. </b>" ).replaceAll( "p" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    replaceAll(target: JQuery.Selector | JQuery | JQuery.TypeOrArray<Element>): this;
-    /**
-     * Replace each element in the set of matched elements with the provided new content and return the set
-     * of elements that was removed.
-     *
-     * @param newContent The content to insert. May be an HTML string, DOM element, array of DOM elements, or jQuery object.
-     *                   A function that returns content with which to replace the set of matched elements.
-     * @see \`{@link https://api.jquery.com/replaceWith/ }\`
-     * @since 1.2
-     * @since 1.4
-     * @example ​ ````On click, replace the button with a div containing the same word.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>replaceWith demo</title>
-  <style>
-  button {
-    display: block;
-    margin: 3px;
-    color: red;
-    width: 200px;
-  }
-  div {
-    color: red;
-    border: 2px solid blue;
-    width: 200px;
-    margin: 3px;
-    text-align: center;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>First</button>
-<button>Second</button>
-<button>Third</button>
-​
-<script>
-$( "button" ).click(function() {
-  $( this ).replaceWith( "<div>" + $( this ).text() + "</div>" );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Replace all paragraphs with bold words.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>replaceWith demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<p>cruel</p>
-<p>World</p>
-​
-<script>
-$( "p" ).replaceWith( "<b>Paragraph. </b>" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````On click, replace each paragraph with a div that is already in the DOM and selected with the $() function. Notice it doesn&#39;t clone the object but rather moves it to replace the paragraph.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>replaceWith demo</title>
-  <style>
-  div {
-    border: 2px solid blue;
-    color: red;
-    margin: 3px;
-  }
-  p {
-    border: 2px solid red;
-    color: blue;
-    margin: 3px;
-    cursor: pointer;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-  <p>Hello</p>
-  <p>cruel</p>
-  <p>World</p>
-  <div>Replaced!</div>
-​
-<script>
-$( "p" ).click(function() {
-  $( this ).replaceWith( $( "div" ) );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````On button click, replace the containing div with its child divs and append the class name of the selected element to the paragraph.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>replaceWith demo</title>
-  <style>
-  .container {
-    background-color: #991;
-  }
-  .inner {
-    color: #911;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>
-  <button>Replace!</button>
-</p>
-<div class="container">
-  <div class="inner">Scooby</div>
-  <div class="inner">Dooby</div>
-  <div class="inner">Doo</div>
-</div>
-​
-<script>
-$( "button" ).on( "click", function() {
-  var $container = $( "div.container" ).replaceWith(function() {
-    return $( this ).contents();
-  });
-​
-  $( "p" ).append( $container.attr( "class" ) );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    replaceWith(newContent: JQuery.htmlString | JQuery | JQuery.TypeOrArray<Element> | ((this: TElement) => any)): this;
-    /**
-     * Bind an event handler to the "resize" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/resize/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    resize<TData>(eventData: TData,
-                  handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "resize" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/resize/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````To see the window width while (or after) it is resized, try:
-```javascript
-$( window ).resize(function() {
-  $( "body" ).prepend( "<div>" + $( window ).width() + "</div>" );
-});
-```
-     */
-    resize(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Bind an event handler to the "scroll" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/scroll/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    scroll<TData>(eventData: TData,
-                  handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "scroll" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/scroll/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````To do something when your page is scrolled:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>scroll demo</title>
-  <style>
-  div {
-    color: blue;
-  }
-  p {
-    color: green;
-  }
-  span {
-    color: red;
-    display: none;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>Try scrolling the iframe.</div>
-<p>Paragraph - <span>Scroll happened!</span></p>
-​
-<script>
-$( "p" ).clone().appendTo( document.body );
-$( "p" ).clone().appendTo( document.body );
-$( "p" ).clone().appendTo( document.body );
-$( window ).scroll(function() {
-  $( "span" ).css( "display", "inline" ).fadeOut( "slow" );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    scroll(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Set the current horizontal position of the scroll bar for each of the set of matched elements.
-     *
-     * @param value An integer indicating the new position to set the scroll bar to.
-     * @see \`{@link https://api.jquery.com/scrollLeft/ }\`
-     * @since 1.2.6
-     * @example ​ ````Set the scrollLeft of a div.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>scrollLeft demo</title>
-  <style>
-  div.demo {
-    background: #ccc none repeat scroll 0 0;
-    border: 3px solid #666;
-    margin: 5px;
-    padding: 5px;
-    position: relative;
-    width: 200px;
-    height: 100px;
-    overflow: auto;
-  }
-  p {
-    margin: 10px;
-    padding: 5px;
-    border: 2px solid #666;
-    width: 1000px;
-    height: 1000px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div class="demo"><h1>lalala</h1><p>Hello</p></div>
-​
-<script>
-$( "div.demo" ).scrollLeft( 300 );
-</script>
-​
-</body>
-</html>
-```
-     */
-    scrollLeft(value: number): this;
-    /**
-     * Get the current horizontal position of the scroll bar for the first element in the set of matched elements.
-     *
-     * @see \`{@link https://api.jquery.com/scrollLeft/ }\`
-     * @since 1.2.6
-     * @example ​ ````Get the scrollLeft of a paragraph.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>scrollLeft demo</title>
-  <style>
-  p {
-    margin: 10px;
-    padding: 5px;
-    border: 2px solid #666;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p><p></p>
-​
-<script>
-var p = $( "p:first" );
-$( "p:last" ).text( "scrollLeft:" + p.scrollLeft() );
-</script>
-​
-</body>
-</html>
-```
-     */
-    scrollLeft(): number | undefined;
-    /**
-     * Set the current vertical position of the scroll bar for each of the set of matched elements.
-     *
-     * @param value A number indicating the new position to set the scroll bar to.
-     * @see \`{@link https://api.jquery.com/scrollTop/ }\`
-     * @since 1.2.6
-     * @example ​ ````Set the scrollTop of a div.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>scrollTop demo</title>
-  <style>
-  div.demo {
-    background: #ccc none repeat scroll 0 0;
-    border: 3px solid #666;
-    margin: 5px;
-    padding: 5px;
-    position: relative;
-    width: 200px;
-    height: 100px;
-    overflow: auto;
-  }
-  p {
-    margin: 10px;
-    padding: 5px;
-    border: 2px solid #666;
-    width: 1000px;
-    height: 1000px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div class="demo"><h1>lalala</h1><p>Hello</p></div>
-​
-<script>
-$( "div.demo" ).scrollTop( 300 );
-</script>
-​
-</body>
-</html>
-```
-     */
-    scrollTop(value: number): this;
-    /**
-     * Get the current vertical position of the scroll bar for the first element in the set of matched
-     * elements or set the vertical position of the scroll bar for every matched element.
-     *
-     * @see \`{@link https://api.jquery.com/scrollTop/ }\`
-     * @since 1.2.6
-     * @example ​ ````Get the scrollTop of a paragraph.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>scrollTop demo</title>
-  <style>
-  p {
-    margin: 10px;
-    padding: 5px;
-    border: 2px solid #666;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p><p></p>
-​
-<script>
-var p = $( "p:first" );
-$( "p:last" ).text( "scrollTop:" + p.scrollTop() );
-</script>
-​
-</body>
-</html>
-```
-     */
-    scrollTop(): number | undefined;
-    /**
-     * Bind an event handler to the "select" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/select/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    select<TData>(eventData: TData,
-                  handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "select" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/select/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````To do something when text in input boxes is selected:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>select demo</title>
-  <style>
-  p {
-    color: blue;
-  }
-  div {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-  <p>Click and drag the mouse to select text in the inputs.</p>
-  <input type="text" value="Some text">
-  <input type="text" value="to test on">
-  <div></div>
-  ​
-<script>
-$( ":input" ).select(function() {
-  $( "div" ).text( "Something was selected" ).show().fadeOut( 1000 );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````To trigger the select event on all input elements, try:
-```javascript
-$( "input" ).select();
-```
-     */
-    select(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Encode a set of form elements as a string for submission.
-     *
-     * @see \`{@link https://api.jquery.com/serialize/ }\`
-     * @since 1.0
-     * @example ​ ````Serialize a form to a query string that could be sent to a server in an Ajax request.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>serialize demo</title>
-  <style>
-  body, select {
-    font-size: 12px;
-  }
-  form {
-    margin: 5px;
-  }
-  p {
-    color: red;
-    margin: 5px;
-    font-size: 14px;
-  }
-  b {
-    color: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<form>
-  <select name="single">
-    <option>Single</option>
-    <option>Single2</option>
-  </select>
-​
-  <br>
-  <select name="multiple" multiple="multiple">
-    <option selected="selected">Multiple</option>
-    <option>Multiple2</option>
-    <option selected="selected">Multiple3</option>
-  </select>
-​
-  <br>
-  <input type="checkbox" name="check" value="check1" id="ch1">
-  <label for="ch1">check1</label>
-  <input type="checkbox" name="check" value="check2" checked="checked" id="ch2">
-  <label for="ch2">check2</label>
-​
-  <br>
-  <input type="radio" name="radio" value="radio1" checked="checked" id="r1">
-  <label for="r1">radio1</label>
-  <input type="radio" name="radio" value="radio2" id="r2">
-  <label for="r2">radio2</label>
-</form>
-​
-<p><tt id="results"></tt></p>
-​
-<script>
-  function showValues() {
-    var str = $( "form" ).serialize();
-    $( "#results" ).text( str );
-  }
-  $( "input[type='checkbox'], input[type='radio']" ).on( "click", showValues );
-  $( "select" ).on( "change", showValues );
-  showValues();
-</script>
-​
-</body>
-</html>
-```
-     */
-    serialize(): string;
-    /**
-     * Encode a set of form elements as an array of names and values.
-     *
-     * @see \`{@link https://api.jquery.com/serializeArray/ }\`
-     * @since 1.2
-     * @example ​ ````Get the values from a form, iterate through them, and append them to a results display.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>serializeArray demo</title>
-  <style>
-  body, select {
-    font-size: 14px;
-  }
-  form {
-    margin: 5px;
-  }
-  p {
-    color: red;
-    margin: 5px;
-  }
-  b {
-    color: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><b>Results:</b> <span id="results"></span></p>
-<form>
-  <select name="single">
-    <option>Single</option>
-    <option>Single2</option>
-  </select>
-  <select name="multiple" multiple="multiple">
-    <option selected="selected">Multiple</option>
-    <option>Multiple2</option>
-    <option selected="selected">Multiple3</option>
-  </select>
-  <br>
-  <input type="checkbox" name="check" value="check1" id="ch1">
-  <label for="ch1">check1</label>
-  <input type="checkbox" name="check" value="check2" checked="checked" id="ch2">
-  <label for="ch2">check2</label>
-  <input type="radio" name="radio" value="radio1" checked="checked" id="r1">
-  <label for="r1">radio1</label>
-  <input type="radio" name="radio" value="radio2" id="r2">
-  <label for="r2">radio2</label>
-</form>
-​
-<script>
-  function showValues() {
-    var fields = $( ":input" ).serializeArray();
-    $( "#results" ).empty();
-    jQuery.each( fields, function( i, field ) {
-      $( "#results" ).append( field.value + " " );
-    });
-  }
-​
-  $( ":checkbox, :radio" ).click( showValues );
-  $( "select" ).change( showValues );
-  showValues();
-</script>
-​
-</body>
-</html>
-```
-     */
-    serializeArray(): JQuery.NameValuePair[];
-    /**
-     * Display the matched elements.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param easing A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/show/ }\`
-     * @since 1.4.3
-     */
-    show(duration: JQuery.Duration, easing: string, complete: (this: TElement) => void): this;
-    /**
-     * Display the matched elements.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param easing_complete _&#x40;param_ `easing_complete`
-     * <br>
-     * * `easing` — A string indicating which easing function to use for the transition. <br>
-     * * `complete` — A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/show/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     * @example ​ ````Show the first div, followed by each next adjacent sibling div in order, with a 200ms animation. Each animation starts when the previous sibling div&#39;s animation ends.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>show demo</title>
-  <style>
-  div {
-    background: #def3ca;
-    margin: 3px;
-    width: 80px;
-    display: none;
-    float: left;
-    text-align: center;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="showr">Show</button>
-<button id="hidr">Hide</button>
-<div>Hello 3,</div>
-<div>how</div>
-<div>are</div>
-<div>you?</div>
-​
-<script>
-$( "#showr" ).click(function() {
-  $( "div" ).first().show( "fast", function showNext() {
-    $( this ).next( "div" ).show( "fast", showNext );
-  });
-});
-​
-$( "#hidr" ).click(function() {
-  $( "div" ).hide( 1000 );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Show all span and input elements with an animation. Change the text once the animation is done.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>show demo</title>
-  <style>
-  span {
-    display: none;
-  }
-  div {
-    display: none;
-  }
-  p {
-    font-weight: bold;
-    background-color: #fcd;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Do it!</button>
-<span>Are you sure? (type 'yes' if you are) </span>
-<div>
-  <form>
-    <input type="text"  value="as;ldkfjalsdf">
-  </form>
-</div>
-<p style="display:none;">I'm hidden...</p>
-​
-<script>
-function doIt() {
-  $( "span,div" ).show( "slow" );
-}
-// Can pass in function name
-$( "button" ).click( doIt );
-​
-$( "form" ).submit(function( event ) {
-  if ( $( "input" ).val() === "yes" ) {
-    $( "p" ).show( 4000, function() {
-      $( this ).text( "Ok, DONE! (now showing)" );
-    });
-  }
-  $( "span,div" ).hide( "fast" );
-​
-  // Prevent form submission
-  event.preventDefault();
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    show(duration: JQuery.Duration, easing_complete: string | ((this: TElement) => void)): this;
-    /**
-     * Display the matched elements.
-     *
-     * @param duration_complete_options _&#x40;param_ `duration_complete_options`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
-     * * `options` — A map of additional options to pass to the method.
-     * @see \`{@link https://api.jquery.com/show/ }\`
-     * @since 1.0
-     * @example ​ ````Animates all hidden paragraphs to show slowly, completing the animation within 600 milliseconds.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>show demo</title>
-  <style>
-  p {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Show it</button>
-<p style="display: none">Hello  2</p>
-​
-<script>
-$( "button" ).click(function() {
-  $( "p" ).show( "slow" );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    show(duration_complete_options?: JQuery.Duration | ((this: TElement) => void) | JQuery.EffectsOptions<TElement>): this;
-    /**
-     * Get the siblings of each element in the set of matched elements, optionally filtered by a selector.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @see \`{@link https://api.jquery.com/siblings/ }\`
-     * @since 1.0
-     * @example ​ ````Find the unique siblings of all yellow li elements in the 3 lists (including other yellow li elements if appropriate).
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>siblings demo</title>
-  <style>
-  ul {
-    float: left;
-    margin: 5px;
-    font-size: 16px;
-    font-weight: bold;
-  }
-  p {
-    color: blue;
-    margin: 10px 20px;
-    font-size: 16px;
-    padding: 5px;
-    font-weight: bolder;
-  }
-  .hilite {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul>
-  <li>One</li>
-  <li>Two</li>
-  <li class="hilite">Three</li>
-  <li>Four</li>
-</ul>
-​
-<ul>
-  <li>Five</li>
-  <li>Six</li>
-  <li>Seven</li>
-</ul>
-​
-<ul>
-  <li>Eight</li>
-  <li class="hilite">Nine</li>
-  <li>Ten</li>
-  <li class="hilite">Eleven</li>
-</ul>
-​
-<p>Unique siblings: <b></b></p>
-​
-<script>
-var len = $( ".hilite" ).siblings()
-  .css( "color", "red" )
-  .length;
-$( "b" ).text( len );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Find all siblings with a class &quot;selected&quot; of each div.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>siblings demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div><span>Hello</span></div>
-<p class="selected">Hello Again</p>
-<p>And Again</p>
-​
-<script>
-$( "p" ).siblings( ".selected" ).css( "background", "yellow" );
-</script>
-​
-</body>
-</html>
-```
-     */
-    siblings(selector?: JQuery.Selector): this;
-    /**
-     * Reduce the set of matched elements to a subset specified by a range of indices.
-     *
-     * @param start An integer indicating the 0-based position at which the elements begin to be selected. If negative,
-     *              it indicates an offset from the end of the set.
-     * @param end An integer indicating the 0-based position at which the elements stop being selected. If negative,
-     *            it indicates an offset from the end of the set. If omitted, the range continues until the end of the set.
-     * @see \`{@link https://api.jquery.com/slice/ }\`
-     * @since 1.1.4
-     * @example ​ ````Turns divs yellow based on a random slice.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>slice demo</title>
-  <style>
-  div {
-    width: 40px;
-    height: 40px;
-    margin: 10px;
-    float: left;
-    border: 2px solid blue;
-  }
-  span {
-    color: red;
-    font-weight: bold;
-  }
-  button {
-    margin: 5px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><button>Turn slice yellow</button>
-  <span>Click the button!</span></p>
-  <div></div>
-  <div></div>
-  <div></div>
-  <div></div>
-  <div></div>
-  <div></div>
-  <div></div>
-  <div></div>
-  <div></div>
-  ​
-<script>
-function colorEm() {
-  var $div = $( "div" );
-  var start = Math.floor( Math.random() * $div.length );
-  var end = Math.floor( Math.random() * ( $div.length - start ) ) +
-    start + 1;
-  if ( end === $div.length ) {
-    end = undefined;
-  }
-  $div.css( "background", "" );
-  if ( end ) {
-    $div.slice( start, end ).css( "background", "yellow" );
-  } else {
-    $div.slice( start ).css( "background", "yellow" );
-  }
-  $( "span" ).text( "$( 'div' ).slice( " + start +
-    (end ? ", " + end : "") +
-    ").css( 'background', 'yellow' );" );
-}
-​
-$( "button" ).click( colorEm );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Selects all paragraphs, then slices the selection to include only the first element.
-```javascript
-$( "p" ).slice( 0, 1 ).wrapInner( "<b></b>" );
-```
-     * @example ​ ````Selects all paragraphs, then slices the selection to include only the first and second element.
-```javascript
-$( "p" ).slice( 0, 2 ).wrapInner( "<b></b>" );
-```
-     * @example ​ ````Selects all paragraphs, then slices the selection to include only the second element.
-```javascript
-$( "p" ).slice( 1, 2 ).wrapInner( "<b></b>" );
-```
-     * @example ​ ````Selects all paragraphs, then slices the selection to include only the second and third element.
-```javascript
-$( "p" ).slice( 1 ).wrapInner( "<b></b>" );
-```
-     * @example ​ ````Selects all paragraphs, then slices the selection to include only the third element.
-```javascript
-$( "p" ).slice( -1 ).wrapInner( "<b></b>" );
-```
-     */
-    slice(start: number, end?: number): this;
-    /**
-     * Display the matched elements with a sliding motion.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param easing A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/slideDown/ }\`
-     * @since 1.4.3
-     */
-    slideDown(duration: JQuery.Duration, easing: string, complete?: (this: TElement) => void): this;
-    /**
-     * Display the matched elements with a sliding motion.
-     *
-     * @param duration_easing _&#x40;param_ `duration_easing`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `easing` — A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/slideDown/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     * @example ​ ````Animates all inputs to slide down, completing the animation within 1000 milliseconds. Once the animation is done, the input look is changed especially if it is the middle input which gets the focus.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>slideDown demo</title>
-  <style>
-  div {
-    background: #cfd;
-    margin: 3px;
-    width: 50px;
-    text-align: center;
-    float: left;
-    cursor: pointer;
-    border: 2px outset black;
-    font-weight: bolder;
-  }
-  input {
-    display: none;
-    width: 120px;
-    float: left;
-    margin: 10px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>Push!</div>
-<input type="text">
-<input type="text" class="middle">
-<input type="text">
-  ​
-<script>
-$( "div" ).click(function() {
-  $( this ).css({
-    borderStyle: "inset",
-    cursor: "wait"
-  });
-  $( "input" ).slideDown( 1000, function() {
-    $( this )
-      .css( "border", "2px red inset" )
-      .filter( ".middle" )
-        .css( "background", "yellow" )
-        .focus();
-    $( "div" ).css( "visibility", "hidden" );
-  });
-});
-​
-</script>
-​
-</body>
-</html>
-```
-     */
-    slideDown(duration_easing: JQuery.Duration | string, complete: (this: TElement) => void): this;
-    /**
-     * Display the matched elements with a sliding motion.
-     *
-     * @param duration_easing_complete_options _&#x40;param_ `duration_easing_complete_options`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `easing` — A string indicating which easing function to use for the transition. <br>
-     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
-     * * `options` — A map of additional options to pass to the method.
-     * @see \`{@link https://api.jquery.com/slideDown/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     * @example ​ ````Animates all divs to slide down and show themselves over 600 milliseconds.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>slideDown demo</title>
-  <style>
-  div {
-    background: #de9a44;
-    margin: 3px;
-    width: 80px;
-    height: 40px;
-    display: none;
-    float: left;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-Click me!
-<div></div>
-<div></div>
-<div></div>
-​
-<script>
-$( document.body ).click(function () {
-  if ( $( "div:first" ).is( ":hidden" ) ) {
-    $( "div" ).slideDown( "slow" );
-  } else {
-    $( "div" ).hide();
-  }
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    slideDown(duration_easing_complete_options?: JQuery.Duration | string | ((this: TElement) => void) | JQuery.EffectsOptions<TElement>): this;
-    /**
-     * Display or hide the matched elements with a sliding motion.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param easing A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/slideToggle/ }\`
-     * @since 1.4.3
-     */
-    slideToggle(duration: JQuery.Duration, easing: string, complete?: (this: TElement) => void): this;
-    /**
-     * Display or hide the matched elements with a sliding motion.
-     *
-     * @param duration_easing _&#x40;param_ `duration_easing`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `easing` — A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/slideToggle/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     * @example ​ ````Animates divs between dividers with a toggle that makes some appear and some disappear.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>slideToggle demo</title>
-  <style>
-  div {
-    background: #b977d1;
-    margin: 3px;
-    width: 60px;
-    height: 60px;
-    float: left;
-  }
-  div.still {
-    background: #345;
-    width: 5px;
-  }
-  div.hider {
-    display: none;
-  }
-  span {
-    color: red;
-  }
-  p {
-    clear: left;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div></div>
-<div class="still"></div>
-<div style="display:none;">
-</div><div class="still"></div>
-<div></div>
-<div class="still"></div>
-<div class="hider"></div>
-<div class="still"></div>
-<div class="hider"></div>
-<div class="still"></div>
-<div></div>
-<p><button id="aa">Toggle</button> There have been <span>0</span> toggled divs.</p>
-​
-<script>
-$( "#aa" ).click(function() {
-  $( "div:not(.still)" ).slideToggle( "slow", function() {
-    var n = parseInt( $( "span" ).text(), 10 );
-    $( "span" ).text( n + 1 );
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    slideToggle(duration_easing: JQuery.Duration | string, complete: (this: TElement) => void): this;
-    /**
-     * Display or hide the matched elements with a sliding motion.
-     *
-     * @param duration_easing_complete_options _&#x40;param_ `duration_easing_complete_options`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `easing` — A string indicating which easing function to use for the transition. <br>
-     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
-     * * `options` — A map of additional options to pass to the method.
-     * @see \`{@link https://api.jquery.com/slideToggle/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     * @example ​ ````Animates all paragraphs to slide up or down, completing the animation within 600 milliseconds.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>slideToggle demo</title>
-  <style>
-  p {
-    width: 400px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Toggle</button>
-<p>
-  This is the paragraph to end all paragraphs.  You
-  should feel <em>lucky</em> to have seen such a paragraph in
-  your life.  Congratulations!
-</p>
-​
-<script>
-$( "button" ).click(function() {
-  $( "p" ).slideToggle( "slow" );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    slideToggle(duration_easing_complete_options?: JQuery.Duration | string | ((this: TElement) => void) | JQuery.EffectsOptions<TElement>): this;
-    /**
-     * Hide the matched elements with a sliding motion.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param easing A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/slideUp/ }\`
-     * @since 1.4.3
-     */
-    slideUp(duration: JQuery.Duration, easing: string, complete?: (this: TElement) => void): this;
-    /**
-     * Hide the matched elements with a sliding motion.
-     *
-     * @param duration_easing _&#x40;param_ `duration_easing`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `easing` — A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/slideUp/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     * @example ​ ````Animates the parent paragraph to slide up, completing the animation within 200 milliseconds. Once the animation is done, it displays an alert.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>slideUp demo</title>
-  <style>
- div {
-   margin: 2px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>
-  <button>Hide One</button>
-  <input type="text" value="One">
-</div>
-​
-<div>
-  <button>Hide Two</button>
-  <input type="text" value="Two">
-</div>
-​
-<div>
-  <button>Hide Three</button>
-  <input type="text" value="Three">
-</div>
-​
-<div id="msg"></div>
-​
-<script>
-$( "button" ).click(function() {
-  $( this ).parent().slideUp( "slow", function() {
-    $( "#msg" ).text( $( "button", this ).text() + " has completed." );
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    slideUp(duration_easing: JQuery.Duration | string, complete: (this: TElement) => void): this;
-    /**
-     * Hide the matched elements with a sliding motion.
-     *
-     * @param duration_easing_complete_options _&#x40;param_ `duration_easing_complete_options`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `easing` — A string indicating which easing function to use for the transition. <br>
-     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
-     * * `options` — A map of additional options to pass to the method.
-     * @see \`{@link https://api.jquery.com/slideUp/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     * @example ​ ````Animates all divs to slide up, completing the animation within 400 milliseconds.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>slideUp demo</title>
-  <style>
-  div {
-    background: #3d9a44;
-    margin: 3px;
-    width: 80px;
-    height: 40px;
-    float: left;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-Click me!
-<div></div>
-<div></div>
-<div></div>
-<div></div>
-<div></div>
-​
-<script>
-$( document.body ).click(function() {
-  if ( $( "div:first" ).is( ":hidden" ) ) {
-    $( "div" ).show( "slow" );
-  } else {
-    $( "div" ).slideUp();
-  }
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    slideUp(duration_easing_complete_options?: JQuery.Duration | string | ((this: TElement) => void) | JQuery.EffectsOptions<TElement>): this;
-    /**
-     * Stop the currently-running animation on the matched elements.
-     *
-     * @param queue The name of the queue in which to stop animations.
-     * @param clearQueue A Boolean indicating whether to remove queued animation as well. Defaults to false.
-     * @param jumpToEnd A Boolean indicating whether to complete the current animation immediately. Defaults to false.
-     * @see \`{@link https://api.jquery.com/stop/ }\`
-     * @since 1.7
-     */
-    stop(queue: string, clearQueue?: boolean, jumpToEnd?: boolean): this;
-    /**
-     * Stop the currently-running animation on the matched elements.
-     *
-     * @param clearQueue A Boolean indicating whether to remove queued animation as well. Defaults to false.
-     * @param jumpToEnd A Boolean indicating whether to complete the current animation immediately. Defaults to false.
-     * @see \`{@link https://api.jquery.com/stop/ }\`
-     * @since 1.2
-     * @example ​ ````Click the Go button once to start the animation, then click the STOP button to stop it where it&#39;s currently positioned.  Another option is to click several buttons to queue them up and see that stop just kills the currently playing one.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>stop demo</title>
-  <style>
-  div {
-    position: absolute;
-    background-color: #abc;
-    left: 0px;
-    top: 30px;
-    width: 60px;
-    height: 60px;
-    margin: 5px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="go">Go</button>
-<button id="stop">STOP!</button>
-<button id="back">Back</button>
-<div class="block"></div>
-​
-<script>
-// Start animation
-$( "#go" ).click(function() {
-  $( ".block" ).animate({ left: "+=100px" }, 2000 );
-});
-​
-// Stop animation when button is clicked
-$( "#stop" ).click(function() {
-  $( ".block" ).stop();
-});
-​
-// Start animation in the opposite direction
-$( "#back" ).click(function() {
-  $( ".block" ).animate({ left: "-=100px" }, 2000 );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Click the slideToggle button to start the animation, then click again before the animation is completed. The animation will toggle the other direction from the saved starting point.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>stop demo</title>
-  <style>
-  .block {
-    background-color: #abc;
-    border: 2px solid black;
-    width: 200px;
-    height: 80px;
-    margin: 10px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="toggle">slideToggle</button>
-<div class="block"></div>
-​
-<script>
-var $block = $( ".block" );
-​
-// Toggle a sliding animation animation
-$( "#toggle" ).on( "click", function() {
-  $block.stop().slideToggle( 1000 );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    stop(clearQueue?: boolean, jumpToEnd?: boolean): this;
-    /**
-     * Bind an event handler to the "submit" JavaScript event, or trigger that event on an element.
-     *
-     * @param eventData An object containing data that will be passed to the event handler.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/submit/ }\`
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     */
-    submit<TData>(eventData: TData,
-                  handler: JQuery.EventHandler<TElement, TData> | JQuery.EventHandlerBase<any, JQuery.Event<TElement, TData>>): this;
-    /**
-     * Bind an event handler to the "submit" JavaScript event, or trigger that event on an element.
-     *
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/submit/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.3. Use \`{@link on }\` or \`{@link trigger }\`.
-     *
-     * **Cause**: The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu.
-     *
-     * **Solution**: Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`.
-     * @example ​ ````If you&#39;d like to prevent forms from being submitted unless a flag variable is set, try:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>submit demo</title>
-  <style>
-  p {
-    margin: 0;
-    color: blue;
-  }
-  div,p {
-    margin-left: 10px;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Type 'correct' to validate.</p>
-<form action="javascript:alert( 'success!' );">
-  <div>
-    <input type="text">
-    <input type="submit">
-  </div>
-</form>
-<span></span>
-​
-<script>
-$( "form" ).submit(function( event ) {
-  if ( $( "input:first" ).val() === "correct" ) {
-    $( "span" ).text( "Validated..." ).show();
-    return;
-  }
-​
-  $( "span" ).text( "Not valid!" ).show().fadeOut( 1000 );
-  event.preventDefault();
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````If you&#39;d like to prevent forms from being submitted unless a flag variable is set, try:
-```javascript
-$( "form" ).submit(function() {
-  return this.some_flag_variable;
-});
-```
-     * @example ​ ````To trigger the submit event on the first form on the page, try:
-```javascript
-$( "form:first" ).submit();
-```
-     */
-    submit(handler?: JQuery.EventHandler<TElement> | JQuery.EventHandlerBase<any, JQuery.Event<TElement>> | false): this;
-    /**
-     * Set the content of each element in the set of matched elements to the specified text.
-     *
-     * @param text The text to set as the content of each matched element. When Number or Boolean is supplied, it will
-     *             be converted to a String representation.
-     *             A function returning the text content to set. Receives the index position of the element in the set
-     *             and the old text value as arguments.
-     * @see \`{@link https://api.jquery.com/text/ }\`
-     * @since 1.0
-     * @since 1.4
-     * @example ​ ````Add text to the paragraph (notice the bold tag is escaped).
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>text demo</title>
-  <style>
-  p {
-    color: blue;
-    margin: 8px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Test Paragraph.</p>
-​
-<script>
-$( "p" ).text( "<b>Some</b> new text." );
-</script>
-​
-</body>
-</html>
-```
-     */
-    text(text: string | number | boolean | ((this: TElement, index: number, text: string) => string | number | boolean)): this;
-    /**
-     * Get the combined text contents of each element in the set of matched elements, including their descendants.
-     *
-     * @see \`{@link https://api.jquery.com/text/ }\`
-     * @since 1.0
-     * @example ​ ````Find the text in the first paragraph (stripping out the html), then set the html of the last paragraph to show it is just text (the red bold is gone).
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>text demo</title>
-  <style>
-  p {
-    color: blue;
-    margin: 8px;
-  }
-  b {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><b>Test</b> Paragraph.</p>
-<p></p>
-​
-<script>
-var str = $( "p:first" ).text();
-$( "p:last" ).html( str );
-</script>
-​
-</body>
-</html>
-```
-     */
-    text(): string;
-    /**
-     * Retrieve all the elements contained in the jQuery set, as an array.
-     *
-     * @see \`{@link https://api.jquery.com/toArray/ }\`
-     * @since 1.4
-     * @example ​ ````Select all divs in the document and return the DOM Elements as an Array; then use the built-in reverse() method to reverse that array.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>toArray demo</title>
-  <style>
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-Reversed - <span></span>
-​
-<div>One</div>
-<div>Two</div>
-<div>Three</div>​
-<script>
-function disp( divs ) {
-  var a = [];
-  for ( var i = 0; i < divs.length; i++ ) {
-    a.push( divs[ i ].innerHTML );
-  }
-  $( "span" ).text( a.join( " " ) );
-}
-​
-disp( $( "div" ).toArray().reverse() );
-</script>
-​
-</body>
-</html>
-```
-     */
-    toArray(): TElement[];
-    /**
-     * Display or hide the matched elements.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param easing A string indicating which easing function to use for the transition.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/toggle/ }\`
-     * @since 1.4.3
-     */
-    toggle(duration: JQuery.Duration, easing: string, complete?: (this: TElement) => void): this;
-    /**
-     * Display or hide the matched elements.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param complete A function to call once the animation is complete, called once per matched element.
-     * @see \`{@link https://api.jquery.com/toggle/ }\`
-     * @since 1.0
-     */
-    toggle(duration: JQuery.Duration, complete: (this: TElement) => void): this;
-    /**
-     * Display or hide the matched elements.
-     *
-     * @param duration_complete_options_display _&#x40;param_ `duration_complete_options_display`
-     * <br>
-     * * `duration` — A string or number determining how long the animation will run. <br>
-     * * `complete` — A function to call once the animation is complete, called once per matched element. <br>
-     * * `options` — A map of additional options to pass to the method. <br>
-     * * `display` — Use true to show the element or false to hide it.
-     * @see \`{@link https://api.jquery.com/toggle/ }\`
-     * @since 1.0
-     * @since 1.3
-     * @example ​ ````Toggles all paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>toggle demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Toggle</button>
-<p>Hello</p>
-<p style="display: none">Good Bye</p>
-​
-<script>
-$( "button" ).click(function() {
-  $( "p" ).toggle();
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Animates all paragraphs to be shown if they are hidden and hidden if they are visible, completing the animation within 600 milliseconds.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>toggle demo</title>
-  <style>
-  p {
-    background: #dad;
-    font-weight: bold;
-    font-size: 16px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Toggle 'em</button>
-<p>Hiya</p>
-<p>Such interesting text, eh?</p>
-​
-<script>
-$( "button" ).click(function() {
-  $( "p" ).toggle( "slow" );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Shows all paragraphs, then hides them all, back and forth.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>toggle demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Toggle</button>
-<p>Hello</p>
-<p style="display: none">Good Bye</p>
-​
-<script>
-var flip = 0;
-$( "button" ).click(function() {
-  $( "p" ).toggle( flip++ % 2 === 0 );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    toggle(duration_complete_options_display?: JQuery.Duration | ((this: TElement) => void) | JQuery.EffectsOptions<TElement> | boolean): this;
-    /**
-     * Add or remove one or more classes from each element in the set of matched elements, depending on
-     * either the class's presence or the value of the state argument.
-     *
-     * @param className One or more class names (separated by spaces) to be toggled for each element in the matched set.
-     *                  An array of classes to be toggled for each element in the matched set.
-     *                  A function that returns class names to be toggled in the class attribute of each element in the
-     *                  matched set. Receives the index position of the element in the set, the old class value, and the state as arguments.
-     * @param state A Boolean (not just truthy/falsy) value to determine whether the class should be added or removed.
-     * @see \`{@link https://api.jquery.com/toggleClass/ }\`
-     * @since 1.0
-     * @since 1.3
-     * @since 1.4
-     * @since 3.3
-     * @example ​ ````Toggle the class &#39;highlight&#39; when a paragraph is clicked.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>toggleClass demo</title>
-  <style>
-  p {
-    margin: 4px;
-    font-size: 16px;
-    font-weight: bolder;
-    cursor: pointer;
-  }
-  .blue {
-    color: blue;
-  }
-  .highlight {
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p class="blue">Click to toggle</p>
-<p class="blue highlight">highlight</p>
-<p class="blue">on these</p>
-<p class="blue">paragraphs</p>
-​
-<script>
-$( "p" ).click(function() {
-  $( this ).toggleClass( "highlight" );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Add the &quot;highlight&quot; class to the clicked paragraph on every third click of that paragraph, remove it every first and second click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>toggleClass demo</title>
-  <style>
-  p {
-    margin: 4px;
-    font-size: 16px;
-    font-weight: bolder;
-    cursor: pointer;
-  }
-  .blue {
-    color: blue;
-  }
-  .highlight {
-    background: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p class="blue">Click to toggle (<span>clicks: 0</span>)</p>
-<p class="blue highlight">highlight (<span>clicks: 0</span>)</p>
-<p class="blue">on these (<span>clicks: 0</span>)</p>
-<p class="blue">paragraphs (<span>clicks: 0</span>)</p>
-​
-<script>
-var count = 0;
-$( "p" ).each(function() {
-  var $thisParagraph = $( this );
-  var count = 0;
-  $thisParagraph.click(function() {
-    count++;
-    $thisParagraph.find( "span" ).text( "clicks: " + count );
-    $thisParagraph.toggleClass( "highlight", count % 3 === 0 );
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Toggle the class name(s) indicated on the buttons for each div.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>toggleClass demo</title>
-  <style>
-  .wrap > div {
-    float: left;
-    width: 100px;
-    margin: 1em 1em 0 0;
-    padding-left: 3px;
-    border: 1px solid #abc;
-  }
-  div.a {
-    background-color: aqua;
-  }
-  div.b {
-    background-color: burlywood;
-  }
-  div.c {
-    background-color: cornsilk;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div class="buttons">
-  <button>toggle</button>
-  <button class="a">toggle a</button>
-  <button class="a b">toggle a b</button>
-  <button class="a b c">toggle a b c</button>
-  <a href="#">reset</a>
-</div>
-<div class="wrap">
-  <div></div>
-  <div class="b"></div>
-  <div class="a b"></div>
-  <div class="a c"></div>
-</div>
-​
-<script>
-var cls = [ "", "a", "a b", "a b c" ];
-var divs = $( "div.wrap" ).children();
-var appendClass = function() {
-  divs.append(function() {
-    return "<div>" + ( this.className || "none" ) + "</div>";
-  });
-};
-​
-appendClass();
-​
-$( "button" ).on( "click", function() {
-  var tc = this.className || undefined;
-  divs.toggleClass( tc );
-  appendClass();
-});
-​
-$( "a" ).on( "click", function( event ) {
-  event.preventDefault();
-  divs.empty().each(function( i ) {
-    this.className = cls[ i ];
-  });
-  appendClass();
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    toggleClass<TState extends boolean>(className: JQuery.TypeOrArray<string> | ((this: TElement, index: number, className: string, state: TState) => string),
-                                        state?: TState): this;
-    /**
-     * Add or remove one or more classes from each element in the set of matched elements, depending on
-     * either the class's presence or the value of the state argument.
-     *
-     * @param state A boolean value to determine whether the class should be added or removed.
-     * @see \`{@link https://api.jquery.com/toggleClass/ }\`
-     * @since 1.4
-     * @deprecated ​ Deprecated since 3.0. See \`{@link https://github.com/jquery/jquery/pull/2618 }\`.
-     *
-     * **Cause**: Calling `.toggleClass()` with no arguments, or with a single Boolean `true` or `false` argument, has been deprecated. Its behavior was poorly documented, but essentially the method saved away the current class value in a data item when the class was removed and restored the saved value when it was toggled back. If you do not believe you are specificially trying to use this form of the method, it is possible you are accidentally doing so via an inadvertent undefined value, as `.toggleClass( undefined )` toggles all classes.
-     *
-     * **Solution**: If this functionality is still needed, save the current full `.attr( "class" )` value in a data item and restore it when required.
-     */
-    toggleClass(state?: boolean): this;
-    /**
-     * Execute all handlers and behaviors attached to the matched elements for the given event type.
-     *
-     * @param eventType A string containing a JavaScript event type, such as click or submit.
-     *                  A jQuery.Event object.
-     * @param extraParameters Additional parameters to pass along to the event handler.
-     * @see \`{@link https://api.jquery.com/trigger/ }\`
-     * @since 1.0
-     * @since 1.3
-     * @example ​ ````Clicks to button #2 also trigger a click for button #1.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>trigger demo</title>
-  <style>
-  button {
-    margin: 10px;
-  }
-  div {
-    color: blue;
-    font-weight: bold;
-  }
-  span {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Button #1</button>
-<button>Button #2</button>
-<div><span>0</span> button #1 clicks.</div>
-<div><span>0</span> button #2 clicks.</div>
-​
-<script>
-$( "button:first" ).click(function() {
-  update( $( "span:first" ) );
-});
-​
-$( "button:last" ).click(function() {
-  $( "button:first" ).trigger( "click" );
-  update( $( "span:last" ) );
-});
-​
-function update( j ) {
-  var n = parseInt( j.text(), 10 );
-  j.text( n + 1 );
-}
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````To submit the first form without using the submit() function, try:
-```javascript
-$( "form:first" ).trigger( "submit" );
-```
-     * @example ​ ````To submit the first form without using the submit() function, try:
-```javascript
-var event = jQuery.Event( "submit" );
-$( "form:first" ).trigger( event );
-if ( event.isDefaultPrevented() ) {
-  // Perform an action...
-}
-```
-     * @example ​ ````To pass arbitrary data to an event:
-```javascript
-$( "p" )
-  .click(function( event, a, b ) {
-    // When a normal click fires, a and b are undefined
-    // for a trigger like below a refers to "foo" and b refers to "bar"
-  })
-  .trigger( "click", [ "foo", "bar" ] );
-```
-     * @example ​ ````To pass arbitrary data through an event object:
-```javascript
-var event = jQuery.Event( "logged" );
-event.user = "foo";
-event.pass = "bar";
-$( "body" ).trigger( event );
-```
-     * @example ​ ````Alternative way to pass data through an event object:
-```javascript
-$( "body" ).trigger({
-  type:"logged",
-  user:"foo",
-  pass:"bar"
-});
-```
-     */
-    trigger(eventType: string | JQuery.Event<TElement>, extraParameters?: any[] | JQuery.PlainObject | string | number | boolean): this;
-    /**
-     * Execute all handlers attached to an element for an event.
-     *
-     * @param eventType A string containing a JavaScript event type, such as click or submit.
-     *                  A jQuery.Event object.
-     * @param extraParameters Additional parameters to pass along to the event handler.
-     * @see \`{@link https://api.jquery.com/triggerHandler/ }\`
-     * @since 1.2
-     * @since 1.3
-     * @example ​ ````If you called .triggerHandler() on a focus event - the browser&#39;s default focus action would not be triggered, only the event handlers bound to the focus event.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>triggerHandler demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="old">.trigger( "focus" )</button>
-<button id="new">.triggerHandler( "focus" )</button><br><br>
-​
-<input type="text" value="To Be Focused">
-​
-<script>
-$( "#old" ).click(function() {
-  $( "input" ).trigger( "focus" );
-});
-$( "#new" ).click(function() {
-  $( "input" ).triggerHandler( "focus" );
-});
-$( "input" ).focus(function() {
-  $( "<span>Focused!</span>" ).appendTo( "body" ).fadeOut( 1000 );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    triggerHandler(eventType: string | JQuery.Event<TElement>, extraParameters?: any[] | JQuery.PlainObject | string | number | boolean): undefined | any;
-    /**
-     * Remove a previously-attached event handler from the elements.
-     *
-     * @param event A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/unbind/ }\`
-     * @since 1.0
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.0. Use \`{@link off }\`.
-     *
-     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
-     *
-     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
-     * @example ​ ````Can bind and unbind events to the colored button.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>unbind demo</title>
-  <style>
-  button {
-    margin: 5px;
-  }
-  button#theone {
-    color: red;
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="theone">Does nothing...</button>
-<button id="bind">Bind Click</button>
-<button id="unbind">Unbind Click</button>
-<div style="display:none;">Click!</div>
-​
-<script>
-function aClick() {
-  $( "div" ).show().fadeOut( "slow" );
-}
-$( "#bind" ).click(function() {
-  $( "#theone" )
-    .bind( "click", aClick )
-    .text( "Can Click!" );
-});
-$( "#unbind" ).click(function() {
-  $( "#theone" )
-    .unbind( "click", aClick )
-    .text( "Does nothing..." );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````To unbind just one previously bound handler, pass the function in as the second argument:
-```javascript
-var foo = function() {
-  // Code to handle some kind of event
-};
-​
-$( "p" ).bind( "click", foo ); // ... Now foo will be called when paragraphs are clicked ...
-​
-$( "p" ).unbind( "click", foo ); // ... foo will no longer be called.
-```
-     */
-    unbind(event: string, handler: JQuery.EventHandlerBase<any, JQuery.Event<TElement, any>> | false): this;
-    /**
-     * Remove a previously-attached event handler from the elements.
-     *
-     * @param event A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
-     *              A jQuery.Event object.
-     * @see \`{@link https://api.jquery.com/unbind/ }\`
-     * @since 1.0
-     * @deprecated ​ Deprecated since 3.0. Use \`{@link off }\`.
-     *
-     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
-     *
-     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
-     * @example ​ ````To unbind all events from all paragraphs, write:
-```javascript
-$( "p" ).unbind();
-```
-     * @example ​ ````To unbind all click events from all paragraphs, write:
-```javascript
-$( "p" ).unbind( "click" );
-```
-     */
-    unbind(event?: string | JQuery.Event<TElement>): this;
-    /**
-     * Remove a handler from the event for all elements which match the current selector, based upon a
-     * specific set of root elements.
-     *
-     * @param selector A selector which will be used to filter the event results.
-     * @param eventType A string containing a JavaScript event type, such as "click" or "keydown"
-     * @param handler A function to execute each time the event is triggered.
-     * @see \`{@link https://api.jquery.com/undelegate/ }\`
-     * @since 1.4.2
-     * @deprecated ​ Deprecated since 3.0. Use \`{@link off }\`.
-     *
-     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
-     *
-     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
-     * @example ​ ````Can bind and unbind events to the colored button.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>undelegate demo</title>
-  <style>
-  button {
-    margin: 5px;
-  }
-  button#theone {
-    color: red;
-    background: yellow;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="theone">Does nothing...</button>
-<button id="bind">Bind Click</button>
-<button id="unbind">Unbind Click</button>
-<div style="display:none;">Click!</div>
-​
-<script>
-function aClick() {
-  $( "div" ).show().fadeOut( "slow" );
-}
-$( "#bind" ).click(function() {
-  $( "body" )
-    .delegate( "#theone", "click", aClick )
-    .find( "#theone" ).text( "Can Click!" );
-});
-$( "#unbind" ).click(function() {
-  $( "body" )
-    .undelegate( "#theone", "click", aClick )
-    .find( "#theone" ).text( "Does nothing..." );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````To undelegate just one previously bound handler, pass the function in as the third argument:
-```javascript
-var foo = function () {
-  // Code to handle some kind of event
-};
-​
-// ... Now foo will be called when paragraphs are clicked ...
-$( "body" ).delegate( "p", "click", foo );
-​
-// ... foo will no longer be called.
-$( "body" ).undelegate( "p", "click", foo );
-```
-     */
-    undelegate(selector: JQuery.Selector, eventType: string, handler: JQuery.EventHandlerBase<any, JQuery.Event<TElement, any>> | false): this;
-    /**
-     * Remove a handler from the event for all elements which match the current selector, based upon a
-     * specific set of root elements.
-     *
-     * @param selector A selector which will be used to filter the event results.
-     * @param eventTypes A string containing a JavaScript event type, such as "click" or "keydown"
-     *                   An object of one or more event types and previously bound functions to unbind from them.
-     * @see \`{@link https://api.jquery.com/undelegate/ }\`
-     * @since 1.4.2
-     * @since 1.4.3
-     * @deprecated ​ Deprecated since 3.0. Use \`{@link off }\`.
-     *
-     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
-     *
-     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
-     */
-    undelegate(selector: JQuery.Selector, eventTypes: string | JQuery.PlainObject<JQuery.EventHandlerBase<any, JQuery.Event<TElement, any>> | false>): this;
-    /**
-     * Remove a handler from the event for all elements which match the current selector, based upon a
-     * specific set of root elements.
-     *
-     * @param namespace A selector which will be used to filter the event results.
-     * @see \`{@link https://api.jquery.com/undelegate/ }\`
-     * @since 1.4.2
-     * @since 1.6
-     * @deprecated ​ Deprecated since 3.0. Use \`{@link off }\`.
-     *
-     * **Cause**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 3.0, they may be removed as early as the next major-version update.
-     *
-     * **Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical.
-     * @example ​ ````To unbind all delegated events from all paragraphs, write:
-```javascript
-$( "p" ).undelegate();
-```
-     * @example ​ ````To unbind all delegated click events from all paragraphs, write:
-```javascript
-$( "p" ).undelegate( "click" );
-```
-     * @example ​ ````To unbind all delegated events by their namespace:
-```javascript
-var foo = function() {
-  // Code to handle some kind of event
-};
-​
-// Delegate events under the ".whatever" namespace
-$( "form" ).delegate( ":button", "click.whatever", foo );
-​
-$( "form" ).delegate( "input[type='text'] ", "keypress.whatever", foo );
-​
-// Unbind all events delegated under the ".whatever" namespace
-$( "form" ).undelegate( ".whatever" );
-```
-     */
-    undelegate(namespace?: string): this;
-    /**
-     * Remove the parents of the set of matched elements from the DOM, leaving the matched elements in their place.
-     *
-     * @param selector A selector to check the parent element against. If an element's parent does not match the selector,
-     *                 the element won't be unwrapped.
-     * @see \`{@link https://api.jquery.com/unwrap/ }\`
-     * @since 1.4
-     * @since 3.0
-     * @example ​ ````Wrap/unwrap a div around each of the paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>unwrap demo</title>
-  <style>
-  div {
-    border: 2px solid blue;
-  }
-  p {
-    background: yellow;
-    margin: 4px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​<button>wrap/unwrap</button>
-<p>Hello</p>
-<p>cruel</p>
-<p>World</p>​
-<script>
-var pTags = $( "p" );
-$( "button" ).click(function() {
-  if ( pTags.parent().is( "div" ) ) {
-    pTags.unwrap();
-  } else {
-    pTags.wrap( "<div></div>" );
-  }
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    unwrap(selector?: string): this;
-    /**
-     * Set the value of each element in the set of matched elements.
-     *
-     * @param value A string of text, a number, or an array of strings corresponding to the value of each matched
-     *              element to set as selected/checked.
-     *              A function returning the value to set. this is the current element. Receives the index position of
-     *              the element in the set and the old value as arguments.
-     * @see \`{@link https://api.jquery.com/val/ }\`
-     * @since 1.0
-     * @since 1.4
-     * @example ​ ````Set the value of an input box.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>val demo</title>
-  <style>
-  button {
-    margin: 4px;
-    cursor: pointer;
-  }
-  input {
-    margin: 4px;
-    color: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>
-  <button>Feed</button>
-  <button>the</button>
-  <button>Input</button>
-</div>
-<input type="text" value="click a button">
-​
-<script>
-$( "button" ).click(function() {
-  var text = $( this ).text();
-  $( "input" ).val( text );
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Use the function argument to modify the value of an input box.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>val demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Type something and then click or tab out of the input.</p>
-<input type="text" value="type something">
-​
-<script>
-$( "input" ).on( "blur", function() {
-  $( this ).val(function( i, val ) {
-    return val.toUpperCase();
-  });
-});
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Set a single select, a multiple select, checkboxes and a radio button .
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>val demo</title>
-  <style>
-  body {
-    color: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<select id="single">
-  <option>Single</option>
-  <option>Single2</option>
-</select>
-​
-<select id="multiple" multiple="multiple">
-  <option selected="selected">Multiple</option>
-  <option>Multiple2</option>
-  <option selected="selected">Multiple3</option>
-</select>
-​
-<br>
-<input type="checkbox" name="checkboxname" value="check1"> check1
-<input type="checkbox" name="checkboxname" value="check2"> check2
-<input type="radio" name="r" value="radio1"> radio1
-<input type="radio" name="r" value="radio2"> radio2
-​
-<script>
-$( "#single" ).val( "Single2" );
-$( "#multiple" ).val([ "Multiple2", "Multiple3" ]);
-$( "input").val([ "check1", "check2", "radio1" ]);
-</script>
-​
-</body>
-</html>
-```
-     */
-    val(value: string | number | string[] | ((this: TElement, index: number, value: string) => string)): this;
-    /**
-     * Get the current value of the first element in the set of matched elements.
-     *
-     * @see \`{@link https://api.jquery.com/val/ }\`
-     * @since 1.0
-     * @example ​ ````Get the single value from a single select and an array of values from a multiple select and display their values.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>val demo</title>
-  <style>
-  p {
-    color: red;
-    margin: 4px;
-  }
-  b {
-    color: blue;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p></p>
-​
-<select id="single">
-  <option>Single</option>
-  <option>Single2</option>
-</select>
-​
-<select id="multiple" multiple="multiple">
-  <option selected="selected">Multiple</option>
-  <option>Multiple2</option>
-  <option selected="selected">Multiple3</option>
-</select>
-​
-<script>
-function displayVals() {
-  var singleValues = $( "#single" ).val();
-  var multipleValues = $( "#multiple" ).val() || [];
-  // When using jQuery 3:
-  // var multipleValues = $( "#multiple" ).val();
-  $( "p" ).html( "<b>Single:</b> " + singleValues +
-    " <b>Multiple:</b> " + multipleValues.join( ", " ) );
-}
-​
-$( "select" ).change( displayVals );
-displayVals();
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Find the value of an input box.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>val demo</title>
-  <style>
-  p {
-    color: blue;
-    margin: 8px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<input type="text" value="some text">
-<p></p>
-​
-<script>
-$( "input" )
-  .keyup(function() {
-    var value = $( this ).val();
-    $( "p" ).text( value );
-  })
-  .keyup();
-</script>
-​
-</body>
-</html>
-```
-     */
-    val(): string | number | string[] | undefined;
-    /**
-     * Set the CSS width of each element in the set of matched elements.
-     *
-     * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure
-     *              appended (as a string).
-     *              A function returning the width to set. Receives the index position of the element in the set and the
-     *              old width as arguments. Within the function, this refers to the current element in the set.
-     * @see \`{@link https://api.jquery.com/width/ }\`
-     * @since 1.0
-     * @since 1.4.1
-     * @example ​ ````Change the width of each div the first time it is clicked (and change its color).
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>width demo</title>
-  <style>
-  div {
-    width: 70px;
-    height: 50px;
-    float: left;
-    margin: 5px;
-    background: red;
-    cursor: pointer;
-  }
-  .mod {
-    background: blue;
-    cursor: default;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>d</div>
-<div>d</div>
-<div>d</div>
-<div>d</div>
-<div>d</div>
-​
-<script>
-var modWidth = 50;
-$( "div" ).one( "click", function() {
-  $( this ).width( modWidth ).addClass( "mod" );
-  modWidth -= 8;
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    width(value: string | number | ((this: TElement, index: number, value: number) => string | number)): this;
-    /**
-     * Get the current computed width for the first element in the set of matched elements.
-     *
-     * @see \`{@link https://api.jquery.com/width/ }\`
-     * @since 1.0
-     * @example ​ ````Show various widths.  Note the values are from the iframe so might be smaller than you expected.  The yellow highlight shows the iframe body.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>width demo</title>
-  <style>
-  body {
-    background: yellow;
-  }
-  button {
-    font-size: 12px;
-    margin: 2px;
-  }
-  p {
-    width: 150px;
-    border: 1px red solid;
-  }
-  div {
-    color: red;
-    font-weight: bold;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button id="getp">Get Paragraph Width</button>
-<button id="getd">Get Document Width</button>
-<button id="getw">Get Window Width</button>
-<div>&nbsp;</div>
-<p>
-  Sample paragraph to test width
-</p>
-​
-<script>
-function showWidth( ele, w ) {
-  $( "div" ).text( "The width for the " + ele + " is " + w + "px." );
-}
-$( "#getp" ).click(function() {
-  showWidth( "paragraph", $( "p" ).width() );
-});
-$( "#getd" ).click(function() {
-  showWidth( "document", $( document ).width() );
-});
-$("#getw").click(function() {
-  showWidth( "window", $( window ).width() );
-});
-</script>
-​
-</body>
-</html>
-```
-     */
-    width(): number | undefined;
-    /**
-     * Wrap an HTML structure around each element in the set of matched elements.
-     *
-     * @param wrappingElement A selector, element, HTML string, or jQuery object specifying the structure to wrap around the
-     *                        matched elements. When you pass a jQuery collection containing more than one element, or a selector
-     *                        matching more than one element, the first element will be used.
-     *                        A callback function returning the HTML content or jQuery object to wrap around the matched elements.
-     *                        Receives the index position of the element in the set as an argument. Within the function, this
-     *                        refers to the current element in the set.
-     * @see \`{@link https://api.jquery.com/wrap/ }\`
-     * @since 1.0
-     * @since 1.4
-     * @example ​ ````Wrap a new div around all of the paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>wrap demo</title>
-  <style>
-  div {
-    border: 2px solid blue;
-  }
-  p {
-    background: yellow;
-    margin: 4px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<p>cruel</p>
-<p>World</p>
-​
-<script>
-$( "p" ).wrap( "<div></div>" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Wraps a newly created tree of objects around the spans.  Notice anything in between the spans gets left out like the &lt;strong&gt; (red text) in this example.  Even the white space between spans is left out.  Click View Source to see the original html.&gt;
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>wrap demo</title>
-  <style>
-  div {
-    border: 2px blue solid;
-    margin: 2px;
-    padding: 2px;
-  }
-  p {
-    background: yellow;
-    margin: 2px;
-    padding: 2px;
-  }
-  strong {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<span>Span Text</span>
-<strong>What about me?</strong>
-<span>Another One</span>
-​
-<script>
-$( "span" ).wrap( "<div><div><p><em><b></b></em></p></div></div>" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Wrap a new div around all of the paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>wrap demo</title>
-  <style>
-  div {
-    border: 2px solid blue;
-  }
-  p {
-    background: yellow;
-    margin: 4px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<p>cruel</p>
-<p>World</p>
-​
-<script>
-$( "p" ).wrap( document.createElement( "div" ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Wrap a jQuery object double depth div around all of the paragraphs.  Notice it doesn&#39;t move the object but just clones it to wrap around its target.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>wrap demo</title>
-  <style>
-  div {
-    border: 2px solid blue;
-    margin: 2px;
-    padding: 2px;
-  }
-  .doublediv {
-    border-color: red;
-  }
-  p {
-    background: yellow;
-    margin: 4px;
-    font-size: 14px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<p>cruel</p>
-<p>World</p>
-<div class="doublediv"><div></div></div>
-​
-<script>
-$( "p" ).wrap( $( ".doublediv" ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    wrap(wrappingElement: JQuery.Selector | JQuery.htmlString | Element | JQuery | ((this: TElement, index: number) => string | JQuery)): this;
-    /**
-     * Wrap an HTML structure around all elements in the set of matched elements.
-     *
-     * @param wrappingElement A selector, element, HTML string, or jQuery object specifying the structure to wrap around the matched elements.
-     *                        A callback function returning the HTML content or jQuery object to wrap around all the matched
-     *                        elements. Within the function, this refers to the first element in the set. Prior to jQuery 3.0, the
-     *                        callback was incorrectly called for every element in the set and received the index position of the
-     *                        element in the set as an argument.
-     * @see \`{@link https://api.jquery.com/wrapAll/ }\`
-     * @since 1.2
-     * @since 1.4
-     * @example ​ ````Wrap a new div around all of the paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>wrapAll demo</title>
-  <style>
-  div {
-    border: 2px solid blue;
-  }
-  p {
-    background: yellow;
-    margin: 4px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<p>cruel</p>
-<p>World</p>
-​
-<script>
-$( "p" ).wrapAll( "<div></div>" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Wraps a newly created tree of objects around the spans.  Notice anything in between the spans gets left out like the &lt;strong&gt; (red text) in this example.  Even the white space between spans is left out.  Click View Source to see the original html.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>wrapAll demo</title>
-  <style>
-  div {
-    border: 2px blue solid;
-    margin: 2px;
-    padding: 2px;
-  }
-  p {
-    background: yellow;
-    margin: 2px;
-    padding: 2px;
-  }
-  strong {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<span>Span Text</span>
-<strong>What about me?</strong>
-<span>Another One</span>
-​
-<script>
-$( "span").wrapAll( "<div><div><p><em><b></b></em></p></div></div>" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Wrap a new div around all of the paragraphs.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>wrapAll demo</title>
-  <style>
-  div {
-    border: 2px solid blue;
-  }
-  p {
-    background: yellow;
-    margin: 4px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<p>cruel</p>
-<p>World</p>
-​
-<script>
-$( "p" ).wrapAll( document.createElement( "div" ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Wrap a jQuery object double depth div around all of the paragraphs.  Notice it doesn&#39;t move the object but just clones it to wrap around its target.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>wrapAll demo</title>
-  <style>
-  div {
-    border: 2px solid blue;
-    margin: 2px;
-    padding: 2px;
-  }
-  .doublediv {
-    border-color: red;
-  }
-  p {
-    background: yellow;
-    margin: 4px;
-    font-size: 14px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<p>cruel</p>
-<p>World</p>
-<div class="doublediv"><div></div></div>
-​
-<script>
-$( "p" ).wrapAll( $( ".doublediv" ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    wrapAll(wrappingElement: JQuery.Selector | JQuery.htmlString | Element | JQuery | ((this: TElement) => string | JQuery)): this;
-    /**
-     * Wrap an HTML structure around the content of each element in the set of matched elements.
-     *
-     * @param wrappingElement An HTML snippet, selector expression, jQuery object, or DOM element specifying the structure to wrap
-     *                        around the content of the matched elements.
-     *                        A callback function which generates a structure to wrap around the content of the matched elements.
-     *                        Receives the index position of the element in the set as an argument. Within the function, this
-     *                        refers to the current element in the set.
-     * @see \`{@link https://api.jquery.com/wrapInner/ }\`
-     * @since 1.2
-     * @since 1.4
-     * @example ​ ````Selects all paragraphs and wraps a bold tag around each of its contents.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>wrapInner demo</title>
-  <style>
-  p {
-    background: #bbf;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<p>cruel</p>
-<p>World</p>
-​
-<script>
-$( "p" ).wrapInner( "<b></b>" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Wraps a newly created tree of objects around the inside of the body.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>wrapInner demo</title>
-  <style>
-  div {
-    border: 2px green solid;
-    margin: 2px;
-    padding: 2px;
-  }
-  p {
-    background: yellow;
-    margin: 2px;
-    padding: 2px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-Plain old text, or is it?
-​
-<script>
-$( "body" ).wrapInner( "<div><div><p><em><b></b></em></p></div></div>" );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Selects all paragraphs and wraps a bold tag around each of its contents.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>wrapInner demo</title>
-  <style>
-  p {
-    background: #9f9;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<p>cruel</p>
-<p>World</p>
-​
-<script>
-$( "p" ).wrapInner( document.createElement( "b" ) );
-</script>
-​
-</body>
-</html>
-```
-     * @example ​ ````Selects all paragraphs and wraps a jQuery object around each of its contents.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>wrapInner demo</title>
-  <style>
-  p {
-    background: #9f9;
-  }
-  .red {
-    color: red;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>Hello</p>
-<p>cruel</p>
-<p>World</p>
-​
-<script>
-$( "p" ).wrapInner( $( "<span class='red'></span>" ) );
-</script>
-​
-</body>
-</html>
-```
-     */
-    wrapInner(wrappingElement: JQuery.Selector | JQuery.htmlString | Element | JQuery | ((this: TElement, index: number) => string | JQuery | Element)): this;
-
-    [n: number]: TElement;
-}
-
-// region ES5 compatibility
-// #region ES5 compatibility
-
-// tslint:disable-next-line:no-empty-interface
-interface Iterable<T> { }
-
-interface SymbolConstructor {
-    /**
-     * A String value that is used in the creation of the default string description of an object.
-     * Called by the built-in method Object.prototype.toString.
-     */
-    readonly toStringTag: symbol;
-}
-
-declare var Symbol: SymbolConstructor;
-
-// #endregion
-
-declare namespace JQuery {
-    type TypeOrArray<T> = T | T[];
-    type Node = Element | Text | Comment | DocumentFragment;
-
-    /**
-     * A string is designated htmlString in jQuery documentation when it is used to represent one or more
-     * DOM elements, typically to be created and inserted in the document. When passed as an argument of
-     * the jQuery() function, the string is identified as HTML if it starts with <tag ... >) and is parsed
-     * as such until the final > character. Prior to jQuery 1.9, a string was considered to be HTML if it
-     * contained <tag ... > anywhere within the string.
-     */
-    type htmlString = string;
-    /**
-     * A selector is used in jQuery to select DOM elements from a DOM document. That document is, in most
-     * cases, the DOM document present in all browsers, but can also be an XML document received via Ajax.
-     */
-    type Selector = string;
-
-    /**
-     * The PlainObject type is a JavaScript object containing zero or more key-value pairs. The plain
-     * object is, in other words, an Object object. It is designated "plain" in jQuery documentation to
-     * distinguish it from other kinds of JavaScript objects: for example, null, user-defined arrays, and
-     * host objects such as document, all of which have a typeof value of "object."
-     *
-     * **Note**: The type declaration of PlainObject is imprecise. It includes host objects and user-defined
-     *           arrays which do not match jQuery's definition.
-     */
-    interface PlainObject<T = any> {
-        [key: string]: T;
-    }
-
-    interface Selectors extends Sizzle.Selectors {
-        /**
-         * @deprecated ​ Deprecated since 3.0. Use \`{@link Selectors#pseudos }\`.
-         *
-         * **Cause**: The standard way to add new custom selectors through jQuery is `jQuery.expr.pseudos`. These two other aliases are deprecated, although they still work as of jQuery 3.0.
-         *
-         * **Solution**: Rename any of the older usage to `jQuery.expr.pseudos`. The functionality is identical.
-         */
-        ':': Sizzle.Selectors.PseudoFunctions;
-        /**
-         * @deprecated ​ Deprecated since 3.0. Use \`{@link Selectors#pseudos }\`.
-         *
-         * **Cause**: The standard way to add new custom selectors through jQuery is `jQuery.expr.pseudos`. These two other aliases are deprecated, although they still work as of jQuery 3.0.
-         *
-         * **Solution**: Rename any of the older usage to `jQuery.expr.pseudos`. The functionality is identical.
-         */
-        filter: Sizzle.Selectors.FilterFunctions;
-    }
-
-    // region Ajax
-    // #region Ajax
-
-    interface AjaxSettings<TContext = any> extends Ajax.AjaxSettingsBase<TContext> {
-        /**
-         * A string containing the URL to which the request is sent.
-         */
-        url?: string;
-        /**
-         * A pre-request callback function that can be used to modify the jqXHR (in jQuery 1.4.x,
-         * XMLHTTPRequest) object before it is sent. Use this to set custom headers, etc. The jqXHR and
-         * settings objects are passed as arguments. This is an Ajax Event. Returning false in the beforeSend
-         * function will cancel the request. As of jQuery 1.5, the beforeSend option will be called regardless
-         * of the type of request.
-         */
-        beforeSend?(this: TContext, jqXHR: jqXHR, settings: AjaxSettings<TContext>): false | void;
-    }
-
-    interface UrlAjaxSettings<TContext = any> extends Ajax.AjaxSettingsBase<TContext> {
-        /**
-         * A string containing the URL to which the request is sent.
-         */
-        url: string;
-        /**
-         * A pre-request callback function that can be used to modify the jqXHR (in jQuery 1.4.x,
-         * XMLHTTPRequest) object before it is sent. Use this to set custom headers, etc. The jqXHR and
-         * settings objects are passed as arguments. This is an Ajax Event. Returning false in the beforeSend
-         * function will cancel the request. As of jQuery 1.5, the beforeSend option will be called regardless
-         * of the type of request.
-         */
-        beforeSend?(this: TContext, jqXHR: jqXHR, settings: UrlAjaxSettings<TContext>): false | void;
-    }
-
-    namespace Ajax {
-        type SuccessTextStatus = 'success' | 'notmodified' | 'nocontent';
-        type ErrorTextStatus = 'timeout' | 'error' | 'abort' | 'parsererror';
-        type TextStatus = SuccessTextStatus | ErrorTextStatus;
-
-        interface SuccessCallback<TContext> {
-            (this: TContext, data: any, textStatus: SuccessTextStatus, jqXHR: jqXHR): void;
-        }
-
-        interface ErrorCallback<TContext> {
-            (this: TContext, jqXHR: jqXHR, textStatus: ErrorTextStatus, errorThrown: string): void;
-        }
-
-        interface CompleteCallback<TContext> {
-            (this: TContext, jqXHR: jqXHR, textStatus: TextStatus): void;
-        }
-
-        /**
-         * @see \`{@link https://api.jquery.com/jquery.ajax/#jQuery-ajax-settings }\`
-         */
-        interface AjaxSettingsBase<TContext> {
-            /**
-             * A set of key/value pairs that map a given dataType to its MIME type, which gets sent in the Accept
-             * request header. This header tells the server what kind of response it will accept in return.
-             */
-            accepts?: PlainObject<string>;
-            /**
-             * By default, all requests are sent asynchronously (i.e. this is set to true by default). If you need
-             * synchronous requests, set this option to false. Cross-domain requests and dataType: "jsonp" requests
-             * do not support synchronous operation. Note that synchronous requests may temporarily lock the
-             * browser, disabling any actions while the request is active. As of jQuery 1.8, the use of async:
-             * false with jqXHR ($.Deferred) is deprecated; you must use the success/error/complete callback
-             * options instead of the corresponding methods of the jqXHR object such as jqXHR.done().
-             */
-            async?: boolean;
-            /**
-             * A pre-request callback function that can be used to modify the jqXHR (in jQuery 1.4.x,
-             * XMLHTTPRequest) object before it is sent. Use this to set custom headers, etc. The jqXHR and
-             * settings objects are passed as arguments. This is an Ajax Event. Returning false in the beforeSend
-             * function will cancel the request. As of jQuery 1.5, the beforeSend option will be called regardless
-             * of the type of request.
-             */
-            beforeSend?(this: TContext, jqXHR: jqXHR, settings: AjaxSettingsBase<TContext>): false | void;
-            /**
-             * If set to false, it will force requested pages not to be cached by the browser. Note: Setting cache
-             * to false will only work correctly with HEAD and GET requests. It works by appending "_={timestamp}"
-             * to the GET parameters. The parameter is not needed for other types of requests, except in IE8 when a
-             * POST is made to a URL that has already been requested by a GET.
-             */
-            cache?: boolean;
-            /**
-             * A function to be called when the request finishes (after success and error callbacks are executed).
-             * The function gets passed two arguments: The jqXHR (in jQuery 1.4.x, XMLHTTPRequest) object and a
-             * string categorizing the status of the request ("success", "notmodified", "nocontent", "error",
-             * "timeout", "abort", or "parsererror"). As of jQuery 1.5, the complete setting can accept an array of
-             * functions. Each function will be called in turn. This is an Ajax Event.
-             */
-            complete?: TypeOrArray<CompleteCallback<TContext>>;
-            /**
-             * An object of string/regular-expression pairs that determine how jQuery will parse the response,
-             * given its content type.
-             */
-            contents?: PlainObject<RegExp>;
-            /**
-             * When sending data to the server, use this content type. Default is
-             * "application/x-www-form-urlencoded; charset=UTF-8", which is fine for most cases. If you explicitly
-             * pass in a content-type to $.ajax(), then it is always sent to the server (even if no data is sent).
-             * As of jQuery 1.6 you can pass false to tell jQuery to not set any content type header. Note: The W3C
-             * XMLHttpRequest specification dictates that the charset is always UTF-8; specifying another charset
-             * will not force the browser to change the encoding. Note: For cross-domain requests, setting the
-             * content type to anything other than application/x-www-form-urlencoded, multipart/form-data, or
-             * text/plain will trigger the browser to send a preflight OPTIONS request to the server.
-             */
-            contentType?: string | false;
-            /**
-             * This object will be the context of all Ajax-related callbacks. By default, the context is an object
-             * that represents the Ajax settings used in the call ($.ajaxSettings merged with the settings passed to $.ajax).
-             */
-            context?: TContext;
-            /**
-             * An object containing dataType-to-dataType converters. Each converter's value is a function that
-             * returns the transformed value of the response.
-             */
-            converters?: PlainObject<((value: any) => any) | true>;
-            /**
-             * If you wish to force a crossDomain request (such as JSONP) on the same domain, set the value of
-             * crossDomain to true. This allows, for example, server-side redirection to another domain.
-             */
-            crossDomain?: boolean;
-            /**
-             * Data to be sent to the server. It is converted to a query string, if not already a string. It's
-             * appended to the url for GET-requests. See processData option to prevent this automatic processing.
-             * Object must be Key/Value pairs. If value is an Array, jQuery serializes multiple values with same
-             * key based on the value of the traditional setting (described below).
-             */
-            data?: PlainObject | string;
-            /**
-             * A function to be used to handle the raw response data of XMLHttpRequest. This is a pre-filtering
-             * function to sanitize the response. You should return the sanitized data. The function accepts two
-             * arguments: The raw data returned from the server and the 'dataType' parameter.
-             */
-            dataFilter?(data: string, type: string): any;
-            /**
-             * The type of data that you're expecting back from the server. If none is specified, jQuery will try
-             * to infer it based on the MIME type of the response (an XML MIME type will yield XML, in 1.4 JSON
-             * will yield a JavaScript object, in 1.4 script will execute the script, and anything else will be
-             * returned as a string). The available types (and the result passed as the first argument to your
-             * success callback) are:
-             *
-             * "xml": Returns a XML document that can be processed via jQuery.
-             *
-             * "html": Returns HTML as plain text; included script tags are evaluated when inserted in the DOM.
-             *
-             * "script": Evaluates the response as JavaScript and returns it as plain text. Disables caching by
-             * appending a query string parameter, _=[TIMESTAMP], to the URL unless the cache option is set to
-             * true. Note: This will turn POSTs into GETs for remote-domain requests.
-             *
-             * "json": Evaluates the response as JSON and returns a JavaScript object. Cross-domain "json" requests
-             * are converted to "jsonp" unless the request includes jsonp: false in its request options. The JSON
-             * data is parsed in a strict manner; any malformed JSON is rejected and a parse error is thrown. As of
-             * jQuery 1.9, an empty response is also rejected; the server should return a response of null or {}
-             * instead. (See json.org for more information on proper JSON formatting.)
-             *
-             * "jsonp": Loads in a JSON block using JSONP. Adds an extra "?callback=?" to the end of your URL to
-             * specify the callback. Disables caching by appending a query string parameter, "_=[TIMESTAMP]", to
-             * the URL unless the cache option is set to true.
-             *
-             * "text": A plain text string.
-             *
-             * multiple, space-separated values: As of jQuery 1.5, jQuery can convert a dataType from what it
-             * received in the Content-Type header to what you require. For example, if you want a text response to
-             * be treated as XML, use "text xml" for the dataType. You can also make a JSONP request, have it
-             * received as text, and interpreted by jQuery as XML: "jsonp text xml". Similarly, a shorthand string
-             * such as "jsonp xml" will first attempt to convert from jsonp to xml, and, failing that, convert from
-             * jsonp to text, and then from text to xml.
-             */
-            dataType?: 'xml' | 'html' | 'script' | 'json' | 'jsonp' | 'text' | string;
-            /**
-             * A function to be called if the request fails. The function receives three arguments: The jqXHR (in
-             * jQuery 1.4.x, XMLHttpRequest) object, a string describing the type of error that occurred and an
-             * optional exception object, if one occurred. Possible values for the second argument (besides null)
-             * are "timeout", "error", "abort", and "parsererror". When an HTTP error occurs, errorThrown receives
-             * the textual portion of the HTTP status, such as "Not Found" or "Internal Server Error." As of jQuery
-             * 1.5, the error setting can accept an array of functions. Each function will be called in turn. Note:
-             * This handler is not called for cross-domain script and cross-domain JSONP requests. This is an Ajax Event.
-             */
-            error?: TypeOrArray<ErrorCallback<TContext>>;
-            /**
-             * Whether to trigger global Ajax event handlers for this request. The default is true. Set to false to
-             * prevent the global handlers like ajaxStart or ajaxStop from being triggered. This can be used to
-             * control various Ajax Events.
-             */
-            global?: boolean;
-            /**
-             * An object of additional header key/value pairs to send along with requests using the XMLHttpRequest
-             * transport. The header X-Requested-With: XMLHttpRequest is always added, but its default
-             * XMLHttpRequest value can be changed here. Values in the headers setting can also be overwritten from
-             * within the beforeSend function.
-             */
-            headers?: PlainObject<string | null | undefined>;
-            /**
-             * Allow the request to be successful only if the response has changed since the last request. This is
-             * done by checking the Last-Modified header. Default value is false, ignoring the header. In jQuery
-             * 1.4 this technique also checks the 'etag' specified by the server to catch unmodified data.
-             */
-            ifModified?: boolean;
-            /**
-             * Allow the current environment to be recognized as "local," (e.g. the filesystem), even if jQuery
-             * does not recognize it as such by default. The following protocols are currently recognized as local:
-             * file, *-extension, and widget. If the isLocal setting needs modification, it is recommended to do so
-             * once in the $.ajaxSetup() method.
-             */
-            isLocal?: boolean;
-            /**
-             * Override the callback function name in a JSONP request. This value will be used instead of
-             * 'callback' in the 'callback=?' part of the query string in the url. So {jsonp:'onJSONPLoad'} would
-             * result in 'onJSONPLoad=?' passed to the server. As of jQuery 1.5, setting the jsonp option to false
-             * prevents jQuery from adding the "?callback" string to the URL or attempting to use "=?" for
-             * transformation. In this case, you should also explicitly set the jsonpCallback setting. For example,
-             * { jsonp: false, jsonpCallback: "callbackName" }. If you don't trust the target of your Ajax
-             * requests, consider setting the jsonp property to false for security reasons.
-             */
-            jsonp?: string | false;
-            /**
-             * Specify the callback function name for a JSONP request. This value will be used instead of the
-             * random name automatically generated by jQuery. It is preferable to let jQuery generate a unique name
-             * as it'll make it easier to manage the requests and provide callbacks and error handling. You may
-             * want to specify the callback when you want to enable better browser caching of GET requests. As of
-             * jQuery 1.5, you can also use a function for this setting, in which case the value of jsonpCallback
-             * is set to the return value of that function.
-             */
-            jsonpCallback?: string | ((this: TContext) => string);
-            /**
-             * The HTTP method to use for the request (e.g. "POST", "GET", "PUT").
-             */
-            method?: string;
-            /**
-             * A mime type to override the XHR mime type.
-             */
-            mimeType?: string;
-            /**
-             * A password to be used with XMLHttpRequest in response to an HTTP access authentication request.
-             */
-            password?: string;
-            /**
-             * By default, data passed in to the data option as an object (technically, anything other than a
-             * string) will be processed and transformed into a query string, fitting to the default content-type
-             * "application/x-www-form-urlencoded". If you want to send a DOMDocument, or other non-processed data,
-             * set this option to false.
-             */
-            processData?: boolean;
-            /**
-             * Only applies when the "script" transport is used (e.g., cross-domain requests with "jsonp" or
-             * "script" dataType and "GET" type). Sets the charset attribute on the script tag used in the request.
-             * Used when the character set on the local page is not the same as the one on the remote script.
-             */
-            scriptCharset?: string;
-            /**
-             * An object of numeric HTTP codes and functions to be called when the response has the corresponding
-             * code.
-             *
-             * If the request is successful, the status code functions take the same parameters as the success
-             * callback; if it results in an error (including 3xx redirect), they take the same parameters as the error callback.
-             */
-            statusCode?: StatusCodeCallbacks<TContext>;
-            /**
-             * A function to be called if the request succeeds. The function gets passed three arguments: The data
-             * returned from the server, formatted according to the dataType parameter or the dataFilter callback
-             * function, if specified; a string describing the status; and the jqXHR (in jQuery 1.4.x,
-             * XMLHttpRequest) object. As of jQuery 1.5, the success setting can accept an array of functions. Each
-             * function will be called in turn. This is an Ajax Event.
-             */
-            success?: TypeOrArray<SuccessCallback<TContext>>;
-            /**
-             * Set a timeout (in milliseconds) for the request. A value of 0 means there will be no timeout. This
-             * will override any global timeout set with $.ajaxSetup(). The timeout period starts at the point the
-             * $.ajax call is made; if several other requests are in progress and the browser has no connections
-             * available, it is possible for a request to time out before it can be sent. In jQuery 1.4.x and
-             * below, the XMLHttpRequest object will be in an invalid state if the request times out; accessing any
-             * object members may throw an exception. In Firefox 3.0+ only, script and JSONP requests cannot be
-             * cancelled by a timeout; the script will run even if it arrives after the timeout period.
-             */
-            timeout?: number;
-            /**
-             * Set this to true if you wish to use the traditional style of param serialization.
-             */
-            traditional?: boolean;
-            /**
-             * An alias for method. You should use type if you're using versions of jQuery prior to 1.9.0.
-             */
-            type?: string;
-            /**
-             * A username to be used with XMLHttpRequest in response to an HTTP access authentication request.
-             */
-            username?: string;
-            // ActiveXObject requires "lib": ["scripthost"] which consumers would also require
-            /**
-             * Callback for creating the XMLHttpRequest object. Defaults to the ActiveXObject when available (IE),
-             * the XMLHttpRequest otherwise. Override to provide your own implementation for XMLHttpRequest or
-             * enhancements to the factory.
-             */
-            xhr?(): XMLHttpRequest;
-            /**
-             * An object of fieldName-fieldValue pairs to set on the native XHR object.
-             *
-             * In jQuery 1.5, the withCredentials property was not propagated to the native XHR and thus CORS
-             * requests requiring it would ignore this flag. For this reason, we recommend using jQuery 1.5.1+
-             * should you require the use of it.
-             */
-            xhrFields?: XHRFields;
-        }
-
-        type StatusCodeCallbacks<TContext> = {
-            // region Success Status Codes
-            // #region Success Status Codes
-
-            // jQuery treats 2xx and 304 status codes as a success
-
-            200?: SuccessCallback<TContext>;
-            201?: SuccessCallback<TContext>;
-            202?: SuccessCallback<TContext>;
-            203?: SuccessCallback<TContext>;
-            204?: SuccessCallback<TContext>;
-            205?: SuccessCallback<TContext>;
-            206?: SuccessCallback<TContext>;
-            207?: SuccessCallback<TContext>;
-            208?: SuccessCallback<TContext>;
-            209?: SuccessCallback<TContext>;
-            210?: SuccessCallback<TContext>;
-            211?: SuccessCallback<TContext>;
-            212?: SuccessCallback<TContext>;
-            213?: SuccessCallback<TContext>;
-            214?: SuccessCallback<TContext>;
-            215?: SuccessCallback<TContext>;
-            216?: SuccessCallback<TContext>;
-            217?: SuccessCallback<TContext>;
-            218?: SuccessCallback<TContext>;
-            219?: SuccessCallback<TContext>;
-            220?: SuccessCallback<TContext>;
-            221?: SuccessCallback<TContext>;
-            222?: SuccessCallback<TContext>;
-            223?: SuccessCallback<TContext>;
-            224?: SuccessCallback<TContext>;
-            225?: SuccessCallback<TContext>;
-            226?: SuccessCallback<TContext>;
-            227?: SuccessCallback<TContext>;
-            228?: SuccessCallback<TContext>;
-            229?: SuccessCallback<TContext>;
-            230?: SuccessCallback<TContext>;
-            231?: SuccessCallback<TContext>;
-            232?: SuccessCallback<TContext>;
-            233?: SuccessCallback<TContext>;
-            234?: SuccessCallback<TContext>;
-            235?: SuccessCallback<TContext>;
-            236?: SuccessCallback<TContext>;
-            237?: SuccessCallback<TContext>;
-            238?: SuccessCallback<TContext>;
-            239?: SuccessCallback<TContext>;
-            240?: SuccessCallback<TContext>;
-            241?: SuccessCallback<TContext>;
-            242?: SuccessCallback<TContext>;
-            243?: SuccessCallback<TContext>;
-            244?: SuccessCallback<TContext>;
-            245?: SuccessCallback<TContext>;
-            246?: SuccessCallback<TContext>;
-            247?: SuccessCallback<TContext>;
-            248?: SuccessCallback<TContext>;
-            249?: SuccessCallback<TContext>;
-            250?: SuccessCallback<TContext>;
-            251?: SuccessCallback<TContext>;
-            252?: SuccessCallback<TContext>;
-            253?: SuccessCallback<TContext>;
-            254?: SuccessCallback<TContext>;
-            255?: SuccessCallback<TContext>;
-            256?: SuccessCallback<TContext>;
-            257?: SuccessCallback<TContext>;
-            258?: SuccessCallback<TContext>;
-            259?: SuccessCallback<TContext>;
-            260?: SuccessCallback<TContext>;
-            261?: SuccessCallback<TContext>;
-            262?: SuccessCallback<TContext>;
-            263?: SuccessCallback<TContext>;
-            264?: SuccessCallback<TContext>;
-            265?: SuccessCallback<TContext>;
-            266?: SuccessCallback<TContext>;
-            267?: SuccessCallback<TContext>;
-            268?: SuccessCallback<TContext>;
-            269?: SuccessCallback<TContext>;
-            270?: SuccessCallback<TContext>;
-            271?: SuccessCallback<TContext>;
-            272?: SuccessCallback<TContext>;
-            273?: SuccessCallback<TContext>;
-            274?: SuccessCallback<TContext>;
-            275?: SuccessCallback<TContext>;
-            276?: SuccessCallback<TContext>;
-            277?: SuccessCallback<TContext>;
-            278?: SuccessCallback<TContext>;
-            279?: SuccessCallback<TContext>;
-            280?: SuccessCallback<TContext>;
-            281?: SuccessCallback<TContext>;
-            282?: SuccessCallback<TContext>;
-            283?: SuccessCallback<TContext>;
-            284?: SuccessCallback<TContext>;
-            285?: SuccessCallback<TContext>;
-            286?: SuccessCallback<TContext>;
-            287?: SuccessCallback<TContext>;
-            288?: SuccessCallback<TContext>;
-            289?: SuccessCallback<TContext>;
-            290?: SuccessCallback<TContext>;
-            291?: SuccessCallback<TContext>;
-            292?: SuccessCallback<TContext>;
-            293?: SuccessCallback<TContext>;
-            294?: SuccessCallback<TContext>;
-            295?: SuccessCallback<TContext>;
-            296?: SuccessCallback<TContext>;
-            297?: SuccessCallback<TContext>;
-            298?: SuccessCallback<TContext>;
-            299?: SuccessCallback<TContext>;
-            304?: SuccessCallback<TContext>;
-
-            // #endregion
-
-            // region Error Status Codes
-            // #region Error Status Codes
-
-            300?: ErrorCallback<TContext>;
-            301?: ErrorCallback<TContext>;
-            302?: ErrorCallback<TContext>;
-            303?: ErrorCallback<TContext>;
-            305?: ErrorCallback<TContext>;
-            306?: ErrorCallback<TContext>;
-            307?: ErrorCallback<TContext>;
-            308?: ErrorCallback<TContext>;
-            309?: ErrorCallback<TContext>;
-            310?: ErrorCallback<TContext>;
-            311?: ErrorCallback<TContext>;
-            312?: ErrorCallback<TContext>;
-            313?: ErrorCallback<TContext>;
-            314?: ErrorCallback<TContext>;
-            315?: ErrorCallback<TContext>;
-            316?: ErrorCallback<TContext>;
-            317?: ErrorCallback<TContext>;
-            318?: ErrorCallback<TContext>;
-            319?: ErrorCallback<TContext>;
-            320?: ErrorCallback<TContext>;
-            321?: ErrorCallback<TContext>;
-            322?: ErrorCallback<TContext>;
-            323?: ErrorCallback<TContext>;
-            324?: ErrorCallback<TContext>;
-            325?: ErrorCallback<TContext>;
-            326?: ErrorCallback<TContext>;
-            327?: ErrorCallback<TContext>;
-            328?: ErrorCallback<TContext>;
-            329?: ErrorCallback<TContext>;
-            330?: ErrorCallback<TContext>;
-            331?: ErrorCallback<TContext>;
-            332?: ErrorCallback<TContext>;
-            333?: ErrorCallback<TContext>;
-            334?: ErrorCallback<TContext>;
-            335?: ErrorCallback<TContext>;
-            336?: ErrorCallback<TContext>;
-            337?: ErrorCallback<TContext>;
-            338?: ErrorCallback<TContext>;
-            339?: ErrorCallback<TContext>;
-            340?: ErrorCallback<TContext>;
-            341?: ErrorCallback<TContext>;
-            342?: ErrorCallback<TContext>;
-            343?: ErrorCallback<TContext>;
-            344?: ErrorCallback<TContext>;
-            345?: ErrorCallback<TContext>;
-            346?: ErrorCallback<TContext>;
-            347?: ErrorCallback<TContext>;
-            348?: ErrorCallback<TContext>;
-            349?: ErrorCallback<TContext>;
-            350?: ErrorCallback<TContext>;
-            351?: ErrorCallback<TContext>;
-            352?: ErrorCallback<TContext>;
-            353?: ErrorCallback<TContext>;
-            354?: ErrorCallback<TContext>;
-            355?: ErrorCallback<TContext>;
-            356?: ErrorCallback<TContext>;
-            357?: ErrorCallback<TContext>;
-            358?: ErrorCallback<TContext>;
-            359?: ErrorCallback<TContext>;
-            360?: ErrorCallback<TContext>;
-            361?: ErrorCallback<TContext>;
-            362?: ErrorCallback<TContext>;
-            363?: ErrorCallback<TContext>;
-            364?: ErrorCallback<TContext>;
-            365?: ErrorCallback<TContext>;
-            366?: ErrorCallback<TContext>;
-            367?: ErrorCallback<TContext>;
-            368?: ErrorCallback<TContext>;
-            369?: ErrorCallback<TContext>;
-            370?: ErrorCallback<TContext>;
-            371?: ErrorCallback<TContext>;
-            372?: ErrorCallback<TContext>;
-            373?: ErrorCallback<TContext>;
-            374?: ErrorCallback<TContext>;
-            375?: ErrorCallback<TContext>;
-            376?: ErrorCallback<TContext>;
-            377?: ErrorCallback<TContext>;
-            378?: ErrorCallback<TContext>;
-            379?: ErrorCallback<TContext>;
-            380?: ErrorCallback<TContext>;
-            381?: ErrorCallback<TContext>;
-            382?: ErrorCallback<TContext>;
-            383?: ErrorCallback<TContext>;
-            384?: ErrorCallback<TContext>;
-            385?: ErrorCallback<TContext>;
-            386?: ErrorCallback<TContext>;
-            387?: ErrorCallback<TContext>;
-            388?: ErrorCallback<TContext>;
-            389?: ErrorCallback<TContext>;
-            390?: ErrorCallback<TContext>;
-            391?: ErrorCallback<TContext>;
-            392?: ErrorCallback<TContext>;
-            393?: ErrorCallback<TContext>;
-            394?: ErrorCallback<TContext>;
-            395?: ErrorCallback<TContext>;
-            396?: ErrorCallback<TContext>;
-            397?: ErrorCallback<TContext>;
-            398?: ErrorCallback<TContext>;
-            399?: ErrorCallback<TContext>;
-            400?: ErrorCallback<TContext>;
-            401?: ErrorCallback<TContext>;
-            402?: ErrorCallback<TContext>;
-            403?: ErrorCallback<TContext>;
-            404?: ErrorCallback<TContext>;
-            405?: ErrorCallback<TContext>;
-            406?: ErrorCallback<TContext>;
-            407?: ErrorCallback<TContext>;
-            408?: ErrorCallback<TContext>;
-            409?: ErrorCallback<TContext>;
-            410?: ErrorCallback<TContext>;
-            411?: ErrorCallback<TContext>;
-            412?: ErrorCallback<TContext>;
-            413?: ErrorCallback<TContext>;
-            414?: ErrorCallback<TContext>;
-            415?: ErrorCallback<TContext>;
-            416?: ErrorCallback<TContext>;
-            417?: ErrorCallback<TContext>;
-            418?: ErrorCallback<TContext>;
-            419?: ErrorCallback<TContext>;
-            420?: ErrorCallback<TContext>;
-            421?: ErrorCallback<TContext>;
-            422?: ErrorCallback<TContext>;
-            423?: ErrorCallback<TContext>;
-            424?: ErrorCallback<TContext>;
-            425?: ErrorCallback<TContext>;
-            426?: ErrorCallback<TContext>;
-            427?: ErrorCallback<TContext>;
-            428?: ErrorCallback<TContext>;
-            429?: ErrorCallback<TContext>;
-            430?: ErrorCallback<TContext>;
-            431?: ErrorCallback<TContext>;
-            432?: ErrorCallback<TContext>;
-            433?: ErrorCallback<TContext>;
-            434?: ErrorCallback<TContext>;
-            435?: ErrorCallback<TContext>;
-            436?: ErrorCallback<TContext>;
-            437?: ErrorCallback<TContext>;
-            438?: ErrorCallback<TContext>;
-            439?: ErrorCallback<TContext>;
-            440?: ErrorCallback<TContext>;
-            441?: ErrorCallback<TContext>;
-            442?: ErrorCallback<TContext>;
-            443?: ErrorCallback<TContext>;
-            444?: ErrorCallback<TContext>;
-            445?: ErrorCallback<TContext>;
-            446?: ErrorCallback<TContext>;
-            447?: ErrorCallback<TContext>;
-            448?: ErrorCallback<TContext>;
-            449?: ErrorCallback<TContext>;
-            450?: ErrorCallback<TContext>;
-            451?: ErrorCallback<TContext>;
-            452?: ErrorCallback<TContext>;
-            453?: ErrorCallback<TContext>;
-            454?: ErrorCallback<TContext>;
-            455?: ErrorCallback<TContext>;
-            456?: ErrorCallback<TContext>;
-            457?: ErrorCallback<TContext>;
-            458?: ErrorCallback<TContext>;
-            459?: ErrorCallback<TContext>;
-            460?: ErrorCallback<TContext>;
-            461?: ErrorCallback<TContext>;
-            462?: ErrorCallback<TContext>;
-            463?: ErrorCallback<TContext>;
-            464?: ErrorCallback<TContext>;
-            465?: ErrorCallback<TContext>;
-            466?: ErrorCallback<TContext>;
-            467?: ErrorCallback<TContext>;
-            468?: ErrorCallback<TContext>;
-            469?: ErrorCallback<TContext>;
-            470?: ErrorCallback<TContext>;
-            471?: ErrorCallback<TContext>;
-            472?: ErrorCallback<TContext>;
-            473?: ErrorCallback<TContext>;
-            474?: ErrorCallback<TContext>;
-            475?: ErrorCallback<TContext>;
-            476?: ErrorCallback<TContext>;
-            477?: ErrorCallback<TContext>;
-            478?: ErrorCallback<TContext>;
-            479?: ErrorCallback<TContext>;
-            480?: ErrorCallback<TContext>;
-            481?: ErrorCallback<TContext>;
-            482?: ErrorCallback<TContext>;
-            483?: ErrorCallback<TContext>;
-            484?: ErrorCallback<TContext>;
-            485?: ErrorCallback<TContext>;
-            486?: ErrorCallback<TContext>;
-            487?: ErrorCallback<TContext>;
-            488?: ErrorCallback<TContext>;
-            489?: ErrorCallback<TContext>;
-            490?: ErrorCallback<TContext>;
-            491?: ErrorCallback<TContext>;
-            492?: ErrorCallback<TContext>;
-            493?: ErrorCallback<TContext>;
-            494?: ErrorCallback<TContext>;
-            495?: ErrorCallback<TContext>;
-            496?: ErrorCallback<TContext>;
-            497?: ErrorCallback<TContext>;
-            498?: ErrorCallback<TContext>;
-            499?: ErrorCallback<TContext>;
-            500?: ErrorCallback<TContext>;
-            501?: ErrorCallback<TContext>;
-            502?: ErrorCallback<TContext>;
-            503?: ErrorCallback<TContext>;
-            504?: ErrorCallback<TContext>;
-            505?: ErrorCallback<TContext>;
-            506?: ErrorCallback<TContext>;
-            507?: ErrorCallback<TContext>;
-            508?: ErrorCallback<TContext>;
-            509?: ErrorCallback<TContext>;
-            510?: ErrorCallback<TContext>;
-            511?: ErrorCallback<TContext>;
-            512?: ErrorCallback<TContext>;
-            513?: ErrorCallback<TContext>;
-            514?: ErrorCallback<TContext>;
-            515?: ErrorCallback<TContext>;
-            516?: ErrorCallback<TContext>;
-            517?: ErrorCallback<TContext>;
-            518?: ErrorCallback<TContext>;
-            519?: ErrorCallback<TContext>;
-            520?: ErrorCallback<TContext>;
-            521?: ErrorCallback<TContext>;
-            522?: ErrorCallback<TContext>;
-            523?: ErrorCallback<TContext>;
-            524?: ErrorCallback<TContext>;
-            525?: ErrorCallback<TContext>;
-            526?: ErrorCallback<TContext>;
-            527?: ErrorCallback<TContext>;
-            528?: ErrorCallback<TContext>;
-            529?: ErrorCallback<TContext>;
-            530?: ErrorCallback<TContext>;
-            531?: ErrorCallback<TContext>;
-            532?: ErrorCallback<TContext>;
-            533?: ErrorCallback<TContext>;
-            534?: ErrorCallback<TContext>;
-            535?: ErrorCallback<TContext>;
-            536?: ErrorCallback<TContext>;
-            537?: ErrorCallback<TContext>;
-            538?: ErrorCallback<TContext>;
-            539?: ErrorCallback<TContext>;
-            540?: ErrorCallback<TContext>;
-            541?: ErrorCallback<TContext>;
-            542?: ErrorCallback<TContext>;
-            543?: ErrorCallback<TContext>;
-            544?: ErrorCallback<TContext>;
-            545?: ErrorCallback<TContext>;
-            546?: ErrorCallback<TContext>;
-            547?: ErrorCallback<TContext>;
-            548?: ErrorCallback<TContext>;
-            549?: ErrorCallback<TContext>;
-            550?: ErrorCallback<TContext>;
-            551?: ErrorCallback<TContext>;
-            552?: ErrorCallback<TContext>;
-            553?: ErrorCallback<TContext>;
-            554?: ErrorCallback<TContext>;
-            555?: ErrorCallback<TContext>;
-            556?: ErrorCallback<TContext>;
-            557?: ErrorCallback<TContext>;
-            558?: ErrorCallback<TContext>;
-            559?: ErrorCallback<TContext>;
-            560?: ErrorCallback<TContext>;
-            561?: ErrorCallback<TContext>;
-            562?: ErrorCallback<TContext>;
-            563?: ErrorCallback<TContext>;
-            564?: ErrorCallback<TContext>;
-            565?: ErrorCallback<TContext>;
-            566?: ErrorCallback<TContext>;
-            567?: ErrorCallback<TContext>;
-            568?: ErrorCallback<TContext>;
-            569?: ErrorCallback<TContext>;
-            570?: ErrorCallback<TContext>;
-            571?: ErrorCallback<TContext>;
-            572?: ErrorCallback<TContext>;
-            573?: ErrorCallback<TContext>;
-            574?: ErrorCallback<TContext>;
-            575?: ErrorCallback<TContext>;
-            576?: ErrorCallback<TContext>;
-            577?: ErrorCallback<TContext>;
-            578?: ErrorCallback<TContext>;
-            579?: ErrorCallback<TContext>;
-            580?: ErrorCallback<TContext>;
-            581?: ErrorCallback<TContext>;
-            582?: ErrorCallback<TContext>;
-            583?: ErrorCallback<TContext>;
-            584?: ErrorCallback<TContext>;
-            585?: ErrorCallback<TContext>;
-            586?: ErrorCallback<TContext>;
-            587?: ErrorCallback<TContext>;
-            588?: ErrorCallback<TContext>;
-            589?: ErrorCallback<TContext>;
-            590?: ErrorCallback<TContext>;
-            591?: ErrorCallback<TContext>;
-            592?: ErrorCallback<TContext>;
-            593?: ErrorCallback<TContext>;
-            594?: ErrorCallback<TContext>;
-            595?: ErrorCallback<TContext>;
-            596?: ErrorCallback<TContext>;
-            597?: ErrorCallback<TContext>;
-            598?: ErrorCallback<TContext>;
-            599?: ErrorCallback<TContext>;
-
-            // #endregion
-        } & {
-            // Status codes not listed require type annotations when defining the callback
-            [index: number]: SuccessCallback<TContext> | ErrorCallback<TContext>;
-        };
-
-        // Writable properties on XMLHttpRequest
-        interface XHRFields extends Partial<Pick<XMLHttpRequest, 'onreadystatechange' | 'responseType' | 'timeout' | 'withCredentials'>> {
-            msCaching?: string;
-        }
-    }
-
-    interface Transport {
-        send(headers: PlainObject, completeCallback: Transport.SuccessCallback): void;
-        abort(): void;
-    }
-
-    namespace Transport {
-        interface SuccessCallback {
-            (status: number, statusText: Ajax.TextStatus, responses?: PlainObject, headers?: string): void;
-        }
-    }
-
-    /**
-     * @see \`{@link https://api.jquery.com/jquery.ajax/#jqXHR }\`
-     */
-    interface jqXHR<TResolve = any> extends Promise3<TResolve, jqXHR<TResolve>, never,
-        Ajax.SuccessTextStatus, Ajax.ErrorTextStatus, never,
-        jqXHR<TResolve>, string, never>,
-        Pick<XMLHttpRequest, 'abort' | 'getAllResponseHeaders' | 'getResponseHeader' | 'overrideMimeType' | 'readyState' | 'responseText' |
-            'setRequestHeader' | 'status' | 'statusText'>,
-        Partial<Pick<XMLHttpRequest, 'responseXML'>> {
-        responseJSON?: any;
-
-        /**
-         * Determine the current state of a Deferred object.
-         *
-         * @see \`{@link https://api.jquery.com/deferred.state/ }\`
-         * @since 1.7
-         */
-        state(): 'pending' | 'resolved' | 'rejected';
-        statusCode(map: Ajax.StatusCodeCallbacks<any>): void;
-    }
-
-    namespace jqXHR {
-        interface DoneCallback<TResolve = any, TjqXHR = jqXHR<TResolve>> extends Deferred.Callback3<TResolve, Ajax.SuccessTextStatus, TjqXHR> { }
-
-        interface FailCallback<TjqXHR> extends Deferred.Callback3<TjqXHR, Ajax.ErrorTextStatus, string> { }
-
-        interface AlwaysCallback<TResolve = any, TjqXHR = jqXHR<TResolve>> extends Deferred.Callback3<TResolve | TjqXHR, Ajax.TextStatus, TjqXHR | string> { }
-    }
-
-    // #endregion
-
-    // region Callbacks
-    // #region Callbacks
-
-    interface CallbacksStatic {
-        /**
-         * A multi-purpose callbacks list object that provides a powerful way to manage callback lists.
-         *
-         * @param flags An optional list of space-separated flags that change how the callback list behaves.
-         * @see \`{@link https://api.jquery.com/jQuery.Callbacks/ }\`
-         * @since 1.7
-         */
-        // tslint:disable-next-line:ban-types no-unnecessary-generics
-        <T extends Function>(flags?: string): Callbacks<T>;
-    }
-
-    // tslint:disable-next-line:ban-types
-    interface Callbacks<T extends Function = Function> {
-        /**
-         * Add a callback or a collection of callbacks to a callback list.
-         *
-         * @param callback A function, or array of functions, that are to be added to the callback list.
-         * @param callbacks A function, or array of functions, that are to be added to the callback list.
-         * @see \`{@link https://api.jquery.com/callbacks.add/ }\`
-         * @since 1.7
-         * @example ​ ````Use callbacks.add() to add new callbacks to a callback list:
-```javascript
-// A sample logging function to be added to a callbacks list
-var foo = function( value ) {
-  console.log( "foo: " + value );
-};
-​
-// Another function to also be added to the list
-var bar = function( value ) {
-  console.log( "bar: " + value );
-};
-​
-var callbacks = $.Callbacks();
-​
-// Add the function "foo" to the list
-callbacks.add( foo );
-​
-// Fire the items on the list
-callbacks.fire( "hello" );
-// Outputs: "foo: hello"
-​
-// Add the function "bar" to the list
-callbacks.add( bar );
-​
-// Fire the items on the list again
-callbacks.fire( "world" );
-​
-// Outputs:
-// "foo: world"
-// "bar: world"
-```
-         */
-        add(callback: TypeOrArray<T>, ...callbacks: Array<TypeOrArray<T>>): this;
-        /**
-         * Disable a callback list from doing anything more.
-         *
-         * @see \`{@link https://api.jquery.com/callbacks.disable/ }\`
-         * @since 1.7
-         * @example ​ ````Use callbacks.disable() to disable further calls to a callback list:
-```javascript
-// A sample logging function to be added to a callbacks list
-var foo = function( value ) {
-  console.log( value );
-};
-​
-var callbacks = $.Callbacks();
-​
-// Add the above function to the list
-callbacks.add( foo );
-​
-// Fire the items on the list
-callbacks.fire( "foo" );
-// Outputs: foo
-​
-// Disable further calls being possible
-callbacks.disable();
-​
-// Attempt to fire with "foobar" as an argument
-callbacks.fire( "foobar" );
-// foobar isn't output
-```
-         */
-        disable(): this;
-        /**
-         * Determine if the callbacks list has been disabled.
-         *
-         * @see \`{@link https://api.jquery.com/callbacks.disabled/ }\`
-         * @since 1.7
-         * @example ​ ````Use callbacks.disabled() to determine if the callbacks list has been disabled:
-```javascript
-// A sample logging function to be added to a callbacks list
-var foo = function( value ) {
-  console.log( "foo:" + value );
-};
-​
-var callbacks = $.Callbacks();
-​
-// Add the logging function to the callback list
-callbacks.add( foo );
-​
-// Fire the items on the list, passing an argument
-callbacks.fire( "hello" );
-// Outputs "foo: hello"
-​
-// Disable the callbacks list
-callbacks.disable();
-​
-// Test the disabled state of the list
-console.log ( callbacks.disabled() );
-// Outputs: true
-```
-         */
-        disabled(): boolean;
-        /**
-         * Remove all of the callbacks from a list.
-         *
-         * @see \`{@link https://api.jquery.com/callbacks.empty/ }\`
-         * @since 1.7
-         * @example ​ ````Use callbacks.empty() to empty a list of callbacks:
-```javascript
-// A sample logging function to be added to a callbacks list
-var foo = function( value1, value2 ) {
-  console.log( "foo: " + value1 + "," + value2 );
-};
-​
-// Another function to also be added to the list
-var bar = function( value1, value2 ) {
-  console.log( "bar: " + value1 + "," + value2 );
-};
-​
-var callbacks = $.Callbacks();
-​
-// Add the two functions
-callbacks.add( foo );
-callbacks.add( bar );
-​
-// Empty the callbacks list
-callbacks.empty();
-​
-// Check to ensure all callbacks have been removed
-console.log( callbacks.has( foo ) );
-// false
-console.log( callbacks.has( bar ) );
-// false
-```
-         */
-        empty(): this;
-        /**
-         * Call all of the callbacks with the given arguments.
-         *
-         * @param args The argument or list of arguments to pass back to the callback list.
-         * @see \`{@link https://api.jquery.com/callbacks.fire/ }\`
-         * @since 1.7
-         * @example ​ ````Use callbacks.fire() to invoke the callbacks in a list with any arguments that have been passed:
-```javascript
-// A sample logging function to be added to a callbacks list
-var foo = function( value ) {
-  console.log( "foo:" + value );
-};
-​
-var callbacks = $.Callbacks();
-​
-// Add the function "foo" to the list
-callbacks.add( foo );
-​
-// Fire the items on the list
-callbacks.fire( "hello" ); // Outputs: "foo: hello"
-callbacks.fire( "world" ); // Outputs: "foo: world"
-​
-// Add another function to the list
-var bar = function( value ){
-  console.log( "bar:" + value );
-};
-​
-// Add this function to the list
-callbacks.add( bar );
-​
-// Fire the items on the list again
-callbacks.fire( "hello again" );
-// Outputs:
-// "foo: hello again"
-// "bar: hello again"
-```
-         */
-        fire(...args: any[]): this;
-        /**
-         * Determine if the callbacks have already been called at least once.
-         *
-         * @see \`{@link https://api.jquery.com/callbacks.fired/ }\`
-         * @since 1.7
-         * @example ​ ````Use callbacks.fired() to determine if the callbacks in a list have been called at least once:
-```javascript
-// A sample logging function to be added to a callbacks list
-var foo = function( value ) {
-  console.log( "foo:" + value );
-};
-​
-var callbacks = $.Callbacks();
-​
-// Add the function "foo" to the list
-callbacks.add( foo );
-​
-// Fire the items on the list
-callbacks.fire( "hello" ); // Outputs: "foo: hello"
-callbacks.fire( "world" ); // Outputs: "foo: world"
-​
-// Test to establish if the callbacks have been called
-console.log( callbacks.fired() );
-```
-         */
-        fired(): boolean;
-        /**
-         * Call all callbacks in a list with the given context and arguments.
-         *
-         * @param context A reference to the context in which the callbacks in the list should be fired.
-         * @param args An argument, or array of arguments, to pass to the callbacks in the list.
-         * @see \`{@link https://api.jquery.com/callbacks.fireWith/ }\`
-         * @since 1.7
-         * @example ​ ````Use callbacks.fireWith() to fire a list of callbacks with a specific context and an array of arguments:
-```javascript
-// A sample logging function to be added to a callbacks list
-var log = function( value1, value2 ) {
-  console.log( "Received: " + value1 + "," + value2 );
-};
-​
-var callbacks = $.Callbacks();
-​
-// Add the log method to the callbacks list
-callbacks.add( log );
-​
-// Fire the callbacks on the list using the context "window"
-// and an arguments array
-​
-callbacks.fireWith( window, [ "foo","bar" ] );
-// Outputs: "Received: foo, bar"
-```
-         */
-        fireWith(context: object, args?: ArrayLike<any>): this;
-        /**
-         * Determine whether or not the list has any callbacks attached. If a callback is provided as an
-         * argument, determine whether it is in a list.
-         *
-         * @param callback The callback to search for.
-         * @see \`{@link https://api.jquery.com/callbacks.has/ }\`
-         * @since 1.7
-         * @example ​ ````Use callbacks.has() to check if a callback list contains a specific callback:
-```javascript
-// A sample logging function to be added to a callbacks list
-var foo = function( value1, value2 ) {
-  console.log( "Received: " + value1 + "," + value2 );
-};
-​
-// A second function which will not be added to the list
-var bar = function( value1, value2 ) {
-  console.log( "foobar" );
-};
-​
-var callbacks = $.Callbacks();
-​
-// Add the log method to the callbacks list
-callbacks.add( foo );
-​
-// Determine which callbacks are in the list
-console.log( callbacks.has( foo ) );
-// true
-console.log( callbacks.has( bar ) );
-// false
-```
-         */
-        has(callback?: T): boolean;
-        /**
-         * Lock a callback list in its current state.
-         *
-         * @see \`{@link https://api.jquery.com/callbacks.lock/ }\`
-         * @since 1.7
-         * @example ​ ````Use callbacks.lock() to lock a callback list to avoid further changes being made to the list state:
-```javascript
-// A sample logging function to be added to a callbacks list
-var foo = function( value ) {
-  console.log( "foo:" + value );
-};
-​
-var callbacks = $.Callbacks();
-​
-// Add the logging function to the callback list
-callbacks.add( foo );
-​
-// Fire the items on the list, passing an argument
-callbacks.fire( "hello" );
-// Outputs "foo: hello"
-​
-// Lock the callbacks list
-callbacks.lock();
-​
-// Try firing the items again
-callbacks.fire( "world" );
-​
-// As the list was locked, no items were called,
-// so "world" isn't logged
-```
-         * @example ​ ````Use callbacks.lock() to lock a callback list with &quot;memory,&quot; and then resume using the list:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>callbacks.lock demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-// Simple function for logging results
-var log = function( value ) {
-  $( "#log" ).append( "<p>" + value + "</p>" );
-};
-​
-// Two sample functions to be added to a callbacks list
-var foo = function( value ) {
-  log( "foo: " + value );
-};
-var bar = function( value ) {
-  log( "bar: " + value );
-};
-​
-// Create the callbacks object with the "memory" flag
-var callbacks = $.Callbacks( "memory" );
-​
-// Add the foo logging function to the callback list
-callbacks.add( foo );
-​
-// Fire the items on the list, passing an argument
-callbacks.fire( "hello" );
-// Outputs "foo: hello"
-​
-// Lock the callbacks list
-callbacks.lock();
-​
-// Try firing the items again
-callbacks.fire( "world" );
-// As the list was locked, no items were called,
-// so "foo: world" isn't logged
-​
-// Add the foo function to the callback list again
-callbacks.add( foo );
-​
-// Try firing the items again
-callbacks.fire( "silentArgument" );
-// Outputs "foo: hello" because the argument value was stored in memory
-​
-// Add the bar function to the callback list
-callbacks.add( bar );
-​
-callbacks.fire( "youHadMeAtHello" );
-// Outputs "bar: hello" because the list is still locked,
-// and the argument value is still stored in memory
-</script>
-​
-</body>
-</html>
-```
-         */
-        lock(): this;
-        /**
-         * Determine if the callbacks list has been locked.
-         *
-         * @see \`{@link https://api.jquery.com/callbacks.locked/ }\`
-         * @since 1.7
-         * @example ​ ````Use callbacks.locked() to determine the lock-state of a callback list:
-```javascript
-// A sample logging function to be added to a callbacks list
-var foo = function( value ) {
-  console.log( "foo: " + value );
-};
-​
-var callbacks = $.Callbacks();
-​
-// Add the logging function to the callback list
-callbacks.add( foo );
-​
-// Fire the items on the list, passing an argument
-callbacks.fire( "hello" );
-// Outputs "foo: hello"
-​
-// Lock the callbacks list
-callbacks.lock();
-​
-// Test the lock-state of the list
-console.log ( callbacks.locked() );
-// true
-```
-         */
-        locked(): boolean;
-        /**
-         * Remove a callback or a collection of callbacks from a callback list.
-         *
-         * @param callbacks A function, or array of functions, that are to be removed from the callback list.
-         * @see \`{@link https://api.jquery.com/callbacks.remove/ }\`
-         * @since 1.7
-         * @example ​ ````Use callbacks.remove() to remove callbacks from a callback list:
-```javascript
-// A sample logging function to be added to a callbacks list
-var foo = function( value ) {
-  console.log( "foo: " + value );
-};
-​
-var callbacks = $.Callbacks();
-​
-// Add the function "foo" to the list
-callbacks.add( foo );
-​
-// Fire the items on the list
-callbacks.fire( "hello" );
-// Outputs: "foo: hello"
-​
-// Remove "foo" from the callback list
-callbacks.remove( foo );
-​
-// Fire the items on the list again
-callbacks.fire( "world" );
-​
-// Nothing output as "foo" is no longer in the list
-```
-         */
-        remove(...callbacks: T[]): this;
-    }
-
-    // #endregion
-
-    // region CSS
-    // #region CSS
-
-    interface CSSHook<TElement> {
-        get(this: this, elem: TElement, computed: any, extra: any): any;
-        set(this: this, elem: TElement, value: any): void;
-    }
-
-    // #endregion
-
-    // region Deferred
-    // #region Deferred
-
-    /**
-     * Any object that has a then method.
-     */
-    interface Thenable<T> extends PromiseLike<T> { }
-
-    // NOTE: This is a private copy of the global Promise interface. It is used by JQuery.PromiseBase to indicate compatibility with other Promise implementations.
-    //       The global Promise interface cannot be used directly as it may be modified, as in the case of @types/bluebird-global.
-    /**
-     * Represents the completion of an asynchronous operation
-     */
-    interface _Promise<T> {
-        readonly [Symbol.toStringTag]: "Promise";
-        /**
-         * Attaches callbacks for the resolution and/or rejection of the Promise.
-         * @param onfulfilled The callback to execute when the Promise is resolved.
-         * @param onrejected The callback to execute when the Promise is rejected.
-         * @returns A Promise for the completion of which ever callback is executed.
-         */
-        then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
-                                             onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): _Promise<TResult1 | TResult2>;
-        /**
-         * Attaches a callback for only the rejection of the Promise.
-         * @param onrejected The callback to execute when the Promise is rejected.
-         * @returns A Promise for the completion of the callback.
-         */
-        catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): _Promise<T | TResult>;
-    }
-
-    // Type parameter guide
-    // --------------------
-    // Each type parameter represents a parameter in one of the three possible callbacks.
-    //
-    // The first letter indicates which position the parameter is in.
-    //
-    // T = A = 1st position
-    // U = B = 2nd position
-    // V = C = 3rd position
-    // S = R = rest position
-    //
-    // The second letter indicates which whether it is a [R]esolve, Re[J]ect, or [N]otify value.
-    //
-    // The third letter indicates whether the value is returned in the [D]one filter, [F]ail filter, or [P]rogress filter.
-
-    /**
-     * This object provides a subset of the methods of the Deferred object (then, done, fail, always,
-     * pipe, progress, state and promise) to prevent users from changing the state of the Deferred.
-     *
-     * @see \`{@link https://api.jquery.com/Types/#Promise }\`
-     */
-    interface PromiseBase<TR, TJ, TN,
-        UR, UJ, UN,
-        VR, VJ, VN,
-        SR, SJ, SN> extends _Promise<TR>, PromiseLike<TR> {
-        /**
-         * Add handlers to be called when the Deferred object is either resolved or rejected.
-         *
-         * @param alwaysCallback A function, or array of functions, that is called when the Deferred is resolved or rejected.
-         * @param alwaysCallbacks Optional additional functions, or arrays of functions, that are called when the Deferred is resolved or rejected.
-         * @see \`{@link https://api.jquery.com/deferred.always/ }\`
-         * @since 1.6
-         * @example ​ ````Since the jQuery.get() method returns a jqXHR object, which is derived from a Deferred object, we can attach a callback for both success and error using the deferred.always() method.
-```javascript
-$.get( "test.php" ).always(function() {
-  alert( "$.get completed with success or error callback arguments" );
-});
-```
-         */
-        always(alwaysCallback: TypeOrArray<Deferred.CallbackBase<TR | TJ, UR | UJ, VR | VJ, SR | SJ>>,
-               ...alwaysCallbacks: Array<TypeOrArray<Deferred.CallbackBase<TR | TJ, UR | UJ, VR | VJ, SR | SJ>>>): this;
-        /**
-         * Add handlers to be called when the Deferred object is resolved.
-         *
-         * @param doneCallback A function, or array of functions, that are called when the Deferred is resolved.
-         * @param doneCallbacks Optional additional functions, or arrays of functions, that are called when the Deferred is resolved.
-         * @see \`{@link https://api.jquery.com/deferred.done/ }\`
-         * @since 1.5
-         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred object, we can attach a success callback using the .done() method.
-```javascript
-$.get( "test.php" ).done(function() {
-  alert( "$.get succeeded" );
-});
-```
-         * @example ​ ````Resolve a Deferred object when the user clicks a button, triggering a number of callback functions:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>deferred.done demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Go</button>
-<p>Ready...</p>
-​
-<script>
-// 3 functions to call when the Deferred object is resolved
-function fn1() {
-  $( "p" ).append( " 1 " );
-}
-function fn2() {
-  $( "p" ).append( " 2 " );
-}
-function fn3( n ) {
-  $( "p" ).append( n + " 3 " + n );
-}
-​
-// Create a deferred object
-var dfd = $.Deferred();
-​
-// Add handlers to be called when dfd is resolved
-dfd
-// .done() can take any number of functions or arrays of functions
-  .done( [ fn1, fn2 ], fn3, [ fn2, fn1 ] )
-// We can chain done methods, too
-  .done(function( n ) {
-    $( "p" ).append( n + " we're done." );
-  });
-​
-// Resolve the Deferred object when the button is clicked
-$( "button" ).on( "click", function() {
-  dfd.resolve( "and" );
-});
-</script>
-​
-</body>
-</html>
-```
-         */
-        done(doneCallback: TypeOrArray<Deferred.CallbackBase<TR, UR, VR, SR>>,
-             ...doneCallbacks: Array<TypeOrArray<Deferred.CallbackBase<TR, UR, VR, SR>>>): this;
-        /**
-         * Add handlers to be called when the Deferred object is rejected.
-         *
-         * @param failCallback A function, or array of functions, that are called when the Deferred is rejected.
-         * @param failCallbacks Optional additional functions, or arrays of functions, that are called when the Deferred is rejected.
-         * @see \`{@link https://api.jquery.com/deferred.fail/ }\`
-         * @since 1.5
-         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred, you can attach a success and failure callback using the deferred.done() and deferred.fail() methods.
-```javascript
-$.get( "test.php" )
-  .done(function() {
-    alert( "$.get succeeded" );
-  })
-  .fail(function() {
-    alert( "$.get failed!" );
-  });
-```
-         */
-        fail(failCallback: TypeOrArray<Deferred.CallbackBase<TJ, UJ, VJ, SJ>>,
-             ...failCallbacks: Array<TypeOrArray<Deferred.CallbackBase<TJ, UJ, VJ, SJ>>>): this;
-        /**
-         * Add handlers to be called when the Deferred object generates progress notifications.
-         *
-         * @param progressCallback A function, or array of functions, to be called when the Deferred generates progress notifications.
-         * @param progressCallbacks Optional additional functions, or arrays of functions, to be called when the Deferred generates
-         *                          progress notifications.
-         * @see \`{@link https://api.jquery.com/deferred.progress/ }\`
-         * @since 1.7
-         */
-        progress(progressCallback: TypeOrArray<Deferred.CallbackBase<TN, UN, VN, SN>>,
-                 ...progressCallbacks: Array<TypeOrArray<Deferred.CallbackBase<TN, UN, VN, SN>>>): this;
-        /**
-         * Return a Deferred's Promise object.
-         *
-         * @param target Object onto which the promise methods have to be attached
-         * @see \`{@link https://api.jquery.com/deferred.promise/ }\`
-         * @since 1.5
-         * @example ​ ````Create a Deferred and set two timer-based functions to either resolve or reject the Deferred after a random interval. Whichever one fires first &quot;wins&quot; and will call one of the callbacks. The second timeout has no effect since the Deferred is already complete (in a resolved or rejected state) from the first timeout action. Also set a timer-based progress notification function, and call a progress handler that adds &quot;working...&quot; to the document body.
-```javascript
-function asyncEvent() {
-  var dfd = jQuery.Deferred();
-​
-  // Resolve after a random interval
-  setTimeout(function() {
-    dfd.resolve( "hurray" );
-  }, Math.floor( 400 + Math.random() * 2000 ) );
-​
-  // Reject after a random interval
-  setTimeout(function() {
-    dfd.reject( "sorry" );
-  }, Math.floor( 400 + Math.random() * 2000 ) );
-​
-  // Show a "working..." message every half-second
-  setTimeout(function working() {
-    if ( dfd.state() === "pending" ) {
-      dfd.notify( "working... " );
-      setTimeout( working, 500 );
-    }
-  }, 1 );
-​
-  // Return the Promise so caller can't change the Deferred
-  return dfd.promise();
-}
-​
-// Attach a done, fail, and progress handler for the asyncEvent
-$.when( asyncEvent() ).then(
-  function( status ) {
-    alert( status + ", things are going well" );
-  },
-  function( status ) {
-    alert( status + ", you fail this time" );
-  },
-  function( status ) {
-    $( "body" ).append( status );
-  }
-);
-```
-         */
-        promise<TTarget extends object>(target: TTarget): this & TTarget;
-        /**
-         * Return a Deferred's Promise object.
-         *
-         * @see \`{@link https://api.jquery.com/deferred.promise/ }\`
-         * @since 1.5
-         * @example ​ ````Use the target argument to promote an existing object to a Promise:
-```javascript
-// Existing object
-var obj = {
-    hello: function( name ) {
-      alert( "Hello " + name );
-    }
-  },
-  // Create a Deferred
-  defer = $.Deferred();
-​
-// Set object as a promise
-defer.promise( obj );
-​
-// Resolve the deferred
-defer.resolve( "John" );
-​
-// Use the object as a Promise
-obj.done(function( name ) {
-  obj.hello( name ); // Will alert "Hello John"
-}).hello( "Karl" ); // Will alert "Hello Karl"
-```
-         */
-        promise(): this;
-        /**
-         * Determine the current state of a Deferred object.
-         *
-         * @see \`{@link https://api.jquery.com/deferred.state/ }\`
-         * @since 1.7
-         */
-        state(): 'pending' | 'resolved' | 'rejected';
-
-        // region pipe
-        // #region pipe
-
-        /**
-         * Utility method to filter and/or chain Deferreds.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
-         * @since 1.6
-         * @since 1.7
-         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
-         *
-         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
-         *
-         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
-         * @example ​ ````Filter resolve value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.pipe(function( value ) {
-    return value * 2;
-  });
-​
-defer.resolve( 5 );
-filtered.done(function( value ) {
-  alert( "Value is ( 2*5 = ) 10: " + value );
-});
-```
-         * @example ​ ````Filter reject value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.pipe( null, function( value ) {
-    return value * 3;
-  });
-​
-defer.reject( 6 );
-filtered.fail(function( value ) {
-  alert( "Value is ( 3*6 = ) 18: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.pipe(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        pipe<ARD = never, AJD = never, AND = never,
-            BRD = never, BJD = never, BND = never,
-            CRD = never, CJD = never, CND = never,
-            RRD = never, RJD = never, RND = never,
-            ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never,
-            ARP = never, AJP = never, ANP = never,
-            BRP = never, BJP = never, BNP = never,
-            CRP = never, CJP = never, CNP = never,
-            RRP = never, RJP = never, RNP = never>(
-                doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
-                    BRD, BJD, BND,
-                    CRD, CJD, CND,
-                    RRD, RJD, RND> | Thenable<ARD> | ARD,
-                failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<AJF> | AJF,
-                progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
-                    BRP, BJP, BNP,
-                    CRP, CJP, CNP,
-                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP,
-            BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP,
-            CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP,
-            RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>;
-        /**
-         * Utility method to filter and/or chain Deferreds.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
-         * @since 1.6
-         * @since 1.7
-         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
-         *
-         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
-         *
-         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
-         * @example ​ ````Filter reject value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.pipe( null, function( value ) {
-    return value * 3;
-  });
-​
-defer.reject( 6 );
-filtered.fail(function( value ) {
-  alert( "Value is ( 3*6 = ) 18: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.pipe(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        pipe<ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never,
-            ARP = never, AJP = never, ANP = never,
-            BRP = never, BJP = never, BNP = never,
-            CRP = never, CJP = never, CNP = never,
-            RRP = never, RJP = never, RNP = never>(
-                doneFilter: null,
-                failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<AJF> | AJF,
-                progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
-                    BRP, BJP, BNP,
-                    CRP, CJP, CNP,
-                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP,
-            BRF | BRP, BJF | BJP, BNF | BNP,
-            CRF | CRP, CJF | CJP, CNF | CNP,
-            RRF | RRP, RJF | RJP, RNF | RNP>;
-        /**
-         * Utility method to filter and/or chain Deferreds.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
-         * @since 1.6
-         * @since 1.7
-         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
-         *
-         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
-         *
-         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
-         * @example ​ ````Filter resolve value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.pipe(function( value ) {
-    return value * 2;
-  });
-​
-defer.resolve( 5 );
-filtered.done(function( value ) {
-  alert( "Value is ( 2*5 = ) 10: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.pipe(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        pipe<ARD = never, AJD = never, AND = never,
-            BRD = never, BJD = never, BND = never,
-            CRD = never, CJD = never, CND = never,
-            RRD = never, RJD = never, RND = never,
-            ARP = never, AJP = never, ANP = never,
-            BRP = never, BJP = never, BNP = never,
-            CRP = never, CJP = never, CNP = never,
-            RRP = never, RJP = never, RNP = never>(
-                doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
-                    BRD, BJD, BND,
-                    CRD, CJD, CND,
-                    RRD, RJD, RND> | Thenable<ARD> | ARD,
-                failFilter: null,
-                progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
-                    BRP, BJP, BNP,
-                    CRP, CJP, CNP,
-                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARP, AJD | AJP, AND | ANP,
-            BRD | BRP, BJD | BJP, BND | BNP,
-            CRD | CRP, CJD | CJP, CND | CNP,
-            RRD | RRP, RJD | RJP, RND | RNP>;
-        /**
-         * Utility method to filter and/or chain Deferreds.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
-         * @since 1.6
-         * @since 1.7
-         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
-         *
-         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
-         *
-         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.pipe(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        pipe<ARP = never, AJP = never, ANP = never,
-            BRP = never, BJP = never, BNP = never,
-            CRP = never, CJP = never, CNP = never,
-            RRP = never, RJP = never, RNP = never>(
-                doneFilter: null,
-                failFilter: null,
-                progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
-                    BRP, BJP, BNP,
-                    CRP, CJP, CNP,
-                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP,
-            BRP, BJP, BNP,
-            CRP, CJP, CNP,
-            RRP, RJP, RNP>;
-        /**
-         * Utility method to filter and/or chain Deferreds.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
-         * @since 1.6
-         * @since 1.7
-         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
-         *
-         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
-         *
-         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
-         * @example ​ ````Filter resolve value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.pipe(function( value ) {
-    return value * 2;
-  });
-​
-defer.resolve( 5 );
-filtered.done(function( value ) {
-  alert( "Value is ( 2*5 = ) 10: " + value );
-});
-```
-         * @example ​ ````Filter reject value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.pipe( null, function( value ) {
-    return value * 3;
-  });
-​
-defer.reject( 6 );
-filtered.fail(function( value ) {
-  alert( "Value is ( 3*6 = ) 18: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.pipe(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        pipe<ARD = never, AJD = never, AND = never,
-            BRD = never, BJD = never, BND = never,
-            CRD = never, CJD = never, CND = never,
-            RRD = never, RJD = never, RND = never,
-            ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never>(
-                doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
-                    BRD, BJD, BND,
-                    CRD, CJD, CND,
-                    RRD, RJD, RND> | Thenable<ARD> | ARD,
-                failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<AJF> | AJF,
-                progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF,
-            BRD | BRF, BJD | BJF, BND | BNF,
-            CRD | CRF, CJD | CJF, CND | CNF,
-            RRD | RRF, RJD | RJF, RND | RNF>;
-        /**
-         * Utility method to filter and/or chain Deferreds.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
-         * @since 1.6
-         * @since 1.7
-         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
-         *
-         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
-         *
-         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
-         * @example ​ ````Filter reject value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.pipe( null, function( value ) {
-    return value * 3;
-  });
-​
-defer.reject( 6 );
-filtered.fail(function( value ) {
-  alert( "Value is ( 3*6 = ) 18: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.pipe(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        pipe<ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never>(
-                doneFilter: null,
-                failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<AJF> | AJF,
-                progressFilter?: null): PromiseBase<ARF, AJF, ANF,
-            BRF, BJF, BNF,
-            CRF, CJF, CNF,
-            RRF, RJF, RNF>;
-        /**
-         * Utility method to filter and/or chain Deferreds.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
-         * @since 1.6
-         * @since 1.7
-         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
-         *
-         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
-         *
-         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
-         * @example ​ ````Filter resolve value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.pipe(function( value ) {
-    return value * 2;
-  });
-​
-defer.resolve( 5 );
-filtered.done(function( value ) {
-  alert( "Value is ( 2*5 = ) 10: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.pipe(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        pipe<ARD = never, AJD = never, AND = never,
-            BRD = never, BJD = never, BND = never,
-            CRD = never, CJD = never, CND = never,
-            RRD = never, RJD = never, RND = never>(
-                doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
-                    BRD, BJD, BND,
-                    CRD, CJD, CND,
-                    RRD, RJD, RND> | Thenable<ARD> | ARD,
-                failFilter?: null,
-                progressFilter?: null): PromiseBase<ARD, AJD, AND,
-            BRD, BJD, BND,
-            CRD, CJD, CND,
-            RRD, RJD, RND>;
-
-        // #endregion
-
-        // region then
-        // #region then
-
-        /**
-         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
-         * @since 1.8
-         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred object, we can attach handlers using the .then method.
-```javascript
-$.get( "test.php" ).then(
-  function() {
-    alert( "$.get succeeded" );
-  }, function() {
-    alert( "$.get failed!" );
-  }
-);
-```
-         * @example ​ ````Filter the resolve value:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>deferred.then demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Filter Resolve</button>
-<p></p>
-​
-<script>
-var filterResolve = function() {
-  var defer = $.Deferred(),
-    filtered = defer.then(function( value ) {
-      return value * 2;
-    });
-​
-  defer.resolve( 5 );
-  filtered.done(function( value ) {
-    $( "p" ).html( "Value is ( 2*5 = ) 10: " + value );
-  });
-};
-​
-$( "button" ).on( "click", filterResolve );
-</script>
-​
-</body>
-</html>
-```
-         * @example ​ ````Filter reject value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.then( null, function( value ) {
-    return value * 3;
-  });
-​
-defer.reject( 6 );
-filtered.fail(function( value ) {
-  alert( "Value is ( 3*6 = ) 18: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.then(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        then<ARD = never, AJD = never, AND = never,
-            BRD = never, BJD = never, BND = never,
-            CRD = never, CJD = never, CND = never,
-            RRD = never, RJD = never, RND = never,
-            ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never,
-            ARP = never, AJP = never, ANP = never,
-            BRP = never, BJP = never, BNP = never,
-            CRP = never, CJP = never, CNP = never,
-            RRP = never, RJP = never, RNP = never>(
-                doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
-                    BRD, BJD, BND,
-                    CRD, CJD, CND,
-                    RRD, RJD, RND> | Thenable<ARD> | ARD,
-                failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<ARF> | ARF,
-                progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
-                    BRP, BJP, BNP,
-                    CRP, CJP, CNP,
-                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP,
-            BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP,
-            CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP,
-            RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>;
-        /**
-         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
-         * @since 1.8
-         * @example ​ ````Filter reject value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.then( null, function( value ) {
-    return value * 3;
-  });
-​
-defer.reject( 6 );
-filtered.fail(function( value ) {
-  alert( "Value is ( 3*6 = ) 18: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.then(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        then<ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never,
-            ARP = never, AJP = never, ANP = never,
-            BRP = never, BJP = never, BNP = never,
-            CRP = never, CJP = never, CNP = never,
-            RRP = never, RJP = never, RNP = never>(
-                doneFilter: null,
-                failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<ARF> | ARF,
-                progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
-                    BRP, BJP, BNP,
-                    CRP, CJP, CNP,
-                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP,
-            BRF | BRP, BJF | BJP, BNF | BNP,
-            CRF | CRP, CJF | CJP, CNF | CNP,
-            RRF | RRP, RJF | RJP, RNF | RNP>;
-        /**
-         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
-         * @since 1.8
-         * @example ​ ````Filter the resolve value:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>deferred.then demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Filter Resolve</button>
-<p></p>
-​
-<script>
-var filterResolve = function() {
-  var defer = $.Deferred(),
-    filtered = defer.then(function( value ) {
-      return value * 2;
-    });
-​
-  defer.resolve( 5 );
-  filtered.done(function( value ) {
-    $( "p" ).html( "Value is ( 2*5 = ) 10: " + value );
-  });
-};
-​
-$( "button" ).on( "click", filterResolve );
-</script>
-​
-</body>
-</html>
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.then(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        then<ARD = never, AJD = never, AND = never,
-            BRD = never, BJD = never, BND = never,
-            CRD = never, CJD = never, CND = never,
-            RRD = never, RJD = never, RND = never,
-            ARP = never, AJP = never, ANP = never,
-            BRP = never, BJP = never, BNP = never,
-            CRP = never, CJP = never, CNP = never,
-            RRP = never, RJP = never, RNP = never>(
-                doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
-                    BRD, BJD, BND,
-                    CRD, CJD, CND,
-                    RRD, RJD, RND> | Thenable<ARD> | ARD,
-                failFilter: null,
-                progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
-                    BRP, BJP, BNP,
-                    CRP, CJP, CNP,
-                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARP, AJD | AJP, AND | ANP,
-            BRD | BRP, BJD | BJP, BND | BNP,
-            CRD | CRP, CJD | CJP, CND | CNP,
-            RRD | RRP, RJD | RJP, RND | RNP>;
-        /**
-         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
-         * @since 1.8
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.then(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        then<ARP = never, AJP = never, ANP = never,
-            BRP = never, BJP = never, BNP = never,
-            CRP = never, CJP = never, CNP = never,
-            RRP = never, RJP = never, RNP = never>(
-                doneFilter: null,
-                failFilter: null,
-                progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
-                    BRP, BJP, BNP,
-                    CRP, CJP, CNP,
-                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP,
-            BRP, BJP, BNP,
-            CRP, CJP, CNP,
-            RRP, RJP, RNP>;
-        /**
-         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
-         * @since 1.8
-         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred object, we can attach handlers using the .then method.
-```javascript
-$.get( "test.php" ).then(
-  function() {
-    alert( "$.get succeeded" );
-  }, function() {
-    alert( "$.get failed!" );
-  }
-);
-```
-         * @example ​ ````Filter the resolve value:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>deferred.then demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Filter Resolve</button>
-<p></p>
-​
-<script>
-var filterResolve = function() {
-  var defer = $.Deferred(),
-    filtered = defer.then(function( value ) {
-      return value * 2;
-    });
-​
-  defer.resolve( 5 );
-  filtered.done(function( value ) {
-    $( "p" ).html( "Value is ( 2*5 = ) 10: " + value );
-  });
-};
-​
-$( "button" ).on( "click", filterResolve );
-</script>
-​
-</body>
-</html>
-```
-         * @example ​ ````Filter reject value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.then( null, function( value ) {
-    return value * 3;
-  });
-​
-defer.reject( 6 );
-filtered.fail(function( value ) {
-  alert( "Value is ( 3*6 = ) 18: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.then(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        then<ARD = never, AJD = never, AND = never,
-            BRD = never, BJD = never, BND = never,
-            CRD = never, CJD = never, CND = never,
-            RRD = never, RJD = never, RND = never,
-            ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never>(
-                doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
-                    BRD, BJD, BND,
-                    CRD, CJD, CND,
-                    RRD, RJD, RND> | Thenable<ARD> | ARD,
-                failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<ARF> | ARF,
-                progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF,
-            BRD | BRF, BJD | BJF, BND | BNF,
-            CRD | CRF, CJD | CJF, CND | CNF,
-            RRD | RRF, RJD | RJF, RND | RNF>;
-        /**
-         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
-         * @since 1.8
-         * @example ​ ````Filter reject value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.then( null, function( value ) {
-    return value * 3;
-  });
-​
-defer.reject( 6 );
-filtered.fail(function( value ) {
-  alert( "Value is ( 3*6 = ) 18: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.then(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        then<ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never>(
-                doneFilter: null,
-                failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<ARF> | ARF,
-                progressFilter?: null): PromiseBase<ARF, AJF, ANF,
-            BRF, BJF, BNF,
-            CRF, CJF, CNF,
-            RRF, RJF, RNF>;
-        /**
-         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
-         * @since 1.8
-         * @example ​ ````Filter the resolve value:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>deferred.then demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Filter Resolve</button>
-<p></p>
-​
-<script>
-var filterResolve = function() {
-  var defer = $.Deferred(),
-    filtered = defer.then(function( value ) {
-      return value * 2;
-    });
-​
-  defer.resolve( 5 );
-  filtered.done(function( value ) {
-    $( "p" ).html( "Value is ( 2*5 = ) 10: " + value );
-  });
-};
-​
-$( "button" ).on( "click", filterResolve );
-</script>
-​
-</body>
-</html>
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.then(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        then<ARD = never, AJD = never, AND = never,
-            BRD = never, BJD = never, BND = never,
-            CRD = never, CJD = never, CND = never,
-            RRD = never, RJD = never, RND = never>(
-                doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
-                    BRD, BJD, BND,
-                    CRD, CJD, CND,
-                    RRD, RJD, RND> | Thenable<ARD> | ARD,
-                failFilter?: null,
-                progressFilter?: null): PromiseBase<ARD, AJD, AND,
-            BRD, BJD, BND,
-            CRD, CJD, CND,
-            RRD, RJD, RND>;
-
-        // #endregion
-
-        /**
-         * Add handlers to be called when the Deferred object is rejected.
-         *
-         * @param failFilter A function that is called when the Deferred is rejected.
-         * @see \`{@link https://api.jquery.com/deferred.catch/ }\`
-         * @since 3.0
-         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred object, we can rejection handlers using the .catch method.
-```javascript
-$.get( "test.php" )
-  .then( function() {
-    alert( "$.get succeeded" );
-  } )
-  .catch( function() {
-    alert( "$.get failed!" );
-  } );
-```
-         */
-        catch<ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never>(
-                failFilter?: ((t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<ARF> | ARF) | null): PromiseBase<ARF, AJF, ANF,
-            BRF, BJF, BNF,
-            CRF, CJF, CNF,
-            RRF, RJF, RNF>;
-    }
-
-    /**
-     * This object provides a subset of the methods of the Deferred object (then, done, fail, always,
-     * pipe, progress, state and promise) to prevent users from changing the state of the Deferred.
-     *
-     * @see \`{@link https://api.jquery.com/Types/#Promise }\`
-     */
-    interface Promise3<TR, TJ, TN,
-        UR, UJ, UN,
-        VR, VJ, VN> extends PromiseBase<TR, TJ, TN,
-        UR, UJ, UN,
-        VR, VJ, VN,
-        never, never, never> { }
-
-    /**
-     * This object provides a subset of the methods of the Deferred object (then, done, fail, always,
-     * pipe, progress, state and promise) to prevent users from changing the state of the Deferred.
-     *
-     * @see \`{@link https://api.jquery.com/Types/#Promise }\`
-     */
-    interface Promise2<TR, TJ, TN,
-        UR, UJ, UN> extends PromiseBase<TR, TJ, TN,
-        UR, UJ, UN,
-        never, never, never,
-        never, never, never> { }
-
-    /**
-     * This object provides a subset of the methods of the Deferred object (then, done, fail, always,
-     * pipe, progress, state and promise) to prevent users from changing the state of the Deferred.
-     *
-     * @see \`{@link https://api.jquery.com/Types/#Promise }\`
-     */
-    interface Promise<TR, TJ = any, TN = any> extends PromiseBase<TR, TJ, TN,
-        TR, TJ, TN,
-        TR, TJ, TN,
-        TR, TJ, TN> { }
-
-    interface DeferredStatic {
-        // https://jquery.com/upgrade-guide/3.0/#callback-exit
-        exceptionHook: any;
-        /**
-         * A factory function that returns a chainable utility object with methods to register multiple
-         * callbacks into callback queues, invoke callback queues, and relay the success or failure state of
-         * any synchronous or asynchronous function.
-         *
-         * @param beforeStart A function that is called just before the constructor returns.
-         * @see \`{@link https://api.jquery.com/jQuery.Deferred/ }\`
-         * @since 1.5
-         */
-        <TR = any, TJ = any, TN = any>(beforeStart?: (this: Deferred<TR, TJ, TN>, deferred: Deferred<TR, TJ, TN>) => void): Deferred<TR, TJ, TN>;
-    }
-
-    interface Deferred<TR, TJ = any, TN = any> {
-        /**
-         * Call the progressCallbacks on a Deferred object with the given args.
-         *
-         * @param args Optional arguments that are passed to the progressCallbacks.
-         * @see \`{@link https://api.jquery.com/deferred.notify/ }\`
-         * @since 1.7
-         */
-        notify(...args: TN[]): this;
-        /**
-         * Call the progressCallbacks on a Deferred object with the given context and args.
-         *
-         * @param context Context passed to the progressCallbacks as the this object.
-         * @param args An optional array of arguments that are passed to the progressCallbacks.
-         * @see \`{@link https://api.jquery.com/deferred.notifyWith/ }\`
-         * @since 1.7
-         */
-        notifyWith(context: object, args?: ArrayLike<TN>): this;
-        /**
-         * Reject a Deferred object and call any failCallbacks with the given args.
-         *
-         * @param args Optional arguments that are passed to the failCallbacks.
-         * @see \`{@link https://api.jquery.com/deferred.reject/ }\`
-         * @since 1.5
-         */
-        reject(...args: TJ[]): this;
-        /**
-         * Reject a Deferred object and call any failCallbacks with the given context and args.
-         *
-         * @param context Context passed to the failCallbacks as the this object.
-         * @param args An optional array of arguments that are passed to the failCallbacks.
-         * @see \`{@link https://api.jquery.com/deferred.rejectWith/ }\`
-         * @since 1.5
-         */
-        rejectWith(context: object, args?: ArrayLike<TJ>): this;
-        /**
-         * Resolve a Deferred object and call any doneCallbacks with the given args.
-         *
-         * @param args Optional arguments that are passed to the doneCallbacks.
-         * @see \`{@link https://api.jquery.com/deferred.resolve/ }\`
-         * @since 1.5
-         */
-        resolve(...args: TR[]): this;
-        /**
-         * Resolve a Deferred object and call any doneCallbacks with the given context and args.
-         *
-         * @param context Context passed to the doneCallbacks as the this object.
-         * @param args An optional array of arguments that are passed to the doneCallbacks.
-         * @see \`{@link https://api.jquery.com/deferred.resolveWith/ }\`
-         * @since 1.5
-         */
-        resolveWith(context: object, args?: ArrayLike<TR>): this;
-
-        /**
-         * Add handlers to be called when the Deferred object is either resolved or rejected.
-         *
-         * @param alwaysCallback A function, or array of functions, that is called when the Deferred is resolved or rejected.
-         * @param alwaysCallbacks Optional additional functions, or arrays of functions, that are called when the Deferred is resolved or rejected.
-         * @see \`{@link https://api.jquery.com/deferred.always/ }\`
-         * @since 1.6
-         * @example ​ ````Since the jQuery.get() method returns a jqXHR object, which is derived from a Deferred object, we can attach a callback for both success and error using the deferred.always() method.
-```javascript
-$.get( "test.php" ).always(function() {
-  alert( "$.get completed with success or error callback arguments" );
-});
-```
-         */
-        always(alwaysCallback: TypeOrArray<Deferred.Callback<TR | TJ>>,
-               ...alwaysCallbacks: Array<TypeOrArray<Deferred.Callback<TR | TJ>>>): this;
-        /**
-         * Add handlers to be called when the Deferred object is resolved.
-         *
-         * @param doneCallback A function, or array of functions, that are called when the Deferred is resolved.
-         * @param doneCallbacks Optional additional functions, or arrays of functions, that are called when the Deferred is resolved.
-         * @see \`{@link https://api.jquery.com/deferred.done/ }\`
-         * @since 1.5
-         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred object, we can attach a success callback using the .done() method.
-```javascript
-$.get( "test.php" ).done(function() {
-  alert( "$.get succeeded" );
-});
-```
-         * @example ​ ````Resolve a Deferred object when the user clicks a button, triggering a number of callback functions:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>deferred.done demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Go</button>
-<p>Ready...</p>
-​
-<script>
-// 3 functions to call when the Deferred object is resolved
-function fn1() {
-  $( "p" ).append( " 1 " );
-}
-function fn2() {
-  $( "p" ).append( " 2 " );
-}
-function fn3( n ) {
-  $( "p" ).append( n + " 3 " + n );
-}
-​
-// Create a deferred object
-var dfd = $.Deferred();
-​
-// Add handlers to be called when dfd is resolved
-dfd
-// .done() can take any number of functions or arrays of functions
-  .done( [ fn1, fn2 ], fn3, [ fn2, fn1 ] )
-// We can chain done methods, too
-  .done(function( n ) {
-    $( "p" ).append( n + " we're done." );
-  });
-​
-// Resolve the Deferred object when the button is clicked
-$( "button" ).on( "click", function() {
-  dfd.resolve( "and" );
-});
-</script>
-​
-</body>
-</html>
-```
-         */
-        done(doneCallback: TypeOrArray<Deferred.Callback<TR>>,
-             ...doneCallbacks: Array<TypeOrArray<Deferred.Callback<TR>>>): this;
-        /**
-         * Add handlers to be called when the Deferred object is rejected.
-         *
-         * @param failCallback A function, or array of functions, that are called when the Deferred is rejected.
-         * @param failCallbacks Optional additional functions, or arrays of functions, that are called when the Deferred is rejected.
-         * @see \`{@link https://api.jquery.com/deferred.fail/ }\`
-         * @since 1.5
-         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred, you can attach a success and failure callback using the deferred.done() and deferred.fail() methods.
-```javascript
-$.get( "test.php" )
-  .done(function() {
-    alert( "$.get succeeded" );
-  })
-  .fail(function() {
-    alert( "$.get failed!" );
-  });
-```
-         */
-        fail(failCallback: TypeOrArray<Deferred.Callback<TJ>>,
-             ...failCallbacks: Array<TypeOrArray<Deferred.Callback<TJ>>>): this;
-        /**
-         * Add handlers to be called when the Deferred object generates progress notifications.
-         *
-         * @param progressCallback A function, or array of functions, to be called when the Deferred generates progress notifications.
-         * @param progressCallbacks Optional additional functions, or arrays of functions, to be called when the Deferred generates
-         *                          progress notifications.
-         * @see \`{@link https://api.jquery.com/deferred.progress/ }\`
-         * @since 1.7
-         */
-        progress(progressCallback: TypeOrArray<Deferred.Callback<TN>>,
-                 ...progressCallbacks: Array<TypeOrArray<Deferred.Callback<TN>>>): this;
-        /**
-         * Return a Deferred's Promise object.
-         *
-         * @param target Object onto which the promise methods have to be attached
-         * @see \`{@link https://api.jquery.com/deferred.promise/ }\`
-         * @since 1.5
-         * @example ​ ````Use the target argument to promote an existing object to a Promise:
-```javascript
-// Existing object
-var obj = {
-    hello: function( name ) {
-      alert( "Hello " + name );
-    }
-  },
-  // Create a Deferred
-  defer = $.Deferred();
-​
-// Set object as a promise
-defer.promise( obj );
-​
-// Resolve the deferred
-defer.resolve( "John" );
-​
-// Use the object as a Promise
-obj.done(function( name ) {
-  obj.hello( name ); // Will alert "Hello John"
-}).hello( "Karl" ); // Will alert "Hello Karl"
-```
-         */
-        promise<TTarget extends object>(target: TTarget): Promise<TR, TJ, TN> & TTarget;
-        /**
-         * Return a Deferred's Promise object.
-         *
-         * @see \`{@link https://api.jquery.com/deferred.promise/ }\`
-         * @since 1.5
-         * @example ​ ````Create a Deferred and set two timer-based functions to either resolve or reject the Deferred after a random interval. Whichever one fires first &quot;wins&quot; and will call one of the callbacks. The second timeout has no effect since the Deferred is already complete (in a resolved or rejected state) from the first timeout action. Also set a timer-based progress notification function, and call a progress handler that adds &quot;working...&quot; to the document body.
-```javascript
-function asyncEvent() {
-  var dfd = jQuery.Deferred();
-​
-  // Resolve after a random interval
-  setTimeout(function() {
-    dfd.resolve( "hurray" );
-  }, Math.floor( 400 + Math.random() * 2000 ) );
-​
-  // Reject after a random interval
-  setTimeout(function() {
-    dfd.reject( "sorry" );
-  }, Math.floor( 400 + Math.random() * 2000 ) );
-​
-  // Show a "working..." message every half-second
-  setTimeout(function working() {
-    if ( dfd.state() === "pending" ) {
-      dfd.notify( "working... " );
-      setTimeout( working, 500 );
-    }
-  }, 1 );
-​
-  // Return the Promise so caller can't change the Deferred
-  return dfd.promise();
-}
-​
-// Attach a done, fail, and progress handler for the asyncEvent
-$.when( asyncEvent() ).then(
-  function( status ) {
-    alert( status + ", things are going well" );
-  },
-  function( status ) {
-    alert( status + ", you fail this time" );
-  },
-  function( status ) {
-    $( "body" ).append( status );
-  }
-);
-```
-         */
-        promise(): Promise<TR, TJ, TN>;
-        /**
-         * Determine the current state of a Deferred object.
-         *
-         * @see \`{@link https://api.jquery.com/deferred.state/ }\`
-         * @since 1.7
-         */
-        state(): 'pending' | 'resolved' | 'rejected';
-
-        // region pipe
-        // #region pipe
-
-        /**
-         * Utility method to filter and/or chain Deferreds.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
-         * @since 1.6
-         * @since 1.7
-         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
-         *
-         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
-         *
-         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
-         * @example ​ ````Filter resolve value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.pipe(function( value ) {
-    return value * 2;
-  });
-​
-defer.resolve( 5 );
-filtered.done(function( value ) {
-  alert( "Value is ( 2*5 = ) 10: " + value );
-});
-```
-         * @example ​ ````Filter reject value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.pipe( null, function( value ) {
-    return value * 3;
-  });
-​
-defer.reject( 6 );
-filtered.fail(function( value ) {
-  alert( "Value is ( 3*6 = ) 18: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.pipe(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        pipe<ARD = never, AJD = never, AND = never,
-            BRD = never, BJD = never, BND = never,
-            CRD = never, CJD = never, CND = never,
-            RRD = never, RJD = never, RND = never,
-            ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never,
-            ARP = never, AJP = never, ANP = never,
-            BRP = never, BJP = never, BNP = never,
-            CRP = never, CJP = never, CNP = never,
-            RRP = never, RJP = never, RNP = never>(
-                doneFilter: (...t: TR[]) => PromiseBase<ARD, AJD, AND,
-                    BRD, BJD, BND,
-                    CRD, CJD, CND,
-                    RRD, RJD, RND> | Thenable<ARD> | ARD,
-                failFilter: (...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<AJF> | AJF,
-                progressFilter: (...t: TN[]) => PromiseBase<ARP, AJP, ANP,
-                    BRP, BJP, BNP,
-                    CRP, CJP, CNP,
-                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP,
-            BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP,
-            CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP,
-            RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>;
-        /**
-         * Utility method to filter and/or chain Deferreds.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
-         * @since 1.6
-         * @since 1.7
-         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
-         *
-         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
-         *
-         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
-         * @example ​ ````Filter reject value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.pipe( null, function( value ) {
-    return value * 3;
-  });
-​
-defer.reject( 6 );
-filtered.fail(function( value ) {
-  alert( "Value is ( 3*6 = ) 18: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.pipe(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        pipe<ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never,
-            ARP = never, AJP = never, ANP = never,
-            BRP = never, BJP = never, BNP = never,
-            CRP = never, CJP = never, CNP = never,
-            RRP = never, RJP = never, RNP = never>(
-                doneFilter: null,
-                failFilter: (...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<AJF> | AJF,
-                progressFilter: (...t: TN[]) => PromiseBase<ARP, AJP, ANP,
-                    BRP, BJP, BNP,
-                    CRP, CJP, CNP,
-                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP,
-            BRF | BRP, BJF | BJP, BNF | BNP,
-            CRF | CRP, CJF | CJP, CNF | CNP,
-            RRF | RRP, RJF | RJP, RNF | RNP>;
-        /**
-         * Utility method to filter and/or chain Deferreds.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
-         * @since 1.6
-         * @since 1.7
-         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
-         *
-         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
-         *
-         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
-         * @example ​ ````Filter resolve value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.pipe(function( value ) {
-    return value * 2;
-  });
-​
-defer.resolve( 5 );
-filtered.done(function( value ) {
-  alert( "Value is ( 2*5 = ) 10: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.pipe(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        pipe<ARD = never, AJD = never, AND = never,
-            BRD = never, BJD = never, BND = never,
-            CRD = never, CJD = never, CND = never,
-            RRD = never, RJD = never, RND = never,
-            ARP = never, AJP = never, ANP = never,
-            BRP = never, BJP = never, BNP = never,
-            CRP = never, CJP = never, CNP = never,
-            RRP = never, RJP = never, RNP = never>(
-                doneFilter: (...t: TR[]) => PromiseBase<ARD, AJD, AND,
-                    BRD, BJD, BND,
-                    CRD, CJD, CND,
-                    RRD, RJD, RND> | Thenable<ARD> | ARD,
-                failFilter: null,
-                progressFilter: (...t: TN[]) => PromiseBase<ARP, AJP, ANP,
-                    BRP, BJP, BNP,
-                    CRP, CJP, CNP,
-                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARP, AJD | AJP, AND | ANP,
-            BRD | BRP, BJD | BJP, BND | BNP,
-            CRD | CRP, CJD | CJP, CND | CNP,
-            RRD | RRP, RJD | RJP, RND | RNP>;
-        /**
-         * Utility method to filter and/or chain Deferreds.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
-         * @since 1.6
-         * @since 1.7
-         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
-         *
-         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
-         *
-         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.pipe(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        pipe<ARP = never, AJP = never, ANP = never,
-            BRP = never, BJP = never, BNP = never,
-            CRP = never, CJP = never, CNP = never,
-            RRP = never, RJP = never, RNP = never>(
-                doneFilter: null,
-                failFilter: null,
-                progressFilter?: (...t: TN[]) => PromiseBase<ARP, AJP, ANP,
-                    BRP, BJP, BNP,
-                    CRP, CJP, CNP,
-                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP,
-            BRP, BJP, BNP,
-            CRP, CJP, CNP,
-            RRP, RJP, RNP>;
-        /**
-         * Utility method to filter and/or chain Deferreds.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
-         * @since 1.6
-         * @since 1.7
-         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
-         *
-         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
-         *
-         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
-         * @example ​ ````Filter resolve value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.pipe(function( value ) {
-    return value * 2;
-  });
-​
-defer.resolve( 5 );
-filtered.done(function( value ) {
-  alert( "Value is ( 2*5 = ) 10: " + value );
-});
-```
-         * @example ​ ````Filter reject value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.pipe( null, function( value ) {
-    return value * 3;
-  });
-​
-defer.reject( 6 );
-filtered.fail(function( value ) {
-  alert( "Value is ( 3*6 = ) 18: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.pipe(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        pipe<ARD = never, AJD = never, AND = never,
-            BRD = never, BJD = never, BND = never,
-            CRD = never, CJD = never, CND = never,
-            RRD = never, RJD = never, RND = never,
-            ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never>(
-                doneFilter: (...t: TR[]) => PromiseBase<ARD, AJD, AND,
-                    BRD, BJD, BND,
-                    CRD, CJD, CND,
-                    RRD, RJD, RND> | Thenable<ARD> | ARD,
-                failFilter: (...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<AJF> | AJF,
-                progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF,
-            BRD | BRF, BJD | BJF, BND | BNF,
-            CRD | CRF, CJD | CJF, CND | CNF,
-            RRD | RRF, RJD | RJF, RND | RNF>;
-        /**
-         * Utility method to filter and/or chain Deferreds.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
-         * @since 1.6
-         * @since 1.7
-         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
-         *
-         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
-         *
-         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
-         * @example ​ ````Filter reject value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.pipe( null, function( value ) {
-    return value * 3;
-  });
-​
-defer.reject( 6 );
-filtered.fail(function( value ) {
-  alert( "Value is ( 3*6 = ) 18: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.pipe(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        pipe<ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never>(
-                doneFilter: null,
-                failFilter: (...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<AJF> | AJF,
-                progressFilter?: null): PromiseBase<ARF, AJF, ANF,
-            BRF, BJF, BNF,
-            CRF, CJF, CNF,
-            RRF, RJF, RNF>;
-        /**
-         * Utility method to filter and/or chain Deferreds.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
-         * @since 1.6
-         * @since 1.7
-         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
-         *
-         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
-         *
-         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
-         * @example ​ ````Filter resolve value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.pipe(function( value ) {
-    return value * 2;
-  });
-​
-defer.resolve( 5 );
-filtered.done(function( value ) {
-  alert( "Value is ( 2*5 = ) 10: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.pipe(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        pipe<ARD = never, AJD = never, AND = never,
-            BRD = never, BJD = never, BND = never,
-            CRD = never, CJD = never, CND = never,
-            RRD = never, RJD = never, RND = never>(
-                doneFilter: (...t: TR[]) => PromiseBase<ARD, AJD, AND,
-                    BRD, BJD, BND,
-                    CRD, CJD, CND,
-                    RRD, RJD, RND> | Thenable<ARD> | ARD,
-                failFilter?: null,
-                progressFilter?: null): PromiseBase<ARD, AJD, AND,
-            BRD, BJD, BND,
-            CRD, CJD, CND,
-            RRD, RJD, RND>;
-
-        // #endregion
-
-        // region then
-        // #region then
-
-        /**
-         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
-         *
-         * @param doneFilter A function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
-         * @since 1.8
-         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred object, we can attach handlers using the .then method.
-```javascript
-$.get( "test.php" ).then(
-  function() {
-    alert( "$.get succeeded" );
-  }, function() {
-    alert( "$.get failed!" );
-  }
-);
-```
-         * @example ​ ````Filter the resolve value:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>deferred.then demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Filter Resolve</button>
-<p></p>
-​
-<script>
-var filterResolve = function() {
-  var defer = $.Deferred(),
-    filtered = defer.then(function( value ) {
-      return value * 2;
-    });
-​
-  defer.resolve( 5 );
-  filtered.done(function( value ) {
-    $( "p" ).html( "Value is ( 2*5 = ) 10: " + value );
-  });
-};
-​
-$( "button" ).on( "click", filterResolve );
-</script>
-​
-</body>
-</html>
-```
-         * @example ​ ````Filter reject value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.then( null, function( value ) {
-    return value * 3;
-  });
-​
-defer.reject( 6 );
-filtered.fail(function( value ) {
-  alert( "Value is ( 3*6 = ) 18: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.then(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        then<ARD = never, AJD = never, AND = never,
-            BRD = never, BJD = never, BND = never,
-            CRD = never, CJD = never, CND = never,
-            RRD = never, RJD = never, RND = never,
-            ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never,
-            ARP = never, AJP = never, ANP = never,
-            BRP = never, BJP = never, BNP = never,
-            CRP = never, CJP = never, CNP = never,
-            RRP = never, RJP = never, RNP = never>(
-                doneFilter: (...t: TR[]) => PromiseBase<ARD, AJD, AND,
-                    BRD, BJD, BND,
-                    CRD, CJD, CND,
-                    RRD, RJD, RND> | Thenable<ARD> | ARD,
-                failFilter: (...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<ARF> | ARF,
-                progressFilter: (...t: TN[]) => PromiseBase<ARP, AJP, ANP,
-                    BRP, BJP, BNP,
-                    CRP, CJP, CNP,
-                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP,
-            BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP,
-            CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP,
-            RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>;
-        /**
-         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
-         *
-         * @param doneFilter A function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
-         * @since 1.8
-         * @example ​ ````Filter reject value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.then( null, function( value ) {
-    return value * 3;
-  });
-​
-defer.reject( 6 );
-filtered.fail(function( value ) {
-  alert( "Value is ( 3*6 = ) 18: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.then(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        then<ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never,
-            ARP = never, AJP = never, ANP = never,
-            BRP = never, BJP = never, BNP = never,
-            CRP = never, CJP = never, CNP = never,
-            RRP = never, RJP = never, RNP = never>(
-                doneFilter: null,
-                failFilter: (...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<ARF> | ARF,
-                progressFilter: (...t: TN[]) => PromiseBase<ARP, AJP, ANP,
-                    BRP, BJP, BNP,
-                    CRP, CJP, CNP,
-                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP,
-            BRF | BRP, BJF | BJP, BNF | BNP,
-            CRF | CRP, CJF | CJP, CNF | CNP,
-            RRF | RRP, RJF | RJP, RNF | RNP>;
-        /**
-         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
-         *
-         * @param doneFilter A function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
-         * @since 1.8
-         * @example ​ ````Filter the resolve value:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>deferred.then demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Filter Resolve</button>
-<p></p>
-​
-<script>
-var filterResolve = function() {
-  var defer = $.Deferred(),
-    filtered = defer.then(function( value ) {
-      return value * 2;
-    });
-​
-  defer.resolve( 5 );
-  filtered.done(function( value ) {
-    $( "p" ).html( "Value is ( 2*5 = ) 10: " + value );
-  });
-};
-​
-$( "button" ).on( "click", filterResolve );
-</script>
-​
-</body>
-</html>
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.then(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        then<ARD = never, AJD = never, AND = never,
-            BRD = never, BJD = never, BND = never,
-            CRD = never, CJD = never, CND = never,
-            RRD = never, RJD = never, RND = never,
-            ARP = never, AJP = never, ANP = never,
-            BRP = never, BJP = never, BNP = never,
-            CRP = never, CJP = never, CNP = never,
-            RRP = never, RJP = never, RNP = never>(
-                doneFilter: (...t: TR[]) => PromiseBase<ARD, AJD, AND,
-                    BRD, BJD, BND,
-                    CRD, CJD, CND,
-                    RRD, RJD, RND> | Thenable<ARD> | ARD,
-                failFilter: null,
-                progressFilter: (...t: TN[]) => PromiseBase<ARP, AJP, ANP,
-                    BRP, BJP, BNP,
-                    CRP, CJP, CNP,
-                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARP, AJD | AJP, AND | ANP,
-            BRD | BRP, BJD | BJP, BND | BNP,
-            CRD | CRP, CJD | CJP, CND | CNP,
-            RRD | RRP, RJD | RJP, RND | RNP>;
-        /**
-         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
-         *
-         * @param doneFilter A function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
-         * @since 1.8
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.then(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        then<ARP = never, AJP = never, ANP = never,
-            BRP = never, BJP = never, BNP = never,
-            CRP = never, CJP = never, CNP = never,
-            RRP = never, RJP = never, RNP = never>(
-                doneFilter: null,
-                failFilter: null,
-                progressFilter?: (...t: TN[]) => PromiseBase<ARP, AJP, ANP,
-                    BRP, BJP, BNP,
-                    CRP, CJP, CNP,
-                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP,
-            BRP, BJP, BNP,
-            CRP, CJP, CNP,
-            RRP, RJP, RNP>;
-        /**
-         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
-         * @since 1.8
-         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred object, we can attach handlers using the .then method.
-```javascript
-$.get( "test.php" ).then(
-  function() {
-    alert( "$.get succeeded" );
-  }, function() {
-    alert( "$.get failed!" );
-  }
-);
-```
-         * @example ​ ````Filter the resolve value:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>deferred.then demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Filter Resolve</button>
-<p></p>
-​
-<script>
-var filterResolve = function() {
-  var defer = $.Deferred(),
-    filtered = defer.then(function( value ) {
-      return value * 2;
-    });
-​
-  defer.resolve( 5 );
-  filtered.done(function( value ) {
-    $( "p" ).html( "Value is ( 2*5 = ) 10: " + value );
-  });
-};
-​
-$( "button" ).on( "click", filterResolve );
-</script>
-​
-</body>
-</html>
-```
-         * @example ​ ````Filter reject value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.then( null, function( value ) {
-    return value * 3;
-  });
-​
-defer.reject( 6 );
-filtered.fail(function( value ) {
-  alert( "Value is ( 3*6 = ) 18: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.then(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        then<ARD = never, AJD = never, AND = never,
-            BRD = never, BJD = never, BND = never,
-            CRD = never, CJD = never, CND = never,
-            RRD = never, RJD = never, RND = never,
-            ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never>(
-                doneFilter: (...t: TR[]) => PromiseBase<ARD, AJD, AND,
-                    BRD, BJD, BND,
-                    CRD, CJD, CND,
-                    RRD, RJD, RND> | Thenable<ARD> | ARD,
-                failFilter: (...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<ARF> | ARF,
-                progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF,
-            BRD | BRF, BJD | BJF, BND | BNF,
-            CRD | CRF, CJD | CJF, CND | CNF,
-            RRD | RRF, RJD | RJF, RND | RNF>;
-        /**
-         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
-         * @since 1.8
-         * @example ​ ````Filter reject value:
-```javascript
-var defer = $.Deferred(),
-  filtered = defer.then( null, function( value ) {
-    return value * 3;
-  });
-​
-defer.reject( 6 );
-filtered.fail(function( value ) {
-  alert( "Value is ( 3*6 = ) 18: " + value );
-});
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.then(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        then<ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never>(
-                doneFilter: null,
-                failFilter: (...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<ARF> | ARF,
-                progressFilter?: null): PromiseBase<ARF, AJF, ANF,
-            BRF, BJF, BNF,
-            CRF, CJF, CNF,
-            RRF, RJF, RNF>;
-        /**
-         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
-         *
-         * @param doneFilter An optional function that is called when the Deferred is resolved.
-         * @param failFilter An optional function that is called when the Deferred is rejected.
-         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
-         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
-         * @since 1.8
-         * @example ​ ````Filter the resolve value:
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>deferred.then demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>Filter Resolve</button>
-<p></p>
-​
-<script>
-var filterResolve = function() {
-  var defer = $.Deferred(),
-    filtered = defer.then(function( value ) {
-      return value * 2;
-    });
-​
-  defer.resolve( 5 );
-  filtered.done(function( value ) {
-    $( "p" ).html( "Value is ( 2*5 = ) 10: " + value );
-  });
-};
-​
-$( "button" ).on( "click", filterResolve );
-</script>
-​
-</body>
-</html>
-```
-         * @example ​ ````Chain tasks:
-```javascript
-var request = $.ajax( url, { dataType: "json" } ),
-  chained = request.then(function( data ) {
-    return $.ajax( url2, { data: { user: data.userId } } );
-  });
-​
-chained.done(function( data ) {
-  // data retrieved from url2 as provided by the first request
-});
-```
-         */
-        then<ARD = never, AJD = never, AND = never,
-            BRD = never, BJD = never, BND = never,
-            CRD = never, CJD = never, CND = never,
-            RRD = never, RJD = never, RND = never>(
-                doneFilter: (...t: TR[]) => PromiseBase<ARD, AJD, AND,
-                    BRD, BJD, BND,
-                    CRD, CJD, CND,
-                    RRD, RJD, RND> | Thenable<ARD> | ARD,
-                failFilter?: null,
-                progressFilter?: null): PromiseBase<ARD, AJD, AND,
-            BRD, BJD, BND,
-            CRD, CJD, CND,
-            RRD, RJD, RND>;
-
-        // #endregion
-
-        /**
-         * Add handlers to be called when the Deferred object is rejected.
-         *
-         * @param failFilter A function that is called when the Deferred is rejected.
-         * @see \`{@link https://api.jquery.com/deferred.catch/ }\`
-         * @since 3.0
-         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred object, we can rejection handlers using the .catch method.
-```javascript
-$.get( "test.php" )
-  .then( function() {
-    alert( "$.get succeeded" );
-  } )
-  .catch( function() {
-    alert( "$.get failed!" );
-  } );
-```
-         */
-        catch<ARF = never, AJF = never, ANF = never,
-            BRF = never, BJF = never, BNF = never,
-            CRF = never, CJF = never, CNF = never,
-            RRF = never, RJF = never, RNF = never>(
-                failFilter?: ((...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
-                    BRF, BJF, BNF,
-                    CRF, CJF, CNF,
-                    RRF, RJF, RNF> | Thenable<ARF> | ARF) | null): PromiseBase<ARF, AJF, ANF,
-            BRF, BJF, BNF,
-            CRF, CJF, CNF,
-            RRF, RJF, RNF>;
-    }
-
-    namespace Deferred {
-        interface CallbackBase<T, U, V, R> {
-            (t: T, u: U, v: V, ...r: R[]): void;
-        }
-
-        interface Callback3<T, U, V> extends CallbackBase<T, U, V, never> { }
-
-        interface Callback<T> {
-            (...args: T[]): void;
-        }
-
-        /**
-         * @deprecated ​ Deprecated. Use \`{@link Callback }\`.
-         */
-        interface DoneCallback<TResolve> extends Callback<TResolve> { }
-
-        /**
-         * @deprecated ​ Deprecated. Use \`{@link Callback }\`.
-         */
-        interface FailCallback<TReject> extends Callback<TReject> { }
-
-        /**
-         * @deprecated ​ Deprecated. Use \`{@link Callback }\`.
-         */
-        interface AlwaysCallback<TResolve, TReject> extends Callback<TResolve | TReject> { }
-
-        /**
-         * @deprecated ​ Deprecated. Use \`{@link Callback }\`.
-         */
-        interface ProgressCallback<TNotify> extends Callback<TNotify> { }
-    }
-
-    // #endregion
-
-    // region Effects
-    // #region Effects
-
-    interface Effects {
-        /**
-         * The rate (in milliseconds) at which animations fire.
-         *
-         * @see \`{@link https://api.jquery.com/jQuery.fx.interval/ }\`
-         * @since 1.4.3
-         * @deprecated ​ Deprecated since 3.0. See \`{@link https://api.jquery.com/jQuery.fx.interval/ }\`.
-         *
-         * **Cause**: As of jQuery 3.0 the `jQuery.fx.interval` property can be used to change the animation interval only on browsers that do not support the `window.requestAnimationFrame()` method. That is currently only Internet Explorer 9 and the Android Browser. Once support is dropped for these browsers, the property will serve no purpose and it will be removed.
-         *
-         * **Solution**: Find and remove code that changes or uses `jQuery.fx.interval`. If the value is being used by code in your page or a plugin, the code may be making assumptions that are no longer valid. The default value of `jQuery.fx.interval` is `13` (milliseconds), which could be used instead of accessing this property.
-         * @example ​ ````Cause all animations to run with less frames.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.fx.interval demo</title>
-  <style>
-  div {
-    width: 50px;
-    height: 30px;
-    margin: 5px;
-    float: left;
-    background: green;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p><input type="button" value="Run"></p>
-<div></div>
-​
-<script>
-jQuery.fx.interval = 100;
-$( "input" ).click(function() {
-  $( "div" ).toggle( 3000 );
-});
-</script>
-</body>
-</html>
-```
-        */
-        interval: number;
-        /**
-         * Globally disable all animations.
-         *
-         * @see \`{@link https://api.jquery.com/jQuery.fx.off/ }\`
-         * @since 1.3
-         * @example ​ ````Toggle animation on and off
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>jQuery.fx.off demo</title>
-  <style>
-  div {
-    width: 50px;
-    height: 30px;
-    margin: 5px;
-    float: left;
-    background: green;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<input type="button" value="Run">
-<button>Toggle fx</button>
-<div></div>
-​
-<script>
-var toggleFx = function() {
-  $.fx.off = !$.fx.off;
-};
-toggleFx();
-$( "button" ).click( toggleFx );
-$( "input" ).click(function() {
-  $( "div" ).toggle( "slow" );
-});
-</script>
-</body>
-</html>
-```
-        */
-        off: boolean;
-        step: PlainObject<AnimationHook<Node>>;
-    }
-
-    type Duration = number | 'fast' | 'slow';
-    // TODO: Is the first element always a string or is that specific to the 'fx' queue?
-    type Queue<TElement> = { 0: string; } & Array<QueueFunction<TElement>>;
-
-    interface QueueFunction<TElement> {
-        (this: TElement, next: () => void): void;
-    }
-
-    /**
-     * @see \`{@link https://api.jquery.com/animate/#animate-properties-options }\`
-     */
-    interface EffectsOptions<TElement> {
-        /**
-         * A function to be called when the animation on an element completes or stops without completing (its
-         * Promise object is either resolved or rejected).
-         */
-        always?(this: TElement, animation: Promise<any>, jumpedToEnd: boolean): void;
-        /**
-         * A function that is called once the animation on an element is complete.
-         */
-        complete?(this: TElement): void;
-        /**
-         * A function to be called when the animation on an element completes (its Promise object is resolved).
-         */
-        done?(this: TElement, animation: Promise<any>, jumpedToEnd: boolean): void;
-        /**
-         * A string or number determining how long the animation will run.
-         */
-        duration?: Duration;
-        /**
-         * A string indicating which easing function to use for the transition.
-         */
-        easing?: string;
-        /**
-         * A function to be called when the animation on an element fails to complete (its Promise object is rejected).
-         */
-        fail?(this: TElement, animation: Promise<any>, jumpedToEnd: boolean): void;
-        /**
-         * A function to be called after each step of the animation, only once per animated element regardless
-         * of the number of animated properties.
-         */
-        progress?(this: TElement, animation: Promise<any>, progress: number, remainingMs: number): void;
-        /**
-         * A Boolean indicating whether to place the animation in the effects queue. If false, the animation
-         * will begin immediately. As of jQuery 1.7, the queue option can also accept a string, in which case
-         * the animation is added to the queue represented by that string. When a custom queue name is used the
-         * animation does not automatically start; you must call .dequeue("queuename") to start it.
-         */
-        queue?: boolean | string;
-        /**
-         * An object containing one or more of the CSS properties defined by the properties argument and their
-         * corresponding easing functions.
-         */
-        specialEasing?: PlainObject<string>;
-        /**
-         * A function to call when the animation on an element begins.
-         */
-        start?(this: TElement, animation: Promise<any>): void;
-        /**
-         * A function to be called for each animated property of each animated element. This function provides
-         * an opportunity to modify the Tween object to change the value of the property before it is set.
-         */
-        step?(this: TElement, now: number, tween: Tween<TElement>): void;
-    }
-
-    interface SpeedSettings<TElement> {
-        /**
-         * A string or number determining how long the animation will run.
-         */
-        duration?: Duration;
-        /**
-         * A string indicating which easing function to use for the transition.
-         */
-        easing?: string;
-        /**
-         * A function to call once the animation is complete.
-         */
-        complete?(this: TElement): void;
-    }
-
-    // This should be a class but doesn't work correctly under the JQuery namespace. Tween should be an inner class of jQuery.
-    // Undocumented
-    // https://github.com/jquery/api.jquery.com/issues/391
-    // https://github.com/jquery/api.jquery.com/issues/61
-    interface Tween<TElement> {
-        easing: string;
-        elem: TElement;
-        end: number;
-        now: number;
-        options: EffectsOptions<TElement>;
-        pos: number;
-        prop: string;
-        start: number;
-        unit: string;
-    }
-
-    interface AnimationHook<TElement> {
-        (fx: Tween<TElement>): void;
-    }
-
-    type EasingMethod = (percent: number) => number;
-
-    interface Easings {
-        [name: string]: EasingMethod;
-    }
-
-    // #endregion
-
-    // region Events
-    // #region Events
-
-    // region Event
-    // #region Event
-
-    // This should be a class but doesn't work correctly under the JQuery namespace. Event should be an inner class of jQuery.
-
-    // Static members
-    interface EventStatic {
-        // tslint:disable-next-line:no-unnecessary-generics
-        <T extends object, TTarget extends EventTarget = HTMLElement>(event: string, properties?: T): Event<TTarget> & T;
-        // tslint:disable-next-line:no-unnecessary-generics
-        <T extends EventLike, TTarget extends EventTarget = HTMLElement>(properties: T): Event<TTarget> & T;
-        // tslint:disable-next-line:no-unnecessary-generics
-        new <T extends object, TTarget extends EventTarget = HTMLElement>(event: string, properties?: T): Event<TTarget> & T;
-        // tslint:disable-next-line:no-unnecessary-generics
-        new <T extends EventLike, TTarget extends EventTarget = HTMLElement>(properties: T): Event<TTarget> & T;
-    }
-
-    // Instance members
-    interface Event {
-        // region Copied properties
-        // #region Copied properties
-
-        // region Event
-        // #region Event
-
-        bubbles?: boolean;
-        cancelable?: boolean;
-        eventPhase?: number;
-
-        // #endregion
-
-        // region UIEvent
-        // #region UIEvent
-
-        detail?: number;
-        view?: Window;
-
-        // #endregion
-
-        // region MouseEvent
-        // #region MouseEvent
-
-        button?: number;
-        buttons?: number;
-        clientX?: number;
-        clientY?: number;
-        offsetX?: number;
-        offsetY?: number;
-        /**
-         * The mouse position relative to the left edge of the document.
-         *
-         * @see \`{@link https://api.jquery.com/event.pageX/ }\`
-         * @since 1.0.4
-         * @example ​ ````Show the mouse position relative to the left and top edges of the document (within this iframe).
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>event.pageX demo</title>
-  <style>
-  body {
-    background-color: #eef;
-  }
-  div {
-    padding: 20px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-$( document ).on( "mousemove", function( event ) {
-  $( "#log" ).text( "pageX: " + event.pageX + ", pageY: " + event.pageY );
-});
-</script>
-​
-</body>
-</html>
-```
-         */
-        pageX: number;
-        /**
-         * The mouse position relative to the top edge of the document.
-         *
-         * @see \`{@link https://api.jquery.com/event.pageY/ }\`
-         * @since 1.0.4
-         * @example ​ ````Show the mouse position relative to the left and top edges of the document (within this iframe).
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>event.pageY demo</title>
-  <style>
-  body {
-    background-color: #eef;
-  }
-  div {
-    padding: 20px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-​
-<script>
-$( document ).on( "mousemove", function( event ) {
-  $( "#log" ).text( "pageX: " + event.pageX + ", pageY: " + event.pageY );
-});
-</script>
-​
-</body>
-</html>
-```
-         */
-        pageY: number;
-        screenX?: number;
-        screenY?: number;
-        /** @deprecated */
-        toElement?: Element;
-
-        // #endregion
-
-        // region PointerEvent
-        // #region PointerEvent
-
-        pointerId?: number;
-        pointerType?: string;
-
-        // #endregion
-
-        // region KeyboardEvent
-        // #region KeyboardEvent
-
-        /** @deprecated */
-        char?: string;
-        /** @deprecated */
-        charCode?: number;
-        key?: string;
-        /** @deprecated */
-        keyCode?: number;
-
-        // #endregion
-
-        // region TouchEvent
-        // #region TouchEvent
-
-        changedTouches?: TouchList;
-        targetTouches?: TouchList;
-        touches?: TouchList;
-
-        // #endregion
-
-        // region MouseEvent, KeyboardEvent, TouchEvent
-        // #region MouseEvent, KeyboardEvent, TouchEvent
-
-        altKey?: boolean;
-        ctrlKey?: boolean;
-        /**
-         * Indicates whether the META key was pressed when the event fired.
-         *
-         * @see \`{@link https://api.jquery.com/event.metaKey/ }\`
-         * @since 1.0.4
-         * @example ​ ````Determine whether the META key was pressed when the event fired.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>event.metaKey demo</title>
-  <style>
-  body {
-    background-color: #eef;
-  }
-  div {
-    padding: 20px;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button value="Test" name="Test" id="checkMetaKey">Click me!</button>
-<div id="display"></div>
-​
-<script>
-$( "#checkMetaKey" ).click(function( event ) {
-  $( "#display" ).text( event.metaKey );
-});
-</script>
-​
-</body>
-</html>
-```
-         */
-        metaKey: boolean;
-        shiftKey?: boolean;
-
-        // #endregion
-
-        // #endregion
-
-        /**
-         * The namespace specified when the event was triggered.
-         *
-         * @see \`{@link https://api.jquery.com/event.namespace/ }\`
-         * @since 1.4.3
-         * @example ​ ````Determine the event namespace used.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>event.namespace demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>display event.namespace</button>
-<p></p>
-​
-<script>
-$( "p" ).on( "test.something", function( event ) {
-  alert( event.namespace );
-});
-$( "button" ).click(function( event ) {
-  $( "p" ).trigger( "test.something" );
-});
-</script>
-​
-</body>
-</html>
-```
-         */
-        namespace: string;
-        /**
-         * The last value returned by an event handler that was triggered by this event, unless the value was undefined.
-         *
-         * @see \`{@link https://api.jquery.com/event.result/ }\`
-         * @since 1.3
-         * @example ​ ````Display previous handler&#39;s return value
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>event.result demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>display event.result</button>
-<p></p>
-​
-<script>
-$( "button" ).click(function( event ) {
-  return "hey";
-});
-$( "button" ).click(function( event ) {
-  $( "p" ).html( event.result );
-});
-</script>
-​
-</body>
-</html>
-```
-         */
-        result: any;
-        /**
-         * The difference in milliseconds between the time the browser created the event and January 1, 1970.
-         *
-         * @see \`{@link https://api.jquery.com/event.timeStamp/ }\`
-         * @since 1.2.6
-         * @example ​ ````Display the time since the click handler last executed.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>event.timeStamp demo</title>
-  <style>
-  div {
-    height: 100px;
-    width: 300px;
-    margin: 10px;
-    background-color: #ffd;
-    overflow: auto;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div>Click.</div>
-​
-<script>
-var last, diff;
-$( "div" ).click(function( event ) {
-  if ( last ) {
-    diff = event.timeStamp - last;
-    $( "div" ).append( "time since last event: " + diff + "<br>" );
-  } else {
-    $( "div" ).append( "Click again.<br>" );
-  }
-  last = event.timeStamp;
-});
-</script>
-​
-</body>
-</html>
-```
-         */
-        timeStamp: number;
-        /**
-         * Describes the nature of the event.
-         *
-         * @see \`{@link https://api.jquery.com/event.type/ }\`
-         * @since 1.0
-         * @example ​ ````On all anchor clicks, alert the event type.
-```javascript
-$( "a" ).click(function( event ) {
-  alert( event.type ); // "click"
-});
-```
-         */
-        type: string;
-        /**
-         * For key or mouse events, this property indicates the specific key or button that was pressed.
-         *
-         * @see \`{@link https://api.jquery.com/event.which/ }\`
-         * @since 1.1.3
-         * @example ​ ````Log which key was depressed.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>event.which demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<input id="whichkey" value="type something">
-<div id="log"></div>
-​
-<script>
-$( "#whichkey" ).on( "keydown", function( event ) {
-  $( "#log" ).html( event.type + ": " +  event.which );
-});
-</script>
-​
-</body>
-</html>
-```
-         * @example ​ ````Log which mouse button was depressed.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>event.which demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<input id="whichkey" value="click here">
-<div id="log"></div>
-​
-<script>
-$( "#whichkey" ).on( "mousedown", function( event ) {
-  $( "#log" ).html( event.type + ": " +  event.which );
-});
-</script>
-​
-</body>
-</html>
-```
-         */
-        which: number;
-        /**
-         * Returns whether event.preventDefault() was ever called on this event object.
-         *
-         * @see \`{@link https://api.jquery.com/event.isDefaultPrevented/ }\`
-         * @since 1.3
-         * @example ​ ````Checks whether event.preventDefault() was called.
-```javascript
-$( "a" ).click(function( event ) {
-  alert( event.isDefaultPrevented() ); // false
-  event.preventDefault();
-  alert( event.isDefaultPrevented() ); // true
-});
-```
-         */
-        isDefaultPrevented(): boolean;
-        /**
-         * Returns whether event.stopImmediatePropagation() was ever called on this event object.
-         *
-         * @see \`{@link https://api.jquery.com/event.isImmediatePropagationStopped/ }\`
-         * @since 1.3
-         * @example ​ ````Checks whether event.stopImmediatePropagation() was called.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>event.isImmediatePropagationStopped demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>click me</button>
-<div id="stop-log"></div>
-  ​
-<script>
-function immediatePropStopped( event ) {
-  var msg = "";
-  if ( event.isImmediatePropagationStopped() ) {
-    msg = "called";
-  } else {
-    msg = "not called";
-  }
-  $( "#stop-log" ).append( "<div>" + msg + "</div>" );
-}
-​
-$( "button" ).click(function( event ) {
-  immediatePropStopped( event );
-  event.stopImmediatePropagation();
-  immediatePropStopped( event );
-});
-</script>
-​
-</body>
-</html>
-```
-         */
-        isImmediatePropagationStopped(): boolean;
-        /**
-         * Returns whether event.stopPropagation() was ever called on this event object.
-         *
-         * @see \`{@link https://api.jquery.com/event.isPropagationStopped/ }\`
-         * @since 1.3
-         * @example ​ ````Checks whether event.stopPropagation() was called
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>event.isPropagationStopped demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button>click me</button>
-<div id="stop-log"></div>
-  ​
-<script>
-function propStopped( event ) {
-  var msg = "";
-  if ( event.isPropagationStopped() ) {
-    msg = "called";
-  } else {
-    msg = "not called";
-  }
-  $( "#stop-log" ).append( "<div>" + msg + "</div>" );
-}
-​
-$( "button" ).click(function(event) {
-  propStopped( event );
-  event.stopPropagation();
-  propStopped( event );
-});
-</script>
-​
-</body>
-</html>
-```
-         */
-        isPropagationStopped(): boolean;
-        /**
-         * If this method is called, the default action of the event will not be triggered.
-         *
-         * @see \`{@link https://api.jquery.com/event.preventDefault/ }\`
-         * @since 1.0
-         * @example ​ ````Cancel the default action (navigation) of the click.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>event.preventDefault demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<a href="https://jquery.com">default click action is prevented</a>
-<div id="log"></div>
-​
-<script>
-$( "a" ).click(function( event ) {
-  event.preventDefault();
-  $( "<div>" )
-    .append( "default " + event.type + " prevented" )
-    .appendTo( "#log" );
-});
-</script>
-​
-</body>
-</html>
-```
-         */
-        preventDefault(): void;
-        /**
-         * Keeps the rest of the handlers from being executed and prevents the event from bubbling up the DOM tree.
-         *
-         * @see \`{@link https://api.jquery.com/event.stopImmediatePropagation/ }\`
-         * @since 1.3
-         * @example ​ ````Prevents other event handlers from being called.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>event.stopImmediatePropagation demo</title>
-  <style>
-  p {
-    height: 30px;
-    width: 150px;
-    background-color: #ccf;
-  }
-  div {
-    height: 30px;
-    width: 150px;
-    background-color: #cfc;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<p>paragraph</p>
-<div>division</div>
-​
-<script>
-$( "p" ).click(function( event ) {
-  event.stopImmediatePropagation();
-});
-$( "p" ).click(function( event ) {
-  // This function won't be executed
-  $( this ).css( "background-color", "#f00" );
-});
-$( "div" ).click(function( event ) {
-  // This function will be executed
-  $( this ).css( "background-color", "#f00" );
-});
-</script>
-​
-</body>
-</html>
-```
-         */
-        stopImmediatePropagation(): void;
-        /**
-         * Prevents the event from bubbling up the DOM tree, preventing any parent handlers from being notified of the event.
-         *
-         * @see \`{@link https://api.jquery.com/event.stopPropagation/ }\`
-         * @since 1.0
-         * @example ​ ````Kill the bubbling on the click event.
-```javascript
-$( "p" ).click(function( event ) {
-  event.stopPropagation();
-  // Do something
-});
-```
-         */
-        stopPropagation(): void;
-    }
-
-    // Generic members
-    interface Event<
-        TTarget = EventTarget,
-        TData = null
-    > {
-        /**
-         * The current DOM element within the event bubbling phase.
-         *
-         * @see \`{@link https://api.jquery.com/event.currentTarget/ }\`
-         * @since 1.3
-         * @example ​ ````Alert that currentTarget matches the `this` keyword.
-```javascript
-$( "p" ).click(function( event ) {
-  alert( event.currentTarget === this ); // true
-});
-```
-         */
-        currentTarget: TTarget;
-        /**
-         * An optional object of data passed to an event method when the current executing handler is bound.
-         *
-         * @see \`{@link https://api.jquery.com/event.data/ }\`
-         * @since 1.1
-         * @example ​ ````Within a for loop, pass the value of i to the .on() method so that the current iteration&#39;s value is preserved.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>event.data demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<button> 0 </button>
-<button> 1 </button>
-<button> 2 </button>
-<button> 3 </button>
-<button> 4 </button>
-​
-<div id="log"></div>
-​
-<script>
-var logDiv = $( "#log" );
-​
-for ( var i = 0; i < 5; i++ ) {
-  $( "button" ).eq( i ).on( "click", { value: i }, function( event ) {
-    var msgs = [
-      "button = " + $( this ).index(),
-      "event.data.value = " + event.data.value,
-      "i = " + i
-    ];
-    logDiv.append( msgs.join( ", " ) + "<br>" );
-  });
-}
-</script>
-​
-</body>
-</html>
-```
-         */
-        data: TData;
-        /**
-         * The element where the currently-called jQuery event handler was attached.
-         *
-         * @see \`{@link https://api.jquery.com/event.delegateTarget/ }\`
-         * @since 1.7
-         * @example ​ ````When a button in any box class is clicked, change the box&#39;s background color to red.
-```javascript
-$( ".box" ).on( "click", "button", function( event ) {
-  $( event.delegateTarget ).css( "background-color", "red" );
-});
-```
-         */
-        delegateTarget: TTarget;
-        originalEvent: _Event;
-        /**
-         * The other DOM element involved in the event, if any.
-         *
-         * @see \`{@link https://api.jquery.com/event.relatedTarget/ }\`
-         * @since 1.1.4
-         * @example ​ ````On mouseout of anchors, alert the element type being entered.
-```javascript
-$( "a" ).mouseout(function( event ) {
-  alert( event.relatedTarget.nodeName ); // "DIV"
-});
-```
-         */
-        relatedTarget: TTarget | null;
-        /**
-         * The DOM element that initiated the event.
-         *
-         * @see \`{@link https://api.jquery.com/event.target/ }\`
-         * @since 1.0
-         * @example ​ ````Display the tag&#39;s name on click
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>event.target demo</title>
-  <style>
-  span, strong, p {
-    padding: 8px;
-    display: block;
-    border: 1px solid #999;
-  }
-  </style>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<div id="log"></div>
-<div>
-  <p>
-    <strong><span>click</span></strong>
-  </p>
-</div>
-​
-<script>
-$( "body" ).click(function( event ) {
-  $( "#log" ).html( "clicked: " + event.target.nodeName );
-});
-</script>
-​
-</body>
-</html>
-```
-         * @example ​ ````Implements a simple event delegation: The click handler is added to an unordered list, and the children of its li children are hidden. Clicking one of the li children toggles (see toggle()) their children.
-```html
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>event.target demo</title>
-  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
-</head>
-<body>
-​
-<ul>
-  <li>item 1
-    <ul>
-      <li>sub item 1-a</li>
-      <li>sub item 1-b</li>
-    </ul>
-  </li>
-  <li>item 2
-    <ul>
-      <li>sub item 2-a</li>
-      <li>sub item 2-b</li>
-    </ul>
-  </li>
-</ul>
-​
-<script>
-function handler( event ) {
-  var target = $( event.target );
-  if ( target.is( "li" ) ) {
-    target.children().toggle();
-  }
-}
-$( "ul" ).click( handler ).find( "ul" ).hide();
-</script>
-​
-</body>
-</html>
-```
-         */
-        target: TTarget;
-    }
-
-    interface EventLike {
-        type: string;
-    }
-
-    // #endregion
-
-    interface EventHandler<TCurrentTarget, TData = null> extends EventHandlerBase<TCurrentTarget, Event<TCurrentTarget, TData>> { }
-
-    interface EventHandlerBase<TContext, T> {
-        // Extra parameters can be passed from trigger()
-        (this: TContext, t: T, ...args: any[]): void | false | any;
-    }
-
-    // region Event extensions
-    // #region Event extensions
-
-    interface EventExtensions {
-        /**
-         * jQuery defines an \`@{link https://api.jquery.com/category/events/event-object/ Event object}\` that
-         * represents a cross-browser subset of the information available when an event occurs. The `jQuery.event.props`
-         * property is an array of string names for properties that are always copied when jQuery processes a
-         * native browser event. (Events fired in code by `.trigger()` do not use this list, since the code can
-         * construct a `jQuery.Event` object with the needed values and trigger using that object.)
-         *
-         * To add a property name to this list, use `jQuery.event.props.push( "newPropertyName" )`. However, be
-         * aware that every event processed by jQuery will now attempt to copy this property name from the native
-         * browser event to jQuery's constructed event. If the property does not exist for that event type, it
-         * will get an undefined value. Adding many properties to this list can significantly reduce event
-         * delivery performance, so for infrequently-needed properties it is more efficient to use the value
-         * directly from `event.originalEvent` instead. If properties must be copied, you are strongly advised
-         * to use `jQuery.event.fixHooks` as of version 1.7.
-         *
-         * @see \`{@link https://learn.jquery.com/events/event-extensions/#jquery-event-props-array }\`
-         */
-        props: string[];
-        /**
-         * The `fixHooks` interface provides a per-event-type way to extend or normalize the event object that
-         * jQuery creates when it processes a _native_ browser event.
-         *
-         * @see \`{@link https://learn.jquery.com/events/event-extensions/#jquery-event-fixhooks-object }\`
-         */
-        fixHooks: FixHooks;
-        /**
-         * The jQuery special event hooks are a set of per-event-name functions and properties that allow code
-         * to control the behavior of event processing within jQuery. The mechanism is similar to `fixHooks` in
-         * that the special event information is stored in `jQuery.event.special.NAME`, where `NAME` is the
-         * name of the special event. Event names are case sensitive.
-         *
-         * As with `fixHooks`, the special event hooks design assumes it will be very rare that two unrelated
-         * pieces of code want to process the same event name. Special event authors who need to modify events
-         * with existing hooks will need to take precautions to avoid introducing unwanted side-effects by
-         * clobbering those hooks.
-         *
-         * @see \`{@link https://learn.jquery.com/events/event-extensions/#special-event-hooks }\`
-         */
-        special: SpecialEventHooks;
-    }
-
-    interface FixHook {
-        /**
-         * Strings representing properties that should be copied from the browser's event object to the jQuery
-         * event object. If omitted, no additional properties are copied beyond the standard ones that jQuery
-         * copies and normalizes (e.g. `event.target` and `event.relatedTarget`).
-         */
-        props?: string[];
-        /**
-         * jQuery calls this function after it constructs the `jQuery.Event` object, copies standard properties
-         * from `jQuery.event.props`, and copies the `fixHooks`-specific props (if any) specified above. The
-         * function can create new properties on the event object or modify existing ones. The second argument
-         * is the browser's native event object, which is also available in `event.originalEvent`.
-         *
-         * Note that for all events, the browser's native event object is available in `event.originalEvent`;
-         * if the jQuery event handler examines the properties there instead of jQuery's normalized `event`
-         * object, there is no need to create a `fixHooks` entry to copy or modify the properties.
-         *
-         * @example ​ ````For example, to set a hook for the "drop" event that copies the `dataTransfer` property, assign an object to `jQuery.event.fixHooks.drop`:
-```javascript
-jQuery.event.fixHooks.drop = {
-    props: [ "dataTransfer" ]
-};
-```
-
-Since fixHooks is an advanced feature and rarely used externally, jQuery does not include code or
-interfaces to deal with conflict resolution. If there is a chance that some other code may be assigning
-`fixHooks` to the same events, the code should check for an existing hook and take appropriate measures.
-A simple solution might look like this:
-
-```javascript
-if ( jQuery.event.fixHooks.drop ) {
-    throw new Error( "Someone else took the jQuery.event.fixHooks.drop hook!" );
-}
-
-jQuery.event.fixHooks.drop = {
-    props: [ "dataTransfer" ]
-};
-```
-
-When there are known cases of different plugins wanting to attach to the drop hook, this solution might be more appropriate:
-
-```javascript
-var existingHook = jQuery.event.fixHooks.drop;
-
-if ( !existingHook ) {
-    jQuery.event.fixHooks.drop = {
-        props: [ "dataTransfer" ]
-    };
-} else {
-    if ( existingHook.props ) {
-        existingHook.props.push( "dataTransfer" );
-    } else {
-        existingHook.props = [ "dataTransfer" ];
-    }
-}
-```
-         */
-        filter?(event: Event, originalEvent: _Event): void;
-    }
-
-    /**
-     * The `fixHooks` interface provides a per-event-type way to extend or normalize the event object that
-     * jQuery creates when it processes a _native_ browser event.
-     *
-     * @see \`{@link https://learn.jquery.com/events/event-extensions/#jquery-event-fixhooks-object }\`
-     */
-    interface FixHooks {
-        [event: string]: FixHook;
-    }
-
-    // region Special event hooks
-    // #region Special event hooks
-
-    /**
-     * The jQuery special event hooks are a set of per-event-name functions and properties that allow code
-     * to control the behavior of event processing within jQuery. The mechanism is similar to `fixHooks` in
-     * that the special event information is stored in `jQuery.event.special.NAME`, where `NAME` is the
-     * name of the special event. Event names are case sensitive.
-     *
-     * As with `fixHooks`, the special event hooks design assumes it will be very rare that two unrelated
-     * pieces of code want to process the same event name. Special event authors who need to modify events
-     * with existing hooks will need to take precautions to avoid introducing unwanted side-effects by
-     * clobbering those hooks.
-     *
-     * @see \`{@link https://learn.jquery.com/events/event-extensions/#special-event-hooks }\`
-     */
-    interface SpecialEventHook<TTarget, TData> {
-        /**
-         * Indicates whether this event type should be bubbled when the `.trigger()` method is called; by
-         * default it is `false`, meaning that a triggered event will bubble to the element's parents up to the
-         * document (if attached to a document) and then to the window. Note that defining `noBubble` on an
-         * event will effectively prevent that event from being used for delegated events with `.trigger()`.
-         *
-         * @see \`{@link https://learn.jquery.com/events/event-extensions/#nobubble-boolean }\`
-         */
-        noBubble?: boolean;
-        /**
-         * When defined, these string properties specify that a special event should be handled like another
-         * event type until the event is delivered. The `bindType` is used if the event is attached directly,
-         * and the `delegateType` is used for delegated events. These types are generally DOM event types,
-         * and _should not_ be a special event themselves.
-         *
-         * @see \`{@link https://learn.jquery.com/events/event-extensions/#bindtype-string-delegatetype-string }\`
-         */
-        bindType?: string;
-        /**
-         * When defined, these string properties specify that a special event should be handled like another
-         * event type until the event is delivered. The `bindType` is used if the event is attached directly,
-         * and the `delegateType` is used for delegated events. These types are generally DOM event types,
-         * and _should not_ be a special event themselves.
-         *
-         * @see \`{@link https://learn.jquery.com/events/event-extensions/#bindtype-string-delegatetype-string }\`
-         */
-        delegateType?: string;
-        /**
-         * The setup hook is called the first time an event of a particular type is attached to an element;
-         * this provides the hook an opportunity to do processing that will apply to all events of this type on
-         * this element. The `this` keyword will be a reference to the element where the event is being attached
-         * and `eventHandle` is jQuery's event handler function. In most cases the `namespaces` argument should
-         * not be used, since it only represents the namespaces of the _first_ event being attached; subsequent
-         * events may not have this same namespaces.
-         *
-         * This hook can perform whatever processing it desires, including attaching its own event handlers to
-         * the element or to other elements and recording setup information on the element using the `jQuery.data()`
-         * method. If the setup hook wants jQuery to add a browser event (via `addEventListener` or `attachEvent`,
-         * depending on browser) it should return `false`. In all other cases, jQuery will not add the browser
-         * event, but will continue all its other bookkeeping for the event. This would be appropriate, for
-         * example, if the event was never fired by the browser but invoked by `.trigger()`. To attach the jQuery
-         * event handler in the setup hook, use the `eventHandle` argument.
-         *
-         * @see \`{@link https://learn.jquery.com/events/event-extensions/#setup-function-data-object-namespaces-eventhandle-function }\`
-         */
-        setup?(this: TTarget, data: TData, namespaces: string, eventHandle: EventHandler<TTarget, TData>): void | false;
-        /**
-         * The teardown hook is called when the final event of a particular type is removed from an element.
-         * The `this` keyword will be a reference to the element where the event is being cleaned up. This hook
-         * should return `false` if it wants jQuery to remove the event from the browser's event system (via
-         * `removeEventListener` or `detachEvent`). In most cases, the setup and teardown hooks should return
-         * the same value.
-         *
-         * If the setup hook attached event handlers or added data to an element through a mechanism such as
-         * `jQuery.data()`, the teardown hook should reverse the process and remove them. jQuery will generally
-         * remove the data and events when an element is totally removed from the document, but failing to
-         * remove data or events on teardown will cause a memory leak if the element stays in the document.
-         *
-         * @see \`{@link https://learn.jquery.com/events/event-extensions/#teardown-function }\`
-         */
-        teardown?(this: TTarget): void | false;
-        /**
-         * Each time an event handler is added to an element through an API such as `.on()`, jQuery calls this
-         * hook. The `this` keyword will be the element to which the event handler is being added, and the
-         * `handleObj` argument is as described in the section above. The return value of this hook is ignored.
-         *
-         * @see \`{@link https://learn.jquery.com/events/event-extensions/#add-function-handleobj }\`
-         */
-        add?(this: TTarget, handleObj: HandleObject<TTarget, TData>): void;
-        /**
-         * When an event handler is removed from an element using an API such as `.off()`, this hook is called.
-         * The `this` keyword will be the element where the handler is being removed, and the `handleObj`
-         * argument is as described in the section above. The return value of this hook is ignored.
-         *
-         * @see \`{@link https://learn.jquery.com/events/event-extensions/#remove-function-handleobj }\`
-         */
-        remove?(this: TTarget, handleObj: HandleObject<TTarget, TData>): void;
-        /**
-         * Called when the `.trigger()` or `.triggerHandler()` methods are used to trigger an event for the
-         * special type from code, as opposed to events that originate from within the browser. The `this`
-         * keyword will be the element being triggered, and the event argument will be a `jQuery.Event` object
-         * constructed from the caller's input. At minimum, the event type, data, namespace, and target
-         * properties are set on the event. The data argument represents additional data passed by `.trigger()`
-         * if present.
-         *
-         * The trigger hook is called early in the process of triggering an event, just after the `jQuery.Event`
-         * object is constructed and before any handlers have been called. It can process the triggered event
-         * in any way, for example by calling `event.stopPropagation()` or `event.preventDefault()` before
-         * returning. If the hook returns `false`, jQuery does not perform any further event triggering actions
-         * and returns immediately. Otherwise, it performs the normal trigger processing, calling any event
-         * handlers for the element and bubbling the event (unless propagation is stopped in advance or `noBubble`
-         * was specified for the special event) to call event handlers attached to parent elements.
-         *
-         * @see \`{@link https://learn.jquery.com/events/event-extensions/#trigger-function-event-jquery-event-data-object }\`
-         */
-        trigger?(this: TTarget, event: Event<TTarget, TData>, data: TData): void | false;
-        /**
-         * When the `.trigger()` method finishes running all the event handlers for an event, it also looks for
-         * and runs any method on the target object by the same name unless of the handlers called `event.preventDefault()`.
-         * So, `.trigger( "submit" )` will execute the `submit()` method on the element if one exists. When a
-         * `_default` hook is specified, the hook is called just prior to checking for and executing the element's
-         * default method. If this hook returns the value `false` the element's default method will be called;
-         * otherwise it is not.
-         *
-         * @see \`{@link https://learn.jquery.com/events/event-extensions/#_default-function-event-jquery-event-data-object }\`
-         */
-        _default?(event: Event<TTarget, TData>, data: TData): void | false;
-        /**
-         * jQuery calls a handle hook when the event has occurred and jQuery would normally call the user's event
-         * handler specified by `.on()` or another event binding method. If the hook exists, jQuery calls it
-         * _instead_ of that event handler, passing it the event and any data passed from `.trigger()` if it was
-         * not a native event. The `this` keyword is the DOM element being handled, and `event.handleObj`
-         * property has the detailed event information.
-         *
-         * Based in the information it has, the handle hook should decide whether to call the original handler
-         * function which is in `event.handleObj.handler`. It can modify information in the event object before
-         * calling the original handler, but _must restore_ that data before returning or subsequent unrelated
-         * event handlers may act unpredictably. In most cases, the handle hook should return the result of the
-         * original handler, but that is at the discretion of the hook. The handle hook is unique in that it is
-         * the only special event function hook that is called under its original special event name when the
-         * type is mapped using `bindType` and `delegateType`. For that reason, it is almost always an error to
-         * have anything other than a handle hook present if the special event defines a `bindType` and
-         * `delegateType`, since those other hooks will never be called.
-         *
-         * @see \`{@link https://learn.jquery.com/events/event-extensions/#handle-function-event-jquery-event-data-object }\`
-         */
-        handle?(this: TTarget, event: Event<TTarget, TData> & { handleObj: HandleObject<TTarget, TData>; }, ...data: TData[]): void;
-    }
-
-    interface SpecialEventHooks {
-        [event: string]: SpecialEventHook<EventTarget, any>;
-    }
-
-    /**
-     * Many of the special event hook functions below are passed a `handleObj` object that provides more
-     * information about the event, how it was attached, and its current state. This object and its contents
-     * should be treated as read-only data, and only the properties below are documented for use by special
-     * event handlers.
-     *
-     * @see \`{@link https://learn.jquery.com/events/event-extensions/#the-handleobj-object }\`
-     */
-    interface HandleObject<TTarget, TData> {
-        /**
-         * The type of event, such as `"click"`. When special event mapping is used via `bindType` or
-         * `delegateType`, this will be the mapped type.
-         */
-        readonly type: string;
-        /**
-         * The original type name regardless of whether it was mapped via `bindType` or `delegateType`. So when
-         * a "pushy" event is mapped to "click" its `origType` would be "pushy".
-         */
-        readonly origType: string;
-        /**
-         * Namespace(s), if any, provided when the event was attached, such as `"myPlugin"`. When multiple
-         * namespaces are given, they are separated by periods and sorted in ascending alphabetical order. If
-         * no namespaces are provided, this property is an empty string.
-         */
-        readonly namespace: string;
-        /**
-         * For delegated events, this is the selector used to filter descendant elements and determine if the
-         * handler should be called. For directly bound events, this property is `null`.
-         */
-        readonly selector: string | undefined | null;
-        /**
-         * The data, if any, passed to jQuery during event binding, e.g. `{ myData: 42 }`. If the data argument
-         * was omitted or `undefined`, this property is `undefined` as well.
-         */
-        readonly data: TData;
-        /**
-         * Event handler function passed to jQuery during event binding. If `false` was passed during event
-         * binding, the handler refers to a single shared function that simply returns `false`.
-         */
-        readonly handler: EventHandler<TTarget, TData>;
-    }
-
-    // #endregion
-
-    // #endregion
-
-    // #endregion
-
-    interface NameValuePair {
-        name: string;
-        value: string;
-    }
-
-    interface Coordinates {
-        left: number;
-        top: number;
-    }
-
-    // Workaround for TypeScript 2.3 which does not have support for weak types handling.
-    type CoordinatesPartial =
-        Pick<Coordinates, 'left'> |
-        Pick<Coordinates, 'top'> |
-        { [key: string]: never; };
-
-    interface ValHook<TElement> {
-        get?(elem: TElement): any;
-        set?(elem: TElement, value: any): any;
-    }
-}
-
-// region Legacy types
-// #region Legacy types
-
-// tslint:disable-next-line:no-empty-interface
-interface JQueryCallback extends JQuery.Callbacks { }
-interface JQueryDeferred<T> extends JQuery.Deferred<T> { }
-// tslint:disable-next-line:no-empty-interface
-interface JQueryEventConstructor extends JQuery.EventStatic { }
-interface JQueryDeferred<T> extends JQuery.Deferred<T> { }
-// tslint:disable-next-line:no-empty-interface
-interface JQueryAjaxSettings extends JQuery.AjaxSettings { }
-interface JQueryAnimationOptions extends JQuery.EffectsOptions<Element> { }
-// tslint:disable-next-line:no-empty-interface
-interface JQueryCoordinates extends JQuery.Coordinates { }
-interface JQueryGenericPromise<T> extends JQuery.Thenable<T> { }
-// tslint:disable-next-line:no-empty-interface
-interface JQueryXHR extends JQuery.jqXHR { }
-interface JQueryPromise<T> extends JQuery.Promise<T> { }
-// tslint:disable-next-line:no-empty-interface
-interface JQuerySerializeArrayElement extends JQuery.NameValuePair { }
-
-/**
- * @deprecated ​ Deprecated since 1.9. See \`{@link https://api.jquery.com/jQuery.support/ }\`.
- */
-// tslint:disable-next-line:no-empty-interface
-interface JQuerySupport extends JQuery.PlainObject { }
-
-// Legacy types that are not represented in the current type definitions are marked deprecated.
-
-/**
- * @deprecated ​ Deprecated. Use \`{@link JQuery.Deferred.Callback }\` or \`{@link JQuery.Deferred.CallbackBase }\`.
- */
-interface JQueryPromiseCallback<T> {
-    (value?: T, ...args: any[]): void;
-}
-/**
- * @deprecated ​ Deprecated. Use \`{@link JQueryStatic.param JQueryStatic&#91;'param'&#93;}\`.
- */
-interface JQueryParam {
-    /**
-     * Create a serialized representation of an array or object, suitable for use in a URL query string or Ajax request.
-     *
-     * @param obj An array or object to serialize.
-     * @param traditional A Boolean indicating whether to perform a traditional "shallow" serialization.
-     */
-    (obj: any, traditional?: boolean): string;
-}
-/**
- * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\`.
- */
-interface BaseJQueryEventObject extends Event {
-    /**
-     * The current DOM element within the event bubbling phase.
-     * @see \`{@link https://api.jquery.com/event.currentTarget/ }\`
-     */
-    currentTarget: Element;
-    /**
-     * An optional object of data passed to an event method when the current executing handler is bound.
-     * @see \`{@link https://api.jquery.com/event.data/ }\`
-     */
-    data: any;
-    /**
-     * The element where the currently-called jQuery event handler was attached.
-     * @see \`{@link https://api.jquery.com/event.delegateTarget/ }\`
-     */
-    delegateTarget: Element;
-    /**
-     * Returns whether event.preventDefault() was ever called on this event object.
-     * @see \`{@link https://api.jquery.com/event.isDefaultPrevented/ }\`
-     */
-    isDefaultPrevented(): boolean;
-    /**
-     * Returns whether event.stopImmediatePropagation() was ever called on this event object.
-     * @see \`{@link https://api.jquery.com/event.isImmediatePropagationStopped/ }\`
-     */
-    isImmediatePropagationStopped(): boolean;
-    /**
-     * Returns whether event.stopPropagation() was ever called on this event object.
-     * @see \`{@link https://api.jquery.com/event.isPropagationStopped/ }\`
-     */
-    isPropagationStopped(): boolean;
-    /**
-     * The namespace specified when the event was triggered.
-     * @see \`{@link https://api.jquery.com/event.namespace/ }\`
-     */
-    namespace: string;
-    /**
-     * The browser's original Event object.
-     * @see \`{@link https://api.jquery.com/category/events/event-object/ }\`
-     */
-    originalEvent: Event;
-    /**
-     * If this method is called, the default action of the event will not be triggered.
-     * @see \`{@link https://api.jquery.com/event.preventDefault/ }\`
-     */
-    preventDefault(): any;
-    /**
-     * The other DOM element involved in the event, if any.
-     * @see \`{@link https://api.jquery.com/event.relatedTarget/ }\`
-     */
-    relatedTarget: Element;
-    /**
-     * The last value returned by an event handler that was triggered by this event, unless the value was undefined.
-     * @see \`{@link https://api.jquery.com/event.result/ }\`
-     */
-    result: any;
-    /**
-     * Keeps the rest of the handlers from being executed and prevents the event from bubbling up the DOM tree.
-     * @see \`{@link https://api.jquery.com/event.stopImmediatePropagation/ }\`
-     */
-    stopImmediatePropagation(): void;
-    /**
-     * Prevents the event from bubbling up the DOM tree, preventing any parent handlers from being notified of the event.
-     * @see \`{@link https://api.jquery.com/event.stopPropagation/ }\`
-     */
-    stopPropagation(): void;
-    /**
-     * The DOM element that initiated the event.
-     * @see \`{@link https://api.jquery.com/event.target/ }\`
-     */
-    target: Element;
-    /**
-     * The mouse position relative to the left edge of the document.
-     * @see \`{@link https://api.jquery.com/event.pageX/ }\`
-     */
-    pageX: number;
-    /**
-     * The mouse position relative to the top edge of the document.
-     * @see \`{@link https://api.jquery.com/event.pageY/ }\`
-     */
-    pageY: number;
-    /**
-     * For key or mouse events, this property indicates the specific key or button that was pressed.
-     * @see \`{@link https://api.jquery.com/event.which/ }\`
-     */
-    which: number;
-    /**
-     * Indicates whether the META key was pressed when the event fired.
-     * @see \`{@link https://api.jquery.com/event.metaKey/ }\`
-     */
-    metaKey: boolean;
-}
-/**
- * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\`.
- */
-interface JQueryInputEventObject extends BaseJQueryEventObject {
-    altKey: boolean;
-    ctrlKey: boolean;
-    metaKey: boolean;
-    shiftKey: boolean;
-}
-/**
- * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\`.
- */
-interface JQueryMouseEventObject extends JQueryInputEventObject {
-    button: number;
-    clientX: number;
-    clientY: number;
-    offsetX: number;
-    offsetY: number;
-    pageX: number;
-    pageY: number;
-    screenX: number;
-    screenY: number;
-}
-/**
- * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\`.
- */
-interface JQueryKeyEventObject extends JQueryInputEventObject {
-    char: any;
-    charCode: number;
-    key: any;
-    keyCode: number;
-}
-/**
- * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\`.
- */
-interface JQueryEventObject extends BaseJQueryEventObject, JQueryInputEventObject, JQueryMouseEventObject, JQueryKeyEventObject { }
-/**
- * @deprecated ​ Deprecated.
- */
-interface JQueryPromiseOperator<T, U> {
-    (callback1: JQuery.TypeOrArray<JQueryPromiseCallback<T>>,
-     ...callbacksN: Array<JQuery.TypeOrArray<JQueryPromiseCallback<any>>>): JQueryPromise<U>;
-}
-/**
- * @deprecated ​ Deprecated. Internal. See \`{@link https://github.com/jquery/api.jquery.com/issues/912 }\`.
- */
-interface JQueryEasingFunction {
-    (percent: number): number;
-}
-/**
- * @deprecated ​ Deprecated. Internal. See \`{@link https://github.com/jquery/api.jquery.com/issues/912 }\`.
- */
-interface JQueryEasingFunctions {
-    [name: string]: JQueryEasingFunction;
-    linear: JQueryEasingFunction;
-    swing: JQueryEasingFunction;
-}
-
-// #endregion
+export = jQuery;
diff --git a/types/jquery/jquery-tests.ts b/types/jquery/jquery-tests.ts
index b5f392b89c..548c20c10b 100644
--- a/types/jquery/jquery-tests.ts
+++ b/types/jquery/jquery-tests.ts
@@ -8,13 +8,18 @@ function JQueryStatic() {
         $.ajaxSettings;
     }
 
+    function Animation() {
+        // $ExpectType AnimationStatic
+        $.Animation;
+    }
+
     function Callbacks() {
         // $ExpectType CallbacksStatic
         $.Callbacks;
     }
 
     function cssHooks() {
-        // $ExpectType PlainObject<CSSHook<HTMLElement>>
+        // $ExpectType CSSHooks
         $.cssHooks;
     }
 
@@ -68,8 +73,18 @@ function JQueryStatic() {
         $.support;
     }
 
+    function timers() {
+        // $ExpectType TickFunction<any>[]
+        $.timers;
+    }
+
+    function Tween() {
+        // $ExpectType TweenStatic
+        $.Tween;
+    }
+
     function valHooks() {
-        // $ExpectType PlainObject<ValHook<HTMLElement>>
+        // $ExpectType ValHooks
         $.valHooks;
     }
 
@@ -873,8 +888,10 @@ function JQueryStatic() {
     }
 
     function nodeName() {
+        const node: Node = undefined!;
+
         // $ExpectType boolean
-        $.nodeName({} as Node, 'name');
+        $.nodeName(node, 'name');
     }
 
     function noop() {
@@ -1016,23 +1033,23 @@ function JQueryStatic() {
     }
 
     function proxy() {
-        interface I1 { kind: 'I1'; }
-        interface I2 { kind: 'I2'; }
-        interface I3 { kind: 'I3'; }
-        interface I4 { kind: 'I4'; }
-        interface I5 { kind: 'I5'; }
-        interface I6 { kind: 'I6'; }
-        interface I7 { kind: 'I7'; }
-        interface I8 { kind: 'I8'; }
+        interface J1 { kind: 'J1'; }
+        interface J2 { kind: 'J2'; }
+        interface J3 { kind: 'J3'; }
+        interface J4 { kind: 'J4'; }
+        interface J5 { kind: 'J5'; }
+        interface J6 { kind: 'J6'; }
+        interface J7 { kind: 'J7'; }
+        interface J8 { kind: 'J8'; }
 
-        const a: I8 = {} as any;
-        const b: I7 = {} as any;
-        const c: I6 = {} as any;
-        const d: I5 = {} as any;
-        const e: I4 = {} as any;
-        const f: I3 = {} as any;
-        const g: I2 = {} as any;
-        const h: I2 = {} as any;
+        const a: J8 = {} as any;
+        const b: J7 = {} as any;
+        const c: J6 = {} as any;
+        const d: J5 = {} as any;
+        const e: J4 = {} as any;
+        const f: J3 = {} as any;
+        const g: J2 = {} as any;
+        const h: J2 = {} as any;
 
         type A = typeof a;
         type B = typeof b;
@@ -1069,200 +1086,200 @@ function JQueryStatic() {
             // $ExpectType () => void
             $.proxy(() => { }, null);
 
-            // $ExpectType (t: I1) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1) => { }, null, a, b, c, d, e, f, g);
+            // $ExpectType (t: J1) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1) => { }, null, a, b, c, d, e, f, g);
 
-            // $ExpectType (t: I1) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1) => { }, null, a, b, c, d, e, f);
+            // $ExpectType (t: J1) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1) => { }, null, a, b, c, d, e, f);
 
-            // $ExpectType (t: I1) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1) => { }, null, a, b, c, d, e);
+            // $ExpectType (t: J1) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1) => { }, null, a, b, c, d, e);
 
-            // $ExpectType (t: I1) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1) => { }, null, a, b, c, d);
+            // $ExpectType (t: J1) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1) => { }, null, a, b, c, d);
 
-            // $ExpectType (t: I1) => void
-            $.proxy((a: A, b: B, c: C, t: I1) => { }, null, a, b, c);
+            // $ExpectType (t: J1) => void
+            $.proxy((a: A, b: B, c: C, t: J1) => { }, null, a, b, c);
 
-            // $ExpectType (t: I1) => void
-            $.proxy((a: A, b: B, t: I1) => { }, null, a, b);
+            // $ExpectType (t: J1) => void
+            $.proxy((a: A, b: B, t: J1) => { }, null, a, b);
 
-            // $ExpectType (t: I1) => void
-            $.proxy((a: A, t: I1) => { }, null, a);
+            // $ExpectType (t: J1) => void
+            $.proxy((a: A, t: J1) => { }, null, a);
 
-            // $ExpectType (t: I1) => void
-            $.proxy((t: I1) => { }, null);
+            // $ExpectType (t: J1) => void
+            $.proxy((t: J1) => { }, null);
 
-            // $ExpectType (t: I1, u: I2) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2) => { }, null, a, b, c, d, e, f, g);
+            // $ExpectType (t: J1, u: J2) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2) => { }, null, a, b, c, d, e, f, g);
 
-            // $ExpectType (t: I1, u: I2) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2) => { }, null, a, b, c, d, e, f);
+            // $ExpectType (t: J1, u: J2) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2) => { }, null, a, b, c, d, e, f);
 
-            // $ExpectType (t: I1, u: I2) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2) => { }, null, a, b, c, d, e);
+            // $ExpectType (t: J1, u: J2) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2) => { }, null, a, b, c, d, e);
 
-            // $ExpectType (t: I1, u: I2) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2) => { }, null, a, b, c, d);
+            // $ExpectType (t: J1, u: J2) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2) => { }, null, a, b, c, d);
 
-            // $ExpectType (t: I1, u: I2) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2) => { }, null, a, b, c);
+            // $ExpectType (t: J1, u: J2) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2) => { }, null, a, b, c);
 
-            // $ExpectType (t: I1, u: I2) => void
-            $.proxy((a: A, b: B, t: I1, u: I2) => { }, null, a, b);
+            // $ExpectType (t: J1, u: J2) => void
+            $.proxy((a: A, b: B, t: J1, u: J2) => { }, null, a, b);
 
-            // $ExpectType (t: I1, u: I2) => void
-            $.proxy((a: A, t: I1, u: I2) => { }, null, a);
+            // $ExpectType (t: J1, u: J2) => void
+            $.proxy((a: A, t: J1, u: J2) => { }, null, a);
 
-            // $ExpectType (t: I1, u: I2) => void
-            $.proxy((t: I1, u: I2) => { }, null);
+            // $ExpectType (t: J1, u: J2) => void
+            $.proxy((t: J1, u: J2) => { }, null);
 
-            // $ExpectType (t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3) => { }, null, a, b, c, d, e, f, g);
+            // $ExpectType (t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3) => { }, null, a, b, c, d, e, f, g);
 
-            // $ExpectType (t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3) => { }, null, a, b, c, d, e, f);
+            // $ExpectType (t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3) => { }, null, a, b, c, d, e, f);
 
-            // $ExpectType (t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3) => { }, null, a, b, c, d, e);
+            // $ExpectType (t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3) => { }, null, a, b, c, d, e);
 
-            // $ExpectType (t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3) => { }, null, a, b, c, d);
+            // $ExpectType (t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3) => { }, null, a, b, c, d);
 
-            // $ExpectType (t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3) => { }, null, a, b, c);
+            // $ExpectType (t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3) => { }, null, a, b, c);
 
-            // $ExpectType (t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3) => { }, null, a, b);
+            // $ExpectType (t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3) => { }, null, a, b);
 
-            // $ExpectType (t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3) => { }, null, a);
+            // $ExpectType (t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3) => { }, null, a);
 
-            // $ExpectType (t: I1, u: I2, v: I3) => void
-            $.proxy((t: I1, u: I2, v: I3) => { }, null);
+            // $ExpectType (t: J1, u: J2, v: J3) => void
+            $.proxy((t: J1, u: J2, v: J3) => { }, null);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3, w: I4) => { }, null, a, b, c, d, e, f, g);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3, w: J4) => { }, null, a, b, c, d, e, f, g);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3, w: I4) => { }, null, a, b, c, d, e, f);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3, w: J4) => { }, null, a, b, c, d, e, f);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3, w: I4) => { }, null, a, b, c, d, e);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3, w: J4) => { }, null, a, b, c, d, e);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3, w: I4) => { }, null, a, b, c, d);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3, w: J4) => { }, null, a, b, c, d);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3, w: I4) => { }, null, a, b, c);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3, w: J4) => { }, null, a, b, c);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3, w: I4) => { }, null, a, b);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3, w: J4) => { }, null, a, b);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3, w: I4) => { }, null, a);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3, w: J4) => { }, null, a);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((t: I1, u: I2, v: I3, w: I4) => { }, null);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((t: J1, u: J2, v: J3, w: J4) => { }, null);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, null, a, b, c, d, e, f, g);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, null, a, b, c, d, e, f, g);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, null, a, b, c, d, e, f);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, null, a, b, c, d, e, f);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, null, a, b, c, d, e);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, null, a, b, c, d, e);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, null, a, b, c, d);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, null, a, b, c, d);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, null, a, b, c);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, null, a, b, c);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, null, a, b);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, null, a, b);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, null, a);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, null, a);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((t: I1, u: I2, v: I3, w: I4, x: I5) => { }, null);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((t: J1, u: J2, v: J3, w: J4, x: J5) => { }, null);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, null, a, b, c, d, e, f, g);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, null, a, b, c, d, e, f, g);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, null, a, b, c, d, e, f);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, null, a, b, c, d, e, f);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, null, a, b, c, d, e);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, null, a, b, c, d, e);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, null, a, b, c, d);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, null, a, b, c, d);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, null, a, b, c);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, null, a, b, c);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, null, a, b);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, null, a, b);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, null, a);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, null, a);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, null);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, null);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, null, a, b, c, d, e, f, g);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, null, a, b, c, d, e, f, g);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, null, a, b, c, d, e, f);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, null, a, b, c, d, e, f);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, null, a, b, c, d, e);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, null, a, b, c, d, e);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, null, a, b, c, d);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, null, a, b, c, d);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, null, a, b, c);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, null, a, b, c);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, null, a, b);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, null, a, b);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, null, a);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, null, a);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, null);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, null);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, null, a, b, c, d, e, f, g);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, null, a, b, c, d, e, f, g);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, null, a, b, c, d, e, f);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, null, a, b, c, d, e, f);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, null, a, b, c, d, e);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, null, a, b, c, d, e);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, null, a, b, c, d);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, null, a, b, c, d);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, null, a, b, c);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, null, a, b, c);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, null, a, b);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, null, a, b);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, null, a);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, null, a);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, null);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, null);
 
             // $ExpectType (...args: any[]) => void
-            $.proxy((a, b, c, d, e, f, g, h, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, null, a, b, c, d, e, f, g, h);
+            $.proxy((a, b, c, d, e, f, g, h, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, null, a, b, c, d, e, f, g, h);
         }
 
         // (fn, undefined)
@@ -1291,200 +1308,200 @@ function JQueryStatic() {
             // $ExpectType () => void
             $.proxy(() => { }, undefined);
 
-            // $ExpectType (t: I1) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1) => { }, undefined, a, b, c, d, e, f, g);
+            // $ExpectType (t: J1) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1) => { }, undefined, a, b, c, d, e, f, g);
 
-            // $ExpectType (t: I1) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1) => { }, undefined, a, b, c, d, e, f);
+            // $ExpectType (t: J1) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1) => { }, undefined, a, b, c, d, e, f);
 
-            // $ExpectType (t: I1) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1) => { }, undefined, a, b, c, d, e);
+            // $ExpectType (t: J1) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1) => { }, undefined, a, b, c, d, e);
 
-            // $ExpectType (t: I1) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1) => { }, undefined, a, b, c, d);
+            // $ExpectType (t: J1) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1) => { }, undefined, a, b, c, d);
 
-            // $ExpectType (t: I1) => void
-            $.proxy((a: A, b: B, c: C, t: I1) => { }, undefined, a, b, c);
+            // $ExpectType (t: J1) => void
+            $.proxy((a: A, b: B, c: C, t: J1) => { }, undefined, a, b, c);
 
-            // $ExpectType (t: I1) => void
-            $.proxy((a: A, b: B, t: I1) => { }, undefined, a, b);
+            // $ExpectType (t: J1) => void
+            $.proxy((a: A, b: B, t: J1) => { }, undefined, a, b);
 
-            // $ExpectType (t: I1) => void
-            $.proxy((a: A, t: I1) => { }, undefined, a);
+            // $ExpectType (t: J1) => void
+            $.proxy((a: A, t: J1) => { }, undefined, a);
 
-            // $ExpectType (t: I1) => void
-            $.proxy((t: I1) => { }, undefined);
+            // $ExpectType (t: J1) => void
+            $.proxy((t: J1) => { }, undefined);
 
-            // $ExpectType (t: I1, u: I2) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2) => { }, undefined, a, b, c, d, e, f, g);
+            // $ExpectType (t: J1, u: J2) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2) => { }, undefined, a, b, c, d, e, f, g);
 
-            // $ExpectType (t: I1, u: I2) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2) => { }, undefined, a, b, c, d, e, f);
+            // $ExpectType (t: J1, u: J2) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2) => { }, undefined, a, b, c, d, e, f);
 
-            // $ExpectType (t: I1, u: I2) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2) => { }, undefined, a, b, c, d, e);
+            // $ExpectType (t: J1, u: J2) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2) => { }, undefined, a, b, c, d, e);
 
-            // $ExpectType (t: I1, u: I2) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2) => { }, undefined, a, b, c, d);
+            // $ExpectType (t: J1, u: J2) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2) => { }, undefined, a, b, c, d);
 
-            // $ExpectType (t: I1, u: I2) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2) => { }, undefined, a, b, c);
+            // $ExpectType (t: J1, u: J2) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2) => { }, undefined, a, b, c);
 
-            // $ExpectType (t: I1, u: I2) => void
-            $.proxy((a: A, b: B, t: I1, u: I2) => { }, undefined, a, b);
+            // $ExpectType (t: J1, u: J2) => void
+            $.proxy((a: A, b: B, t: J1, u: J2) => { }, undefined, a, b);
 
-            // $ExpectType (t: I1, u: I2) => void
-            $.proxy((a: A, t: I1, u: I2) => { }, undefined, a);
+            // $ExpectType (t: J1, u: J2) => void
+            $.proxy((a: A, t: J1, u: J2) => { }, undefined, a);
 
-            // $ExpectType (t: I1, u: I2) => void
-            $.proxy((t: I1, u: I2) => { }, undefined);
+            // $ExpectType (t: J1, u: J2) => void
+            $.proxy((t: J1, u: J2) => { }, undefined);
 
-            // $ExpectType (t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3) => { }, undefined, a, b, c, d, e, f, g);
+            // $ExpectType (t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3) => { }, undefined, a, b, c, d, e, f, g);
 
-            // $ExpectType (t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3) => { }, undefined, a, b, c, d, e, f);
+            // $ExpectType (t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3) => { }, undefined, a, b, c, d, e, f);
 
-            // $ExpectType (t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3) => { }, undefined, a, b, c, d, e);
+            // $ExpectType (t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3) => { }, undefined, a, b, c, d, e);
 
-            // $ExpectType (t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3) => { }, undefined, a, b, c, d);
+            // $ExpectType (t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3) => { }, undefined, a, b, c, d);
 
-            // $ExpectType (t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3) => { }, undefined, a, b, c);
+            // $ExpectType (t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3) => { }, undefined, a, b, c);
 
-            // $ExpectType (t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3) => { }, undefined, a, b);
+            // $ExpectType (t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3) => { }, undefined, a, b);
 
-            // $ExpectType (t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3) => { }, undefined, a);
+            // $ExpectType (t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3) => { }, undefined, a);
 
-            // $ExpectType (t: I1, u: I2, v: I3) => void
-            $.proxy((t: I1, u: I2, v: I3) => { }, undefined);
+            // $ExpectType (t: J1, u: J2, v: J3) => void
+            $.proxy((t: J1, u: J2, v: J3) => { }, undefined);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3, w: I4) => { }, undefined, a, b, c, d, e, f, g);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3, w: J4) => { }, undefined, a, b, c, d, e, f, g);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3, w: I4) => { }, undefined, a, b, c, d, e, f);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3, w: J4) => { }, undefined, a, b, c, d, e, f);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3, w: I4) => { }, undefined, a, b, c, d, e);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3, w: J4) => { }, undefined, a, b, c, d, e);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3, w: I4) => { }, undefined, a, b, c, d);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3, w: J4) => { }, undefined, a, b, c, d);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3, w: I4) => { }, undefined, a, b, c);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3, w: J4) => { }, undefined, a, b, c);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3, w: I4) => { }, undefined, a, b);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3, w: J4) => { }, undefined, a, b);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3, w: I4) => { }, undefined, a);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3, w: J4) => { }, undefined, a);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((t: I1, u: I2, v: I3, w: I4) => { }, undefined);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((t: J1, u: J2, v: J3, w: J4) => { }, undefined);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, undefined, a, b, c, d, e, f, g);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, undefined, a, b, c, d, e, f, g);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, undefined, a, b, c, d, e, f);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, undefined, a, b, c, d, e, f);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, undefined, a, b, c, d, e);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, undefined, a, b, c, d, e);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, undefined, a, b, c, d);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, undefined, a, b, c, d);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, undefined, a, b, c);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, undefined, a, b, c);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, undefined, a, b);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, undefined, a, b);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, undefined, a);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, undefined, a);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((t: I1, u: I2, v: I3, w: I4, x: I5) => { }, undefined);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((t: J1, u: J2, v: J3, w: J4, x: J5) => { }, undefined);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, undefined, a, b, c, d, e, f, g);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, undefined, a, b, c, d, e, f, g);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, undefined, a, b, c, d, e, f);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, undefined, a, b, c, d, e, f);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, undefined, a, b, c, d, e);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, undefined, a, b, c, d, e);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, undefined, a, b, c, d);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, undefined, a, b, c, d);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, undefined, a, b, c);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, undefined, a, b, c);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, undefined, a, b);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, undefined, a, b);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, undefined, a);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, undefined, a);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, undefined);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, undefined);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, undefined, a, b, c, d, e, f, g);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, undefined, a, b, c, d, e, f, g);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, undefined, a, b, c, d, e, f);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, undefined, a, b, c, d, e, f);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, undefined, a, b, c, d, e);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, undefined, a, b, c, d, e);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, undefined, a, b, c, d);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, undefined, a, b, c, d);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, undefined, a, b, c);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, undefined, a, b, c);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, undefined, a, b);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, undefined, a, b);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, undefined, a);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, undefined, a);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, undefined);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, undefined);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, undefined, a, b, c, d, e, f, g);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, undefined, a, b, c, d, e, f, g);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, undefined, a, b, c, d, e, f);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, undefined, a, b, c, d, e, f);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, undefined, a, b, c, d, e);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, undefined, a, b, c, d, e);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, undefined, a, b, c, d);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, undefined, a, b, c, d);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, undefined, a, b, c);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, undefined, a, b, c);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, undefined, a, b);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, undefined, a, b);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, undefined, a);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, undefined, a);
 
-            // $ExpectType (t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, undefined);
+            // $ExpectType (t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, undefined);
 
             // $ExpectType (...args: any[]) => void
-            $.proxy((a, b, c, d, e, f, g, h, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, undefined, a, b, c, d, e, f, g, h);
+            $.proxy((a, b, c, d, e, f, g, h, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, undefined, a, b, c, d, e, f, g, h);
         }
 
         // (fn, context)
@@ -1513,200 +1530,200 @@ function JQueryStatic() {
             // $ExpectType (this: {}) => void
             $.proxy(() => { }, {});
 
-            // $ExpectType (this: {}, t: I1) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1) => { }, {}, a, b, c, d, e, f, g);
+            // $ExpectType (this: {}, t: J1) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1) => { }, {}, a, b, c, d, e, f, g);
 
-            // $ExpectType (this: {}, t: I1) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1) => { }, {}, a, b, c, d, e, f);
+            // $ExpectType (this: {}, t: J1) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1) => { }, {}, a, b, c, d, e, f);
 
-            // $ExpectType (this: {}, t: I1) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1) => { }, {}, a, b, c, d, e);
+            // $ExpectType (this: {}, t: J1) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1) => { }, {}, a, b, c, d, e);
 
-            // $ExpectType (this: {}, t: I1) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1) => { }, {}, a, b, c, d);
+            // $ExpectType (this: {}, t: J1) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1) => { }, {}, a, b, c, d);
 
-            // $ExpectType (this: {}, t: I1) => void
-            $.proxy((a: A, b: B, c: C, t: I1) => { }, {}, a, b, c);
+            // $ExpectType (this: {}, t: J1) => void
+            $.proxy((a: A, b: B, c: C, t: J1) => { }, {}, a, b, c);
 
-            // $ExpectType (this: {}, t: I1) => void
-            $.proxy((a: A, b: B, t: I1) => { }, {}, a, b);
+            // $ExpectType (this: {}, t: J1) => void
+            $.proxy((a: A, b: B, t: J1) => { }, {}, a, b);
 
-            // $ExpectType (this: {}, t: I1) => void
-            $.proxy((a: A, t: I1) => { }, {}, a);
+            // $ExpectType (this: {}, t: J1) => void
+            $.proxy((a: A, t: J1) => { }, {}, a);
 
-            // $ExpectType (this: {}, t: I1) => void
-            $.proxy((t: I1) => { }, {});
+            // $ExpectType (this: {}, t: J1) => void
+            $.proxy((t: J1) => { }, {});
 
-            // $ExpectType (this: {}, t: I1, u: I2) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2) => { }, {}, a, b, c, d, e, f, g);
+            // $ExpectType (this: {}, t: J1, u: J2) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2) => { }, {}, a, b, c, d, e, f, g);
 
-            // $ExpectType (this: {}, t: I1, u: I2) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2) => { }, {}, a, b, c, d, e, f);
+            // $ExpectType (this: {}, t: J1, u: J2) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2) => { }, {}, a, b, c, d, e, f);
 
-            // $ExpectType (this: {}, t: I1, u: I2) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2) => { }, {}, a, b, c, d, e);
+            // $ExpectType (this: {}, t: J1, u: J2) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2) => { }, {}, a, b, c, d, e);
 
-            // $ExpectType (this: {}, t: I1, u: I2) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2) => { }, {}, a, b, c, d);
+            // $ExpectType (this: {}, t: J1, u: J2) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2) => { }, {}, a, b, c, d);
 
-            // $ExpectType (this: {}, t: I1, u: I2) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2) => { }, {}, a, b, c);
+            // $ExpectType (this: {}, t: J1, u: J2) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2) => { }, {}, a, b, c);
 
-            // $ExpectType (this: {}, t: I1, u: I2) => void
-            $.proxy((a: A, b: B, t: I1, u: I2) => { }, {}, a, b);
+            // $ExpectType (this: {}, t: J1, u: J2) => void
+            $.proxy((a: A, b: B, t: J1, u: J2) => { }, {}, a, b);
 
-            // $ExpectType (this: {}, t: I1, u: I2) => void
-            $.proxy((a: A, t: I1, u: I2) => { }, {}, a);
+            // $ExpectType (this: {}, t: J1, u: J2) => void
+            $.proxy((a: A, t: J1, u: J2) => { }, {}, a);
 
-            // $ExpectType (this: {}, t: I1, u: I2) => void
-            $.proxy((t: I1, u: I2) => { }, {});
+            // $ExpectType (this: {}, t: J1, u: J2) => void
+            $.proxy((t: J1, u: J2) => { }, {});
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3) => { }, {}, a, b, c, d, e, f, g);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3) => { }, {}, a, b, c, d, e, f, g);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3) => { }, {}, a, b, c, d, e, f);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3) => { }, {}, a, b, c, d, e, f);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3) => { }, {}, a, b, c, d, e);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3) => { }, {}, a, b, c, d, e);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3) => { }, {}, a, b, c, d);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3) => { }, {}, a, b, c, d);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3) => { }, {}, a, b, c);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3) => { }, {}, a, b, c);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3) => { }, {}, a, b);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3) => { }, {}, a, b);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3) => { }, {}, a);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3) => { }, {}, a);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3) => void
-            $.proxy((t: I1, u: I2, v: I3) => { }, {});
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3) => void
+            $.proxy((t: J1, u: J2, v: J3) => { }, {});
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3, w: I4) => { }, {}, a, b, c, d, e, f, g);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3, w: J4) => { }, {}, a, b, c, d, e, f, g);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3, w: I4) => { }, {}, a, b, c, d, e, f);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3, w: J4) => { }, {}, a, b, c, d, e, f);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3, w: I4) => { }, {}, a, b, c, d, e);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3, w: J4) => { }, {}, a, b, c, d, e);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3, w: I4) => { }, {}, a, b, c, d);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3, w: J4) => { }, {}, a, b, c, d);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3, w: I4) => { }, {}, a, b, c);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3, w: J4) => { }, {}, a, b, c);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3, w: I4) => { }, {}, a, b);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3, w: J4) => { }, {}, a, b);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3, w: I4) => { }, {}, a);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3, w: J4) => { }, {}, a);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4) => void
-            $.proxy((t: I1, u: I2, v: I3, w: I4) => { }, {});
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4) => void
+            $.proxy((t: J1, u: J2, v: J3, w: J4) => { }, {});
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, {}, a, b, c, d, e, f, g);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, {}, a, b, c, d, e, f, g);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, {}, a, b, c, d, e, f);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, {}, a, b, c, d, e, f);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, {}, a, b, c, d, e);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, {}, a, b, c, d, e);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, {}, a, b, c, d);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, {}, a, b, c, d);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, {}, a, b, c);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, {}, a, b, c);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, {}, a, b);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, {}, a, b);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3, w: I4, x: I5) => { }, {}, a);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3, w: J4, x: J5) => { }, {}, a);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5) => void
-            $.proxy((t: I1, u: I2, v: I3, w: I4, x: I5) => { }, {});
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5) => void
+            $.proxy((t: J1, u: J2, v: J3, w: J4, x: J5) => { }, {});
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, {}, a, b, c, d, e, f, g);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, {}, a, b, c, d, e, f, g);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, {}, a, b, c, d, e, f);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, {}, a, b, c, d, e, f);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, {}, a, b, c, d, e);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, {}, a, b, c, d, e);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, {}, a, b, c, d);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, {}, a, b, c, d);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, {}, a, b, c);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, {}, a, b, c);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, {}, a, b);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, {}, a, b);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, {}, a);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, {}, a);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => void
-            $.proxy((t: I1, u: I2, v: I3, w: I4, x: I5, y: I6) => { }, {});
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => void
+            $.proxy((t: J1, u: J2, v: J3, w: J4, x: J5, y: J6) => { }, {});
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, {}, a, b, c, d, e, f, g);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, {}, a, b, c, d, e, f, g);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, {}, a, b, c, d, e, f);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, {}, a, b, c, d, e, f);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, {}, a, b, c, d, e);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, {}, a, b, c, d, e);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, {}, a, b, c, d);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, {}, a, b, c, d);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, {}, a, b, c);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, {}, a, b, c);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, {}, a, b);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, {}, a, b);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, {}, a);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, {}, a);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7) => { }, {});
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7) => { }, {});
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, {}, a, b, c, d, e, f, g);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, g: G, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, {}, a, b, c, d, e, f, g);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, {}, a, b, c, d, e, f);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, f: F, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, {}, a, b, c, d, e, f);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, e: E, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, {}, a, b, c, d, e);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, e: E, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, {}, a, b, c, d, e);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, d: D, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, {}, a, b, c, d);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, d: D, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, {}, a, b, c, d);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, c: C, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, {}, a, b, c);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, c: C, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, {}, a, b, c);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, b: B, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, {}, a, b);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, b: B, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, {}, a, b);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((a: A, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, {}, a);
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((a: A, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, {}, a);
 
-            // $ExpectType (this: {}, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, ...args: any[]) => void
-            $.proxy((t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, {});
+            // $ExpectType (this: {}, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, ...args: any[]) => void
+            $.proxy((t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, {});
 
             // $ExpectType (this: {}, ...args: any[]) => void
-            $.proxy((a, b, c, d, e, f, g, h, t: I1, u: I2, v: I3, w: I4, x: I5, y: I6, z: I7, _: I8) => { }, {}, a, b, c, d, e, f, g, h);
+            $.proxy((a, b, c, d, e, f, g, h, t: J1, u: J2, v: J3, w: J4, x: J5, y: J6, z: J7, _: J8) => { }, {}, a, b, c, d, e, f, g, h);
         }
 
         // $ExpectType (this: { myFunc: () => undefined; }, ...args: any[]) => any
@@ -1791,6 +1808,10 @@ function JQueryStatic() {
             }
         });
 
+        // Weak type test. This may be removed if the TypeScript requirement is increased to 2.4+.
+        // $ExpectError
+        $.speed(false);
+
         // $ExpectType EffectsOptions<HTMLElement>
         $.speed();
     }
@@ -1816,15 +1837,15 @@ function JQueryStatic() {
     }
 
     function when() {
-        interface I1 { kind: 'I1'; }
-        interface I2 { kind: 'I2'; }
-        interface I3 { kind: 'I3'; }
-        interface I4 { kind: 'I4'; }
-        interface I5 { kind: 'I5'; }
-        interface I6 { kind: 'I6'; }
-        interface I7 { kind: 'I7'; }
-        interface I8 { kind: 'I8'; }
-        interface I9 { kind: 'I9'; }
+        interface J1 { kind: 'J1'; }
+        interface J2 { kind: 'J2'; }
+        interface J3 { kind: 'J3'; }
+        interface J4 { kind: 'J4'; }
+        interface J5 { kind: 'J5'; }
+        interface J6 { kind: 'J6'; }
+        interface J7 { kind: 'J7'; }
+        interface J8 { kind: 'J8'; }
+        interface J9 { kind: 'J9'; }
 
         function Promise3() {
             const t = $.ajax() as JQuery.jqXHR<string>;
@@ -1974,22 +1995,22 @@ function JQueryStatic() {
         }
 
         function Promise() {
-            const p1: JQuery.Promise<I1, I2, I3> = {} as any;
-            const p2: JQuery.Promise<I2, I3, I4> = {} as any;
-            const p3: JQuery.Promise<I3, I4, I5> = {} as any;
+            const p1: JQuery.Promise<J1, J2, J3> = {} as any;
+            const p2: JQuery.Promise<J2, J3, J4> = {} as any;
+            const p3: JQuery.Promise<J3, J4, J5> = {} as any;
 
             // 3 parameters
             {
                 const w = $.when(p1, p2, p3);
 
                 w.then((a, b, c) => {
-                    a; // $ExpectType I1
-                    b; // $ExpectType I2
-                    c; // $ExpectType I3
+                    a; // $ExpectType J1
+                    b; // $ExpectType J2
+                    c; // $ExpectType J3
                 }, (a, b, c) => {
-                    a; // $ExpectType I2
-                    b; // $ExpectType I3
-                    c; // $ExpectType I4
+                    a; // $ExpectType J2
+                    b; // $ExpectType J3
+                    c; // $ExpectType J4
                 }, (a, b, c) => {
                     a; // $ExpectType never
                     b; // $ExpectType never
@@ -2002,11 +2023,11 @@ function JQueryStatic() {
                 const w = $.when(p1, p2);
 
                 w.then((a, b) => {
-                    a; // $ExpectType I1
-                    b; // $ExpectType I2
+                    a; // $ExpectType J1
+                    b; // $ExpectType J2
                 }, (a, b) => {
-                    a; // $ExpectType I2
-                    b; // $ExpectType I3
+                    a; // $ExpectType J2
+                    b; // $ExpectType J3
                 }, (a, b) => {
                     a; // $ExpectType never
                     b; // $ExpectType never
@@ -2018,9 +2039,9 @@ function JQueryStatic() {
                 const w = $.when(p1);
 
                 w.then(a => {
-                    a; // $ExpectType I1
+                    a; // $ExpectType J1
                 }, a => {
-                    a; // $ExpectType I2
+                    a; // $ExpectType J2
                 }, a => {
                     a; // $ExpectType never
                 });
@@ -2028,18 +2049,18 @@ function JQueryStatic() {
         }
 
         function Thenable() {
-            const t1: JQuery.Thenable<I1> = {} as any;
-            const t2: JQuery.Thenable<I2> = {} as any;
-            const t3: JQuery.Thenable<I3> = {} as any;
+            const t1: JQuery.Thenable<J1> = {} as any;
+            const t2: JQuery.Thenable<J2> = {} as any;
+            const t3: JQuery.Thenable<J3> = {} as any;
 
             // 3 parameters
             {
                 const w = $.when(t1, t2, t3);
 
                 w.then((a, b, c) => {
-                    a; // $ExpectType I1
-                    b; // $ExpectType I2
-                    c; // $ExpectType I3
+                    a; // $ExpectType J1
+                    b; // $ExpectType J2
+                    c; // $ExpectType J3
                 }, (a, b, c) => {
                     a; // $ExpectType any
                     b; // $ExpectType any
@@ -2056,8 +2077,8 @@ function JQueryStatic() {
                 const w = $.when(t1, t2);
 
                 w.then((a, b) => {
-                    a; // $ExpectType I1
-                    b; // $ExpectType I2
+                    a; // $ExpectType J1
+                    b; // $ExpectType J2
                 }, (a, b) => {
                     a; // $ExpectType any
                     b; // $ExpectType any
@@ -2072,7 +2093,7 @@ function JQueryStatic() {
                 const w = $.when(t1);
 
                 w.then(a => {
-                    a; // $ExpectType I1
+                    a; // $ExpectType J1
                 }, a => {
                     a; // $ExpectType any
                 }, a => {
@@ -2597,12 +2618,29 @@ function JQuery() {
         }
 
         function outerHeight() {
+            const value: string | number = undefined!;
+
+            // $ExpectType JQuery<HTMLElement>
+            $('p').outerHeight(value, true);
+
             // $ExpectType JQuery<HTMLElement>
             $('p').outerHeight('200px');
 
             // $ExpectType JQuery<HTMLElement>
             $('p').outerHeight(400);
 
+            // $ExpectType JQuery<HTMLElement>
+            $('p').outerHeight(function(index, height) {
+                // $ExpectType HTMLElement
+                this;
+                // $ExpectType number
+                index;
+                // $ExpectType number
+                height;
+
+                return '200px';
+            }, false);
+
             // $ExpectType JQuery<HTMLElement>
             $('p').outerHeight(function(index, height) {
                 // $ExpectType HTMLElement
@@ -2705,12 +2743,29 @@ function JQuery() {
         }
 
         function outerWidth() {
+            const value: string | number = undefined!;
+
+            // $ExpectType JQuery<HTMLElement>
+            $('p').outerWidth(value, true);
+
             // $ExpectType JQuery<HTMLElement>
             $('p').outerWidth('200px');
 
             // $ExpectType JQuery<HTMLElement>
             $('p').outerWidth(400);
 
+            // $ExpectType JQuery<HTMLElement>
+            $('p').outerWidth(function(index, width) {
+                // $ExpectType HTMLElement
+                this;
+                // $ExpectType number
+                index;
+                // $ExpectType number
+                width;
+
+                return '200px';
+            }, false);
+
             // $ExpectType JQuery<HTMLElement>
             $('p').outerWidth(function(index, width) {
                 // $ExpectType HTMLElement
@@ -3602,7 +3657,7 @@ function JQuery() {
     function events() {
         // [bind() overloads] https://github.com/jquery/api.jquery.com/issues/1048
         function bind() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').bind('myEvent', 'myData', function(event) {
@@ -3613,8 +3668,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').bind('myEvent', 'myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').bind('myEvent', 'myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -3629,8 +3684,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').bind('myEvent', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').bind('myEvent', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -3648,8 +3703,8 @@ function JQuery() {
                     // $ExpectType Event<HTMLElement, null>
                     event;
                 },
-                myEvent3(this: I1, event) {
-                    // $ExpectType I1
+                myEvent3(this: J1, event) {
+                    // $ExpectType J1
                     this;
                     // $ExpectType Event<HTMLElement, null>
                     event;
@@ -3664,7 +3719,7 @@ function JQuery() {
         }
 
         function delegate() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('table').delegate('td', 'myEvent', 'myData', function(event) {
@@ -3675,8 +3730,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('table').delegate('td', 'myEvent', 'myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('table').delegate('td', 'myEvent', 'myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -3691,8 +3746,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('table').delegate('td', 'myEvent', function(this: I1, event) {
-                // $ExpectType I1
+            $('table').delegate('td', 'myEvent', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -3710,8 +3765,8 @@ function JQuery() {
                     event;
                 },
                 myEvent2: false,
-                myEvent3(this: I1, event) {
-                    // $ExpectType I1
+                myEvent3(this: J1, event) {
+                    // $ExpectType J1
                     this;
                     // $ExpectType Event<HTMLElement, null>
                     event;
@@ -3724,11 +3779,11 @@ function JQuery() {
 
             function defaultContext_customData(this: HTMLElement, event: JQuery.Event<HTMLElement, string>) { }
 
-            function customContext_defaultData(this: I1, event: JQuery.Event<HTMLElement>) { }
+            function customContext_defaultData(this: J1, event: JQuery.Event<HTMLElement>) { }
 
-            function customContext_customData(this: I1, event: JQuery.Event<HTMLElement, string>) { }
+            function customContext_customData(this: J1, event: JQuery.Event<HTMLElement, string>) { }
 
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('table').off('myEvent', 'td', defaultContext_defaultData);
@@ -3792,7 +3847,7 @@ function JQuery() {
         }
 
         function on() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('table').on('myEvent', 'td', 'myData', function(event) {
@@ -3811,8 +3866,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('table').on('myEvent', 'td', 'myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('table').on('myEvent', 'td', 'myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -3835,8 +3890,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('table').on('myEvent', null, 'myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('table').on('myEvent', null, 'myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -3859,8 +3914,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('table').on('myEvent', 'td', function(this: I1, event) {
-                // $ExpectType I1
+            $('table').on('myEvent', 'td', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -3886,8 +3941,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('table').on('myEvent', 3, function(this: I1, event) {
-                // $ExpectType I1
+            $('table').on('myEvent', 3, function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, number>
                 event;
@@ -3934,8 +3989,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('table').on('myEvent', function(this: I1, event) {
-                // $ExpectType I1
+            $('table').on('myEvent', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -3953,8 +4008,8 @@ function JQuery() {
                     // $ExpectType Event<HTMLElement, string>
                     event;
                 },
-                myEvent3(this: I1, event) {
-                    // $ExpectType I1
+                myEvent3(this: J1, event) {
+                    // $ExpectType J1
                     this;
                     // $ExpectType Event<HTMLElement, string>
                     event;
@@ -3970,8 +4025,8 @@ function JQuery() {
                     // $ExpectType Event<HTMLElement, string>
                     event;
                 },
-                myEvent3(this: I1, event) {
-                    // $ExpectType I1
+                myEvent3(this: J1, event) {
+                    // $ExpectType J1
                     this;
                     // $ExpectType Event<HTMLElement, string>
                     event;
@@ -3987,8 +4042,8 @@ function JQuery() {
                     // $ExpectType Event<HTMLElement, null>
                     event;
                 },
-                myEvent3(this: I1, event) {
-                    // $ExpectType I1
+                myEvent3(this: J1, event) {
+                    // $ExpectType J1
                     this;
                     // $ExpectType Event<HTMLElement, null>
                     event;
@@ -4004,8 +4059,8 @@ function JQuery() {
                     // $ExpectType Event<HTMLElement, number>
                     event;
                 },
-                myEvent3(this: I1, event) {
-                    // $ExpectType I1
+                myEvent3(this: J1, event) {
+                    // $ExpectType J1
                     this;
                     // $ExpectType Event<HTMLElement, number>
                     event;
@@ -4021,8 +4076,8 @@ function JQuery() {
                     // $ExpectType Event<HTMLElement, null>
                     event;
                 },
-                myEvent3(this: I1, event) {
-                    // $ExpectType I1
+                myEvent3(this: J1, event) {
+                    // $ExpectType J1
                     this;
                     // $ExpectType Event<HTMLElement, null>
                     event;
@@ -4031,7 +4086,7 @@ function JQuery() {
         }
 
         function one() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('table').one('myEvent', 'td', 'myData', function(event) {
@@ -4042,8 +4097,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('table').one('myEvent', 'td', 'myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('table').one('myEvent', 'td', 'myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4058,8 +4113,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('table').one('myEvent', null, 'myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('table').one('myEvent', null, 'myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4074,8 +4129,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('table').one('myEvent', 'td', function(this: I1, event) {
-                // $ExpectType I1
+            $('table').one('myEvent', 'td', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4093,8 +4148,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('table').one('myEvent', 3, function(this: I1, event) {
-                // $ExpectType I1
+            $('table').one('myEvent', 3, function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, number>
                 event;
@@ -4109,8 +4164,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('table').one('myEvent', function(this: I1, event) {
-                // $ExpectType I1
+            $('table').one('myEvent', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4128,8 +4183,8 @@ function JQuery() {
                     // $ExpectType Event<HTMLElement, string>
                     event;
                 },
-                myEvent3(this: I1, event) {
-                    // $ExpectType I1
+                myEvent3(this: J1, event) {
+                    // $ExpectType J1
                     this;
                     // $ExpectType Event<HTMLElement, string>
                     event;
@@ -4145,8 +4200,8 @@ function JQuery() {
                     // $ExpectType Event<HTMLElement, string>
                     event;
                 },
-                myEvent3(this: I1, event) {
-                    // $ExpectType I1
+                myEvent3(this: J1, event) {
+                    // $ExpectType J1
                     this;
                     // $ExpectType Event<HTMLElement, string>
                     event;
@@ -4162,8 +4217,8 @@ function JQuery() {
                     // $ExpectType Event<HTMLElement, null>
                     event;
                 },
-                myEvent3(this: I1, event) {
-                    // $ExpectType I1
+                myEvent3(this: J1, event) {
+                    // $ExpectType J1
                     this;
                     // $ExpectType Event<HTMLElement, null>
                     event;
@@ -4179,8 +4234,8 @@ function JQuery() {
                     // $ExpectType Event<HTMLElement, number>
                     event;
                 },
-                myEvent3(this: I1, event) {
-                    // $ExpectType I1
+                myEvent3(this: J1, event) {
+                    // $ExpectType J1
                     this;
                     // $ExpectType Event<HTMLElement, number>
                     event;
@@ -4196,8 +4251,8 @@ function JQuery() {
                     // $ExpectType Event<HTMLElement, null>
                     event;
                 },
-                myEvent3(this: I1, event) {
-                    // $ExpectType I1
+                myEvent3(this: J1, event) {
+                    // $ExpectType J1
                     this;
                     // $ExpectType Event<HTMLElement, null>
                     event;
@@ -4274,11 +4329,11 @@ function JQuery() {
 
             function defaultContext_customData(this: HTMLElement, event: JQuery.Event<HTMLElement, string>) { }
 
-            function customContext_defaultData(this: I1, event: JQuery.Event<HTMLElement>) { }
+            function customContext_defaultData(this: J1, event: JQuery.Event<HTMLElement>) { }
 
-            function customContext_customData(this: I1, event: JQuery.Event<HTMLElement, string>) { }
+            function customContext_customData(this: J1, event: JQuery.Event<HTMLElement, string>) { }
 
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').unbind('myEvent', defaultContext_defaultData);
@@ -4310,11 +4365,11 @@ function JQuery() {
 
             function defaultContext_customData(this: HTMLElement, event: JQuery.Event<HTMLElement, string>) { }
 
-            function customContext_defaultData(this: I1, event: JQuery.Event<HTMLElement>) { }
+            function customContext_defaultData(this: J1, event: JQuery.Event<HTMLElement>) { }
 
-            function customContext_customData(this: I1, event: JQuery.Event<HTMLElement, string>) { }
+            function customContext_customData(this: J1, event: JQuery.Event<HTMLElement, string>) { }
 
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('table').undelegate('td', 'click', defaultContext_defaultData);
@@ -4351,7 +4406,7 @@ function JQuery() {
         }
 
         function blur() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').blur('myData', function(event) {
@@ -4362,8 +4417,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').blur('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').blur('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4378,8 +4433,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').blur(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').blur(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4393,7 +4448,7 @@ function JQuery() {
         }
 
         function change() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').change('myData', function(event) {
@@ -4404,8 +4459,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').change('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').change('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4420,8 +4475,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').change(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').change(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4435,7 +4490,7 @@ function JQuery() {
         }
 
         function click() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').click('myData', function(event) {
@@ -4446,8 +4501,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').click('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').click('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4462,8 +4517,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').click(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').click(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4477,7 +4532,7 @@ function JQuery() {
         }
 
         function contextmenu() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').contextmenu('myData', function(event) {
@@ -4488,8 +4543,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').contextmenu('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').contextmenu('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4504,8 +4559,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').contextmenu(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').contextmenu(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4519,7 +4574,7 @@ function JQuery() {
         }
 
         function dblclick() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').dblclick('myData', function(event) {
@@ -4530,8 +4585,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').dblclick('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').dblclick('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4546,8 +4601,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').dblclick(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').dblclick(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4561,7 +4616,7 @@ function JQuery() {
         }
 
         function focus() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').focus('myData', function(event) {
@@ -4572,8 +4627,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').focus('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').focus('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4588,8 +4643,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').focus(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').focus(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4603,7 +4658,7 @@ function JQuery() {
         }
 
         function focusin() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').focusin('myData', function(event) {
@@ -4614,8 +4669,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').focusin('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').focusin('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4630,8 +4685,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').focusin(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').focusin(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4645,7 +4700,7 @@ function JQuery() {
         }
 
         function focusout() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').focusout('myData', function(event) {
@@ -4656,8 +4711,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').focusout('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').focusout('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4672,8 +4727,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').focusout(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').focusout(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4687,7 +4742,7 @@ function JQuery() {
         }
 
         function keydown() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').keydown('myData', function(event) {
@@ -4698,8 +4753,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').keydown('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').keydown('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4714,8 +4769,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').keydown(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').keydown(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4729,7 +4784,7 @@ function JQuery() {
         }
 
         function keypress() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').keypress('myData', function(event) {
@@ -4740,8 +4795,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').keypress('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').keypress('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4756,8 +4811,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').keypress(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').keypress(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4771,7 +4826,7 @@ function JQuery() {
         }
 
         function keyup() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').keyup('myData', function(event) {
@@ -4782,8 +4837,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').keyup('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').keyup('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4798,8 +4853,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').keyup(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').keyup(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4813,7 +4868,7 @@ function JQuery() {
         }
 
         function mousedown() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').mousedown('myData', function(event) {
@@ -4824,8 +4879,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').mousedown('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').mousedown('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4840,8 +4895,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').mousedown(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').mousedown(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4855,7 +4910,7 @@ function JQuery() {
         }
 
         function mouseenter() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').mouseenter('myData', function(event) {
@@ -4866,8 +4921,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').mouseenter('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').mouseenter('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4882,8 +4937,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').mouseenter(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').mouseenter(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4897,7 +4952,7 @@ function JQuery() {
         }
 
         function mouseleave() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').mouseleave('myData', function(event) {
@@ -4908,8 +4963,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').mouseleave('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').mouseleave('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4924,8 +4979,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').mouseleave(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').mouseleave(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4939,7 +4994,7 @@ function JQuery() {
         }
 
         function mousemove() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').mousemove('myData', function(event) {
@@ -4950,8 +5005,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').mousemove('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').mousemove('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -4966,8 +5021,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').mousemove(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').mousemove(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -4981,7 +5036,7 @@ function JQuery() {
         }
 
         function mouseout() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').mouseout('myData', function(event) {
@@ -4992,8 +5047,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').mouseout('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').mouseout('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -5008,8 +5063,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').mouseout(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').mouseout(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -5023,7 +5078,7 @@ function JQuery() {
         }
 
         function mouseover() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').mouseover('myData', function(event) {
@@ -5034,8 +5089,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').mouseover('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').mouseover('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -5050,8 +5105,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').mouseover(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').mouseover(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -5065,7 +5120,7 @@ function JQuery() {
         }
 
         function mouseup() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').mouseup('myData', function(event) {
@@ -5076,8 +5131,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').mouseup('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').mouseup('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -5092,8 +5147,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').mouseup(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').mouseup(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -5107,7 +5162,7 @@ function JQuery() {
         }
 
         function resize() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').resize('myData', function(event) {
@@ -5118,8 +5173,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').resize('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').resize('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -5134,8 +5189,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').resize(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').resize(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -5149,7 +5204,7 @@ function JQuery() {
         }
 
         function scroll() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').scroll('myData', function(event) {
@@ -5160,8 +5215,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').scroll('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').scroll('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -5176,8 +5231,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').scroll(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').scroll(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -5191,7 +5246,7 @@ function JQuery() {
         }
 
         function select() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').select('myData', function(event) {
@@ -5202,8 +5257,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').select('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').select('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -5218,8 +5273,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').select(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').select(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -5233,7 +5288,7 @@ function JQuery() {
         }
 
         function submit() {
-            interface I1 { kind: 'I1'; }
+            interface J1 { kind: 'J1'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').submit('myData', function(event) {
@@ -5244,8 +5299,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').submit('myData', function(this: I1, event) {
-                // $ExpectType I1
+            $('p').submit('myData', function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, string>
                 event;
@@ -5260,8 +5315,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').submit(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').submit(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -5275,8 +5330,8 @@ function JQuery() {
         }
 
         function hover() {
-            interface I1 { kind: 'I1'; }
-            interface I2 { kind: 'I2'; }
+            interface J1 { kind: 'J1'; }
+            interface J2 { kind: 'J2'; }
 
             // $ExpectType JQuery<HTMLElement>
             $('p').hover(function(event) {
@@ -5292,8 +5347,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').hover(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').hover(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -5310,21 +5365,21 @@ function JQuery() {
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
-            }, function(this: I1, event) {
-                // $ExpectType I1
+            }, function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').hover(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').hover(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
-            }, function(this: I2, event) {
-                // $ExpectType I2
+            }, function(this: J2, event) {
+                // $ExpectType J2
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -5339,8 +5394,8 @@ function JQuery() {
             }, false);
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').hover(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').hover(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -5355,8 +5410,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').hover(false, function(this: I1, event) {
-                // $ExpectType I1
+            $('p').hover(false, function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -5374,8 +5429,8 @@ function JQuery() {
             });
 
             // $ExpectType JQuery<HTMLElement>
-            $('p').hover(function(this: I1, event) {
-                // $ExpectType I1
+            $('p').hover(function(this: J1, event) {
+                // $ExpectType J1
                 this;
                 // $ExpectType Event<HTMLElement, null>
                 event;
@@ -7070,26 +7125,70 @@ function JQuery_Callbacks() {
     }
 }
 
+function JQuery_CSSHooks() {
+    $.cssHooks.borderRadius = {
+        get(elem, computed, extra) {
+            // $ExpectedType HTMLElement
+            elem;
+            // $ExpectedType any
+            computed;
+            // $ExpectedType any
+            extra;
+        },
+        set(elem, value) {
+            // $ExpectedType HTMLElement
+            elem;
+            // $ExpectedType any
+            value;
+        }
+    };
+
+    $.cssHooks.borderRadius = {
+        get(elem, computed, extra) {
+            // $ExpectedType HTMLElement
+            elem;
+            // $ExpectedType any
+            computed;
+            // $ExpectedType any
+            extra;
+        }
+    };
+
+    $.cssHooks.borderRadius = {
+        set(elem, value) {
+            // $ExpectedType HTMLElement
+            elem;
+            // $ExpectedType any
+            value;
+        }
+    };
+
+    // Weak type test. This may be removed if the TypeScript requirement is increased to 2.4+.
+    // $ExpectError
+    $.cssHooks.borderRadius = function get(elem: HTMLElement, computed: any, extra: any) {
+        return 1;
+    };
+}
+
 function JQuery_Promise3() {
-    interface I1 { kind: 'I1'; }
-    interface I2 { kind: 'I2'; }
-    interface I3 { kind: 'I3'; }
-    interface I4 { kind: 'I4'; }
-    interface I5 { kind: 'I5'; }
-    interface I6 { kind: 'I6'; }
-    interface I7 { kind: 'I7'; }
-    interface I8 { kind: 'I8'; }
-    interface I9 { kind: 'I9'; }
+    interface J1 { kind: 'J1'; }
+    interface J2 { kind: 'J2'; }
+    interface J3 { kind: 'J3'; }
+    interface J4 { kind: 'J4'; }
+    interface J5 { kind: 'J5'; }
+    interface J6 { kind: 'J6'; }
+    interface J7 { kind: 'J7'; }
+    interface J8 { kind: 'J8'; }
+    interface J9 { kind: 'J9'; }
 
-    // tslint:disable-next-line:ban-types
-    const p: JQuery.Promise3<string, Error, number, JQuery, string, boolean, any, Function, never> = {} as any;
-    const p1: JQuery.Promise3<I1, I2, I3, I4, I5, I6, I7, I8, I9> = {} as any;
-    const p2: JQuery.Promise3<I2, I3, I4, I5, I6, I7, I8, I9, I1> = {} as any;
-    const p3: JQuery.Promise3<I3, I4, I5, I6, I7, I8, I9, I1, I2> = {} as any;
+    const p: JQuery.Promise3<string, Error, number, JQuery, string, boolean, any, Element, never> = {} as any;
+    const p1: JQuery.Promise3<J1, J2, J3, J4, J5, J6, J7, J8, J9> = {} as any;
+    const p2: JQuery.Promise3<J2, J3, J4, J5, J6, J7, J8, J9, J1> = {} as any;
+    const p3: JQuery.Promise3<J3, J4, J5, J6, J7, J8, J9, J1, J2> = {} as any;
 
-    const t1: JQuery.Thenable<I1> = {} as any;
-    const t2: JQuery.Thenable<I2> = {} as any;
-    const t3: JQuery.Thenable<I3> = {} as any;
+    const t1: JQuery.Thenable<J1> = {} as any;
+    const t2: JQuery.Thenable<J2> = {} as any;
+    const t3: JQuery.Thenable<J3> = {} as any;
 
     function then() {
         p.then((a, b, c) => {
@@ -7099,7 +7198,7 @@ function JQuery_Promise3() {
         }, (a, b, c) => {
             a; // $ExpectType Error
             b; // $ExpectType string
-            c; // $ExpectType Function
+            c; // $ExpectType Element
         }, (a, b, c) => {
             a; // $ExpectType number
             b; // $ExpectType boolean
@@ -7109,7 +7208,7 @@ function JQuery_Promise3() {
         p.then(null, (a, b, c) => {
             a; // $ExpectType Error
             b; // $ExpectType string
-            c; // $ExpectType Function
+            c; // $ExpectType Element
         }, (a, b, c) => {
             a; // $ExpectType number
             b; // $ExpectType boolean
@@ -7139,7 +7238,7 @@ function JQuery_Promise3() {
         }, (a, b, c) => {
             a; // $ExpectType Error
             b; // $ExpectType string
-            c; // $ExpectType Function
+            c; // $ExpectType Element
         }, null);
 
         p.then((a, b, c) => {
@@ -7149,19 +7248,19 @@ function JQuery_Promise3() {
         }, (a, b, c) => {
             a; // $ExpectType Error
             b; // $ExpectType string
-            c; // $ExpectType Function
+            c; // $ExpectType Element
         });
 
         p.then(null, (a, b, c) => {
             a; // $ExpectType Error
             b; // $ExpectType string
-            c; // $ExpectType Function
+            c; // $ExpectType Element
         }, null);
 
         p.then(null, (a, b, c) => {
             a; // $ExpectType Error
             b; // $ExpectType string
-            c; // $ExpectType Function
+            c; // $ExpectType Element
         });
 
         p.then((a, b, c) => {
@@ -7204,7 +7303,7 @@ function JQuery_Promise3() {
             }, (a, b, c) => {
                 a; // $ExpectType Error
                 b; // $ExpectType string
-                c; // $ExpectType Function
+                c; // $ExpectType Element
             }, (a, b, c) => {
                 a; // $ExpectType number
                 b; // $ExpectType boolean
@@ -7234,7 +7333,7 @@ function JQuery_Promise3() {
             }, (a, b, c) => {
                 a; // $ExpectType Error
                 b; // $ExpectType string
-                c; // $ExpectType Function
+                c; // $ExpectType Element
             }, (a, b, c) => {
                 a; // $ExpectType number
                 b; // $ExpectType boolean
@@ -7271,7 +7370,7 @@ function JQuery_Promise3() {
                 });
 
                 q.then((a) => {
-                    a; // $ExpectType I1 | I2
+                    a; // $ExpectType J1 | J2
                 }, (a) => {
                     a; // $ExpectType never
                 }, (a, b, c) => {
@@ -7290,17 +7389,17 @@ function JQuery_Promise3() {
                 });
 
                 q.then((a, b, c) => {
-                    a; // $ExpectType I1 | I2
-                    b; // $ExpectType I4 | I5
-                    c; // $ExpectType I7 | I8
+                    a; // $ExpectType J1 | J2
+                    b; // $ExpectType J4 | J5
+                    c; // $ExpectType J7 | J8
                 }, (a, b, c) => {
-                    a; // $ExpectType I2 | I3
-                    b; // $ExpectType I5 | I6
-                    c; // $ExpectType I8 | I9
+                    a; // $ExpectType J2 | J3
+                    b; // $ExpectType J5 | J6
+                    c; // $ExpectType J8 | J9
                 }, (a, b, c) => {
-                    a; // $ExpectType I3 | I4
-                    b; // $ExpectType I6 | I7
-                    c; // $ExpectType I1 | I9
+                    a; // $ExpectType J3 | J4
+                    b; // $ExpectType J6 | J7
+                    c; // $ExpectType J1 | J9
                 });
             }
 
@@ -7313,7 +7412,7 @@ function JQuery_Promise3() {
                 });
 
                 q.then((a) => {
-                    a; // $ExpectType number | I1
+                    a; // $ExpectType number | J1
                 }, (a) => {
                     a; // never
                 }, (a, b, c) => {
@@ -7332,7 +7431,7 @@ function JQuery_Promise3() {
                 });
 
                 q.then((a) => {
-                    a; // $ExpectType number | I1
+                    a; // $ExpectType number | J1
                 }, (a) => {
                     a; // never
                 }, (a, b, c) => {
@@ -7351,17 +7450,17 @@ function JQuery_Promise3() {
                 });
 
                 q.then((a, b, c) => {
-                    a; // $ExpectType number | I1
-                    b; // $ExpectType I4
-                    c; // $ExpectType I7
+                    a; // $ExpectType number | J1
+                    b; // $ExpectType J4
+                    c; // $ExpectType J7
                 }, (a, b, c) => {
-                    a; // $ExpectType I2
-                    b; // $ExpectType I5
-                    c; // $ExpectType I8
+                    a; // $ExpectType J2
+                    b; // $ExpectType J5
+                    c; // $ExpectType J8
                 }, (a, b, c) => {
-                    a; // $ExpectType I3
-                    b; // $ExpectType I6
-                    c; // $ExpectType I9
+                    a; // $ExpectType J3
+                    b; // $ExpectType J6
+                    c; // $ExpectType J9
                 });
             }
 
@@ -7374,17 +7473,17 @@ function JQuery_Promise3() {
                 });
 
                 q.then((a, b, c) => {
-                    a; // $ExpectType number | I1
-                    b; // $ExpectType I4
-                    c; // $ExpectType I7
+                    a; // $ExpectType number | J1
+                    b; // $ExpectType J4
+                    c; // $ExpectType J7
                 }, (a, b, c) => {
-                    a; // $ExpectType I2
-                    b; // $ExpectType I5
-                    c; // $ExpectType I8
+                    a; // $ExpectType J2
+                    b; // $ExpectType J5
+                    c; // $ExpectType J8
                 }, (a, b, c) => {
-                    a; // $ExpectType I3
-                    b; // $ExpectType I6
-                    c; // $ExpectType I9
+                    a; // $ExpectType J3
+                    b; // $ExpectType J6
+                    c; // $ExpectType J9
                 });
             }
 
@@ -7397,17 +7496,17 @@ function JQuery_Promise3() {
                 });
 
                 q.then((a, b, c) => {
-                    a; // $ExpectType I1 | I2
-                    b; // $ExpectType I5
-                    c; // $ExpectType I8
+                    a; // $ExpectType J1 | J2
+                    b; // $ExpectType J5
+                    c; // $ExpectType J8
                 }, (a, b, c) => {
-                    a; // $ExpectType I3
-                    b; // $ExpectType I6
-                    c; // $ExpectType I9
+                    a; // $ExpectType J3
+                    b; // $ExpectType J6
+                    c; // $ExpectType J9
                 }, (a, b, c) => {
-                    a; // $ExpectType I4
-                    b; // $ExpectType I7
-                    c; // $ExpectType I1
+                    a; // $ExpectType J4
+                    b; // $ExpectType J7
+                    c; // $ExpectType J1
                 });
             }
 
@@ -7420,17 +7519,17 @@ function JQuery_Promise3() {
                 });
 
                 q.then((a, b, c) => {
-                    a; // $ExpectType I1 | I2
-                    b; // $ExpectType I4
-                    c; // $ExpectType I7
+                    a; // $ExpectType J1 | J2
+                    b; // $ExpectType J4
+                    c; // $ExpectType J7
                 }, (a, b, c) => {
-                    a; // $ExpectType I2
-                    b; // $ExpectType I5
-                    c; // $ExpectType I8
+                    a; // $ExpectType J2
+                    b; // $ExpectType J5
+                    c; // $ExpectType J8
                 }, (a, b, c) => {
-                    a; // $ExpectType I3
-                    b; // $ExpectType I6
-                    c; // $ExpectType I9
+                    a; // $ExpectType J3
+                    b; // $ExpectType J6
+                    c; // $ExpectType J9
                 });
             }
         }
@@ -7449,9 +7548,9 @@ function JQuery_Promise3() {
             const a = $.ajax('/echo/json').catch(() => {
                 return t1;
             });
-            // $ExpectType PromiseBase<I1, never, never, never, never, never, never, never, never, never, never, never>
+            // $ExpectType PromiseBase<J1, never, never, never, never, never, never, never, never, never, never, never>
             a;
-            const b: JQuery.Promise3<I1, never, never, never, never, never, never, never, never> = a;
+            const b: JQuery.Promise3<J1, never, never, never, never, never, never, never, never> = a;
         }
         {
             const a = $.ajax('/echo/json').catch(() => {
@@ -7809,21 +7908,218 @@ function JQuery_DeferredStatic() {
 }
 
 function JQuery_Deferred() {
-    interface I1 { kind: 'I1'; }
-    interface I2 { kind: 'I2'; }
-    interface I3 { kind: 'I3'; }
+    interface J1 { kind: 'J1'; }
+    interface J2 { kind: 'J2'; }
+    interface J3 { kind: 'J3'; }
 
-    const d1 = $.Deferred<I1, I2, I3>();
+    const d1 = $.Deferred<J1, J2, J3>();
 
     function promise() {
-        const target: I1 = {} as any;
+        const target: J1 = {} as any;
 
-        d1.promise(target); // $ExpectType Promise<I1, I2, I3> & I1
+        d1.promise(target); // $ExpectType Promise<J1, J2, J3> & J1
 
-        d1.promise(); // $ExpectType Promise<I1, I2, I3>
+        d1.promise(); // $ExpectType Promise<J1, J2, J3>
     }
 }
 
+function JQuery_EffectsOptions() {
+    $('p').show({
+        always(animation, jumpToEnd) {
+            // $ExpectType HTMLElement
+            this;
+            // $ExpectType Animation<HTMLElement>
+            animation;
+            // $ExpectType boolean
+            jumpToEnd;
+        },
+        complete() {
+            // $ExpectType HTMLElement
+            this;
+        },
+        done(animation, jumpToEnd) {
+            // $ExpectType HTMLElement
+            this;
+            // $ExpectType Animation<HTMLElement>
+            animation;
+            // $ExpectType boolean
+            jumpToEnd;
+        },
+        duration: 5000,
+        easing: 'linear',
+        fail(animation, jumpToEnd) {
+            // $ExpectType HTMLElement
+            this;
+            // $ExpectType Animation<HTMLElement>
+            animation;
+            // $ExpectType boolean
+            jumpToEnd;
+        },
+        progress(animation, progress, remainingMs) {
+            // $ExpectType HTMLElement
+            this;
+            // $ExpectType Animation<HTMLElement>
+            animation;
+            // $ExpectType number
+            progress;
+            // $ExpectType number
+            remainingMs;
+        },
+        queue: true,
+        specialEasing: {
+            width: 'linear',
+            height: 'easeOutBounce'
+        },
+        start(animation) {
+            // $ExpectType HTMLElement
+            this;
+            // $ExpectType Animation<HTMLElement>
+            animation;
+        },
+        step(now, tween) {
+            // $ExpectType HTMLElement
+            this;
+            // $ExpectType number
+            now;
+            // $ExpectType Tween<HTMLElement>
+            tween;
+        }
+    });
+}
+
+function JQuery_AnimationStatic() {
+    function call_signature() {
+        const element: HTMLElement = undefined!;
+
+        // $ExpectType Animation<HTMLElement>
+        $.Animation(element, {}, {});
+    }
+
+    function prefilter() {
+        // https://github.com/jquery/api.jquery.com/issues/256 -> http://jsfiddle.net/y4L35/
+        {
+            // $ExpectType void
+            $.Animation.prefilter(function(element: HTMLElement, properties, options) {
+                // $ExpectType Animation<HTMLElement>
+                this;
+                // $ExpectType HTMLElement
+                element;
+                // $ExpectType PlainObject<any>
+                properties;
+                // $ExpectType EffectsOptions<HTMLElement>
+                options;
+                // $ExpectType any
+                options.removeAfter;
+
+                if (options.removeAfter) {
+                    this.done(() => {
+                        $(element).remove();
+                    });
+                }
+            });
+
+            $("#element").hide({
+                duration: 500,
+                removeAfter: true,
+                complete() {
+                    // 0, because the prefilter done happens first!
+                    console.log($(this).parent().length);
+                }
+            });
+        }
+    }
+
+    function tweener() {
+        // $ExpectType void
+        $.Animation.tweener('*', function(propName, finalValue) {
+            // $ExpectType Animation<any>
+            this;
+            // $ExpectType string
+            propName;
+            // $ExpectType number
+            finalValue;
+
+            return this.createTween(propName, finalValue);
+        });
+    }
+}
+
+function JQuery_Animation() {
+    const element: Element = undefined!;
+
+    const animation = $.Animation(element, {}, {});
+
+    animation.done((anim, jumpedToEnd) => {
+        // $ExpectType Animation<Element>
+        anim;
+        // $ExpectType true | undefined
+        jumpedToEnd;
+    });
+
+    animation.fail((anim, jumpedToEnd) => {
+        // $ExpectType Animation<Element>
+        anim;
+        // $ExpectType false
+        jumpedToEnd;
+    });
+
+    animation.always((anim, jumpedToEnd) => {
+        // $ExpectType Animation<Element>
+        anim;
+        // $ExpectType boolean | undefined
+        jumpedToEnd;
+    });
+
+    animation.progress((anim, progress, remainingMs) => {
+        // $ExpectType Animation<Element>
+        anim;
+        // $ExpectType number
+        progress;
+        // $ExpectType number
+        remainingMs;
+    });
+}
+
+function JQuery_TweenStatic() {
+    function propHooks() {
+        $.Tween.propHooks['myProp'] = {
+            get(tween) {
+                // $ExpectType Tween<Node>
+                tween;
+
+                return tween.elem[tween.prop as keyof typeof tween.elem];
+            },
+            set(tween) {
+                // $ExpectType Tween<Node>
+                tween;
+            },
+        };
+
+        // Weak type test. This may be removed if the TypeScript requirement is increased to 2.4+.
+        // $ExpectError
+        $.Tween.propHooks['myProp'] = 1;
+    }
+
+    function call_signature() {
+        const elem: HTMLElement = undefined!;
+
+        // $ExpectType Tween<HTMLElement>
+        $.Tween(elem, {}, 'myProp', 1, 'myEasing', 'myUnit');
+
+        // $ExpectType Tween<HTMLElement>
+        $.Tween(elem, {}, 'myProp', 1, 'myEasing');
+
+        // $ExpectType Tween<HTMLElement>
+        $.Tween(elem, {}, 'myProp', 1);
+    }
+}
+
+function JQuery_Easings() {
+    jQuery.easing.easeInCubic = (p) => {
+        return Math.pow(p, 3);
+    };
+}
+
 function JQuery_Effects() {
     function interval() {
         // $ExpectType number
@@ -7839,76 +8135,39 @@ function JQuery_Effects() {
         // $ExpectType PlainObject<AnimationHook<Node>>
         $.fx.step;
     }
-}
 
-function JQuery_EffectsOptions() {
-    $('p').show({
-        always(animation, jumpToEnd) {
-            // $ExpectType HTMLElement
-            this;
-            // $ExpectType Promise<any, any, any>
-            animation;
-            // $ExpectType boolean
-            jumpToEnd;
-        },
-        complete() {
-            // $ExpectType HTMLElement
-            this;
-        },
-        done(animation, jumpToEnd) {
-            // $ExpectType HTMLElement
-            this;
-            // $ExpectType Promise<any, any, any>
-            animation;
-            // $ExpectType boolean
-            jumpToEnd;
-        },
-        duration: 5000,
-        easing: 'linear',
-        fail(animation, jumpToEnd) {
-            // $ExpectType HTMLElement
-            this;
-            // $ExpectType Promise<any, any, any>
-            animation;
-            // $ExpectType boolean
-            jumpToEnd;
-        },
-        progress(animation, progress, remainingMs) {
-            // $ExpectType HTMLElement
-            this;
-            // $ExpectType Promise<any, any, any>
-            animation;
-            // $ExpectType number
-            progress;
-            // $ExpectType number
-            remainingMs;
-        },
-        queue: true,
-        specialEasing: {
-            width: 'linear',
-            height: 'easeOutBounce'
-        },
-        start(animation) {
-            // $ExpectType HTMLElement
-            this;
-            // $ExpectType Promise<any, any, any>
-            animation;
-        },
-        step(now, tween) {
-            // $ExpectType HTMLElement
-            this;
-            // $ExpectType number
-            now;
-            // $ExpectType Tween<HTMLElement>
-            tween;
+    function stop() {
+        // $ExpectType () => void
+        $.fx.stop;
+
+        function override() {
+            let animating: boolean;
+
+            jQuery.fx.stop = () => {
+                animating = false;
+            };
         }
-    });
-}
+    }
 
-function JQuery_Easings() {
-    jQuery.easing.easeInCubic = (p) => {
-        return Math.pow(p, 3);
-    };
+    function timer() {
+        // $ExpectType (tickFunction: TickFunction<any>) => void
+        $.fx.timer;
+
+        function override() {
+            let animating: boolean;
+            const raf: () => void = {} as any;
+
+            jQuery.fx.timer = (timer) => {
+                // $ExpectType TickFunction<any>
+                timer;
+
+                if (timer() && jQuery.timers.push(timer) && !animating) {
+                    animating = true;
+                    raf();
+                }
+            };
+        }
+    }
 }
 
 function JQuery_Event() {
@@ -7940,3 +8199,130 @@ function JQuery_Event() {
         $(window).trigger(event);
     }
 }
+
+function JQuery_EventExtensions() {
+    function fixHooks() {
+        jQuery.event.fixHooks.drop = {
+            props: ['dataTransfer'],
+            filter(event, originalEvent) {
+                // $ExpectType Event<EventTarget, null>
+                event;
+                // $ExpectType Event
+                originalEvent;
+            },
+        };
+
+        // Weak type test. This may be removed if the TypeScript requirement is increased to 2.4+.
+        // $ExpectError
+        jQuery.event.fixHooks.drop = ['dataTransfer'];
+    }
+
+    function special() {
+        jQuery.event.special.multiclick = {
+            noBubble: true,
+            bindType: 'click',
+            delegateType: 'click',
+            setup(data, namespaces, eventHandle) {
+                // $ExpectType EventTarget
+                this;
+                // $ExpectType any
+                data;
+                // $ExpectType string
+                namespaces;
+                // $ExpectType EventHandler<EventTarget, any>
+                eventHandle;
+
+                return false;
+            },
+            teardown() {
+                // $ExpectType EventTarget
+                this;
+
+                return false;
+            },
+            add(handleObj) {
+                // $ExpectType EventTarget
+                this;
+                // $ExpectType HandleObject<EventTarget, any>
+                handleObj;
+            },
+            remove(handleObj) {
+                // $ExpectType EventTarget
+                this;
+                // $ExpectType HandleObject<EventTarget, any>
+                handleObj;
+            },
+            trigger(event, data) {
+                // $ExpectType EventTarget
+                this;
+                // $ExpectType Event<EventTarget, any>
+                event;
+                // $ExpectType any
+                data;
+
+                return false;
+            },
+            _default(event, data) {
+                // $ExpectType Event<EventTarget, any>
+                event;
+                // $ExpectType any
+                data;
+
+                return false;
+            },
+            handle(event, data) {
+                // $ExpectType Event<EventTarget, any> & { handleObj: HandleObject<EventTarget, any>; }
+                event;
+                // $ExpectType any
+                data;
+            },
+            preDispatch(event) {
+                // $ExpectType EventTarget
+                this;
+                // $ExpectType Event<EventTarget, any>
+                event;
+
+                return false;
+            },
+            postDispatch(event) {
+                // $ExpectType EventTarget
+                this;
+                // $ExpectType Event<EventTarget, any>
+                event;
+            }
+        };
+
+        // Weak type test. This may be removed if the TypeScript requirement is increased to 2.4+.
+        // $ExpectError
+        jQuery.event.special.multiclick = 1;
+    }
+}
+
+declare namespace JQuery {
+    interface ValHooks {
+        textarea: ValHook<HTMLTextAreaElement>;
+    }
+}
+
+function JQuery_ValHooks() {
+    jQuery.valHooks.textarea = {
+        get(elem) {
+            // $ExpectType HTMLTextAreaElement
+            elem;
+
+            return elem.value.replace(/\r?\n/g, "\r\n");
+        },
+        set(elem) {
+            // $ExpectType HTMLTextAreaElement
+            elem;
+
+            return elem.value;
+        }
+    };
+
+    // Weak type test. This may be removed if the TypeScript requirement is increased to 2.4+.
+    // $ExpectError
+    jQuery.valHooks.textarea = function get(elem: HTMLTextAreaElement) {
+        return elem.value.replace(/\r?\n/g, "\r\n");
+    };
+}
diff --git a/types/jquery/legacy.d.ts b/types/jquery/legacy.d.ts
new file mode 100644
index 0000000000..a3a98b936c
--- /dev/null
+++ b/types/jquery/legacy.d.ts
@@ -0,0 +1,201 @@
+// tslint:disable:no-irregular-whitespace
+
+// tslint:disable-next-line:no-empty-interface
+interface JQueryCallback extends JQuery.Callbacks { }
+interface JQueryDeferred<T> extends JQuery.Deferred<T> { }
+// tslint:disable-next-line:no-empty-interface
+interface JQueryEventConstructor extends JQuery.EventStatic { }
+interface JQueryDeferred<T> extends JQuery.Deferred<T> { }
+// tslint:disable-next-line:no-empty-interface
+interface JQueryAjaxSettings extends JQuery.AjaxSettings { }
+interface JQueryAnimationOptions extends JQuery.EffectsOptions<Element> { }
+// tslint:disable-next-line:no-empty-interface
+interface JQueryCoordinates extends JQuery.Coordinates { }
+interface JQueryGenericPromise<T> extends JQuery.Thenable<T> { }
+// tslint:disable-next-line:no-empty-interface
+interface JQueryXHR extends JQuery.jqXHR { }
+interface JQueryPromise<T> extends JQuery.Promise<T> { }
+// tslint:disable-next-line:no-empty-interface
+interface JQuerySerializeArrayElement extends JQuery.NameValuePair { }
+
+/**
+ * @deprecated ​ Deprecated since 1.9. See \`{@link https://api.jquery.com/jQuery.support/ }\`.
+ */
+// tslint:disable-next-line:no-empty-interface
+interface JQuerySupport extends JQuery.PlainObject { }
+
+// Legacy types that are not represented in the current type definitions are marked deprecated.
+
+/**
+ * @deprecated ​ Deprecated. Use \`{@link JQuery.Deferred.Callback }\` or \`{@link JQuery.Deferred.CallbackBase }\`.
+ */
+interface JQueryPromiseCallback<T> {
+    // tslint:disable-next-line:callable-types
+    (value?: T, ...args: any[]): void;
+}
+/**
+ * @deprecated ​ Deprecated. Use \`{@link JQueryStatic.param JQueryStatic&#91;'param'&#93;}\`.
+ */
+interface JQueryParam {
+    /**
+     * Create a serialized representation of an array or object, suitable for use in a URL query string or Ajax request.
+     * @param obj An array or object to serialize.
+     * @param traditional A Boolean indicating whether to perform a traditional "shallow" serialization.
+     */
+    // tslint:disable-next-line:callable-types
+    (obj: any, traditional?: boolean): string;
+}
+/**
+ * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\`.
+ */
+interface BaseJQueryEventObject extends Event {
+    /**
+     * The current DOM element within the event bubbling phase.
+     * @see \`{@link https://api.jquery.com/event.currentTarget/ }\`
+     */
+    currentTarget: Element;
+    /**
+     * An optional object of data passed to an event method when the current executing handler is bound.
+     * @see \`{@link https://api.jquery.com/event.data/ }\`
+     */
+    data: any;
+    /**
+     * The element where the currently-called jQuery event handler was attached.
+     * @see \`{@link https://api.jquery.com/event.delegateTarget/ }\`
+     */
+    delegateTarget: Element;
+    /**
+     * Returns whether event.preventDefault() was ever called on this event object.
+     * @see \`{@link https://api.jquery.com/event.isDefaultPrevented/ }\`
+     */
+    isDefaultPrevented(): boolean;
+    /**
+     * Returns whether event.stopImmediatePropagation() was ever called on this event object.
+     * @see \`{@link https://api.jquery.com/event.isImmediatePropagationStopped/ }\`
+     */
+    isImmediatePropagationStopped(): boolean;
+    /**
+     * Returns whether event.stopPropagation() was ever called on this event object.
+     * @see \`{@link https://api.jquery.com/event.isPropagationStopped/ }\`
+     */
+    isPropagationStopped(): boolean;
+    /**
+     * The namespace specified when the event was triggered.
+     * @see \`{@link https://api.jquery.com/event.namespace/ }\`
+     */
+    namespace: string;
+    /**
+     * The browser's original Event object.
+     * @see \`{@link https://api.jquery.com/category/events/event-object/ }\`
+     */
+    originalEvent: Event;
+    /**
+     * If this method is called, the default action of the event will not be triggered.
+     * @see \`{@link https://api.jquery.com/event.preventDefault/ }\`
+     */
+    preventDefault(): any;
+    /**
+     * The other DOM element involved in the event, if any.
+     * @see \`{@link https://api.jquery.com/event.relatedTarget/ }\`
+     */
+    relatedTarget: Element;
+    /**
+     * The last value returned by an event handler that was triggered by this event, unless the value was undefined.
+     * @see \`{@link https://api.jquery.com/event.result/ }\`
+     */
+    result: any;
+    /**
+     * Keeps the rest of the handlers from being executed and prevents the event from bubbling up the DOM tree.
+     * @see \`{@link https://api.jquery.com/event.stopImmediatePropagation/ }\`
+     */
+    stopImmediatePropagation(): void;
+    /**
+     * Prevents the event from bubbling up the DOM tree, preventing any parent handlers from being notified of the event.
+     * @see \`{@link https://api.jquery.com/event.stopPropagation/ }\`
+     */
+    stopPropagation(): void;
+    /**
+     * The DOM element that initiated the event.
+     * @see \`{@link https://api.jquery.com/event.target/ }\`
+     */
+    target: Element;
+    /**
+     * The mouse position relative to the left edge of the document.
+     * @see \`{@link https://api.jquery.com/event.pageX/ }\`
+     */
+    pageX: number;
+    /**
+     * The mouse position relative to the top edge of the document.
+     * @see \`{@link https://api.jquery.com/event.pageY/ }\`
+     */
+    pageY: number;
+    /**
+     * For key or mouse events, this property indicates the specific key or button that was pressed.
+     * @see \`{@link https://api.jquery.com/event.which/ }\`
+     */
+    which: number;
+    /**
+     * Indicates whether the META key was pressed when the event fired.
+     * @see \`{@link https://api.jquery.com/event.metaKey/ }\`
+     */
+    metaKey: boolean;
+}
+/**
+ * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\`.
+ */
+interface JQueryInputEventObject extends BaseJQueryEventObject {
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    shiftKey: boolean;
+}
+/**
+ * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\`.
+ */
+interface JQueryMouseEventObject extends JQueryInputEventObject {
+    button: number;
+    clientX: number;
+    clientY: number;
+    offsetX: number;
+    offsetY: number;
+    pageX: number;
+    pageY: number;
+    screenX: number;
+    screenY: number;
+}
+/**
+ * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\`.
+ */
+interface JQueryKeyEventObject extends JQueryInputEventObject {
+    char: any;
+    charCode: number;
+    key: any;
+    keyCode: number;
+}
+/**
+ * @deprecated ​ Deprecated. Use \`{@link JQuery.Event }\`.
+ */
+interface JQueryEventObject extends BaseJQueryEventObject, JQueryInputEventObject, JQueryMouseEventObject, JQueryKeyEventObject { }
+/**
+ * @deprecated ​ Deprecated.
+ */
+interface JQueryPromiseOperator<T, U> {
+    // tslint:disable-next-line:callable-types
+    (callback1: JQuery.TypeOrArray<JQueryPromiseCallback<T>>,
+     ...callbacksN: Array<JQuery.TypeOrArray<JQueryPromiseCallback<any>>>): JQueryPromise<U>;
+}
+/**
+ * @deprecated ​ Deprecated. Internal. See \`{@link https://github.com/jquery/api.jquery.com/issues/912 }\`.
+ */
+interface JQueryEasingFunction {
+    // tslint:disable-next-line:callable-types
+    (percent: number): number;
+}
+/**
+ * @deprecated ​ Deprecated. Internal. See \`{@link https://github.com/jquery/api.jquery.com/issues/912 }\`.
+ */
+interface JQueryEasingFunctions {
+    [name: string]: JQueryEasingFunction;
+    linear: JQueryEasingFunction;
+    swing: JQueryEasingFunction;
+}
diff --git a/types/jquery/misc.d.ts b/types/jquery/misc.d.ts
new file mode 100644
index 0000000000..7b09b6a4dc
--- /dev/null
+++ b/types/jquery/misc.d.ts
@@ -0,0 +1,5012 @@
+// tslint:disable:jsdoc-format
+// tslint:disable:max-line-length
+// tslint:disable:no-irregular-whitespace
+
+declare namespace JQuery {
+    type TypeOrArray<T> = T | T[];
+    type Node = Element | Text | Comment | DocumentFragment;
+
+    /**
+     * A string is designated htmlString in jQuery documentation when it is used to represent one or more DOM elements, typically to be created and inserted in the document. When passed as an argument of the jQuery() function, the string is identified as HTML if it starts with <tag ... >) and is parsed as such until the final > character. Prior to jQuery 1.9, a string was considered to be HTML if it contained <tag ... > anywhere within the string.
+     */
+    type htmlString = string;
+    /**
+     * A selector is used in jQuery to select DOM elements from a DOM document. That document is, in most cases, the DOM document present in all browsers, but can also be an XML document received via Ajax.
+     */
+    type Selector = string;
+
+    /**
+     * The PlainObject type is a JavaScript object containing zero or more key-value pairs. The plain object is, in other words, an Object object. It is designated "plain" in jQuery documentation to distinguish it from other kinds of JavaScript objects: for example, null, user-defined arrays, and host objects such as document, all of which have a typeof value of "object."
+     *
+     * **Note**: The type declaration of PlainObject is imprecise. It includes host objects and user-defined arrays which do not match jQuery's definition.
+     */
+    interface PlainObject<T = any> {
+        [key: string]: T;
+    }
+
+    interface Selectors extends Sizzle.Selectors {
+        /**
+         * @deprecated ​ Deprecated since 3.0. Use \`{@link Selectors#pseudos }\`.
+         *
+         * **Cause**: The standard way to add new custom selectors through jQuery is `jQuery.expr.pseudos`. These two other aliases are deprecated, although they still work as of jQuery 3.0.
+         *
+         * **Solution**: Rename any of the older usage to `jQuery.expr.pseudos`. The functionality is identical.
+         */
+        ':': Sizzle.Selectors.PseudoFunctions;
+        /**
+         * @deprecated ​ Deprecated since 3.0. Use \`{@link Selectors#pseudos }\`.
+         *
+         * **Cause**: The standard way to add new custom selectors through jQuery is `jQuery.expr.pseudos`. These two other aliases are deprecated, although they still work as of jQuery 3.0.
+         *
+         * **Solution**: Rename any of the older usage to `jQuery.expr.pseudos`. The functionality is identical.
+         */
+        filter: Sizzle.Selectors.FilterFunctions;
+    }
+
+    // region Ajax
+    // #region Ajax
+
+    interface AjaxSettings<TContext = any> extends Ajax.AjaxSettingsBase<TContext> {
+        /**
+         * A string containing the URL to which the request is sent.
+         */
+        url?: string;
+    }
+
+    interface UrlAjaxSettings<TContext = any> extends Ajax.AjaxSettingsBase<TContext> {
+        /**
+         * A string containing the URL to which the request is sent.
+         */
+        url: string;
+    }
+
+    namespace Ajax {
+        type SuccessTextStatus = 'success' | 'notmodified' | 'nocontent';
+        type ErrorTextStatus = 'timeout' | 'error' | 'abort' | 'parsererror';
+        type TextStatus = SuccessTextStatus | ErrorTextStatus;
+
+        type SuccessCallback<TContext> = (this: TContext, data: any, textStatus: SuccessTextStatus, jqXHR: jqXHR) => void;
+
+        type ErrorCallback<TContext> = (this: TContext, jqXHR: jqXHR, textStatus: ErrorTextStatus, errorThrown: string) => void;
+
+        type CompleteCallback<TContext> = (this: TContext, jqXHR: jqXHR, textStatus: TextStatus) => void;
+
+        /**
+         * @see \`{@link https://api.jquery.com/jquery.ajax/#jQuery-ajax-settings }\`
+         */
+        interface AjaxSettingsBase<TContext> {
+            /**
+             * A set of key/value pairs that map a given dataType to its MIME type, which gets sent in the Accept request header. This header tells the server what kind of response it will accept in return.
+             */
+            accepts?: PlainObject<string>;
+            /**
+             * By default, all requests are sent asynchronously (i.e. this is set to true by default). If you need synchronous requests, set this option to false. Cross-domain requests and dataType: "jsonp" requests do not support synchronous operation. Note that synchronous requests may temporarily lock the browser, disabling any actions while the request is active. As of jQuery 1.8, the use of async: false with jqXHR ($.Deferred) is deprecated; you must use the success/error/complete callback options instead of the corresponding methods of the jqXHR object such as jqXHR.done().
+             */
+            async?: boolean;
+            /**
+             * A pre-request callback function that can be used to modify the jqXHR (in jQuery 1.4.x, XMLHTTPRequest) object before it is sent. Use this to set custom headers, etc. The jqXHR and settings objects are passed as arguments. This is an Ajax Event. Returning false in the beforeSend function will cancel the request. As of jQuery 1.5, the beforeSend option will be called regardless of the type of request.
+             */
+            beforeSend?(this: TContext, jqXHR: jqXHR, settings: this): false | void;
+            /**
+             * If set to false, it will force requested pages not to be cached by the browser. Note: Setting cache to false will only work correctly with HEAD and GET requests. It works by appending "_={timestamp}" to the GET parameters. The parameter is not needed for other types of requests, except in IE8 when a POST is made to a URL that has already been requested by a GET.
+             */
+            cache?: boolean;
+            /**
+             * A function to be called when the request finishes (after success and error callbacks are executed). The function gets passed two arguments: The jqXHR (in jQuery 1.4.x, XMLHTTPRequest) object and a string categorizing the status of the request ("success", "notmodified", "nocontent", "error", "timeout", "abort", or "parsererror"). As of jQuery 1.5, the complete setting can accept an array of functions. Each function will be called in turn. This is an Ajax Event.
+             */
+            complete?: TypeOrArray<CompleteCallback<TContext>>;
+            /**
+             * An object of string/regular-expression pairs that determine how jQuery will parse the response, given its content type.
+             */
+            contents?: PlainObject<RegExp>;
+            /**
+             * When sending data to the server, use this content type. Default is "application/x-www-form-urlencoded; charset=UTF-8", which is fine for most cases. If you explicitly pass in a content-type to $.ajax(), then it is always sent to the server (even if no data is sent). As of jQuery 1.6 you can pass false to tell jQuery to not set any content type header. Note: The W3C XMLHttpRequest specification dictates that the charset is always UTF-8; specifying another charset will not force the browser to change the encoding. Note: For cross-domain requests, setting the content type to anything other than application/x-www-form-urlencoded, multipart/form-data, or text/plain will trigger the browser to send a preflight OPTIONS request to the server.
+             */
+            contentType?: string | false;
+            /**
+             * This object will be the context of all Ajax-related callbacks. By default, the context is an object that represents the Ajax settings used in the call ($.ajaxSettings merged with the settings passed to $.ajax).
+             */
+            context?: TContext;
+            /**
+             * An object containing dataType-to-dataType converters. Each converter's value is a function that returns the transformed value of the response.
+             */
+            converters?: PlainObject<((value: any) => any) | true>;
+            /**
+             * If you wish to force a crossDomain request (such as JSONP) on the same domain, set the value of crossDomain to true. This allows, for example, server-side redirection to another domain.
+             */
+            crossDomain?: boolean;
+            /**
+             * Data to be sent to the server. It is converted to a query string, if not already a string. It's appended to the url for GET-requests. See processData option to prevent this automatic processing. Object must be Key/Value pairs. If value is an Array, jQuery serializes multiple values with same key based on the value of the traditional setting (described below).
+             */
+            data?: PlainObject | string;
+            /**
+             * A function to be used to handle the raw response data of XMLHttpRequest. This is a pre-filtering function to sanitize the response. You should return the sanitized data. The function accepts two arguments: The raw data returned from the server and the 'dataType' parameter.
+             */
+            dataFilter?(data: string, type: string): any;
+            /**
+             * The type of data that you're expecting back from the server. If none is specified, jQuery will try to infer it based on the MIME type of the response (an XML MIME type will yield XML, in 1.4 JSON will yield a JavaScript object, in 1.4 script will execute the script, and anything else will be returned as a string). The available types (and the result passed as the first argument to your success callback) are:
+             *
+             * "xml": Returns a XML document that can be processed via jQuery.
+             *
+             * "html": Returns HTML as plain text; included script tags are evaluated when inserted in the DOM.
+             *
+             * "script": Evaluates the response as JavaScript and returns it as plain text. Disables caching by appending a query string parameter, _=[TIMESTAMP], to the URL unless the cache option is set to true. Note: This will turn POSTs into GETs for remote-domain requests.
+             *
+             * "json": Evaluates the response as JSON and returns a JavaScript object. Cross-domain "json" requests are converted to "jsonp" unless the request includes jsonp: false in its request options. The JSON data is parsed in a strict manner; any malformed JSON is rejected and a parse error is thrown. As of jQuery 1.9, an empty response is also rejected; the server should return a response of null or {} instead. (See json.org for more information on proper JSON formatting.)
+             *
+             * "jsonp": Loads in a JSON block using JSONP. Adds an extra "?callback=?" to the end of your URL to specify the callback. Disables caching by appending a query string parameter, "_=[TIMESTAMP]", to the URL unless the cache option is set to true.
+             *
+             * "text": A plain text string.
+             *
+             * multiple, space-separated values: As of jQuery 1.5, jQuery can convert a dataType from what it received in the Content-Type header to what you require. For example, if you want a text response to be treated as XML, use "text xml" for the dataType. You can also make a JSONP request, have it received as text, and interpreted by jQuery as XML: "jsonp text xml". Similarly, a shorthand string such as "jsonp xml" will first attempt to convert from jsonp to xml, and, failing that, convert from jsonp to text, and then from text to xml.
+             */
+            dataType?: 'xml' | 'html' | 'script' | 'json' | 'jsonp' | 'text' | string;
+            /**
+             * A function to be called if the request fails. The function receives three arguments: The jqXHR (in jQuery 1.4.x, XMLHttpRequest) object, a string describing the type of error that occurred and an optional exception object, if one occurred. Possible values for the second argument (besides null) are "timeout", "error", "abort", and "parsererror". When an HTTP error occurs, errorThrown receives the textual portion of the HTTP status, such as "Not Found" or "Internal Server Error." As of jQuery 1.5, the error setting can accept an array of functions. Each function will be called in turn. Note: This handler is not called for cross-domain script and cross-domain JSONP requests. This is an Ajax Event.
+             */
+            error?: TypeOrArray<ErrorCallback<TContext>>;
+            /**
+             * Whether to trigger global Ajax event handlers for this request. The default is true. Set to false to prevent the global handlers like ajaxStart or ajaxStop from being triggered. This can be used to control various Ajax Events.
+             */
+            global?: boolean;
+            /**
+             * An object of additional header key/value pairs to send along with requests using the XMLHttpRequest transport. The header X-Requested-With: XMLHttpRequest is always added, but its default XMLHttpRequest value can be changed here. Values in the headers setting can also be overwritten from within the beforeSend function.
+             */
+            headers?: PlainObject<string | null | undefined>;
+            /**
+             * Allow the request to be successful only if the response has changed since the last request. This is done by checking the Last-Modified header. Default value is false, ignoring the header. In jQuery 1.4 this technique also checks the 'etag' specified by the server to catch unmodified data.
+             */
+            ifModified?: boolean;
+            /**
+             * Allow the current environment to be recognized as "local," (e.g. the filesystem), even if jQuery does not recognize it as such by default. The following protocols are currently recognized as local: file, *-extension, and widget. If the isLocal setting needs modification, it is recommended to do so once in the $.ajaxSetup() method.
+             */
+            isLocal?: boolean;
+            /**
+             * Override the callback function name in a JSONP request. This value will be used instead of 'callback' in the 'callback=?' part of the query string in the url. So {jsonp:'onJSONPLoad'} would result in 'onJSONPLoad=?' passed to the server. As of jQuery 1.5, setting the jsonp option to false prevents jQuery from adding the "?callback" string to the URL or attempting to use "=?" for transformation. In this case, you should also explicitly set the jsonpCallback setting. For example, { jsonp: false, jsonpCallback: "callbackName" }. If you don't trust the target of your Ajax requests, consider setting the jsonp property to false for security reasons.
+             */
+            jsonp?: string | false;
+            /**
+             * Specify the callback function name for a JSONP request. This value will be used instead of the random name automatically generated by jQuery. It is preferable to let jQuery generate a unique name as it'll make it easier to manage the requests and provide callbacks and error handling. You may want to specify the callback when you want to enable better browser caching of GET requests. As of jQuery 1.5, you can also use a function for this setting, in which case the value of jsonpCallback is set to the return value of that function.
+             */
+            jsonpCallback?: string | ((this: TContext) => string);
+            /**
+             * The HTTP method to use for the request (e.g. "POST", "GET", "PUT").
+             */
+            method?: string;
+            /**
+             * A mime type to override the XHR mime type.
+             */
+            mimeType?: string;
+            /**
+             * A password to be used with XMLHttpRequest in response to an HTTP access authentication request.
+             */
+            password?: string;
+            /**
+             * By default, data passed in to the data option as an object (technically, anything other than a string) will be processed and transformed into a query string, fitting to the default content-type "application/x-www-form-urlencoded". If you want to send a DOMDocument, or other non-processed data, set this option to false.
+             */
+            processData?: boolean;
+            /**
+             * Only applies when the "script" transport is used (e.g., cross-domain requests with "jsonp" or "script" dataType and "GET" type). Sets the charset attribute on the script tag used in the request. Used when the character set on the local page is not the same as the one on the remote script.
+             */
+            scriptCharset?: string;
+            /**
+             * An object of numeric HTTP codes and functions to be called when the response has the corresponding code.
+             *
+             * If the request is successful, the status code functions take the same parameters as the success callback; if it results in an error (including 3xx redirect), they take the same parameters as the error callback.
+             */
+            statusCode?: StatusCodeCallbacks<TContext>;
+            /**
+             * A function to be called if the request succeeds. The function gets passed three arguments: The data returned from the server, formatted according to the dataType parameter or the dataFilter callback function, if specified; a string describing the status; and the jqXHR (in jQuery 1.4.x, XMLHttpRequest) object. As of jQuery 1.5, the success setting can accept an array of functions. Each function will be called in turn. This is an Ajax Event.
+             */
+            success?: TypeOrArray<SuccessCallback<TContext>>;
+            /**
+             * Set a timeout (in milliseconds) for the request. A value of 0 means there will be no timeout. This will override any global timeout set with $.ajaxSetup(). The timeout period starts at the point the $.ajax call is made; if several other requests are in progress and the browser has no connections available, it is possible for a request to time out before it can be sent. In jQuery 1.4.x and below, the XMLHttpRequest object will be in an invalid state if the request times out; accessing any object members may throw an exception. In Firefox 3.0+ only, script and JSONP requests cannot be cancelled by a timeout; the script will run even if it arrives after the timeout period.
+             */
+            timeout?: number;
+            /**
+             * Set this to true if you wish to use the traditional style of param serialization.
+             */
+            traditional?: boolean;
+            /**
+             * An alias for method. You should use type if you're using versions of jQuery prior to 1.9.0.
+             */
+            type?: string;
+            /**
+             * A username to be used with XMLHttpRequest in response to an HTTP access authentication request.
+             */
+            username?: string;
+            // ActiveXObject requires "lib": ["scripthost"] which consumers would also require
+            /**
+             * Callback for creating the XMLHttpRequest object. Defaults to the ActiveXObject when available (IE), the XMLHttpRequest otherwise. Override to provide your own implementation for XMLHttpRequest or enhancements to the factory.
+             */
+            xhr?(): XMLHttpRequest;
+            /**
+             * An object of fieldName-fieldValue pairs to set on the native XHR object.
+             *
+             * In jQuery 1.5, the withCredentials property was not propagated to the native XHR and thus CORS requests requiring it would ignore this flag. For this reason, we recommend using jQuery 1.5.1+ should you require the use of it.
+             */
+            xhrFields?: XHRFields;
+        }
+
+        // region StatusCodeCallbacks
+        // #region StatusCodeCallbacks
+
+        type StatusCodeCallbacks<TContext> = {
+            // region Success Status Codes
+            // #region Success Status Codes
+
+            // jQuery treats 2xx and 304 status codes as a success
+
+            200?: SuccessCallback<TContext>;
+            201?: SuccessCallback<TContext>;
+            202?: SuccessCallback<TContext>;
+            203?: SuccessCallback<TContext>;
+            204?: SuccessCallback<TContext>;
+            205?: SuccessCallback<TContext>;
+            206?: SuccessCallback<TContext>;
+            207?: SuccessCallback<TContext>;
+            208?: SuccessCallback<TContext>;
+            209?: SuccessCallback<TContext>;
+            210?: SuccessCallback<TContext>;
+            211?: SuccessCallback<TContext>;
+            212?: SuccessCallback<TContext>;
+            213?: SuccessCallback<TContext>;
+            214?: SuccessCallback<TContext>;
+            215?: SuccessCallback<TContext>;
+            216?: SuccessCallback<TContext>;
+            217?: SuccessCallback<TContext>;
+            218?: SuccessCallback<TContext>;
+            219?: SuccessCallback<TContext>;
+            220?: SuccessCallback<TContext>;
+            221?: SuccessCallback<TContext>;
+            222?: SuccessCallback<TContext>;
+            223?: SuccessCallback<TContext>;
+            224?: SuccessCallback<TContext>;
+            225?: SuccessCallback<TContext>;
+            226?: SuccessCallback<TContext>;
+            227?: SuccessCallback<TContext>;
+            228?: SuccessCallback<TContext>;
+            229?: SuccessCallback<TContext>;
+            230?: SuccessCallback<TContext>;
+            231?: SuccessCallback<TContext>;
+            232?: SuccessCallback<TContext>;
+            233?: SuccessCallback<TContext>;
+            234?: SuccessCallback<TContext>;
+            235?: SuccessCallback<TContext>;
+            236?: SuccessCallback<TContext>;
+            237?: SuccessCallback<TContext>;
+            238?: SuccessCallback<TContext>;
+            239?: SuccessCallback<TContext>;
+            240?: SuccessCallback<TContext>;
+            241?: SuccessCallback<TContext>;
+            242?: SuccessCallback<TContext>;
+            243?: SuccessCallback<TContext>;
+            244?: SuccessCallback<TContext>;
+            245?: SuccessCallback<TContext>;
+            246?: SuccessCallback<TContext>;
+            247?: SuccessCallback<TContext>;
+            248?: SuccessCallback<TContext>;
+            249?: SuccessCallback<TContext>;
+            250?: SuccessCallback<TContext>;
+            251?: SuccessCallback<TContext>;
+            252?: SuccessCallback<TContext>;
+            253?: SuccessCallback<TContext>;
+            254?: SuccessCallback<TContext>;
+            255?: SuccessCallback<TContext>;
+            256?: SuccessCallback<TContext>;
+            257?: SuccessCallback<TContext>;
+            258?: SuccessCallback<TContext>;
+            259?: SuccessCallback<TContext>;
+            260?: SuccessCallback<TContext>;
+            261?: SuccessCallback<TContext>;
+            262?: SuccessCallback<TContext>;
+            263?: SuccessCallback<TContext>;
+            264?: SuccessCallback<TContext>;
+            265?: SuccessCallback<TContext>;
+            266?: SuccessCallback<TContext>;
+            267?: SuccessCallback<TContext>;
+            268?: SuccessCallback<TContext>;
+            269?: SuccessCallback<TContext>;
+            270?: SuccessCallback<TContext>;
+            271?: SuccessCallback<TContext>;
+            272?: SuccessCallback<TContext>;
+            273?: SuccessCallback<TContext>;
+            274?: SuccessCallback<TContext>;
+            275?: SuccessCallback<TContext>;
+            276?: SuccessCallback<TContext>;
+            277?: SuccessCallback<TContext>;
+            278?: SuccessCallback<TContext>;
+            279?: SuccessCallback<TContext>;
+            280?: SuccessCallback<TContext>;
+            281?: SuccessCallback<TContext>;
+            282?: SuccessCallback<TContext>;
+            283?: SuccessCallback<TContext>;
+            284?: SuccessCallback<TContext>;
+            285?: SuccessCallback<TContext>;
+            286?: SuccessCallback<TContext>;
+            287?: SuccessCallback<TContext>;
+            288?: SuccessCallback<TContext>;
+            289?: SuccessCallback<TContext>;
+            290?: SuccessCallback<TContext>;
+            291?: SuccessCallback<TContext>;
+            292?: SuccessCallback<TContext>;
+            293?: SuccessCallback<TContext>;
+            294?: SuccessCallback<TContext>;
+            295?: SuccessCallback<TContext>;
+            296?: SuccessCallback<TContext>;
+            297?: SuccessCallback<TContext>;
+            298?: SuccessCallback<TContext>;
+            299?: SuccessCallback<TContext>;
+            304?: SuccessCallback<TContext>;
+
+            // #endregion
+
+            // region Error Status Codes
+            // #region Error Status Codes
+
+            300?: ErrorCallback<TContext>;
+            301?: ErrorCallback<TContext>;
+            302?: ErrorCallback<TContext>;
+            303?: ErrorCallback<TContext>;
+            305?: ErrorCallback<TContext>;
+            306?: ErrorCallback<TContext>;
+            307?: ErrorCallback<TContext>;
+            308?: ErrorCallback<TContext>;
+            309?: ErrorCallback<TContext>;
+            310?: ErrorCallback<TContext>;
+            311?: ErrorCallback<TContext>;
+            312?: ErrorCallback<TContext>;
+            313?: ErrorCallback<TContext>;
+            314?: ErrorCallback<TContext>;
+            315?: ErrorCallback<TContext>;
+            316?: ErrorCallback<TContext>;
+            317?: ErrorCallback<TContext>;
+            318?: ErrorCallback<TContext>;
+            319?: ErrorCallback<TContext>;
+            320?: ErrorCallback<TContext>;
+            321?: ErrorCallback<TContext>;
+            322?: ErrorCallback<TContext>;
+            323?: ErrorCallback<TContext>;
+            324?: ErrorCallback<TContext>;
+            325?: ErrorCallback<TContext>;
+            326?: ErrorCallback<TContext>;
+            327?: ErrorCallback<TContext>;
+            328?: ErrorCallback<TContext>;
+            329?: ErrorCallback<TContext>;
+            330?: ErrorCallback<TContext>;
+            331?: ErrorCallback<TContext>;
+            332?: ErrorCallback<TContext>;
+            333?: ErrorCallback<TContext>;
+            334?: ErrorCallback<TContext>;
+            335?: ErrorCallback<TContext>;
+            336?: ErrorCallback<TContext>;
+            337?: ErrorCallback<TContext>;
+            338?: ErrorCallback<TContext>;
+            339?: ErrorCallback<TContext>;
+            340?: ErrorCallback<TContext>;
+            341?: ErrorCallback<TContext>;
+            342?: ErrorCallback<TContext>;
+            343?: ErrorCallback<TContext>;
+            344?: ErrorCallback<TContext>;
+            345?: ErrorCallback<TContext>;
+            346?: ErrorCallback<TContext>;
+            347?: ErrorCallback<TContext>;
+            348?: ErrorCallback<TContext>;
+            349?: ErrorCallback<TContext>;
+            350?: ErrorCallback<TContext>;
+            351?: ErrorCallback<TContext>;
+            352?: ErrorCallback<TContext>;
+            353?: ErrorCallback<TContext>;
+            354?: ErrorCallback<TContext>;
+            355?: ErrorCallback<TContext>;
+            356?: ErrorCallback<TContext>;
+            357?: ErrorCallback<TContext>;
+            358?: ErrorCallback<TContext>;
+            359?: ErrorCallback<TContext>;
+            360?: ErrorCallback<TContext>;
+            361?: ErrorCallback<TContext>;
+            362?: ErrorCallback<TContext>;
+            363?: ErrorCallback<TContext>;
+            364?: ErrorCallback<TContext>;
+            365?: ErrorCallback<TContext>;
+            366?: ErrorCallback<TContext>;
+            367?: ErrorCallback<TContext>;
+            368?: ErrorCallback<TContext>;
+            369?: ErrorCallback<TContext>;
+            370?: ErrorCallback<TContext>;
+            371?: ErrorCallback<TContext>;
+            372?: ErrorCallback<TContext>;
+            373?: ErrorCallback<TContext>;
+            374?: ErrorCallback<TContext>;
+            375?: ErrorCallback<TContext>;
+            376?: ErrorCallback<TContext>;
+            377?: ErrorCallback<TContext>;
+            378?: ErrorCallback<TContext>;
+            379?: ErrorCallback<TContext>;
+            380?: ErrorCallback<TContext>;
+            381?: ErrorCallback<TContext>;
+            382?: ErrorCallback<TContext>;
+            383?: ErrorCallback<TContext>;
+            384?: ErrorCallback<TContext>;
+            385?: ErrorCallback<TContext>;
+            386?: ErrorCallback<TContext>;
+            387?: ErrorCallback<TContext>;
+            388?: ErrorCallback<TContext>;
+            389?: ErrorCallback<TContext>;
+            390?: ErrorCallback<TContext>;
+            391?: ErrorCallback<TContext>;
+            392?: ErrorCallback<TContext>;
+            393?: ErrorCallback<TContext>;
+            394?: ErrorCallback<TContext>;
+            395?: ErrorCallback<TContext>;
+            396?: ErrorCallback<TContext>;
+            397?: ErrorCallback<TContext>;
+            398?: ErrorCallback<TContext>;
+            399?: ErrorCallback<TContext>;
+            400?: ErrorCallback<TContext>;
+            401?: ErrorCallback<TContext>;
+            402?: ErrorCallback<TContext>;
+            403?: ErrorCallback<TContext>;
+            404?: ErrorCallback<TContext>;
+            405?: ErrorCallback<TContext>;
+            406?: ErrorCallback<TContext>;
+            407?: ErrorCallback<TContext>;
+            408?: ErrorCallback<TContext>;
+            409?: ErrorCallback<TContext>;
+            410?: ErrorCallback<TContext>;
+            411?: ErrorCallback<TContext>;
+            412?: ErrorCallback<TContext>;
+            413?: ErrorCallback<TContext>;
+            414?: ErrorCallback<TContext>;
+            415?: ErrorCallback<TContext>;
+            416?: ErrorCallback<TContext>;
+            417?: ErrorCallback<TContext>;
+            418?: ErrorCallback<TContext>;
+            419?: ErrorCallback<TContext>;
+            420?: ErrorCallback<TContext>;
+            421?: ErrorCallback<TContext>;
+            422?: ErrorCallback<TContext>;
+            423?: ErrorCallback<TContext>;
+            424?: ErrorCallback<TContext>;
+            425?: ErrorCallback<TContext>;
+            426?: ErrorCallback<TContext>;
+            427?: ErrorCallback<TContext>;
+            428?: ErrorCallback<TContext>;
+            429?: ErrorCallback<TContext>;
+            430?: ErrorCallback<TContext>;
+            431?: ErrorCallback<TContext>;
+            432?: ErrorCallback<TContext>;
+            433?: ErrorCallback<TContext>;
+            434?: ErrorCallback<TContext>;
+            435?: ErrorCallback<TContext>;
+            436?: ErrorCallback<TContext>;
+            437?: ErrorCallback<TContext>;
+            438?: ErrorCallback<TContext>;
+            439?: ErrorCallback<TContext>;
+            440?: ErrorCallback<TContext>;
+            441?: ErrorCallback<TContext>;
+            442?: ErrorCallback<TContext>;
+            443?: ErrorCallback<TContext>;
+            444?: ErrorCallback<TContext>;
+            445?: ErrorCallback<TContext>;
+            446?: ErrorCallback<TContext>;
+            447?: ErrorCallback<TContext>;
+            448?: ErrorCallback<TContext>;
+            449?: ErrorCallback<TContext>;
+            450?: ErrorCallback<TContext>;
+            451?: ErrorCallback<TContext>;
+            452?: ErrorCallback<TContext>;
+            453?: ErrorCallback<TContext>;
+            454?: ErrorCallback<TContext>;
+            455?: ErrorCallback<TContext>;
+            456?: ErrorCallback<TContext>;
+            457?: ErrorCallback<TContext>;
+            458?: ErrorCallback<TContext>;
+            459?: ErrorCallback<TContext>;
+            460?: ErrorCallback<TContext>;
+            461?: ErrorCallback<TContext>;
+            462?: ErrorCallback<TContext>;
+            463?: ErrorCallback<TContext>;
+            464?: ErrorCallback<TContext>;
+            465?: ErrorCallback<TContext>;
+            466?: ErrorCallback<TContext>;
+            467?: ErrorCallback<TContext>;
+            468?: ErrorCallback<TContext>;
+            469?: ErrorCallback<TContext>;
+            470?: ErrorCallback<TContext>;
+            471?: ErrorCallback<TContext>;
+            472?: ErrorCallback<TContext>;
+            473?: ErrorCallback<TContext>;
+            474?: ErrorCallback<TContext>;
+            475?: ErrorCallback<TContext>;
+            476?: ErrorCallback<TContext>;
+            477?: ErrorCallback<TContext>;
+            478?: ErrorCallback<TContext>;
+            479?: ErrorCallback<TContext>;
+            480?: ErrorCallback<TContext>;
+            481?: ErrorCallback<TContext>;
+            482?: ErrorCallback<TContext>;
+            483?: ErrorCallback<TContext>;
+            484?: ErrorCallback<TContext>;
+            485?: ErrorCallback<TContext>;
+            486?: ErrorCallback<TContext>;
+            487?: ErrorCallback<TContext>;
+            488?: ErrorCallback<TContext>;
+            489?: ErrorCallback<TContext>;
+            490?: ErrorCallback<TContext>;
+            491?: ErrorCallback<TContext>;
+            492?: ErrorCallback<TContext>;
+            493?: ErrorCallback<TContext>;
+            494?: ErrorCallback<TContext>;
+            495?: ErrorCallback<TContext>;
+            496?: ErrorCallback<TContext>;
+            497?: ErrorCallback<TContext>;
+            498?: ErrorCallback<TContext>;
+            499?: ErrorCallback<TContext>;
+            500?: ErrorCallback<TContext>;
+            501?: ErrorCallback<TContext>;
+            502?: ErrorCallback<TContext>;
+            503?: ErrorCallback<TContext>;
+            504?: ErrorCallback<TContext>;
+            505?: ErrorCallback<TContext>;
+            506?: ErrorCallback<TContext>;
+            507?: ErrorCallback<TContext>;
+            508?: ErrorCallback<TContext>;
+            509?: ErrorCallback<TContext>;
+            510?: ErrorCallback<TContext>;
+            511?: ErrorCallback<TContext>;
+            512?: ErrorCallback<TContext>;
+            513?: ErrorCallback<TContext>;
+            514?: ErrorCallback<TContext>;
+            515?: ErrorCallback<TContext>;
+            516?: ErrorCallback<TContext>;
+            517?: ErrorCallback<TContext>;
+            518?: ErrorCallback<TContext>;
+            519?: ErrorCallback<TContext>;
+            520?: ErrorCallback<TContext>;
+            521?: ErrorCallback<TContext>;
+            522?: ErrorCallback<TContext>;
+            523?: ErrorCallback<TContext>;
+            524?: ErrorCallback<TContext>;
+            525?: ErrorCallback<TContext>;
+            526?: ErrorCallback<TContext>;
+            527?: ErrorCallback<TContext>;
+            528?: ErrorCallback<TContext>;
+            529?: ErrorCallback<TContext>;
+            530?: ErrorCallback<TContext>;
+            531?: ErrorCallback<TContext>;
+            532?: ErrorCallback<TContext>;
+            533?: ErrorCallback<TContext>;
+            534?: ErrorCallback<TContext>;
+            535?: ErrorCallback<TContext>;
+            536?: ErrorCallback<TContext>;
+            537?: ErrorCallback<TContext>;
+            538?: ErrorCallback<TContext>;
+            539?: ErrorCallback<TContext>;
+            540?: ErrorCallback<TContext>;
+            541?: ErrorCallback<TContext>;
+            542?: ErrorCallback<TContext>;
+            543?: ErrorCallback<TContext>;
+            544?: ErrorCallback<TContext>;
+            545?: ErrorCallback<TContext>;
+            546?: ErrorCallback<TContext>;
+            547?: ErrorCallback<TContext>;
+            548?: ErrorCallback<TContext>;
+            549?: ErrorCallback<TContext>;
+            550?: ErrorCallback<TContext>;
+            551?: ErrorCallback<TContext>;
+            552?: ErrorCallback<TContext>;
+            553?: ErrorCallback<TContext>;
+            554?: ErrorCallback<TContext>;
+            555?: ErrorCallback<TContext>;
+            556?: ErrorCallback<TContext>;
+            557?: ErrorCallback<TContext>;
+            558?: ErrorCallback<TContext>;
+            559?: ErrorCallback<TContext>;
+            560?: ErrorCallback<TContext>;
+            561?: ErrorCallback<TContext>;
+            562?: ErrorCallback<TContext>;
+            563?: ErrorCallback<TContext>;
+            564?: ErrorCallback<TContext>;
+            565?: ErrorCallback<TContext>;
+            566?: ErrorCallback<TContext>;
+            567?: ErrorCallback<TContext>;
+            568?: ErrorCallback<TContext>;
+            569?: ErrorCallback<TContext>;
+            570?: ErrorCallback<TContext>;
+            571?: ErrorCallback<TContext>;
+            572?: ErrorCallback<TContext>;
+            573?: ErrorCallback<TContext>;
+            574?: ErrorCallback<TContext>;
+            575?: ErrorCallback<TContext>;
+            576?: ErrorCallback<TContext>;
+            577?: ErrorCallback<TContext>;
+            578?: ErrorCallback<TContext>;
+            579?: ErrorCallback<TContext>;
+            580?: ErrorCallback<TContext>;
+            581?: ErrorCallback<TContext>;
+            582?: ErrorCallback<TContext>;
+            583?: ErrorCallback<TContext>;
+            584?: ErrorCallback<TContext>;
+            585?: ErrorCallback<TContext>;
+            586?: ErrorCallback<TContext>;
+            587?: ErrorCallback<TContext>;
+            588?: ErrorCallback<TContext>;
+            589?: ErrorCallback<TContext>;
+            590?: ErrorCallback<TContext>;
+            591?: ErrorCallback<TContext>;
+            592?: ErrorCallback<TContext>;
+            593?: ErrorCallback<TContext>;
+            594?: ErrorCallback<TContext>;
+            595?: ErrorCallback<TContext>;
+            596?: ErrorCallback<TContext>;
+            597?: ErrorCallback<TContext>;
+            598?: ErrorCallback<TContext>;
+            599?: ErrorCallback<TContext>;
+
+            // #endregion
+        } & {
+            // Status codes not listed require type annotations when defining the callback
+            [index: number]: SuccessCallback<TContext> | ErrorCallback<TContext>;
+        };
+
+        // #endregion
+
+        // Writable properties on XMLHttpRequest
+        interface XHRFields extends Partial<Pick<XMLHttpRequest, 'onreadystatechange' | 'responseType' | 'timeout' | 'withCredentials'>> {
+            msCaching?: string;
+        }
+    }
+
+    interface Transport {
+        send(headers: PlainObject, completeCallback: Transport.SuccessCallback): void;
+        abort(): void;
+    }
+
+    namespace Transport {
+        type SuccessCallback = (status: number, statusText: Ajax.TextStatus, responses?: PlainObject, headers?: string) => void;
+    }
+
+    /**
+     * @see \`{@link https://api.jquery.com/jquery.ajax/#jqXHR }\`
+     */
+    interface jqXHR<TResolve = any> extends Promise3<TResolve, jqXHR<TResolve>, never,
+        Ajax.SuccessTextStatus, Ajax.ErrorTextStatus, never,
+        jqXHR<TResolve>, string, never>,
+        Pick<XMLHttpRequest, 'abort' | 'getAllResponseHeaders' | 'getResponseHeader' | 'overrideMimeType' | 'readyState' | 'responseText' |
+            'setRequestHeader' | 'status' | 'statusText'>,
+        Partial<Pick<XMLHttpRequest, 'responseXML'>> {
+        responseJSON?: any;
+
+        /**
+         * Determine the current state of a Deferred object.
+         * @see \`{@link https://api.jquery.com/deferred.state/ }\`
+         * @since 1.7
+         */
+        state(): 'pending' | 'resolved' | 'rejected';
+        statusCode(map: Ajax.StatusCodeCallbacks<any>): void;
+    }
+
+    namespace jqXHR {
+        interface DoneCallback<TResolve = any, TjqXHR = jqXHR<TResolve>> extends Deferred.Callback3<TResolve, Ajax.SuccessTextStatus, TjqXHR> { }
+
+        interface FailCallback<TjqXHR> extends Deferred.Callback3<TjqXHR, Ajax.ErrorTextStatus, string> { }
+
+        interface AlwaysCallback<TResolve = any, TjqXHR = jqXHR<TResolve>> extends Deferred.Callback3<TResolve | TjqXHR, Ajax.TextStatus, TjqXHR | string> { }
+    }
+
+    // #endregion
+
+    // region Callbacks
+    // #region Callbacks
+
+    interface CallbacksStatic {
+        /**
+         * A multi-purpose callbacks list object that provides a powerful way to manage callback lists.
+         * @param flags An optional list of space-separated flags that change how the callback list behaves.
+         * @see \`{@link https://api.jquery.com/jQuery.Callbacks/ }\`
+         * @since 1.7
+         */
+        // tslint:disable-next-line:ban-types callable-types no-unnecessary-generics
+        <T extends Function>(flags?: string): Callbacks<T>;
+    }
+
+    // tslint:disable-next-line:ban-types
+    interface Callbacks<T extends Function = Function> {
+        /**
+         * Add a callback or a collection of callbacks to a callback list.
+         * @param callback A function, or array of functions, that are to be added to the callback list.
+         * @param callbacks A function, or array of functions, that are to be added to the callback list.
+         * @see \`{@link https://api.jquery.com/callbacks.add/ }\`
+         * @since 1.7
+         * @example ​ ````Use callbacks.add() to add new callbacks to a callback list:
+```javascript
+// A sample logging function to be added to a callbacks list
+var foo = function( value ) {
+  console.log( "foo: " + value );
+};
+​
+// Another function to also be added to the list
+var bar = function( value ) {
+  console.log( "bar: " + value );
+};
+​
+var callbacks = $.Callbacks();
+​
+// Add the function "foo" to the list
+callbacks.add( foo );
+​
+// Fire the items on the list
+callbacks.fire( "hello" );
+// Outputs: "foo: hello"
+​
+// Add the function "bar" to the list
+callbacks.add( bar );
+​
+// Fire the items on the list again
+callbacks.fire( "world" );
+​
+// Outputs:
+// "foo: world"
+// "bar: world"
+```
+         */
+        add(callback: TypeOrArray<T>, ...callbacks: Array<TypeOrArray<T>>): this;
+        /**
+         * Disable a callback list from doing anything more.
+         * @see \`{@link https://api.jquery.com/callbacks.disable/ }\`
+         * @since 1.7
+         * @example ​ ````Use callbacks.disable() to disable further calls to a callback list:
+```javascript
+// A sample logging function to be added to a callbacks list
+var foo = function( value ) {
+  console.log( value );
+};
+​
+var callbacks = $.Callbacks();
+​
+// Add the above function to the list
+callbacks.add( foo );
+​
+// Fire the items on the list
+callbacks.fire( "foo" );
+// Outputs: foo
+​
+// Disable further calls being possible
+callbacks.disable();
+​
+// Attempt to fire with "foobar" as an argument
+callbacks.fire( "foobar" );
+// foobar isn't output
+```
+         */
+        disable(): this;
+        /**
+         * Determine if the callbacks list has been disabled.
+         * @see \`{@link https://api.jquery.com/callbacks.disabled/ }\`
+         * @since 1.7
+         * @example ​ ````Use callbacks.disabled() to determine if the callbacks list has been disabled:
+```javascript
+// A sample logging function to be added to a callbacks list
+var foo = function( value ) {
+  console.log( "foo:" + value );
+};
+​
+var callbacks = $.Callbacks();
+​
+// Add the logging function to the callback list
+callbacks.add( foo );
+​
+// Fire the items on the list, passing an argument
+callbacks.fire( "hello" );
+// Outputs "foo: hello"
+​
+// Disable the callbacks list
+callbacks.disable();
+​
+// Test the disabled state of the list
+console.log ( callbacks.disabled() );
+// Outputs: true
+```
+         */
+        disabled(): boolean;
+        /**
+         * Remove all of the callbacks from a list.
+         * @see \`{@link https://api.jquery.com/callbacks.empty/ }\`
+         * @since 1.7
+         * @example ​ ````Use callbacks.empty() to empty a list of callbacks:
+```javascript
+// A sample logging function to be added to a callbacks list
+var foo = function( value1, value2 ) {
+  console.log( "foo: " + value1 + "," + value2 );
+};
+​
+// Another function to also be added to the list
+var bar = function( value1, value2 ) {
+  console.log( "bar: " + value1 + "," + value2 );
+};
+​
+var callbacks = $.Callbacks();
+​
+// Add the two functions
+callbacks.add( foo );
+callbacks.add( bar );
+​
+// Empty the callbacks list
+callbacks.empty();
+​
+// Check to ensure all callbacks have been removed
+console.log( callbacks.has( foo ) );
+// false
+console.log( callbacks.has( bar ) );
+// false
+```
+         */
+        empty(): this;
+        /**
+         * Call all of the callbacks with the given arguments.
+         * @param args The argument or list of arguments to pass back to the callback list.
+         * @see \`{@link https://api.jquery.com/callbacks.fire/ }\`
+         * @since 1.7
+         * @example ​ ````Use callbacks.fire() to invoke the callbacks in a list with any arguments that have been passed:
+```javascript
+// A sample logging function to be added to a callbacks list
+var foo = function( value ) {
+  console.log( "foo:" + value );
+};
+​
+var callbacks = $.Callbacks();
+​
+// Add the function "foo" to the list
+callbacks.add( foo );
+​
+// Fire the items on the list
+callbacks.fire( "hello" ); // Outputs: "foo: hello"
+callbacks.fire( "world" ); // Outputs: "foo: world"
+​
+// Add another function to the list
+var bar = function( value ){
+  console.log( "bar:" + value );
+};
+​
+// Add this function to the list
+callbacks.add( bar );
+​
+// Fire the items on the list again
+callbacks.fire( "hello again" );
+// Outputs:
+// "foo: hello again"
+// "bar: hello again"
+```
+         */
+        fire(...args: any[]): this;
+        /**
+         * Determine if the callbacks have already been called at least once.
+         * @see \`{@link https://api.jquery.com/callbacks.fired/ }\`
+         * @since 1.7
+         * @example ​ ````Use callbacks.fired() to determine if the callbacks in a list have been called at least once:
+```javascript
+// A sample logging function to be added to a callbacks list
+var foo = function( value ) {
+  console.log( "foo:" + value );
+};
+​
+var callbacks = $.Callbacks();
+​
+// Add the function "foo" to the list
+callbacks.add( foo );
+​
+// Fire the items on the list
+callbacks.fire( "hello" ); // Outputs: "foo: hello"
+callbacks.fire( "world" ); // Outputs: "foo: world"
+​
+// Test to establish if the callbacks have been called
+console.log( callbacks.fired() );
+```
+         */
+        fired(): boolean;
+        /**
+         * Call all callbacks in a list with the given context and arguments.
+         * @param context A reference to the context in which the callbacks in the list should be fired.
+         * @param args An argument, or array of arguments, to pass to the callbacks in the list.
+         * @see \`{@link https://api.jquery.com/callbacks.fireWith/ }\`
+         * @since 1.7
+         * @example ​ ````Use callbacks.fireWith() to fire a list of callbacks with a specific context and an array of arguments:
+```javascript
+// A sample logging function to be added to a callbacks list
+var log = function( value1, value2 ) {
+  console.log( "Received: " + value1 + "," + value2 );
+};
+​
+var callbacks = $.Callbacks();
+​
+// Add the log method to the callbacks list
+callbacks.add( log );
+​
+// Fire the callbacks on the list using the context "window"
+// and an arguments array
+​
+callbacks.fireWith( window, [ "foo","bar" ] );
+// Outputs: "Received: foo, bar"
+```
+         */
+        fireWith(context: object, args?: ArrayLike<any>): this;
+        /**
+         * Determine whether or not the list has any callbacks attached. If a callback is provided as an argument, determine whether it is in a list.
+         * @param callback The callback to search for.
+         * @see \`{@link https://api.jquery.com/callbacks.has/ }\`
+         * @since 1.7
+         * @example ​ ````Use callbacks.has() to check if a callback list contains a specific callback:
+```javascript
+// A sample logging function to be added to a callbacks list
+var foo = function( value1, value2 ) {
+  console.log( "Received: " + value1 + "," + value2 );
+};
+​
+// A second function which will not be added to the list
+var bar = function( value1, value2 ) {
+  console.log( "foobar" );
+};
+​
+var callbacks = $.Callbacks();
+​
+// Add the log method to the callbacks list
+callbacks.add( foo );
+​
+// Determine which callbacks are in the list
+console.log( callbacks.has( foo ) );
+// true
+console.log( callbacks.has( bar ) );
+// false
+```
+         */
+        has(callback?: T): boolean;
+        /**
+         * Lock a callback list in its current state.
+         * @see \`{@link https://api.jquery.com/callbacks.lock/ }\`
+         * @since 1.7
+         * @example ​ ````Use callbacks.lock() to lock a callback list to avoid further changes being made to the list state:
+```javascript
+// A sample logging function to be added to a callbacks list
+var foo = function( value ) {
+  console.log( "foo:" + value );
+};
+​
+var callbacks = $.Callbacks();
+​
+// Add the logging function to the callback list
+callbacks.add( foo );
+​
+// Fire the items on the list, passing an argument
+callbacks.fire( "hello" );
+// Outputs "foo: hello"
+​
+// Lock the callbacks list
+callbacks.lock();
+​
+// Try firing the items again
+callbacks.fire( "world" );
+​
+// As the list was locked, no items were called,
+// so "world" isn't logged
+```
+         * @example ​ ````Use callbacks.lock() to lock a callback list with &quot;memory,&quot; and then resume using the list:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>callbacks.lock demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+// Simple function for logging results
+var log = function( value ) {
+  $( "#log" ).append( "<p>" + value + "</p>" );
+};
+​
+// Two sample functions to be added to a callbacks list
+var foo = function( value ) {
+  log( "foo: " + value );
+};
+var bar = function( value ) {
+  log( "bar: " + value );
+};
+​
+// Create the callbacks object with the "memory" flag
+var callbacks = $.Callbacks( "memory" );
+​
+// Add the foo logging function to the callback list
+callbacks.add( foo );
+​
+// Fire the items on the list, passing an argument
+callbacks.fire( "hello" );
+// Outputs "foo: hello"
+​
+// Lock the callbacks list
+callbacks.lock();
+​
+// Try firing the items again
+callbacks.fire( "world" );
+// As the list was locked, no items were called,
+// so "foo: world" isn't logged
+​
+// Add the foo function to the callback list again
+callbacks.add( foo );
+​
+// Try firing the items again
+callbacks.fire( "silentArgument" );
+// Outputs "foo: hello" because the argument value was stored in memory
+​
+// Add the bar function to the callback list
+callbacks.add( bar );
+​
+callbacks.fire( "youHadMeAtHello" );
+// Outputs "bar: hello" because the list is still locked,
+// and the argument value is still stored in memory
+</script>
+​
+</body>
+</html>
+```
+         */
+        lock(): this;
+        /**
+         * Determine if the callbacks list has been locked.
+         * @see \`{@link https://api.jquery.com/callbacks.locked/ }\`
+         * @since 1.7
+         * @example ​ ````Use callbacks.locked() to determine the lock-state of a callback list:
+```javascript
+// A sample logging function to be added to a callbacks list
+var foo = function( value ) {
+  console.log( "foo: " + value );
+};
+​
+var callbacks = $.Callbacks();
+​
+// Add the logging function to the callback list
+callbacks.add( foo );
+​
+// Fire the items on the list, passing an argument
+callbacks.fire( "hello" );
+// Outputs "foo: hello"
+​
+// Lock the callbacks list
+callbacks.lock();
+​
+// Test the lock-state of the list
+console.log ( callbacks.locked() );
+// true
+```
+         */
+        locked(): boolean;
+        /**
+         * Remove a callback or a collection of callbacks from a callback list.
+         * @param callbacks A function, or array of functions, that are to be removed from the callback list.
+         * @see \`{@link https://api.jquery.com/callbacks.remove/ }\`
+         * @since 1.7
+         * @example ​ ````Use callbacks.remove() to remove callbacks from a callback list:
+```javascript
+// A sample logging function to be added to a callbacks list
+var foo = function( value ) {
+  console.log( "foo: " + value );
+};
+​
+var callbacks = $.Callbacks();
+​
+// Add the function "foo" to the list
+callbacks.add( foo );
+​
+// Fire the items on the list
+callbacks.fire( "hello" );
+// Outputs: "foo: hello"
+​
+// Remove "foo" from the callback list
+callbacks.remove( foo );
+​
+// Fire the items on the list again
+callbacks.fire( "world" );
+​
+// Nothing output as "foo" is no longer in the list
+```
+         */
+        remove(...callbacks: T[]): this;
+    }
+
+    // #endregion
+
+    // region CSS hooks
+    // #region CSS hooks
+
+    // Workaround for TypeScript 2.3 which does not have support for weak types handling.
+    type CSSHook<TElement> =
+        Partial<_CSSHook<TElement>> & (
+            Pick<_CSSHook<TElement>, 'get'> |
+            Pick<_CSSHook<TElement>, 'set'>
+        );
+
+    interface _CSSHook<TElement> {
+        get(elem: TElement, computed: any, extra: any): any;
+        set(elem: TElement, value: any): void;
+    }
+
+    interface CSSHooks {
+        // Set to HTMLElement to minimize breaks but should probably be Element.
+        [propertyName: string]: CSSHook<HTMLElement>;
+    }
+
+    // #endregion
+
+    // region Deferred
+    // #region Deferred
+
+    /**
+     * Any object that has a then method.
+     */
+    interface Thenable<T> extends PromiseLike<T> { }
+
+    // NOTE: This is a private copy of the global Promise interface. It is used by JQuery.PromiseBase to indicate compatibility with other Promise implementations.
+    //       The global Promise interface cannot be used directly as it may be modified, as in the case of @types/bluebird-global.
+    /**
+     * Represents the completion of an asynchronous operation
+     */
+    interface _Promise<T> {
+        readonly [Symbol.toStringTag]: "Promise";
+        /**
+         * Attaches callbacks for the resolution and/or rejection of the Promise.
+         * @param onfulfilled The callback to execute when the Promise is resolved.
+         * @param onrejected The callback to execute when the Promise is rejected.
+         * @returns A Promise for the completion of which ever callback is executed.
+         */
+        then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+                                             onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): _Promise<TResult1 | TResult2>;
+        /**
+         * Attaches a callback for only the rejection of the Promise.
+         * @param onrejected The callback to execute when the Promise is rejected.
+         * @returns A Promise for the completion of the callback.
+         */
+        catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): _Promise<T | TResult>;
+    }
+
+    // Type parameter guide
+    // --------------------
+    // Each type parameter represents a parameter in one of the three possible callbacks.
+    //
+    // The first letter indicates which position the parameter is in.
+    //
+    // T = A = 1st position
+    // U = B = 2nd position
+    // V = C = 3rd position
+    // S = R = rest position
+    //
+    // The second letter indicates which whether it is a [R]esolve, Re[J]ect, or [N]otify value.
+    //
+    // The third letter indicates whether the value is returned in the [D]one filter, [F]ail filter, or [P]rogress filter.
+
+    /**
+     * This object provides a subset of the methods of the Deferred object (then, done, fail, always, pipe, progress, state and promise) to prevent users from changing the state of the Deferred.
+     * @see \`{@link https://api.jquery.com/Types/#Promise }\`
+     */
+    interface PromiseBase<TR, TJ, TN,
+        UR, UJ, UN,
+        VR, VJ, VN,
+        SR, SJ, SN> extends _Promise<TR>, PromiseLike<TR> {
+        /**
+         * Add handlers to be called when the Deferred object is either resolved or rejected.
+         * @param alwaysCallback A function, or array of functions, that is called when the Deferred is resolved or rejected.
+         * @param alwaysCallbacks Optional additional functions, or arrays of functions, that are called when the Deferred is resolved or rejected.
+         * @see \`{@link https://api.jquery.com/deferred.always/ }\`
+         * @since 1.6
+         * @example ​ ````Since the jQuery.get() method returns a jqXHR object, which is derived from a Deferred object, we can attach a callback for both success and error using the deferred.always() method.
+```javascript
+$.get( "test.php" ).always(function() {
+  alert( "$.get completed with success or error callback arguments" );
+});
+```
+         */
+        always(alwaysCallback: TypeOrArray<Deferred.CallbackBase<TR | TJ, UR | UJ, VR | VJ, SR | SJ>>,
+               ...alwaysCallbacks: Array<TypeOrArray<Deferred.CallbackBase<TR | TJ, UR | UJ, VR | VJ, SR | SJ>>>): this;
+        /**
+         * Add handlers to be called when the Deferred object is resolved.
+         * @param doneCallback A function, or array of functions, that are called when the Deferred is resolved.
+         * @param doneCallbacks Optional additional functions, or arrays of functions, that are called when the Deferred is resolved.
+         * @see \`{@link https://api.jquery.com/deferred.done/ }\`
+         * @since 1.5
+         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred object, we can attach a success callback using the .done() method.
+```javascript
+$.get( "test.php" ).done(function() {
+  alert( "$.get succeeded" );
+});
+```
+         * @example ​ ````Resolve a Deferred object when the user clicks a button, triggering a number of callback functions:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>deferred.done demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Go</button>
+<p>Ready...</p>
+​
+<script>
+// 3 functions to call when the Deferred object is resolved
+function fn1() {
+  $( "p" ).append( " 1 " );
+}
+function fn2() {
+  $( "p" ).append( " 2 " );
+}
+function fn3( n ) {
+  $( "p" ).append( n + " 3 " + n );
+}
+​
+// Create a deferred object
+var dfd = $.Deferred();
+​
+// Add handlers to be called when dfd is resolved
+dfd
+// .done() can take any number of functions or arrays of functions
+  .done( [ fn1, fn2 ], fn3, [ fn2, fn1 ] )
+// We can chain done methods, too
+  .done(function( n ) {
+    $( "p" ).append( n + " we're done." );
+  });
+​
+// Resolve the Deferred object when the button is clicked
+$( "button" ).on( "click", function() {
+  dfd.resolve( "and" );
+});
+</script>
+​
+</body>
+</html>
+```
+         */
+        done(doneCallback: TypeOrArray<Deferred.CallbackBase<TR, UR, VR, SR>>,
+             ...doneCallbacks: Array<TypeOrArray<Deferred.CallbackBase<TR, UR, VR, SR>>>): this;
+        /**
+         * Add handlers to be called when the Deferred object is rejected.
+         * @param failCallback A function, or array of functions, that are called when the Deferred is rejected.
+         * @param failCallbacks Optional additional functions, or arrays of functions, that are called when the Deferred is rejected.
+         * @see \`{@link https://api.jquery.com/deferred.fail/ }\`
+         * @since 1.5
+         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred, you can attach a success and failure callback using the deferred.done() and deferred.fail() methods.
+```javascript
+$.get( "test.php" )
+  .done(function() {
+    alert( "$.get succeeded" );
+  })
+  .fail(function() {
+    alert( "$.get failed!" );
+  });
+```
+         */
+        fail(failCallback: TypeOrArray<Deferred.CallbackBase<TJ, UJ, VJ, SJ>>,
+             ...failCallbacks: Array<TypeOrArray<Deferred.CallbackBase<TJ, UJ, VJ, SJ>>>): this;
+        /**
+         * Add handlers to be called when the Deferred object generates progress notifications.
+         * @param progressCallback A function, or array of functions, to be called when the Deferred generates progress notifications.
+         * @param progressCallbacks Optional additional functions, or arrays of functions, to be called when the Deferred generates
+         *                          progress notifications.
+         * @see \`{@link https://api.jquery.com/deferred.progress/ }\`
+         * @since 1.7
+         */
+        progress(progressCallback: TypeOrArray<Deferred.CallbackBase<TN, UN, VN, SN>>,
+                 ...progressCallbacks: Array<TypeOrArray<Deferred.CallbackBase<TN, UN, VN, SN>>>): this;
+        /**
+         * Return a Deferred's Promise object.
+         * @param target Object onto which the promise methods have to be attached
+         * @see \`{@link https://api.jquery.com/deferred.promise/ }\`
+         * @since 1.5
+         * @example ​ ````Create a Deferred and set two timer-based functions to either resolve or reject the Deferred after a random interval. Whichever one fires first &quot;wins&quot; and will call one of the callbacks. The second timeout has no effect since the Deferred is already complete (in a resolved or rejected state) from the first timeout action. Also set a timer-based progress notification function, and call a progress handler that adds &quot;working...&quot; to the document body.
+```javascript
+function asyncEvent() {
+  var dfd = jQuery.Deferred();
+​
+  // Resolve after a random interval
+  setTimeout(function() {
+    dfd.resolve( "hurray" );
+  }, Math.floor( 400 + Math.random() * 2000 ) );
+​
+  // Reject after a random interval
+  setTimeout(function() {
+    dfd.reject( "sorry" );
+  }, Math.floor( 400 + Math.random() * 2000 ) );
+​
+  // Show a "working..." message every half-second
+  setTimeout(function working() {
+    if ( dfd.state() === "pending" ) {
+      dfd.notify( "working... " );
+      setTimeout( working, 500 );
+    }
+  }, 1 );
+​
+  // Return the Promise so caller can't change the Deferred
+  return dfd.promise();
+}
+​
+// Attach a done, fail, and progress handler for the asyncEvent
+$.when( asyncEvent() ).then(
+  function( status ) {
+    alert( status + ", things are going well" );
+  },
+  function( status ) {
+    alert( status + ", you fail this time" );
+  },
+  function( status ) {
+    $( "body" ).append( status );
+  }
+);
+```
+         */
+        promise<TTarget extends object>(target: TTarget): this & TTarget;
+        /**
+         * Return a Deferred's Promise object.
+         * @see \`{@link https://api.jquery.com/deferred.promise/ }\`
+         * @since 1.5
+         * @example ​ ````Use the target argument to promote an existing object to a Promise:
+```javascript
+// Existing object
+var obj = {
+    hello: function( name ) {
+      alert( "Hello " + name );
+    }
+  },
+  // Create a Deferred
+  defer = $.Deferred();
+​
+// Set object as a promise
+defer.promise( obj );
+​
+// Resolve the deferred
+defer.resolve( "John" );
+​
+// Use the object as a Promise
+obj.done(function( name ) {
+  obj.hello( name ); // Will alert "Hello John"
+}).hello( "Karl" ); // Will alert "Hello Karl"
+```
+         */
+        promise(): this;
+        /**
+         * Determine the current state of a Deferred object.
+         * @see \`{@link https://api.jquery.com/deferred.state/ }\`
+         * @since 1.7
+         */
+        state(): 'pending' | 'resolved' | 'rejected';
+
+        // region pipe
+        // #region pipe
+
+        /**
+         * Utility method to filter and/or chain Deferreds.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
+         * @since 1.6
+         * @since 1.7
+         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
+         *
+         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
+         *
+         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
+         * @example ​ ````Filter resolve value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.pipe(function( value ) {
+    return value * 2;
+  });
+​
+defer.resolve( 5 );
+filtered.done(function( value ) {
+  alert( "Value is ( 2*5 = ) 10: " + value );
+});
+```
+         * @example ​ ````Filter reject value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.pipe( null, function( value ) {
+    return value * 3;
+  });
+​
+defer.reject( 6 );
+filtered.fail(function( value ) {
+  alert( "Value is ( 3*6 = ) 18: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.pipe(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        pipe<ARD = never, AJD = never, AND = never,
+            BRD = never, BJD = never, BND = never,
+            CRD = never, CJD = never, CND = never,
+            RRD = never, RJD = never, RND = never,
+            ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never,
+            ARP = never, AJP = never, ANP = never,
+            BRP = never, BJP = never, BNP = never,
+            CRP = never, CJP = never, CNP = never,
+            RRP = never, RJP = never, RNP = never>(
+                doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+                    BRD, BJD, BND,
+                    CRD, CJD, CND,
+                    RRD, RJD, RND> | Thenable<ARD> | ARD,
+                failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<AJF> | AJF,
+                progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+                    BRP, BJP, BNP,
+                    CRP, CJP, CNP,
+                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP,
+            BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP,
+            CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP,
+            RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>;
+        /**
+         * Utility method to filter and/or chain Deferreds.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
+         * @since 1.6
+         * @since 1.7
+         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
+         *
+         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
+         *
+         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
+         * @example ​ ````Filter reject value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.pipe( null, function( value ) {
+    return value * 3;
+  });
+​
+defer.reject( 6 );
+filtered.fail(function( value ) {
+  alert( "Value is ( 3*6 = ) 18: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.pipe(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        pipe<ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never,
+            ARP = never, AJP = never, ANP = never,
+            BRP = never, BJP = never, BNP = never,
+            CRP = never, CJP = never, CNP = never,
+            RRP = never, RJP = never, RNP = never>(
+                doneFilter: null,
+                failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<AJF> | AJF,
+                progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+                    BRP, BJP, BNP,
+                    CRP, CJP, CNP,
+                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP,
+            BRF | BRP, BJF | BJP, BNF | BNP,
+            CRF | CRP, CJF | CJP, CNF | CNP,
+            RRF | RRP, RJF | RJP, RNF | RNP>;
+        /**
+         * Utility method to filter and/or chain Deferreds.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
+         * @since 1.6
+         * @since 1.7
+         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
+         *
+         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
+         *
+         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
+         * @example ​ ````Filter resolve value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.pipe(function( value ) {
+    return value * 2;
+  });
+​
+defer.resolve( 5 );
+filtered.done(function( value ) {
+  alert( "Value is ( 2*5 = ) 10: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.pipe(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        pipe<ARD = never, AJD = never, AND = never,
+            BRD = never, BJD = never, BND = never,
+            CRD = never, CJD = never, CND = never,
+            RRD = never, RJD = never, RND = never,
+            ARP = never, AJP = never, ANP = never,
+            BRP = never, BJP = never, BNP = never,
+            CRP = never, CJP = never, CNP = never,
+            RRP = never, RJP = never, RNP = never>(
+                doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+                    BRD, BJD, BND,
+                    CRD, CJD, CND,
+                    RRD, RJD, RND> | Thenable<ARD> | ARD,
+                failFilter: null,
+                progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+                    BRP, BJP, BNP,
+                    CRP, CJP, CNP,
+                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARP, AJD | AJP, AND | ANP,
+            BRD | BRP, BJD | BJP, BND | BNP,
+            CRD | CRP, CJD | CJP, CND | CNP,
+            RRD | RRP, RJD | RJP, RND | RNP>;
+        /**
+         * Utility method to filter and/or chain Deferreds.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
+         * @since 1.6
+         * @since 1.7
+         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
+         *
+         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
+         *
+         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.pipe(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        pipe<ARP = never, AJP = never, ANP = never,
+            BRP = never, BJP = never, BNP = never,
+            CRP = never, CJP = never, CNP = never,
+            RRP = never, RJP = never, RNP = never>(
+                doneFilter: null,
+                failFilter: null,
+                progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+                    BRP, BJP, BNP,
+                    CRP, CJP, CNP,
+                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP,
+            BRP, BJP, BNP,
+            CRP, CJP, CNP,
+            RRP, RJP, RNP>;
+        /**
+         * Utility method to filter and/or chain Deferreds.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
+         * @since 1.6
+         * @since 1.7
+         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
+         *
+         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
+         *
+         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
+         * @example ​ ````Filter resolve value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.pipe(function( value ) {
+    return value * 2;
+  });
+​
+defer.resolve( 5 );
+filtered.done(function( value ) {
+  alert( "Value is ( 2*5 = ) 10: " + value );
+});
+```
+         * @example ​ ````Filter reject value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.pipe( null, function( value ) {
+    return value * 3;
+  });
+​
+defer.reject( 6 );
+filtered.fail(function( value ) {
+  alert( "Value is ( 3*6 = ) 18: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.pipe(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        pipe<ARD = never, AJD = never, AND = never,
+            BRD = never, BJD = never, BND = never,
+            CRD = never, CJD = never, CND = never,
+            RRD = never, RJD = never, RND = never,
+            ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never>(
+                doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+                    BRD, BJD, BND,
+                    CRD, CJD, CND,
+                    RRD, RJD, RND> | Thenable<ARD> | ARD,
+                failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<AJF> | AJF,
+                progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF,
+            BRD | BRF, BJD | BJF, BND | BNF,
+            CRD | CRF, CJD | CJF, CND | CNF,
+            RRD | RRF, RJD | RJF, RND | RNF>;
+        /**
+         * Utility method to filter and/or chain Deferreds.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
+         * @since 1.6
+         * @since 1.7
+         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
+         *
+         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
+         *
+         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
+         * @example ​ ````Filter reject value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.pipe( null, function( value ) {
+    return value * 3;
+  });
+​
+defer.reject( 6 );
+filtered.fail(function( value ) {
+  alert( "Value is ( 3*6 = ) 18: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.pipe(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        pipe<ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never>(
+                doneFilter: null,
+                failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<AJF> | AJF,
+                progressFilter?: null): PromiseBase<ARF, AJF, ANF,
+            BRF, BJF, BNF,
+            CRF, CJF, CNF,
+            RRF, RJF, RNF>;
+        /**
+         * Utility method to filter and/or chain Deferreds.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
+         * @since 1.6
+         * @since 1.7
+         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
+         *
+         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
+         *
+         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
+         * @example ​ ````Filter resolve value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.pipe(function( value ) {
+    return value * 2;
+  });
+​
+defer.resolve( 5 );
+filtered.done(function( value ) {
+  alert( "Value is ( 2*5 = ) 10: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.pipe(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        pipe<ARD = never, AJD = never, AND = never,
+            BRD = never, BJD = never, BND = never,
+            CRD = never, CJD = never, CND = never,
+            RRD = never, RJD = never, RND = never>(
+                doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+                    BRD, BJD, BND,
+                    CRD, CJD, CND,
+                    RRD, RJD, RND> | Thenable<ARD> | ARD,
+                failFilter?: null,
+                progressFilter?: null): PromiseBase<ARD, AJD, AND,
+            BRD, BJD, BND,
+            CRD, CJD, CND,
+            RRD, RJD, RND>;
+
+        // #endregion
+
+        // region then
+        // #region then
+
+        /**
+         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
+         * @since 1.8
+         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred object, we can attach handlers using the .then method.
+```javascript
+$.get( "test.php" ).then(
+  function() {
+    alert( "$.get succeeded" );
+  }, function() {
+    alert( "$.get failed!" );
+  }
+);
+```
+         * @example ​ ````Filter the resolve value:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>deferred.then demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Filter Resolve</button>
+<p></p>
+​
+<script>
+var filterResolve = function() {
+  var defer = $.Deferred(),
+    filtered = defer.then(function( value ) {
+      return value * 2;
+    });
+​
+  defer.resolve( 5 );
+  filtered.done(function( value ) {
+    $( "p" ).html( "Value is ( 2*5 = ) 10: " + value );
+  });
+};
+​
+$( "button" ).on( "click", filterResolve );
+</script>
+​
+</body>
+</html>
+```
+         * @example ​ ````Filter reject value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.then( null, function( value ) {
+    return value * 3;
+  });
+​
+defer.reject( 6 );
+filtered.fail(function( value ) {
+  alert( "Value is ( 3*6 = ) 18: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.then(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        then<ARD = never, AJD = never, AND = never,
+            BRD = never, BJD = never, BND = never,
+            CRD = never, CJD = never, CND = never,
+            RRD = never, RJD = never, RND = never,
+            ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never,
+            ARP = never, AJP = never, ANP = never,
+            BRP = never, BJP = never, BNP = never,
+            CRP = never, CJP = never, CNP = never,
+            RRP = never, RJP = never, RNP = never>(
+                doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+                    BRD, BJD, BND,
+                    CRD, CJD, CND,
+                    RRD, RJD, RND> | Thenable<ARD> | ARD,
+                failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<ARF> | ARF,
+                progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+                    BRP, BJP, BNP,
+                    CRP, CJP, CNP,
+                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP,
+            BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP,
+            CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP,
+            RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>;
+        /**
+         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
+         * @since 1.8
+         * @example ​ ````Filter reject value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.then( null, function( value ) {
+    return value * 3;
+  });
+​
+defer.reject( 6 );
+filtered.fail(function( value ) {
+  alert( "Value is ( 3*6 = ) 18: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.then(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        then<ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never,
+            ARP = never, AJP = never, ANP = never,
+            BRP = never, BJP = never, BNP = never,
+            CRP = never, CJP = never, CNP = never,
+            RRP = never, RJP = never, RNP = never>(
+                doneFilter: null,
+                failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<ARF> | ARF,
+                progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+                    BRP, BJP, BNP,
+                    CRP, CJP, CNP,
+                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP,
+            BRF | BRP, BJF | BJP, BNF | BNP,
+            CRF | CRP, CJF | CJP, CNF | CNP,
+            RRF | RRP, RJF | RJP, RNF | RNP>;
+        /**
+         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
+         * @since 1.8
+         * @example ​ ````Filter the resolve value:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>deferred.then demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Filter Resolve</button>
+<p></p>
+​
+<script>
+var filterResolve = function() {
+  var defer = $.Deferred(),
+    filtered = defer.then(function( value ) {
+      return value * 2;
+    });
+​
+  defer.resolve( 5 );
+  filtered.done(function( value ) {
+    $( "p" ).html( "Value is ( 2*5 = ) 10: " + value );
+  });
+};
+​
+$( "button" ).on( "click", filterResolve );
+</script>
+​
+</body>
+</html>
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.then(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        then<ARD = never, AJD = never, AND = never,
+            BRD = never, BJD = never, BND = never,
+            CRD = never, CJD = never, CND = never,
+            RRD = never, RJD = never, RND = never,
+            ARP = never, AJP = never, ANP = never,
+            BRP = never, BJP = never, BNP = never,
+            CRP = never, CJP = never, CNP = never,
+            RRP = never, RJP = never, RNP = never>(
+                doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+                    BRD, BJD, BND,
+                    CRD, CJD, CND,
+                    RRD, RJD, RND> | Thenable<ARD> | ARD,
+                failFilter: null,
+                progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+                    BRP, BJP, BNP,
+                    CRP, CJP, CNP,
+                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARP, AJD | AJP, AND | ANP,
+            BRD | BRP, BJD | BJP, BND | BNP,
+            CRD | CRP, CJD | CJP, CND | CNP,
+            RRD | RRP, RJD | RJP, RND | RNP>;
+        /**
+         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
+         * @since 1.8
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.then(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        then<ARP = never, AJP = never, ANP = never,
+            BRP = never, BJP = never, BNP = never,
+            CRP = never, CJP = never, CNP = never,
+            RRP = never, RJP = never, RNP = never>(
+                doneFilter: null,
+                failFilter: null,
+                progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+                    BRP, BJP, BNP,
+                    CRP, CJP, CNP,
+                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP,
+            BRP, BJP, BNP,
+            CRP, CJP, CNP,
+            RRP, RJP, RNP>;
+        /**
+         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
+         * @since 1.8
+         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred object, we can attach handlers using the .then method.
+```javascript
+$.get( "test.php" ).then(
+  function() {
+    alert( "$.get succeeded" );
+  }, function() {
+    alert( "$.get failed!" );
+  }
+);
+```
+         * @example ​ ````Filter the resolve value:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>deferred.then demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Filter Resolve</button>
+<p></p>
+​
+<script>
+var filterResolve = function() {
+  var defer = $.Deferred(),
+    filtered = defer.then(function( value ) {
+      return value * 2;
+    });
+​
+  defer.resolve( 5 );
+  filtered.done(function( value ) {
+    $( "p" ).html( "Value is ( 2*5 = ) 10: " + value );
+  });
+};
+​
+$( "button" ).on( "click", filterResolve );
+</script>
+​
+</body>
+</html>
+```
+         * @example ​ ````Filter reject value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.then( null, function( value ) {
+    return value * 3;
+  });
+​
+defer.reject( 6 );
+filtered.fail(function( value ) {
+  alert( "Value is ( 3*6 = ) 18: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.then(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        then<ARD = never, AJD = never, AND = never,
+            BRD = never, BJD = never, BND = never,
+            CRD = never, CJD = never, CND = never,
+            RRD = never, RJD = never, RND = never,
+            ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never>(
+                doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+                    BRD, BJD, BND,
+                    CRD, CJD, CND,
+                    RRD, RJD, RND> | Thenable<ARD> | ARD,
+                failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<ARF> | ARF,
+                progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF,
+            BRD | BRF, BJD | BJF, BND | BNF,
+            CRD | CRF, CJD | CJF, CND | CNF,
+            RRD | RRF, RJD | RJF, RND | RNF>;
+        /**
+         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
+         * @since 1.8
+         * @example ​ ````Filter reject value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.then( null, function( value ) {
+    return value * 3;
+  });
+​
+defer.reject( 6 );
+filtered.fail(function( value ) {
+  alert( "Value is ( 3*6 = ) 18: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.then(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        then<ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never>(
+                doneFilter: null,
+                failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<ARF> | ARF,
+                progressFilter?: null): PromiseBase<ARF, AJF, ANF,
+            BRF, BJF, BNF,
+            CRF, CJF, CNF,
+            RRF, RJF, RNF>;
+        /**
+         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
+         * @since 1.8
+         * @example ​ ````Filter the resolve value:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>deferred.then demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Filter Resolve</button>
+<p></p>
+​
+<script>
+var filterResolve = function() {
+  var defer = $.Deferred(),
+    filtered = defer.then(function( value ) {
+      return value * 2;
+    });
+​
+  defer.resolve( 5 );
+  filtered.done(function( value ) {
+    $( "p" ).html( "Value is ( 2*5 = ) 10: " + value );
+  });
+};
+​
+$( "button" ).on( "click", filterResolve );
+</script>
+​
+</body>
+</html>
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.then(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        then<ARD = never, AJD = never, AND = never,
+            BRD = never, BJD = never, BND = never,
+            CRD = never, CJD = never, CND = never,
+            RRD = never, RJD = never, RND = never>(
+                doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+                    BRD, BJD, BND,
+                    CRD, CJD, CND,
+                    RRD, RJD, RND> | Thenable<ARD> | ARD,
+                failFilter?: null,
+                progressFilter?: null): PromiseBase<ARD, AJD, AND,
+            BRD, BJD, BND,
+            CRD, CJD, CND,
+            RRD, RJD, RND>;
+
+        // #endregion
+
+        /**
+         * Add handlers to be called when the Deferred object is rejected.
+         * @param failFilter A function that is called when the Deferred is rejected.
+         * @see \`{@link https://api.jquery.com/deferred.catch/ }\`
+         * @since 3.0
+         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred object, we can rejection handlers using the .catch method.
+```javascript
+$.get( "test.php" )
+  .then( function() {
+    alert( "$.get succeeded" );
+  } )
+  .catch( function() {
+    alert( "$.get failed!" );
+  } );
+```
+         */
+        catch<ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never>(
+                failFilter?: ((t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<ARF> | ARF) | null): PromiseBase<ARF, AJF, ANF,
+            BRF, BJF, BNF,
+            CRF, CJF, CNF,
+            RRF, RJF, RNF>;
+    }
+
+    /**
+     * This object provides a subset of the methods of the Deferred object (then, done, fail, always, pipe, progress, state and promise) to prevent users from changing the state of the Deferred.
+     * @see \`{@link https://api.jquery.com/Types/#Promise }\`
+     */
+    interface Promise3<TR, TJ, TN,
+        UR, UJ, UN,
+        VR, VJ, VN> extends PromiseBase<TR, TJ, TN,
+        UR, UJ, UN,
+        VR, VJ, VN,
+        never, never, never> { }
+
+    /**
+     * This object provides a subset of the methods of the Deferred object (then, done, fail, always, pipe, progress, state and promise) to prevent users from changing the state of the Deferred.
+     * @see \`{@link https://api.jquery.com/Types/#Promise }\`
+     */
+    interface Promise2<TR, TJ, TN,
+        UR, UJ, UN> extends PromiseBase<TR, TJ, TN,
+        UR, UJ, UN,
+        never, never, never,
+        never, never, never> { }
+
+    /**
+     * This object provides a subset of the methods of the Deferred object (then, done, fail, always, pipe, progress, state and promise) to prevent users from changing the state of the Deferred.
+     * @see \`{@link https://api.jquery.com/Types/#Promise }\`
+     */
+    interface Promise<TR, TJ = any, TN = any> extends PromiseBase<TR, TJ, TN,
+        TR, TJ, TN,
+        TR, TJ, TN,
+        TR, TJ, TN> { }
+
+    interface DeferredStatic {
+        // https://jquery.com/upgrade-guide/3.0/#callback-exit
+        exceptionHook: any;
+        /**
+         * A factory function that returns a chainable utility object with methods to register multiple callbacks into callback queues, invoke callback queues, and relay the success or failure state of any synchronous or asynchronous function.
+         * @param beforeStart A function that is called just before the constructor returns.
+         * @see \`{@link https://api.jquery.com/jQuery.Deferred/ }\`
+         * @since 1.5
+         */
+        <TR = any, TJ = any, TN = any>(beforeStart?: (this: Deferred<TR, TJ, TN>, deferred: Deferred<TR, TJ, TN>) => void): Deferred<TR, TJ, TN>;
+    }
+
+    interface Deferred<TR, TJ = any, TN = any> {
+        /**
+         * Call the progressCallbacks on a Deferred object with the given args.
+         * @param args Optional arguments that are passed to the progressCallbacks.
+         * @see \`{@link https://api.jquery.com/deferred.notify/ }\`
+         * @since 1.7
+         */
+        notify(...args: TN[]): this;
+        /**
+         * Call the progressCallbacks on a Deferred object with the given context and args.
+         * @param context Context passed to the progressCallbacks as the this object.
+         * @param args An optional array of arguments that are passed to the progressCallbacks.
+         * @see \`{@link https://api.jquery.com/deferred.notifyWith/ }\`
+         * @since 1.7
+         */
+        notifyWith(context: object, args?: ArrayLike<TN>): this;
+        /**
+         * Reject a Deferred object and call any failCallbacks with the given args.
+         * @param args Optional arguments that are passed to the failCallbacks.
+         * @see \`{@link https://api.jquery.com/deferred.reject/ }\`
+         * @since 1.5
+         */
+        reject(...args: TJ[]): this;
+        /**
+         * Reject a Deferred object and call any failCallbacks with the given context and args.
+         * @param context Context passed to the failCallbacks as the this object.
+         * @param args An optional array of arguments that are passed to the failCallbacks.
+         * @see \`{@link https://api.jquery.com/deferred.rejectWith/ }\`
+         * @since 1.5
+         */
+        rejectWith(context: object, args?: ArrayLike<TJ>): this;
+        /**
+         * Resolve a Deferred object and call any doneCallbacks with the given args.
+         * @param args Optional arguments that are passed to the doneCallbacks.
+         * @see \`{@link https://api.jquery.com/deferred.resolve/ }\`
+         * @since 1.5
+         */
+        resolve(...args: TR[]): this;
+        /**
+         * Resolve a Deferred object and call any doneCallbacks with the given context and args.
+         * @param context Context passed to the doneCallbacks as the this object.
+         * @param args An optional array of arguments that are passed to the doneCallbacks.
+         * @see \`{@link https://api.jquery.com/deferred.resolveWith/ }\`
+         * @since 1.5
+         */
+        resolveWith(context: object, args?: ArrayLike<TR>): this;
+
+        /**
+         * Add handlers to be called when the Deferred object is either resolved or rejected.
+         * @param alwaysCallback A function, or array of functions, that is called when the Deferred is resolved or rejected.
+         * @param alwaysCallbacks Optional additional functions, or arrays of functions, that are called when the Deferred is resolved or rejected.
+         * @see \`{@link https://api.jquery.com/deferred.always/ }\`
+         * @since 1.6
+         * @example ​ ````Since the jQuery.get() method returns a jqXHR object, which is derived from a Deferred object, we can attach a callback for both success and error using the deferred.always() method.
+```javascript
+$.get( "test.php" ).always(function() {
+  alert( "$.get completed with success or error callback arguments" );
+});
+```
+         */
+        always(alwaysCallback: TypeOrArray<Deferred.Callback<TR | TJ>>,
+               ...alwaysCallbacks: Array<TypeOrArray<Deferred.Callback<TR | TJ>>>): this;
+        /**
+         * Add handlers to be called when the Deferred object is resolved.
+         * @param doneCallback A function, or array of functions, that are called when the Deferred is resolved.
+         * @param doneCallbacks Optional additional functions, or arrays of functions, that are called when the Deferred is resolved.
+         * @see \`{@link https://api.jquery.com/deferred.done/ }\`
+         * @since 1.5
+         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred object, we can attach a success callback using the .done() method.
+```javascript
+$.get( "test.php" ).done(function() {
+  alert( "$.get succeeded" );
+});
+```
+         * @example ​ ````Resolve a Deferred object when the user clicks a button, triggering a number of callback functions:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>deferred.done demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Go</button>
+<p>Ready...</p>
+​
+<script>
+// 3 functions to call when the Deferred object is resolved
+function fn1() {
+  $( "p" ).append( " 1 " );
+}
+function fn2() {
+  $( "p" ).append( " 2 " );
+}
+function fn3( n ) {
+  $( "p" ).append( n + " 3 " + n );
+}
+​
+// Create a deferred object
+var dfd = $.Deferred();
+​
+// Add handlers to be called when dfd is resolved
+dfd
+// .done() can take any number of functions or arrays of functions
+  .done( [ fn1, fn2 ], fn3, [ fn2, fn1 ] )
+// We can chain done methods, too
+  .done(function( n ) {
+    $( "p" ).append( n + " we're done." );
+  });
+​
+// Resolve the Deferred object when the button is clicked
+$( "button" ).on( "click", function() {
+  dfd.resolve( "and" );
+});
+</script>
+​
+</body>
+</html>
+```
+         */
+        done(doneCallback: TypeOrArray<Deferred.Callback<TR>>,
+             ...doneCallbacks: Array<TypeOrArray<Deferred.Callback<TR>>>): this;
+        /**
+         * Add handlers to be called when the Deferred object is rejected.
+         * @param failCallback A function, or array of functions, that are called when the Deferred is rejected.
+         * @param failCallbacks Optional additional functions, or arrays of functions, that are called when the Deferred is rejected.
+         * @see \`{@link https://api.jquery.com/deferred.fail/ }\`
+         * @since 1.5
+         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred, you can attach a success and failure callback using the deferred.done() and deferred.fail() methods.
+```javascript
+$.get( "test.php" )
+  .done(function() {
+    alert( "$.get succeeded" );
+  })
+  .fail(function() {
+    alert( "$.get failed!" );
+  });
+```
+         */
+        fail(failCallback: TypeOrArray<Deferred.Callback<TJ>>,
+             ...failCallbacks: Array<TypeOrArray<Deferred.Callback<TJ>>>): this;
+        /**
+         * Add handlers to be called when the Deferred object generates progress notifications.
+         * @param progressCallback A function, or array of functions, to be called when the Deferred generates progress notifications.
+         * @param progressCallbacks Optional additional functions, or arrays of functions, to be called when the Deferred generates
+         *                          progress notifications.
+         * @see \`{@link https://api.jquery.com/deferred.progress/ }\`
+         * @since 1.7
+         */
+        progress(progressCallback: TypeOrArray<Deferred.Callback<TN>>,
+                 ...progressCallbacks: Array<TypeOrArray<Deferred.Callback<TN>>>): this;
+        /**
+         * Return a Deferred's Promise object.
+         * @param target Object onto which the promise methods have to be attached
+         * @see \`{@link https://api.jquery.com/deferred.promise/ }\`
+         * @since 1.5
+         * @example ​ ````Use the target argument to promote an existing object to a Promise:
+```javascript
+// Existing object
+var obj = {
+    hello: function( name ) {
+      alert( "Hello " + name );
+    }
+  },
+  // Create a Deferred
+  defer = $.Deferred();
+​
+// Set object as a promise
+defer.promise( obj );
+​
+// Resolve the deferred
+defer.resolve( "John" );
+​
+// Use the object as a Promise
+obj.done(function( name ) {
+  obj.hello( name ); // Will alert "Hello John"
+}).hello( "Karl" ); // Will alert "Hello Karl"
+```
+         */
+        promise<TTarget extends object>(target: TTarget): Promise<TR, TJ, TN> & TTarget;
+        /**
+         * Return a Deferred's Promise object.
+         * @see \`{@link https://api.jquery.com/deferred.promise/ }\`
+         * @since 1.5
+         * @example ​ ````Create a Deferred and set two timer-based functions to either resolve or reject the Deferred after a random interval. Whichever one fires first &quot;wins&quot; and will call one of the callbacks. The second timeout has no effect since the Deferred is already complete (in a resolved or rejected state) from the first timeout action. Also set a timer-based progress notification function, and call a progress handler that adds &quot;working...&quot; to the document body.
+```javascript
+function asyncEvent() {
+  var dfd = jQuery.Deferred();
+​
+  // Resolve after a random interval
+  setTimeout(function() {
+    dfd.resolve( "hurray" );
+  }, Math.floor( 400 + Math.random() * 2000 ) );
+​
+  // Reject after a random interval
+  setTimeout(function() {
+    dfd.reject( "sorry" );
+  }, Math.floor( 400 + Math.random() * 2000 ) );
+​
+  // Show a "working..." message every half-second
+  setTimeout(function working() {
+    if ( dfd.state() === "pending" ) {
+      dfd.notify( "working... " );
+      setTimeout( working, 500 );
+    }
+  }, 1 );
+​
+  // Return the Promise so caller can't change the Deferred
+  return dfd.promise();
+}
+​
+// Attach a done, fail, and progress handler for the asyncEvent
+$.when( asyncEvent() ).then(
+  function( status ) {
+    alert( status + ", things are going well" );
+  },
+  function( status ) {
+    alert( status + ", you fail this time" );
+  },
+  function( status ) {
+    $( "body" ).append( status );
+  }
+);
+```
+         */
+        promise(): Promise<TR, TJ, TN>;
+        /**
+         * Determine the current state of a Deferred object.
+         * @see \`{@link https://api.jquery.com/deferred.state/ }\`
+         * @since 1.7
+         */
+        state(): 'pending' | 'resolved' | 'rejected';
+
+        // region pipe
+        // #region pipe
+
+        /**
+         * Utility method to filter and/or chain Deferreds.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
+         * @since 1.6
+         * @since 1.7
+         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
+         *
+         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
+         *
+         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
+         * @example ​ ````Filter resolve value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.pipe(function( value ) {
+    return value * 2;
+  });
+​
+defer.resolve( 5 );
+filtered.done(function( value ) {
+  alert( "Value is ( 2*5 = ) 10: " + value );
+});
+```
+         * @example ​ ````Filter reject value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.pipe( null, function( value ) {
+    return value * 3;
+  });
+​
+defer.reject( 6 );
+filtered.fail(function( value ) {
+  alert( "Value is ( 3*6 = ) 18: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.pipe(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        pipe<ARD = never, AJD = never, AND = never,
+            BRD = never, BJD = never, BND = never,
+            CRD = never, CJD = never, CND = never,
+            RRD = never, RJD = never, RND = never,
+            ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never,
+            ARP = never, AJP = never, ANP = never,
+            BRP = never, BJP = never, BNP = never,
+            CRP = never, CJP = never, CNP = never,
+            RRP = never, RJP = never, RNP = never>(
+                doneFilter: (...t: TR[]) => PromiseBase<ARD, AJD, AND,
+                    BRD, BJD, BND,
+                    CRD, CJD, CND,
+                    RRD, RJD, RND> | Thenable<ARD> | ARD,
+                failFilter: (...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<AJF> | AJF,
+                progressFilter: (...t: TN[]) => PromiseBase<ARP, AJP, ANP,
+                    BRP, BJP, BNP,
+                    CRP, CJP, CNP,
+                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP,
+            BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP,
+            CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP,
+            RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>;
+        /**
+         * Utility method to filter and/or chain Deferreds.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
+         * @since 1.6
+         * @since 1.7
+         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
+         *
+         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
+         *
+         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
+         * @example ​ ````Filter reject value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.pipe( null, function( value ) {
+    return value * 3;
+  });
+​
+defer.reject( 6 );
+filtered.fail(function( value ) {
+  alert( "Value is ( 3*6 = ) 18: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.pipe(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        pipe<ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never,
+            ARP = never, AJP = never, ANP = never,
+            BRP = never, BJP = never, BNP = never,
+            CRP = never, CJP = never, CNP = never,
+            RRP = never, RJP = never, RNP = never>(
+                doneFilter: null,
+                failFilter: (...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<AJF> | AJF,
+                progressFilter: (...t: TN[]) => PromiseBase<ARP, AJP, ANP,
+                    BRP, BJP, BNP,
+                    CRP, CJP, CNP,
+                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP,
+            BRF | BRP, BJF | BJP, BNF | BNP,
+            CRF | CRP, CJF | CJP, CNF | CNP,
+            RRF | RRP, RJF | RJP, RNF | RNP>;
+        /**
+         * Utility method to filter and/or chain Deferreds.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
+         * @since 1.6
+         * @since 1.7
+         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
+         *
+         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
+         *
+         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
+         * @example ​ ````Filter resolve value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.pipe(function( value ) {
+    return value * 2;
+  });
+​
+defer.resolve( 5 );
+filtered.done(function( value ) {
+  alert( "Value is ( 2*5 = ) 10: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.pipe(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        pipe<ARD = never, AJD = never, AND = never,
+            BRD = never, BJD = never, BND = never,
+            CRD = never, CJD = never, CND = never,
+            RRD = never, RJD = never, RND = never,
+            ARP = never, AJP = never, ANP = never,
+            BRP = never, BJP = never, BNP = never,
+            CRP = never, CJP = never, CNP = never,
+            RRP = never, RJP = never, RNP = never>(
+                doneFilter: (...t: TR[]) => PromiseBase<ARD, AJD, AND,
+                    BRD, BJD, BND,
+                    CRD, CJD, CND,
+                    RRD, RJD, RND> | Thenable<ARD> | ARD,
+                failFilter: null,
+                progressFilter: (...t: TN[]) => PromiseBase<ARP, AJP, ANP,
+                    BRP, BJP, BNP,
+                    CRP, CJP, CNP,
+                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARP, AJD | AJP, AND | ANP,
+            BRD | BRP, BJD | BJP, BND | BNP,
+            CRD | CRP, CJD | CJP, CND | CNP,
+            RRD | RRP, RJD | RJP, RND | RNP>;
+        /**
+         * Utility method to filter and/or chain Deferreds.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
+         * @since 1.6
+         * @since 1.7
+         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
+         *
+         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
+         *
+         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.pipe(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        pipe<ARP = never, AJP = never, ANP = never,
+            BRP = never, BJP = never, BNP = never,
+            CRP = never, CJP = never, CNP = never,
+            RRP = never, RJP = never, RNP = never>(
+                doneFilter: null,
+                failFilter: null,
+                progressFilter?: (...t: TN[]) => PromiseBase<ARP, AJP, ANP,
+                    BRP, BJP, BNP,
+                    CRP, CJP, CNP,
+                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP,
+            BRP, BJP, BNP,
+            CRP, CJP, CNP,
+            RRP, RJP, RNP>;
+        /**
+         * Utility method to filter and/or chain Deferreds.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
+         * @since 1.6
+         * @since 1.7
+         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
+         *
+         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
+         *
+         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
+         * @example ​ ````Filter resolve value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.pipe(function( value ) {
+    return value * 2;
+  });
+​
+defer.resolve( 5 );
+filtered.done(function( value ) {
+  alert( "Value is ( 2*5 = ) 10: " + value );
+});
+```
+         * @example ​ ````Filter reject value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.pipe( null, function( value ) {
+    return value * 3;
+  });
+​
+defer.reject( 6 );
+filtered.fail(function( value ) {
+  alert( "Value is ( 3*6 = ) 18: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.pipe(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        pipe<ARD = never, AJD = never, AND = never,
+            BRD = never, BJD = never, BND = never,
+            CRD = never, CJD = never, CND = never,
+            RRD = never, RJD = never, RND = never,
+            ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never>(
+                doneFilter: (...t: TR[]) => PromiseBase<ARD, AJD, AND,
+                    BRD, BJD, BND,
+                    CRD, CJD, CND,
+                    RRD, RJD, RND> | Thenable<ARD> | ARD,
+                failFilter: (...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<AJF> | AJF,
+                progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF,
+            BRD | BRF, BJD | BJF, BND | BNF,
+            CRD | CRF, CJD | CJF, CND | CNF,
+            RRD | RRF, RJD | RJF, RND | RNF>;
+        /**
+         * Utility method to filter and/or chain Deferreds.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
+         * @since 1.6
+         * @since 1.7
+         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
+         *
+         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
+         *
+         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
+         * @example ​ ````Filter reject value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.pipe( null, function( value ) {
+    return value * 3;
+  });
+​
+defer.reject( 6 );
+filtered.fail(function( value ) {
+  alert( "Value is ( 3*6 = ) 18: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.pipe(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        pipe<ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never>(
+                doneFilter: null,
+                failFilter: (...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<AJF> | AJF,
+                progressFilter?: null): PromiseBase<ARF, AJF, ANF,
+            BRF, BJF, BNF,
+            CRF, CJF, CNF,
+            RRF, RJF, RNF>;
+        /**
+         * Utility method to filter and/or chain Deferreds.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.pipe/ }\`
+         * @since 1.6
+         * @since 1.7
+         * @deprecated ​ Deprecated since 1.8. Use \`{@link then }\`.
+         *
+         * **Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function.
+         *
+         * **Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0.
+         * @example ​ ````Filter resolve value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.pipe(function( value ) {
+    return value * 2;
+  });
+​
+defer.resolve( 5 );
+filtered.done(function( value ) {
+  alert( "Value is ( 2*5 = ) 10: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.pipe(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        pipe<ARD = never, AJD = never, AND = never,
+            BRD = never, BJD = never, BND = never,
+            CRD = never, CJD = never, CND = never,
+            RRD = never, RJD = never, RND = never>(
+                doneFilter: (...t: TR[]) => PromiseBase<ARD, AJD, AND,
+                    BRD, BJD, BND,
+                    CRD, CJD, CND,
+                    RRD, RJD, RND> | Thenable<ARD> | ARD,
+                failFilter?: null,
+                progressFilter?: null): PromiseBase<ARD, AJD, AND,
+            BRD, BJD, BND,
+            CRD, CJD, CND,
+            RRD, RJD, RND>;
+
+        // #endregion
+
+        // region then
+        // #region then
+
+        /**
+         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+         * @param doneFilter A function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
+         * @since 1.8
+         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred object, we can attach handlers using the .then method.
+```javascript
+$.get( "test.php" ).then(
+  function() {
+    alert( "$.get succeeded" );
+  }, function() {
+    alert( "$.get failed!" );
+  }
+);
+```
+         * @example ​ ````Filter the resolve value:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>deferred.then demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Filter Resolve</button>
+<p></p>
+​
+<script>
+var filterResolve = function() {
+  var defer = $.Deferred(),
+    filtered = defer.then(function( value ) {
+      return value * 2;
+    });
+​
+  defer.resolve( 5 );
+  filtered.done(function( value ) {
+    $( "p" ).html( "Value is ( 2*5 = ) 10: " + value );
+  });
+};
+​
+$( "button" ).on( "click", filterResolve );
+</script>
+​
+</body>
+</html>
+```
+         * @example ​ ````Filter reject value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.then( null, function( value ) {
+    return value * 3;
+  });
+​
+defer.reject( 6 );
+filtered.fail(function( value ) {
+  alert( "Value is ( 3*6 = ) 18: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.then(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        then<ARD = never, AJD = never, AND = never,
+            BRD = never, BJD = never, BND = never,
+            CRD = never, CJD = never, CND = never,
+            RRD = never, RJD = never, RND = never,
+            ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never,
+            ARP = never, AJP = never, ANP = never,
+            BRP = never, BJP = never, BNP = never,
+            CRP = never, CJP = never, CNP = never,
+            RRP = never, RJP = never, RNP = never>(
+                doneFilter: (...t: TR[]) => PromiseBase<ARD, AJD, AND,
+                    BRD, BJD, BND,
+                    CRD, CJD, CND,
+                    RRD, RJD, RND> | Thenable<ARD> | ARD,
+                failFilter: (...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<ARF> | ARF,
+                progressFilter: (...t: TN[]) => PromiseBase<ARP, AJP, ANP,
+                    BRP, BJP, BNP,
+                    CRP, CJP, CNP,
+                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP,
+            BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP,
+            CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP,
+            RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>;
+        /**
+         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+         * @param doneFilter A function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
+         * @since 1.8
+         * @example ​ ````Filter reject value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.then( null, function( value ) {
+    return value * 3;
+  });
+​
+defer.reject( 6 );
+filtered.fail(function( value ) {
+  alert( "Value is ( 3*6 = ) 18: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.then(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        then<ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never,
+            ARP = never, AJP = never, ANP = never,
+            BRP = never, BJP = never, BNP = never,
+            CRP = never, CJP = never, CNP = never,
+            RRP = never, RJP = never, RNP = never>(
+                doneFilter: null,
+                failFilter: (...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<ARF> | ARF,
+                progressFilter: (...t: TN[]) => PromiseBase<ARP, AJP, ANP,
+                    BRP, BJP, BNP,
+                    CRP, CJP, CNP,
+                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP,
+            BRF | BRP, BJF | BJP, BNF | BNP,
+            CRF | CRP, CJF | CJP, CNF | CNP,
+            RRF | RRP, RJF | RJP, RNF | RNP>;
+        /**
+         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+         * @param doneFilter A function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
+         * @since 1.8
+         * @example ​ ````Filter the resolve value:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>deferred.then demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Filter Resolve</button>
+<p></p>
+​
+<script>
+var filterResolve = function() {
+  var defer = $.Deferred(),
+    filtered = defer.then(function( value ) {
+      return value * 2;
+    });
+​
+  defer.resolve( 5 );
+  filtered.done(function( value ) {
+    $( "p" ).html( "Value is ( 2*5 = ) 10: " + value );
+  });
+};
+​
+$( "button" ).on( "click", filterResolve );
+</script>
+​
+</body>
+</html>
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.then(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        then<ARD = never, AJD = never, AND = never,
+            BRD = never, BJD = never, BND = never,
+            CRD = never, CJD = never, CND = never,
+            RRD = never, RJD = never, RND = never,
+            ARP = never, AJP = never, ANP = never,
+            BRP = never, BJP = never, BNP = never,
+            CRP = never, CJP = never, CNP = never,
+            RRP = never, RJP = never, RNP = never>(
+                doneFilter: (...t: TR[]) => PromiseBase<ARD, AJD, AND,
+                    BRD, BJD, BND,
+                    CRD, CJD, CND,
+                    RRD, RJD, RND> | Thenable<ARD> | ARD,
+                failFilter: null,
+                progressFilter: (...t: TN[]) => PromiseBase<ARP, AJP, ANP,
+                    BRP, BJP, BNP,
+                    CRP, CJP, CNP,
+                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARP, AJD | AJP, AND | ANP,
+            BRD | BRP, BJD | BJP, BND | BNP,
+            CRD | CRP, CJD | CJP, CND | CNP,
+            RRD | RRP, RJD | RJP, RND | RNP>;
+        /**
+         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+         * @param doneFilter A function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
+         * @since 1.8
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.then(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        then<ARP = never, AJP = never, ANP = never,
+            BRP = never, BJP = never, BNP = never,
+            CRP = never, CJP = never, CNP = never,
+            RRP = never, RJP = never, RNP = never>(
+                doneFilter: null,
+                failFilter: null,
+                progressFilter?: (...t: TN[]) => PromiseBase<ARP, AJP, ANP,
+                    BRP, BJP, BNP,
+                    CRP, CJP, CNP,
+                    RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP,
+            BRP, BJP, BNP,
+            CRP, CJP, CNP,
+            RRP, RJP, RNP>;
+        /**
+         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
+         * @since 1.8
+         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred object, we can attach handlers using the .then method.
+```javascript
+$.get( "test.php" ).then(
+  function() {
+    alert( "$.get succeeded" );
+  }, function() {
+    alert( "$.get failed!" );
+  }
+);
+```
+         * @example ​ ````Filter the resolve value:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>deferred.then demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Filter Resolve</button>
+<p></p>
+​
+<script>
+var filterResolve = function() {
+  var defer = $.Deferred(),
+    filtered = defer.then(function( value ) {
+      return value * 2;
+    });
+​
+  defer.resolve( 5 );
+  filtered.done(function( value ) {
+    $( "p" ).html( "Value is ( 2*5 = ) 10: " + value );
+  });
+};
+​
+$( "button" ).on( "click", filterResolve );
+</script>
+​
+</body>
+</html>
+```
+         * @example ​ ````Filter reject value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.then( null, function( value ) {
+    return value * 3;
+  });
+​
+defer.reject( 6 );
+filtered.fail(function( value ) {
+  alert( "Value is ( 3*6 = ) 18: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.then(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        then<ARD = never, AJD = never, AND = never,
+            BRD = never, BJD = never, BND = never,
+            CRD = never, CJD = never, CND = never,
+            RRD = never, RJD = never, RND = never,
+            ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never>(
+                doneFilter: (...t: TR[]) => PromiseBase<ARD, AJD, AND,
+                    BRD, BJD, BND,
+                    CRD, CJD, CND,
+                    RRD, RJD, RND> | Thenable<ARD> | ARD,
+                failFilter: (...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<ARF> | ARF,
+                progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF,
+            BRD | BRF, BJD | BJF, BND | BNF,
+            CRD | CRF, CJD | CJF, CND | CNF,
+            RRD | RRF, RJD | RJF, RND | RNF>;
+        /**
+         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
+         * @since 1.8
+         * @example ​ ````Filter reject value:
+```javascript
+var defer = $.Deferred(),
+  filtered = defer.then( null, function( value ) {
+    return value * 3;
+  });
+​
+defer.reject( 6 );
+filtered.fail(function( value ) {
+  alert( "Value is ( 3*6 = ) 18: " + value );
+});
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.then(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        then<ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never>(
+                doneFilter: null,
+                failFilter: (...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<ARF> | ARF,
+                progressFilter?: null): PromiseBase<ARF, AJF, ANF,
+            BRF, BJF, BNF,
+            CRF, CJF, CNF,
+            RRF, RJF, RNF>;
+        /**
+         * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+         * @param doneFilter An optional function that is called when the Deferred is resolved.
+         * @param failFilter An optional function that is called when the Deferred is rejected.
+         * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+         * @see \`{@link https://api.jquery.com/deferred.then/ }\`
+         * @since 1.8
+         * @example ​ ````Filter the resolve value:
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>deferred.then demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>Filter Resolve</button>
+<p></p>
+​
+<script>
+var filterResolve = function() {
+  var defer = $.Deferred(),
+    filtered = defer.then(function( value ) {
+      return value * 2;
+    });
+​
+  defer.resolve( 5 );
+  filtered.done(function( value ) {
+    $( "p" ).html( "Value is ( 2*5 = ) 10: " + value );
+  });
+};
+​
+$( "button" ).on( "click", filterResolve );
+</script>
+​
+</body>
+</html>
+```
+         * @example ​ ````Chain tasks:
+```javascript
+var request = $.ajax( url, { dataType: "json" } ),
+  chained = request.then(function( data ) {
+    return $.ajax( url2, { data: { user: data.userId } } );
+  });
+​
+chained.done(function( data ) {
+  // data retrieved from url2 as provided by the first request
+});
+```
+         */
+        then<ARD = never, AJD = never, AND = never,
+            BRD = never, BJD = never, BND = never,
+            CRD = never, CJD = never, CND = never,
+            RRD = never, RJD = never, RND = never>(
+                doneFilter: (...t: TR[]) => PromiseBase<ARD, AJD, AND,
+                    BRD, BJD, BND,
+                    CRD, CJD, CND,
+                    RRD, RJD, RND> | Thenable<ARD> | ARD,
+                failFilter?: null,
+                progressFilter?: null): PromiseBase<ARD, AJD, AND,
+            BRD, BJD, BND,
+            CRD, CJD, CND,
+            RRD, RJD, RND>;
+
+        // #endregion
+
+        /**
+         * Add handlers to be called when the Deferred object is rejected.
+         * @param failFilter A function that is called when the Deferred is rejected.
+         * @see \`{@link https://api.jquery.com/deferred.catch/ }\`
+         * @since 3.0
+         * @example ​ ````Since the jQuery.get method returns a jqXHR object, which is derived from a Deferred object, we can rejection handlers using the .catch method.
+```javascript
+$.get( "test.php" )
+  .then( function() {
+    alert( "$.get succeeded" );
+  } )
+  .catch( function() {
+    alert( "$.get failed!" );
+  } );
+```
+         */
+        catch<ARF = never, AJF = never, ANF = never,
+            BRF = never, BJF = never, BNF = never,
+            CRF = never, CJF = never, CNF = never,
+            RRF = never, RJF = never, RNF = never>(
+                failFilter?: ((...t: TJ[]) => PromiseBase<ARF, AJF, ANF,
+                    BRF, BJF, BNF,
+                    CRF, CJF, CNF,
+                    RRF, RJF, RNF> | Thenable<ARF> | ARF) | null): PromiseBase<ARF, AJF, ANF,
+            BRF, BJF, BNF,
+            CRF, CJF, CNF,
+            RRF, RJF, RNF>;
+    }
+
+    namespace Deferred {
+        type CallbackBase<T, U, V, R> = (t: T, u: U, v: V, ...r: R[]) => void;
+
+        interface Callback3<T, U, V> extends CallbackBase<T, U, V, never> { }
+
+        type Callback<T> = (...args: T[]) => void;
+
+        /**
+         * @deprecated ​ Deprecated. Use \`{@link Callback }\`.
+         */
+        interface DoneCallback<TResolve> extends Callback<TResolve> { }
+
+        /**
+         * @deprecated ​ Deprecated. Use \`{@link Callback }\`.
+         */
+        interface FailCallback<TReject> extends Callback<TReject> { }
+
+        /**
+         * @deprecated ​ Deprecated. Use \`{@link Callback }\`.
+         */
+        interface AlwaysCallback<TResolve, TReject> extends Callback<TResolve | TReject> { }
+
+        /**
+         * @deprecated ​ Deprecated. Use \`{@link Callback }\`.
+         */
+        interface ProgressCallback<TNotify> extends Callback<TNotify> { }
+    }
+
+    // #endregion
+
+    // region Effects
+    // #region Effects
+
+    type Duration = number | 'fast' | 'slow';
+
+    /**
+     * @see \`{@link https://api.jquery.com/animate/#animate-properties-options }\`
+     */
+    interface EffectsOptions<TElement> extends PlainObject {
+        /**
+         * A function to be called when the animation on an element completes or stops without completing (its Promise object is either resolved or rejected).
+         */
+        always?(this: TElement, animation: Animation<TElement>, jumpedToEnd: boolean): void;
+        /**
+         * A function that is called once the animation on an element is complete.
+         */
+        complete?(this: TElement): void;
+        /**
+         * A function to be called when the animation on an element completes (its Promise object is resolved).
+         */
+        done?(this: TElement, animation: Animation<TElement>, jumpedToEnd: boolean): void;
+        /**
+         * A string or number determining how long the animation will run.
+         */
+        duration?: Duration;
+        /**
+         * A string indicating which easing function to use for the transition.
+         */
+        easing?: string;
+        /**
+         * A function to be called when the animation on an element fails to complete (its Promise object is rejected).
+         */
+        fail?(this: TElement, animation: Animation<TElement>, jumpedToEnd: boolean): void;
+        /**
+         * A function to be called after each step of the animation, only once per animated element regardless of the number of animated properties.
+         */
+        progress?(this: TElement, animation: Animation<TElement>, progress: number, remainingMs: number): void;
+        /**
+         * A Boolean indicating whether to place the animation in the effects queue. If false, the animation will begin immediately. As of jQuery 1.7, the queue option can also accept a string, in which case the animation is added to the queue represented by that string. When a custom queue name is used the animation does not automatically start; you must call .dequeue("queuename") to start it.
+         */
+        queue?: boolean | string;
+        /**
+         * An object containing one or more of the CSS properties defined by the properties argument and their corresponding easing functions.
+         */
+        specialEasing?: PlainObject<string>;
+        /**
+         * A function to call when the animation on an element begins.
+         */
+        start?(this: TElement, animation: Animation<TElement>): void;
+        /**
+         * A function to be called for each animated property of each animated element. This function provides an opportunity to modify the Tween object to change the value of the property before it is set.
+         */
+        step?(this: TElement, now: number, tween: Tween<TElement>): void;
+    }
+
+    // region Animation
+    // #region Animation
+
+    /**
+     * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#animation-factory }\`
+     * @since 1.8
+     */
+    interface AnimationStatic {
+        /**
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#animation-factory }\`
+         * @since 1.8
+         */
+        <TElement>(element: TElement, props: PlainObject, opts: EffectsOptions<TElement>): Animation<TElement>;
+        /**
+         * During the initial setup, `jQuery.Animation` will call any callbacks that have been registered through `jQuery.Animation.prefilter( function( element, props, opts ) )`.
+         * @param callback The prefilter will have `this` set to an animation object, and you can modify any of the `props` or
+         *                 `opts` however you need. The prefilter _may_ return its own promise which also implements `stop()`,
+         *                 in which case, processing of prefilters stops. If the prefilter is not trying to override the animation
+         *                 entirely, it should return `undefined` or some other falsy value.
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#prefilters }\`
+         * @since 1.8
+         */
+        prefilter<TElement>(
+            callback: (this: Animation<TElement>, element: TElement, props: PlainObject, opts: EffectsOptions<TElement>) => Animation<TElement> | _Falsy | void,
+            prepend?: boolean
+        ): void;
+        /**
+         * A "Tweener" is a function responsible for creating a tween object, and you might want to override these if you want to implement complex values ( like a clip/transform array matrix ) in a single property.
+         *
+         * You can override the default process for creating a tween in order to provide your own tween object by using `jQuery.Animation.tweener( props, callback( prop, value ) )`.
+         * @param props A space separated list of properties to be passed to your tweener, or `"*"` if it should be called
+         *              for all properties.
+         * @param callback The callback will be called with `this` being an `Animation` object. The tweener function will
+         *                 generally start with `var tween = this.createTween( prop, value );`, but doesn't nessecarily need to
+         *                 use the `jQuery.Tween()` factory.
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tweeners }\`
+         * @since 1.8
+         */
+        tweener(props: string, callback: Tweener<any>): void;
+    }
+
+    /**
+     * The promise will be resolved when the animation reaches its end, and rejected when terminated early. The context of callbacks attached to the promise will be the element, and the arguments will be the `Animation` object and a boolean `jumpedToEnd` which when true means the animation was stopped with `gotoEnd`, when `undefined` the animation completed naturally.
+     * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#animation-factory }\`
+     * @since 1.8
+     */
+    interface Animation<TElement> extends Promise3<
+        Animation<TElement>, Animation<TElement>, Animation<TElement>,
+        true | undefined, false, number,
+        never, never, number
+    > {
+        /**
+         * The duration specified in ms
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#animation-factory }\`
+         * @since 1.8
+         */
+        duration: number;
+        /**
+         * The element being animatied
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#animation-factory }\`
+         * @since 1.8
+         */
+        elem: TElement;
+        /**
+         * The final value of each property animating
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#animation-factory }\`
+         * @since 1.8
+         */
+        props: PlainObject;
+        /**
+         * The animation options
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#animation-factory }\`
+         * @since 1.8
+         */
+        opts: EffectsOptions<TElement>;
+        /**
+         * The original properties before being filtered
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#animation-factory }\`
+         * @since 1.8
+         */
+        originalProps: PlainObject;
+        /**
+         * The original options before being filtered
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#animation-factory }\`
+         * @since 1.8
+         */
+        originalOpts: EffectsOptions<TElement>;
+        /**
+         * The numeric value of `new Date()` when the animation began
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#animation-factory }\`
+         * @since 1.8
+         */
+        startTime: number;
+        /**
+         * The animations tweens.
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#animation-factory }\`
+         * @since 1.8
+         */
+        tweens: Array<Tween<TElement>>;
+        /**
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#animation-factory }\`
+         * @since 1.8
+         */
+        createTween(propName: string, finalValue: number): Tween<TElement>;
+        /**
+         * Stops the animation early, optionally going to the end.
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#animation-factory }\`
+         * @since 1.8
+         */
+        stop(gotoEnd: boolean): this;
+    }
+
+    /**
+     * A "Tweener" is a function responsible for creating a tween object, and you might want to override these if you want to implement complex values ( like a clip/transform array matrix ) in a single property.
+     * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tweeners }\`
+     * @since 1.8
+     */
+    type Tweener<TElement> = (this: Animation<TElement>, propName: string, finalValue: number) => Tween<TElement>;
+
+    /**
+     * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tweens }\`
+     * @since 1.8
+     */
+    interface TweenStatic {
+        /**
+         * `jQuery.Tween.propHooks[ prop ]` is a hook point that replaces `jQuery.fx.step[ prop ]` (which is being deprecated.) These hooks are used by the tween to get and set values on elements.
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tween-hooks }\`
+         * @since 1.8
+         * @example
+```javascript
+jQuery.Tween.propHooks[ property ] = {
+    get: function( tween ) {
+         // get tween.prop from tween.elem and return it
+    },
+    set: function( tween ) {
+         // set tween.prop on tween.elem to tween.now + tween.unit
+    }
+}
+```
+         */
+        propHooks: PropHooks;
+        /**
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tweens }\`
+         * @since 1.8
+         */
+        <TElement>(elem: TElement, options: EffectsOptions<TElement>, prop: string, end: number, easing?: string, unit?: string): Tween<TElement>;
+    }
+
+    /**
+     * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tweens }\`
+     * @since 1.8
+     */
+    // This should be a class but doesn't work correctly under the JQuery namespace. Tween should be an inner class of jQuery.
+    interface Tween<TElement> {
+        /**
+         * The easing used
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tweens }\`
+         * @since 1.8
+         */
+        easing: string;
+        /**
+         * The element being animated
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tweens }\`
+         * @since 1.8
+         */
+        elem: TElement;
+        /**
+         * The ending value of the tween
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tweens }\`
+         * @since 1.8
+         */
+        end: number;
+        /**
+         * The current value of the tween
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tweens }\`
+         * @since 1.8
+         */
+        now: number;
+        /**
+         * A reference to the animation options
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tweens }\`
+         * @since 1.8
+         */
+        options: EffectsOptions<TElement>;
+        // Undocumented. Is this intended to be public?
+        pos?: number;
+        /**
+         * The property being animated
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tweens }\`
+         * @since 1.8
+         */
+        prop: string;
+        /**
+         * The starting value of the tween
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tweens }\`
+         * @since 1.8
+         */
+        start: number;
+        /**
+         * The CSS unit for the tween
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tweens }\`
+         * @since 1.8
+         */
+        unit: string;
+        /**
+         * Reads the current value for property from the element
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tweens }\`
+         * @since 1.8
+         */
+        cur(): any;
+        /**
+         * Updates the value for the property on the animated elemd.
+         * @param progress A number from 0 to 1.
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tweens }\`
+         * @since 1.8
+         */
+        run(progress: number): this;
+    }
+
+    /**
+     * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tween-hooks }\`
+     * @since 1.8
+     */
+    // Workaround for TypeScript 2.3 which does not have support for weak types handling.
+    type PropHook<TElement> = {
+        /**
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tween-hooks }\`
+         * @since 1.8
+         */
+        get(tween: Tween<TElement>): any;
+    } | {
+        /**
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tween-hooks }\`
+         * @since 1.8
+         */
+        set(tween: Tween<TElement>): void;
+    } | {
+        [key: string]: never;
+    };
+
+    /**
+     * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#tween-hooks }\`
+     * @since 1.8
+     */
+    interface PropHooks {
+        [property: string]: PropHook<Node>;
+    }
+
+    // #endregion
+
+    // region Easing
+    // #region Easing
+
+    type EasingMethod = (percent: number) => number;
+
+    interface Easings {
+        [name: string]: EasingMethod;
+    }
+
+    // #endregion
+
+    // region Effects (fx)
+    // #region Effects (fx)
+
+    interface Effects {
+        /**
+         * The rate (in milliseconds) at which animations fire.
+         * @see \`{@link https://api.jquery.com/jQuery.fx.interval/ }\`
+         * @since 1.4.3
+         * @deprecated ​ Deprecated since 3.0. See \`{@link https://api.jquery.com/jQuery.fx.interval/ }\`.
+         *
+         * **Cause**: As of jQuery 3.0 the `jQuery.fx.interval` property can be used to change the animation interval only on browsers that do not support the `window.requestAnimationFrame()` method. That is currently only Internet Explorer 9 and the Android Browser. Once support is dropped for these browsers, the property will serve no purpose and it will be removed.
+         *
+         * **Solution**: Find and remove code that changes or uses `jQuery.fx.interval`. If the value is being used by code in your page or a plugin, the code may be making assumptions that are no longer valid. The default value of `jQuery.fx.interval` is `13` (milliseconds), which could be used instead of accessing this property.
+         * @example ​ ````Cause all animations to run with less frames.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.fx.interval demo</title>
+  <style>
+  div {
+    width: 50px;
+    height: 30px;
+    margin: 5px;
+    float: left;
+    background: green;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p><input type="button" value="Run"></p>
+<div></div>
+​
+<script>
+jQuery.fx.interval = 100;
+$( "input" ).click(function() {
+  $( "div" ).toggle( 3000 );
+});
+</script>
+</body>
+</html>
+```
+        */
+        interval: number;
+        /**
+         * Globally disable all animations.
+         * @see \`{@link https://api.jquery.com/jQuery.fx.off/ }\`
+         * @since 1.3
+         * @example ​ ````Toggle animation on and off
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>jQuery.fx.off demo</title>
+  <style>
+  div {
+    width: 50px;
+    height: 30px;
+    margin: 5px;
+    float: left;
+    background: green;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<input type="button" value="Run">
+<button>Toggle fx</button>
+<div></div>
+​
+<script>
+var toggleFx = function() {
+  $.fx.off = !$.fx.off;
+};
+toggleFx();
+$( "button" ).click( toggleFx );
+$( "input" ).click(function() {
+  $( "div" ).toggle( "slow" );
+});
+</script>
+</body>
+</html>
+```
+        */
+        off: boolean;
+        /**
+         * @deprecated ​ Deprecated since 1.8. Use \`{@link Tween.propHooks jQuery.Tween.propHooks}\`.
+         *
+         * `jQuery.fx.step` functions are being replaced by `jQuery.Tween.propHooks` and may eventually be removed, but are still supported via the default tween propHook.
+         */
+        step: PlainObject<AnimationHook<Node>>;
+        /**
+         * _overridable_ Clears up the `setInterval`
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#plugging-in-a-different-timer-loop }\`
+         * @since 1.8
+         */
+        stop(): void;
+        /**
+         * Calls `.run()` on each object in the `jQuery.timers` array, removing it from the array if `.run()` returns a falsy value. Calls `jQuery.fx.stop()` whenever there are no timers remaining.
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#plugging-in-a-different-timer-loop }\`
+         * @since 1.8
+         */
+        tick(): void;
+        /**
+         * _overridable_ Creates a `setInterval` if one doesn't already exist, and pushes `tickFunction` to the `jQuery.timers` array. `tickFunction` should also have `anim`, `elem`, and `queue` properties that reference the animation object, animated element, and queue option to facilitate `jQuery.fn.stop()`
+         *
+         * By overriding `fx.timer` and `fx.stop` you should be able to implement any animation tick behaviour you desire. (like using `requestAnimationFrame` instead of `setTimeout`.)
+         *
+         * There is an example of overriding the timer loop in \`{@link https://github.com/gnarf37/jquery-requestAnimationFrame jquery.requestAnimationFrame}\`
+         * @see \`{@link https://gist.github.com/gnarf/54829d408993526fe475#plugging-in-a-different-timer-loop }\`
+         * @since 1.8
+         */
+        timer(tickFunction: TickFunction<any>): void;
+    }
+
+    /**
+     * @deprecated ​ Deprecated since 1.8. Use \`{@link Tween.propHooks jQuery.Tween.propHooks}\`.
+     *
+     * `jQuery.fx.step` functions are being replaced by `jQuery.Tween.propHooks` and may eventually be removed, but are still supported via the default tween propHook.
+     */
+    type AnimationHook<TElement> = (fx: Tween<TElement>) => void;
+
+    interface TickFunction<TElement> {
+        anim: Animation<TElement>;
+        elem: TElement;
+        queue: boolean | string;
+        (): any;
+    }
+
+    // #endregion
+
+    // region Queue
+    // #region Queue
+
+    // TODO: Is the first element always a string or is that specific to the 'fx' queue?
+    type Queue<TElement> = { 0: string; } & Array<QueueFunction<TElement>>;
+
+    type QueueFunction<TElement> = (this: TElement, next: () => void) => void;
+
+    // #endregion
+
+    // region Speed
+    // #region Speed
+
+    // Workaround for TypeScript 2.3 which does not have support for weak types handling.
+    type SpeedSettings<TElement> = {
+        /**
+         * A string or number determining how long the animation will run.
+         */
+        duration: Duration;
+    } | {
+        /**
+         * A string indicating which easing function to use for the transition.
+         */
+        easing: string;
+    } | {
+        /**
+         * A function to call once the animation is complete.
+         */
+        complete(this: TElement): void;
+    } | {
+        [key: string]: never;
+    };
+
+    // #endregion
+
+    // #endregion
+
+    // region Events
+    // #region Events
+
+    // region Event
+    // #region Event
+
+    // This should be a class but doesn't work correctly under the JQuery namespace. Event should be an inner class of jQuery.
+
+    // Static members
+    interface EventStatic {
+        // tslint:disable-next-line:no-unnecessary-generics
+        <T extends object, TTarget extends EventTarget = HTMLElement>(event: string, properties?: T): Event<TTarget> & T;
+        // tslint:disable-next-line:no-unnecessary-generics
+        <T extends EventLike, TTarget extends EventTarget = HTMLElement>(properties: T): Event<TTarget> & T;
+        // tslint:disable-next-line:no-unnecessary-generics
+        new <T extends object, TTarget extends EventTarget = HTMLElement>(event: string, properties?: T): Event<TTarget> & T;
+        // tslint:disable-next-line:no-unnecessary-generics
+        new <T extends EventLike, TTarget extends EventTarget = HTMLElement>(properties: T): Event<TTarget> & T;
+    }
+
+    // Instance members
+    interface Event {
+        // region Copied properties
+        // #region Copied properties
+
+        // region Event
+        // #region Event
+
+        bubbles?: boolean;
+        cancelable?: boolean;
+        eventPhase?: number;
+
+        // #endregion
+
+        // region UIEvent
+        // #region UIEvent
+
+        detail?: number;
+        view?: Window;
+
+        // #endregion
+
+        // region MouseEvent
+        // #region MouseEvent
+
+        button?: number;
+        buttons?: number;
+        clientX?: number;
+        clientY?: number;
+        offsetX?: number;
+        offsetY?: number;
+        /**
+         * The mouse position relative to the left edge of the document.
+         * @see \`{@link https://api.jquery.com/event.pageX/ }\`
+         * @since 1.0.4
+         * @example ​ ````Show the mouse position relative to the left and top edges of the document (within this iframe).
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>event.pageX demo</title>
+  <style>
+  body {
+    background-color: #eef;
+  }
+  div {
+    padding: 20px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+$( document ).on( "mousemove", function( event ) {
+  $( "#log" ).text( "pageX: " + event.pageX + ", pageY: " + event.pageY );
+});
+</script>
+​
+</body>
+</html>
+```
+         */
+        pageX: number;
+        /**
+         * The mouse position relative to the top edge of the document.
+         * @see \`{@link https://api.jquery.com/event.pageY/ }\`
+         * @since 1.0.4
+         * @example ​ ````Show the mouse position relative to the left and top edges of the document (within this iframe).
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>event.pageY demo</title>
+  <style>
+  body {
+    background-color: #eef;
+  }
+  div {
+    padding: 20px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+​
+<script>
+$( document ).on( "mousemove", function( event ) {
+  $( "#log" ).text( "pageX: " + event.pageX + ", pageY: " + event.pageY );
+});
+</script>
+​
+</body>
+</html>
+```
+         */
+        pageY: number;
+        screenX?: number;
+        screenY?: number;
+        /** @deprecated */
+        toElement?: Element;
+
+        // #endregion
+
+        // region PointerEvent
+        // #region PointerEvent
+
+        pointerId?: number;
+        pointerType?: string;
+
+        // #endregion
+
+        // region KeyboardEvent
+        // #region KeyboardEvent
+
+        /** @deprecated */
+        char?: string;
+        /** @deprecated */
+        charCode?: number;
+        key?: string;
+        /** @deprecated */
+        keyCode?: number;
+
+        // #endregion
+
+        // region TouchEvent
+        // #region TouchEvent
+
+        changedTouches?: TouchList;
+        targetTouches?: TouchList;
+        touches?: TouchList;
+
+        // #endregion
+
+        // region MouseEvent, KeyboardEvent, TouchEvent
+        // #region MouseEvent, KeyboardEvent, TouchEvent
+
+        altKey?: boolean;
+        ctrlKey?: boolean;
+        /**
+         * Indicates whether the META key was pressed when the event fired.
+         * @see \`{@link https://api.jquery.com/event.metaKey/ }\`
+         * @since 1.0.4
+         * @example ​ ````Determine whether the META key was pressed when the event fired.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>event.metaKey demo</title>
+  <style>
+  body {
+    background-color: #eef;
+  }
+  div {
+    padding: 20px;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button value="Test" name="Test" id="checkMetaKey">Click me!</button>
+<div id="display"></div>
+​
+<script>
+$( "#checkMetaKey" ).click(function( event ) {
+  $( "#display" ).text( event.metaKey );
+});
+</script>
+​
+</body>
+</html>
+```
+         */
+        metaKey: boolean;
+        shiftKey?: boolean;
+
+        // #endregion
+
+        // #endregion
+
+        /**
+         * The namespace specified when the event was triggered.
+         * @see \`{@link https://api.jquery.com/event.namespace/ }\`
+         * @since 1.4.3
+         * @example ​ ````Determine the event namespace used.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>event.namespace demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>display event.namespace</button>
+<p></p>
+​
+<script>
+$( "p" ).on( "test.something", function( event ) {
+  alert( event.namespace );
+});
+$( "button" ).click(function( event ) {
+  $( "p" ).trigger( "test.something" );
+});
+</script>
+​
+</body>
+</html>
+```
+         */
+        namespace: string;
+        /**
+         * The last value returned by an event handler that was triggered by this event, unless the value was undefined.
+         * @see \`{@link https://api.jquery.com/event.result/ }\`
+         * @since 1.3
+         * @example ​ ````Display previous handler&#39;s return value
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>event.result demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>display event.result</button>
+<p></p>
+​
+<script>
+$( "button" ).click(function( event ) {
+  return "hey";
+});
+$( "button" ).click(function( event ) {
+  $( "p" ).html( event.result );
+});
+</script>
+​
+</body>
+</html>
+```
+         */
+        result: any;
+        /**
+         * The difference in milliseconds between the time the browser created the event and January 1, 1970.
+         * @see \`{@link https://api.jquery.com/event.timeStamp/ }\`
+         * @since 1.2.6
+         * @example ​ ````Display the time since the click handler last executed.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>event.timeStamp demo</title>
+  <style>
+  div {
+    height: 100px;
+    width: 300px;
+    margin: 10px;
+    background-color: #ffd;
+    overflow: auto;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div>Click.</div>
+​
+<script>
+var last, diff;
+$( "div" ).click(function( event ) {
+  if ( last ) {
+    diff = event.timeStamp - last;
+    $( "div" ).append( "time since last event: " + diff + "<br>" );
+  } else {
+    $( "div" ).append( "Click again.<br>" );
+  }
+  last = event.timeStamp;
+});
+</script>
+​
+</body>
+</html>
+```
+         */
+        timeStamp: number;
+        /**
+         * Describes the nature of the event.
+         * @see \`{@link https://api.jquery.com/event.type/ }\`
+         * @since 1.0
+         * @example ​ ````On all anchor clicks, alert the event type.
+```javascript
+$( "a" ).click(function( event ) {
+  alert( event.type ); // "click"
+});
+```
+         */
+        type: string;
+        /**
+         * For key or mouse events, this property indicates the specific key or button that was pressed.
+         * @see \`{@link https://api.jquery.com/event.which/ }\`
+         * @since 1.1.3
+         * @example ​ ````Log which key was depressed.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>event.which demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<input id="whichkey" value="type something">
+<div id="log"></div>
+​
+<script>
+$( "#whichkey" ).on( "keydown", function( event ) {
+  $( "#log" ).html( event.type + ": " +  event.which );
+});
+</script>
+​
+</body>
+</html>
+```
+         * @example ​ ````Log which mouse button was depressed.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>event.which demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<input id="whichkey" value="click here">
+<div id="log"></div>
+​
+<script>
+$( "#whichkey" ).on( "mousedown", function( event ) {
+  $( "#log" ).html( event.type + ": " +  event.which );
+});
+</script>
+​
+</body>
+</html>
+```
+         */
+        which: number;
+        /**
+         * Returns whether event.preventDefault() was ever called on this event object.
+         * @see \`{@link https://api.jquery.com/event.isDefaultPrevented/ }\`
+         * @since 1.3
+         * @example ​ ````Checks whether event.preventDefault() was called.
+```javascript
+$( "a" ).click(function( event ) {
+  alert( event.isDefaultPrevented() ); // false
+  event.preventDefault();
+  alert( event.isDefaultPrevented() ); // true
+});
+```
+         */
+        isDefaultPrevented(): boolean;
+        /**
+         * Returns whether event.stopImmediatePropagation() was ever called on this event object.
+         * @see \`{@link https://api.jquery.com/event.isImmediatePropagationStopped/ }\`
+         * @since 1.3
+         * @example ​ ````Checks whether event.stopImmediatePropagation() was called.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>event.isImmediatePropagationStopped demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>click me</button>
+<div id="stop-log"></div>
+  ​
+<script>
+function immediatePropStopped( event ) {
+  var msg = "";
+  if ( event.isImmediatePropagationStopped() ) {
+    msg = "called";
+  } else {
+    msg = "not called";
+  }
+  $( "#stop-log" ).append( "<div>" + msg + "</div>" );
+}
+​
+$( "button" ).click(function( event ) {
+  immediatePropStopped( event );
+  event.stopImmediatePropagation();
+  immediatePropStopped( event );
+});
+</script>
+​
+</body>
+</html>
+```
+         */
+        isImmediatePropagationStopped(): boolean;
+        /**
+         * Returns whether event.stopPropagation() was ever called on this event object.
+         * @see \`{@link https://api.jquery.com/event.isPropagationStopped/ }\`
+         * @since 1.3
+         * @example ​ ````Checks whether event.stopPropagation() was called
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>event.isPropagationStopped demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button>click me</button>
+<div id="stop-log"></div>
+  ​
+<script>
+function propStopped( event ) {
+  var msg = "";
+  if ( event.isPropagationStopped() ) {
+    msg = "called";
+  } else {
+    msg = "not called";
+  }
+  $( "#stop-log" ).append( "<div>" + msg + "</div>" );
+}
+​
+$( "button" ).click(function(event) {
+  propStopped( event );
+  event.stopPropagation();
+  propStopped( event );
+});
+</script>
+​
+</body>
+</html>
+```
+         */
+        isPropagationStopped(): boolean;
+        /**
+         * If this method is called, the default action of the event will not be triggered.
+         * @see \`{@link https://api.jquery.com/event.preventDefault/ }\`
+         * @since 1.0
+         * @example ​ ````Cancel the default action (navigation) of the click.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>event.preventDefault demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<a href="https://jquery.com">default click action is prevented</a>
+<div id="log"></div>
+​
+<script>
+$( "a" ).click(function( event ) {
+  event.preventDefault();
+  $( "<div>" )
+    .append( "default " + event.type + " prevented" )
+    .appendTo( "#log" );
+});
+</script>
+​
+</body>
+</html>
+```
+         */
+        preventDefault(): void;
+        /**
+         * Keeps the rest of the handlers from being executed and prevents the event from bubbling up the DOM tree.
+         * @see \`{@link https://api.jquery.com/event.stopImmediatePropagation/ }\`
+         * @since 1.3
+         * @example ​ ````Prevents other event handlers from being called.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>event.stopImmediatePropagation demo</title>
+  <style>
+  p {
+    height: 30px;
+    width: 150px;
+    background-color: #ccf;
+  }
+  div {
+    height: 30px;
+    width: 150px;
+    background-color: #cfc;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<p>paragraph</p>
+<div>division</div>
+​
+<script>
+$( "p" ).click(function( event ) {
+  event.stopImmediatePropagation();
+});
+$( "p" ).click(function( event ) {
+  // This function won't be executed
+  $( this ).css( "background-color", "#f00" );
+});
+$( "div" ).click(function( event ) {
+  // This function will be executed
+  $( this ).css( "background-color", "#f00" );
+});
+</script>
+​
+</body>
+</html>
+```
+         */
+        stopImmediatePropagation(): void;
+        /**
+         * Prevents the event from bubbling up the DOM tree, preventing any parent handlers from being notified of the event.
+         * @see \`{@link https://api.jquery.com/event.stopPropagation/ }\`
+         * @since 1.0
+         * @example ​ ````Kill the bubbling on the click event.
+```javascript
+$( "p" ).click(function( event ) {
+  event.stopPropagation();
+  // Do something
+});
+```
+         */
+        stopPropagation(): void;
+    }
+
+    // Generic members
+    interface Event<
+        TTarget = EventTarget,
+        TData = null
+    > {
+        /**
+         * The current DOM element within the event bubbling phase.
+         * @see \`{@link https://api.jquery.com/event.currentTarget/ }\`
+         * @since 1.3
+         * @example ​ ````Alert that currentTarget matches the `this` keyword.
+```javascript
+$( "p" ).click(function( event ) {
+  alert( event.currentTarget === this ); // true
+});
+```
+         */
+        currentTarget: TTarget;
+        /**
+         * An optional object of data passed to an event method when the current executing handler is bound.
+         * @see \`{@link https://api.jquery.com/event.data/ }\`
+         * @since 1.1
+         * @example ​ ````Within a for loop, pass the value of i to the .on() method so that the current iteration&#39;s value is preserved.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>event.data demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<button> 0 </button>
+<button> 1 </button>
+<button> 2 </button>
+<button> 3 </button>
+<button> 4 </button>
+​
+<div id="log"></div>
+​
+<script>
+var logDiv = $( "#log" );
+​
+for ( var i = 0; i < 5; i++ ) {
+  $( "button" ).eq( i ).on( "click", { value: i }, function( event ) {
+    var msgs = [
+      "button = " + $( this ).index(),
+      "event.data.value = " + event.data.value,
+      "i = " + i
+    ];
+    logDiv.append( msgs.join( ", " ) + "<br>" );
+  });
+}
+</script>
+​
+</body>
+</html>
+```
+         */
+        data: TData;
+        /**
+         * The element where the currently-called jQuery event handler was attached.
+         * @see \`{@link https://api.jquery.com/event.delegateTarget/ }\`
+         * @since 1.7
+         * @example ​ ````When a button in any box class is clicked, change the box&#39;s background color to red.
+```javascript
+$( ".box" ).on( "click", "button", function( event ) {
+  $( event.delegateTarget ).css( "background-color", "red" );
+});
+```
+         */
+        delegateTarget: TTarget;
+        originalEvent: _Event;
+        /**
+         * The other DOM element involved in the event, if any.
+         * @see \`{@link https://api.jquery.com/event.relatedTarget/ }\`
+         * @since 1.1.4
+         * @example ​ ````On mouseout of anchors, alert the element type being entered.
+```javascript
+$( "a" ).mouseout(function( event ) {
+  alert( event.relatedTarget.nodeName ); // "DIV"
+});
+```
+         */
+        relatedTarget: TTarget | null;
+        /**
+         * The DOM element that initiated the event.
+         * @see \`{@link https://api.jquery.com/event.target/ }\`
+         * @since 1.0
+         * @example ​ ````Display the tag&#39;s name on click
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>event.target demo</title>
+  <style>
+  span, strong, p {
+    padding: 8px;
+    display: block;
+    border: 1px solid #999;
+  }
+  </style>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<div id="log"></div>
+<div>
+  <p>
+    <strong><span>click</span></strong>
+  </p>
+</div>
+​
+<script>
+$( "body" ).click(function( event ) {
+  $( "#log" ).html( "clicked: " + event.target.nodeName );
+});
+</script>
+​
+</body>
+</html>
+```
+         * @example ​ ````Implements a simple event delegation: The click handler is added to an unordered list, and the children of its li children are hidden. Clicking one of the li children toggles (see toggle()) their children.
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>event.target demo</title>
+  <script src="https://code.jquery.com/jquery-3.3.1.js"></script>
+</head>
+<body>
+​
+<ul>
+  <li>item 1
+    <ul>
+      <li>sub item 1-a</li>
+      <li>sub item 1-b</li>
+    </ul>
+  </li>
+  <li>item 2
+    <ul>
+      <li>sub item 2-a</li>
+      <li>sub item 2-b</li>
+    </ul>
+  </li>
+</ul>
+​
+<script>
+function handler( event ) {
+  var target = $( event.target );
+  if ( target.is( "li" ) ) {
+    target.children().toggle();
+  }
+}
+$( "ul" ).click( handler ).find( "ul" ).hide();
+</script>
+​
+</body>
+</html>
+```
+         */
+        target: TTarget;
+    }
+
+    interface EventLike {
+        type: string;
+    }
+
+    // #endregion
+
+    interface EventHandler<TCurrentTarget, TData = null> extends EventHandlerBase<TCurrentTarget, Event<TCurrentTarget, TData>> { }
+
+    // Extra parameters can be passed from trigger()
+    type EventHandlerBase<TContext, T> = (this: TContext, t: T, ...args: any[]) => any;
+
+    // region Event extensions
+    // #region Event extensions
+
+    interface EventExtensions {
+        /**
+         * jQuery defines an \`{@link https://api.jquery.com/category/events/event-object/ Event object}\` that represents a cross-browser subset of the information available when an event occurs. The `jQuery.event.props` property is an array of string names for properties that are always copied when jQuery processes a native browser event. (Events fired in code by `.trigger()` do not use this list, since the code can construct a `jQuery.Event` object with the needed values and trigger using that object.)
+         *
+         * To add a property name to this list, use `jQuery.event.props.push( "newPropertyName" )`. However, be aware that every event processed by jQuery will now attempt to copy this property name from the native browser event to jQuery's constructed event. If the property does not exist for that event type, it will get an undefined value. Adding many properties to this list can significantly reduce event delivery performance, so for infrequently-needed properties it is more efficient to use the value directly from `event.originalEvent` instead. If properties must be copied, you are strongly advised to use `jQuery.event.fixHooks` as of version 1.7.
+         * @see \`{@link https://learn.jquery.com/events/event-extensions/#jquery-event-props-array }\`
+         */
+        props: string[];
+        /**
+         * The `fixHooks` interface provides a per-event-type way to extend or normalize the event object that jQuery creates when it processes a _native_ browser event.
+         * @see \`{@link https://learn.jquery.com/events/event-extensions/#jquery-event-fixhooks-object }\`
+         */
+        fixHooks: FixHooks;
+        /**
+         * The jQuery special event hooks are a set of per-event-name functions and properties that allow code to control the behavior of event processing within jQuery. The mechanism is similar to `fixHooks` in that the special event information is stored in `jQuery.event.special.NAME`, where `NAME` is the name of the special event. Event names are case sensitive.
+         *
+         * As with `fixHooks`, the special event hooks design assumes it will be very rare that two unrelated pieces of code want to process the same event name. Special event authors who need to modify events with existing hooks will need to take precautions to avoid introducing unwanted side-effects by clobbering those hooks.
+         * @see \`{@link https://learn.jquery.com/events/event-extensions/#special-event-hooks }\`
+         */
+        special: SpecialEventHooks;
+    }
+
+    // region Fix hooks
+    // #region Fix hooks
+
+    // Workaround for TypeScript 2.3 which does not have support for weak types handling.
+    type FixHook = {
+        /**
+         * Strings representing properties that should be copied from the browser's event object to the jQuery event object. If omitted, no additional properties are copied beyond the standard ones that jQuery copies and normalizes (e.g. `event.target` and `event.relatedTarget`).
+         */
+        props: string[];
+    } | {
+        /**
+         * jQuery calls this function after it constructs the `jQuery.Event` object, copies standard properties from `jQuery.event.props`, and copies the `fixHooks`-specific props (if any) specified above. The function can create new properties on the event object or modify existing ones. The second argument is the browser's native event object, which is also available in `event.originalEvent`.
+         *
+         * Note that for all events, the browser's native event object is available in `event.originalEvent`; if the jQuery event handler examines the properties there instead of jQuery's normalized `event` object, there is no need to create a `fixHooks` entry to copy or modify the properties.
+         * @example ​ ````For example, to set a hook for the "drop" event that copies the `dataTransfer` property, assign an object to `jQuery.event.fixHooks.drop`:
+```javascript
+jQuery.event.fixHooks.drop = {
+    props: [ "dataTransfer" ]
+};
+```
+
+Since fixHooks is an advanced feature and rarely used externally, jQuery does not include code or
+interfaces to deal with conflict resolution. If there is a chance that some other code may be assigning
+`fixHooks` to the same events, the code should check for an existing hook and take appropriate measures.
+A simple solution might look like this:
+
+```javascript
+if ( jQuery.event.fixHooks.drop ) {
+    throw new Error( "Someone else took the jQuery.event.fixHooks.drop hook!" );
+}
+
+jQuery.event.fixHooks.drop = {
+    props: [ "dataTransfer" ]
+};
+```
+
+When there are known cases of different plugins wanting to attach to the drop hook, this solution might be more appropriate:
+
+```javascript
+var existingHook = jQuery.event.fixHooks.drop;
+
+if ( !existingHook ) {
+    jQuery.event.fixHooks.drop = {
+        props: [ "dataTransfer" ]
+    };
+} else {
+    if ( existingHook.props ) {
+        existingHook.props.push( "dataTransfer" );
+    } else {
+        existingHook.props = [ "dataTransfer" ];
+    }
+}
+```
+         */
+        filter(event: Event, originalEvent: _Event): void;
+    } | {
+        [key: string]: never;
+    };
+
+    /**
+     * The `fixHooks` interface provides a per-event-type way to extend or normalize the event object that jQuery creates when it processes a _native_ browser event.
+     * @see \`{@link https://learn.jquery.com/events/event-extensions/#jquery-event-fixhooks-object }\`
+     */
+    interface FixHooks {
+        [event: string]: FixHook;
+    }
+
+    // #endregion
+
+    // region Special event hooks
+    // #region Special event hooks
+
+    /**
+     * The jQuery special event hooks are a set of per-event-name functions and properties that allow code to control the behavior of event processing within jQuery. The mechanism is similar to `fixHooks` in that the special event information is stored in `jQuery.event.special.NAME`, where `NAME` is the name of the special event. Event names are case sensitive.
+     *
+     * As with `fixHooks`, the special event hooks design assumes it will be very rare that two unrelated pieces of code want to process the same event name. Special event authors who need to modify events with existing hooks will need to take precautions to avoid introducing unwanted side-effects by clobbering those hooks.
+     * @see \`{@link https://learn.jquery.com/events/event-extensions/#special-event-hooks }\`
+     */
+    // Workaround for TypeScript 2.3 which does not have support for weak types handling.
+    type SpecialEventHook<TTarget, TData> = {
+        /**
+         * Indicates whether this event type should be bubbled when the `.trigger()` method is called; by default it is `false`, meaning that a triggered event will bubble to the element's parents up to the document (if attached to a document) and then to the window. Note that defining `noBubble` on an event will effectively prevent that event from being used for delegated events with `.trigger()`.
+         * @see \`{@link https://learn.jquery.com/events/event-extensions/#nobubble-boolean }\`
+         */
+        noBubble: boolean;
+    } | {
+        /**
+         * When defined, these string properties specify that a special event should be handled like another event type until the event is delivered. The `bindType` is used if the event is attached directly, and the `delegateType` is used for delegated events. These types are generally DOM event types, and _should not_ be a special event themselves.
+         * @see \`{@link https://learn.jquery.com/events/event-extensions/#bindtype-string-delegatetype-string }\`
+         */
+        bindType: string;
+    } | {
+        /**
+         * When defined, these string properties specify that a special event should be handled like another event type until the event is delivered. The `bindType` is used if the event is attached directly, and the `delegateType` is used for delegated events. These types are generally DOM event types, and _should not_ be a special event themselves.
+         * @see \`{@link https://learn.jquery.com/events/event-extensions/#bindtype-string-delegatetype-string }\`
+         */
+        delegateType: string;
+    } | {
+        /**
+         * The setup hook is called the first time an event of a particular type is attached to an element; this provides the hook an opportunity to do processing that will apply to all events of this type on this element. The `this` keyword will be a reference to the element where the event is being attached and `eventHandle` is jQuery's event handler function. In most cases the `namespaces` argument should not be used, since it only represents the namespaces of the _first_ event being attached; subsequent events may not have this same namespaces.
+         *
+         * This hook can perform whatever processing it desires, including attaching its own event handlers to the element or to other elements and recording setup information on the element using the `jQuery.data()` method. If the setup hook wants jQuery to add a browser event (via `addEventListener` or `attachEvent`, depending on browser) it should return `false`. In all other cases, jQuery will not add the browser event, but will continue all its other bookkeeping for the event. This would be appropriate, for example, if the event was never fired by the browser but invoked by `.trigger()`. To attach the jQuery event handler in the setup hook, use the `eventHandle` argument.
+         * @see \`{@link https://learn.jquery.com/events/event-extensions/#setup-function-data-object-namespaces-eventhandle-function }\`
+         */
+        setup(this: TTarget, data: TData, namespaces: string, eventHandle: EventHandler<TTarget, TData>): void | false;
+    } | {
+        /**
+         * The teardown hook is called when the final event of a particular type is removed from an element. The `this` keyword will be a reference to the element where the event is being cleaned up. This hook should return `false` if it wants jQuery to remove the event from the browser's event system (via `removeEventListener` or `detachEvent`). In most cases, the setup and teardown hooks should return the same value.
+         *
+         * If the setup hook attached event handlers or added data to an element through a mechanism such as `jQuery.data()`, the teardown hook should reverse the process and remove them. jQuery will generally remove the data and events when an element is totally removed from the document, but failing to remove data or events on teardown will cause a memory leak if the element stays in the document.
+         * @see \`{@link https://learn.jquery.com/events/event-extensions/#teardown-function }\`
+         */
+        teardown(this: TTarget): void | false;
+    } | {
+        /**
+         * Each time an event handler is added to an element through an API such as `.on()`, jQuery calls this hook. The `this` keyword will be the element to which the event handler is being added, and the `handleObj` argument is as described in the section above. The return value of this hook is ignored.
+         * @see \`{@link https://learn.jquery.com/events/event-extensions/#add-function-handleobj }\`
+         */
+        add(this: TTarget, handleObj: HandleObject<TTarget, TData>): void;
+    } | {
+        /**
+         * When an event handler is removed from an element using an API such as `.off()`, this hook is called. The `this` keyword will be the element where the handler is being removed, and the `handleObj` argument is as described in the section above. The return value of this hook is ignored.
+         * @see \`{@link https://learn.jquery.com/events/event-extensions/#remove-function-handleobj }\`
+         */
+        remove(this: TTarget, handleObj: HandleObject<TTarget, TData>): void;
+    } | {
+        /**
+         * Called when the `.trigger()` or `.triggerHandler()` methods are used to trigger an event for the special type from code, as opposed to events that originate from within the browser. The `this` keyword will be the element being triggered, and the event argument will be a `jQuery.Event` object constructed from the caller's input. At minimum, the event type, data, namespace, and target properties are set on the event. The data argument represents additional data passed by `.trigger()` if present.
+         *
+         * The trigger hook is called early in the process of triggering an event, just after the `jQuery.Event` object is constructed and before any handlers have been called. It can process the triggered event in any way, for example by calling `event.stopPropagation()` or `event.preventDefault()` before returning. If the hook returns `false`, jQuery does not perform any further event triggering actions and returns immediately. Otherwise, it performs the normal trigger processing, calling any event handlers for the element and bubbling the event (unless propagation is stopped in advance or `noBubble` was specified for the special event) to call event handlers attached to parent elements.
+         * @see \`{@link https://learn.jquery.com/events/event-extensions/#trigger-function-event-jquery-event-data-object }\`
+         */
+        trigger(this: TTarget, event: Event<TTarget, TData>, data: TData): void | false;
+    } | {
+        /**
+         * When the `.trigger()` method finishes running all the event handlers for an event, it also looks for and runs any method on the target object by the same name unless of the handlers called `event.preventDefault()`. So, `.trigger( "submit" )` will execute the `submit()` method on the element if one exists. When a `_default` hook is specified, the hook is called just prior to checking for and executing the element's default method. If this hook returns the value `false` the element's default method will be called; otherwise it is not.
+         * @see \`{@link https://learn.jquery.com/events/event-extensions/#_default-function-event-jquery-event-data-object }\`
+         */
+        _default(event: Event<TTarget, TData>, data: TData): void | false;
+    } | {
+        /**
+         * jQuery calls a handle hook when the event has occurred and jQuery would normally call the user's event handler specified by `.on()` or another event binding method. If the hook exists, jQuery calls it _instead_ of that event handler, passing it the event and any data passed from `.trigger()` if it was not a native event. The `this` keyword is the DOM element being handled, and `event.handleObj` property has the detailed event information.
+         *
+         * Based in the information it has, the handle hook should decide whether to call the original handler function which is in `event.handleObj.handler`. It can modify information in the event object before calling the original handler, but _must restore_ that data before returning or subsequent unrelated event handlers may act unpredictably. In most cases, the handle hook should return the result of the original handler, but that is at the discretion of the hook. The handle hook is unique in that it is the only special event function hook that is called under its original special event name when the type is mapped using `bindType` and `delegateType`. For that reason, it is almost always an error to have anything other than a handle hook present if the special event defines a `bindType` and `delegateType`, since those other hooks will never be called.
+         * @see \`{@link https://learn.jquery.com/events/event-extensions/#handle-function-event-jquery-event-data-object }\`
+         */
+        handle(this: TTarget, event: Event<TTarget, TData> & { handleObj: HandleObject<TTarget, TData>; }, ...data: TData[]): void;
+    } | {
+        preDispatch(this: TTarget, event: Event<TTarget, TData>): false | void;
+    } | {
+        postDispatch(this: TTarget, event: Event<TTarget, TData>): void;
+    } | {
+        [key: string]: never;
+    };
+
+    interface SpecialEventHooks {
+        [event: string]: SpecialEventHook<EventTarget, any>;
+    }
+
+    /**
+     * Many of the special event hook functions below are passed a `handleObj` object that provides more information about the event, how it was attached, and its current state. This object and its contents should be treated as read-only data, and only the properties below are documented for use by special event handlers.
+     * @see \`{@link https://learn.jquery.com/events/event-extensions/#the-handleobj-object }\`
+     */
+    interface HandleObject<TTarget, TData> {
+        /**
+         * The type of event, such as `"click"`. When special event mapping is used via `bindType` or `delegateType`, this will be the mapped type.
+         */
+        readonly type: string;
+        /**
+         * The original type name regardless of whether it was mapped via `bindType` or `delegateType`. So when a "pushy" event is mapped to "click" its `origType` would be "pushy".
+         */
+        readonly origType: string;
+        /**
+         * Namespace(s), if any, provided when the event was attached, such as `"myPlugin"`. When multiple namespaces are given, they are separated by periods and sorted in ascending alphabetical order. If no namespaces are provided, this property is an empty string.
+         */
+        readonly namespace: string;
+        /**
+         * For delegated events, this is the selector used to filter descendant elements and determine if the handler should be called. For directly bound events, this property is `null`.
+         */
+        readonly selector: string | undefined | null;
+        /**
+         * The data, if any, passed to jQuery during event binding, e.g. `{ myData: 42 }`. If the data argument was omitted or `undefined`, this property is `undefined` as well.
+         */
+        readonly data: TData;
+        /**
+         * Event handler function passed to jQuery during event binding. If `false` was passed during event binding, the handler refers to a single shared function that simply returns `false`.
+         */
+        readonly handler: EventHandler<TTarget, TData>;
+    }
+
+    // #endregion
+
+    // #endregion
+
+    // #endregion
+
+    interface NameValuePair {
+        name: string;
+        value: string;
+    }
+
+    // region Coordinates
+    // #region Coordinates
+
+    interface Coordinates {
+        left: number;
+        top: number;
+    }
+
+    // Workaround for TypeScript 2.3 which does not have support for weak types handling.
+    type CoordinatesPartial =
+        Pick<Coordinates, 'left'> |
+        Pick<Coordinates, 'top'> |
+        { [key: string]: never; };
+
+    // #endregion
+
+    // region Val hooks
+    // #region Val hooks
+
+    // Workaround for TypeScript 2.3 which does not have support for weak types handling.
+    type ValHook<TElement> = {
+        get(elem: TElement): any;
+    } | {
+        set(elem: TElement, value: any): any;
+    } | {
+        [key: string]: never;
+    };
+
+    interface ValHooks {
+        // Set to HTMLElement to minimize breaks but should probably be Element.
+        [nodeName: string]: ValHook<HTMLElement>;
+    }
+
+    // #endregion
+
+    type _Falsy = false | null | undefined | 0 | '' | typeof document.all;
+}
+
+declare const jQuery: JQueryStatic;
+declare const $: JQueryStatic;
+
+// Used by JQuery.Event
+type _Event = Event;
+
+// region ES5 compatibility
+// #region ES5 compatibility
+
+// Forward declaration of `Iterable<T>`.
+// tslint:disable-next-line:no-empty-interface
+interface Iterable<T> { }
+
+interface SymbolConstructor {
+    /**
+     * A String value that is used in the creation of the default string description of an object.
+     * Called by the built-in method Object.prototype.toString.
+     */
+    readonly toStringTag: symbol;
+}
+
+declare var Symbol: SymbolConstructor;
+
+// #endregion
diff --git a/types/jquery/test/learn-tests.ts b/types/jquery/test/learn-tests.ts
index 338ae7c8ba..8ef5eb2cfa 100644
--- a/types/jquery/test/learn-tests.ts
+++ b/types/jquery/test/learn-tests.ts
@@ -7,6 +7,7 @@ interface JQuery {
 }
 
 interface GreenifyPlugin {
+    // tslint:disable-next-line:callable-types
     (this: JQuery): void;
 }
 
diff --git a/types/jquery/test/longdesc-tests.ts b/types/jquery/test/longdesc-tests.ts
index 4390ae014a..bb3bb4c83c 100644
--- a/types/jquery/test/longdesc-tests.ts
+++ b/types/jquery/test/longdesc-tests.ts
@@ -1,3 +1,4 @@
+// tslint:disable:ban-types
 // tslint:disable:no-var-keyword
 // tslint:disable:object-literal-key-quotes
 // tslint:disable:object-literal-shorthand
@@ -951,8 +952,10 @@ function longdesc() {
 
     function jquery_ajax_transport_2() {
         $.ajaxTransport('script', function(options, originalOptions, jqXHR) {
+            let transport: JQuery.Transport = undefined!;
+
             // Will only be called for script requests
-            return {} as JQuery.Transport;
+            return transport;
         });
     }
 
@@ -1341,7 +1344,7 @@ function longdesc() {
 
     function jquery_css_hooks_6() {
         $.fx.step.someCSSProp = function(fx) {
-            $.cssHooks.someCSSProp.set(fx.elem as HTMLElement, fx.now + fx.unit);
+            $.cssHooks.someCSSProp.set!(fx.elem as HTMLElement, fx.now + fx.unit);
         };
     }
 
diff --git a/types/jquery/tsconfig.json b/types/jquery/tsconfig.json
index 86c99c452f..8b159bc81f 100644
--- a/types/jquery/tsconfig.json
+++ b/types/jquery/tsconfig.json
@@ -20,6 +20,7 @@
     },
     "files": [
         "index.d.ts",
+        "dist/jquery.slim.d.ts",
         "jquery-tests.ts",
         "test/example-tests.ts",
         "test/longdesc-tests.ts",
diff --git a/types/jquery/tslint.json b/types/jquery/tslint.json
index 93e1f3e072..f93cf8562a 100644
--- a/types/jquery/tslint.json
+++ b/types/jquery/tslint.json
@@ -1,12 +1,3 @@
 {
-    "extends": "dtslint/dt.json",
-    "rules": {
-        "callable-types": false,
-        "interface-name": false,
-        "no-any-union": false,
-        "no-declare-current-package": false,
-
-        "ban-types": false,
-        "no-object-literal-type-assertion": false
-    }
+    "extends": "dtslint/dt.json"
 }
diff --git a/types/jqueryui/index.d.ts b/types/jqueryui/index.d.ts
index 7092de2d06..cc164360c0 100644
--- a/types/jqueryui/index.d.ts
+++ b/types/jqueryui/index.d.ts
@@ -1857,7 +1857,9 @@ interface JQuery {
     tabs(): JQuery;
     tabs(methodName: 'destroy'): void;
     tabs(methodName: 'disable'): void;
+    tabs(methodName: 'disable', index: number): void;
     tabs(methodName: 'enable'): void;
+    tabs(methodName: 'enable', index: number): void;
     tabs(methodName: 'load', index: number): void;
     tabs(methodName: 'refresh'): void;
     tabs(methodName: 'widget'): JQuery;
diff --git a/types/js-money/tslint.json b/types/js-money/tslint.json
index 3db14f85ea..42522eff7e 100644
--- a/types/js-money/tslint.json
+++ b/types/js-money/tslint.json
@@ -1 +1,9 @@
-{ "extends": "dtslint/dt.json" }
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        // All are TODOs
+        "dt-header": false,
+        "eofline": false,
+        "no-unnecessary-qualifier": false
+    }
+}
diff --git a/types/jschannel/index.d.ts b/types/jschannel/index.d.ts
index 42145531ea..ba1ce6f61d 100644
--- a/types/jschannel/index.d.ts
+++ b/types/jschannel/index.d.ts
@@ -1,6 +1,7 @@
 // Type definitions for jschannel 1.0
 // Project: https://github.com/yochannah/jschannel
 // Definitions by: Yitzchok Gottlieb <https://github.com/yitzchok>
+//                 McFlat <https://github.com/McFlat>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.4
 
@@ -25,7 +26,7 @@ export interface Message {
 }
 
 export interface ChannelConfiguration {
-    window: any;
+    window: Window;
     origin: string;
     scope: string;
     debugOutput?: boolean;
diff --git a/types/jschannel/jschannel-tests.ts b/types/jschannel/jschannel-tests.ts
index eabd150bf2..c618eea253 100644
--- a/types/jschannel/jschannel-tests.ts
+++ b/types/jschannel/jschannel-tests.ts
@@ -1,3 +1,3 @@
 import { build } from 'jschannel';
 
-build({ window: null, origin: "*", scope: "testScope"});
+build({ window, origin: "*", scope: "testScope"});
diff --git a/types/jschannel/tsconfig.json b/types/jschannel/tsconfig.json
index 58b8ca059e..e8988e8fe1 100644
--- a/types/jschannel/tsconfig.json
+++ b/types/jschannel/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
@@ -20,4 +21,4 @@
         "index.d.ts",
         "jschannel-tests.ts"
     ]
-}
\ No newline at end of file
+}
diff --git a/types/jsforce/tslint.json b/types/jsforce/tslint.json
index 3b1f082eb2..43829466b8 100644
--- a/types/jsforce/tslint.json
+++ b/types/jsforce/tslint.json
@@ -2,9 +2,19 @@
     "extends": "dtslint/dt.json",
     "rules": {
         // TODOs
+        "array-type": false,
         "ban-types": false,
+        "eofline": false,
+        "max-line-length": false,
         "no-any-union": false,
+        "no-empty-interface": false,
+        "no-redundant-undefined": false,
         "no-unnecessary-class": false,
-        "no-unnecessary-generics": false
+        "no-unnecessary-generics": false,
+        "semicolon": false,
+        "space-within-parens": false,
+        "strict-export-declare-modifiers": false,
+        "typedef-whitespace": false,
+        "whitespace": false
     }
 }
diff --git a/types/json2csv/tslint.json b/types/json2csv/tslint.json
index 3db14f85ea..389fc5f08e 100644
--- a/types/json2csv/tslint.json
+++ b/types/json2csv/tslint.json
@@ -1 +1,15 @@
-{ "extends": "dtslint/dt.json" }
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        // All are TODOs
+        "array-type": false,
+        "ban-types": false,
+        "callable-types": false,
+        "jsdoc-format": false,
+        "member-access": false,
+        "no-duplicate-imports": false,
+        "no-redundant-jsdoc-2": false,
+        "strict-export-declare-modifiers": false,
+        "typedef-whitespace": false
+    }
+}
diff --git a/types/jss/css.d.ts b/types/jss/css.d.ts
index 2d5e89139a..9bed74d702 100644
--- a/types/jss/css.d.ts
+++ b/types/jss/css.d.ts
@@ -3,7 +3,7 @@
 import { Observable } from 'indefinite-observable';
 import * as csstype from 'csstype';
 
-type Length = string | number;
+export type Length = string | number;
 
 export type ObservableProperties<P> = {
     [K in keyof P]: P[K] | Observable<P[K]>
diff --git a/types/koa-websocket/index.d.ts b/types/koa-websocket/index.d.ts
index 91b50b5ace..c23c9036b8 100644
--- a/types/koa-websocket/index.d.ts
+++ b/types/koa-websocket/index.d.ts
@@ -3,32 +3,41 @@
 // Definitions by: Maël Lavault <https://github.com/moimael>
 //                 Jaco Greeff <https://github.com/jacogr>
 //                 Martin Ždila <https://github.com/zdila>
+//                 Eunchong Yu <https://github.com/Kroisse>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
 import Koa = require('koa');
+import compose = require('koa-compose');
 import * as ws from 'ws';
 import * as http from 'http';
 import * as https from 'https';
 
-declare namespace KoaWebsocket {
-    type ConnectionHandler = (socket: ws) => void;
-
-    type Middleware = (this: MiddlewareContext, context: Koa.Context, next: () => Promise<any>) => any;
-
-    interface MiddlewareContext extends Koa.Context {
+declare module "koa" {
+    interface Context {
         websocket: ws;
         path: string;
     }
+}
+
+declare namespace KoaWebsocket {
+    type Middleware = compose.Middleware<MiddlewareContext>;
+
+    interface MiddlewareContext extends Koa.Context {
+        // Limitation: Declaration merging cannot overwrap existing properties.
+        // That's why this property is here, not in the merged declaration above.
+        app: App;
+    }
 
     class Server {
-        app: Koa;
-        middleware: Koa.Middleware[];
+        app: App;
+        middleware: Middleware[];
+        server?: ws.Server;
 
         constructor(app: Koa);
 
         listen(options: ws.ServerOptions): ws.Server;
-        onConnection(handler: ConnectionHandler): void;
+        onConnection(socket: ws, request: http.IncomingMessage): void;
         use(middleware: Middleware): this;
     }
 
diff --git a/types/koa-websocket/koa-websocket-tests.ts b/types/koa-websocket/koa-websocket-tests.ts
index bd99c3d17e..502b366652 100644
--- a/types/koa-websocket/koa-websocket-tests.ts
+++ b/types/koa-websocket/koa-websocket-tests.ts
@@ -3,11 +3,19 @@ import websocket = require('koa-websocket');
 
 const app = websocket(new Koa());
 
-app.ws.use(async function(context, next) {
-    this.websocket.on('message', (message) => {
+app.ws.use(async (ctx, next) => {
+    ctx.websocket.on('message', (message) => {
         console.log(message);
+        const server = ctx.app.ws.server;
+        if (server) {
+            server.clients.forEach(client => {
+                if (client !== ctx.websocket) {
+                    client.send(message);
+                }
+            });
+        }
     });
-    this.websocket.send('Hello world');
+    ctx.websocket.send('Hello world');
     await next();
 });
 
diff --git a/types/koa-websocket/tsconfig.json b/types/koa-websocket/tsconfig.json
index 87c9225d08..ffe283f2ad 100644
--- a/types/koa-websocket/tsconfig.json
+++ b/types/koa-websocket/tsconfig.json
@@ -20,4 +20,4 @@
         "index.d.ts",
         "koa-websocket-tests.ts"
     ]
-}
\ No newline at end of file
+}
diff --git a/types/kos-core/index.d.ts b/types/kos-core/index.d.ts
new file mode 100644
index 0000000000..061c3c98f6
--- /dev/null
+++ b/types/kos-core/index.d.ts
@@ -0,0 +1,64 @@
+// Type definitions for kos-core 0.3
+// Project: https://github.com/ali-Kos/Kos
+// Definitions by: alibaba ali-Kos <https://github.com/ali-Kos>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+import * as React from 'react';
+
+type ReactComponent<P = any, S = any> = React.ComponentClass<P, S>;
+
+interface Util {
+    getActionType: (action: string) => { namespace: string | null; type: string };
+}
+
+interface WrapperConfig {
+    model: KosModel;
+    autoLoad?: boolean;
+    autoReset?: boolean;
+    namespace?: string;
+}
+
+interface Action<T = any> {
+    type: string;
+    payload?: Partial<T>;
+}
+
+export interface KosProps<T = any> {
+    dispatch?: (action: Action<T>) => void;
+    getParam?: () => string;
+    getNamespace?: () => string;
+}
+
+export type KosDispatch = (action: Action) => void;
+
+export type GetKosState<T = any> = () => T;
+
+export interface KosModel<T = any> {
+    namespace: string;
+    initial: T;
+    reducers: {
+        [key: string]: (state: T, { payload }: { payload: T }) => void;
+    };
+    asyncs: {
+        [key: string]: (dispatch: KosDispatch, getState?: GetKosState<T>) => void;
+    };
+    setup?: (dispatch: KosDispatch, getState: GetKosState<T>) => void;
+    getAsync?: (
+        key: string
+    ) => (dispatch: KosDispatch, getState?: GetKosState) => void;
+}
+
+interface Kos {
+    Util: Util;
+    registeModel: (model: any) => void;
+    removeModel: (namespace: string) => void;
+    getModel: (namespace: string) => KosModel;
+    use: (middleware: (api: { dispatch: any; getState: any }) => void) => void;
+    Wrapper: (
+        config: WrapperConfig
+    ) => (component: ReactComponent<any & KosProps>) => any;
+    start: (Layout: ReactComponent, container?: string) => void;
+}
+
+declare let KOS: Kos;
+export default KOS;
diff --git a/types/kos-core/kos-core-tests.ts b/types/kos-core/kos-core-tests.ts
new file mode 100644
index 0000000000..e879236456
--- /dev/null
+++ b/types/kos-core/kos-core-tests.ts
@@ -0,0 +1,6 @@
+import KOS from 'kos-core';
+
+type IReactComponent<P = any, S = any> = React.ComponentClass<P, S>;
+declare let RC: IReactComponent;
+
+KOS.start(RC, "#root");
diff --git a/types/kos-core/tsconfig.json b/types/kos-core/tsconfig.json
new file mode 100644
index 0000000000..9c4ff911b3
--- /dev/null
+++ b/types/kos-core/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "kos-core-tests.ts"
+    ]
+}
\ No newline at end of file
diff --git a/types/kos-core/tslint.json b/types/kos-core/tslint.json
new file mode 100644
index 0000000000..b4b47a0378
--- /dev/null
+++ b/types/kos-core/tslint.json
@@ -0,0 +1,3 @@
+{
+	"extends": "dtslint/dt.json"
+}
diff --git a/types/lambda-tester/index.d.ts b/types/lambda-tester/index.d.ts
index b65ac009c6..8f942ddd19 100644
--- a/types/lambda-tester/index.d.ts
+++ b/types/lambda-tester/index.d.ts
@@ -1,6 +1,7 @@
 // Type definitions for lambda-tester 3.5
 // Project: https://github.com/vandium-io/lambda-tester#readme
 // Definitions by: Ivan Kerin <https://github.com/ivank>
+//                 Hajo Aho-Mantila <https://github.com/HajoAhoMantila>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
@@ -19,12 +20,12 @@ declare namespace lambdaTester {
         ): this;
         timeout(seconds: number): this;
         xray(): this;
-        expectSucceed(verifier: Verifier): this;
-        expectFail(verifier: Verifier): this;
-        expectError(verifier: Verifier): this;
-        expectResult(verifier: Verifier): this;
-        expectReject(verifier: Verifier): this;
-        expectResolve(verifier: Verifier): this;
+        expectSucceed(verifier: Verifier): Promise<any>;
+        expectFail(verifier: Verifier): Promise<any>;
+        expectError(verifier: Verifier): Promise<any>;
+        expectResult(verifier: Verifier): Promise<any>;
+        expectReject(verifier: Verifier): Promise<any>;
+        expectResolve(verifier: Verifier): Promise<any>;
     }
 }
 
diff --git a/types/lambda-tester/lambda-tester-tests.ts b/types/lambda-tester/lambda-tester-tests.ts
index ed2b7d875f..61a9815fe0 100644
--- a/types/lambda-tester/lambda-tester-tests.ts
+++ b/types/lambda-tester/lambda-tester-tests.ts
@@ -12,27 +12,35 @@ interface TError {
     message: string;
 }
 
-lambdaTester(handler)
-    .event({ test: "123" })
+function lambdaTesterInstance() {
+    return lambdaTester(handler).event({ test: "123" });
+}
+
+lambdaTesterInstance()
     .context(context)
     .clientContext(clientContext)
     .xray()
     .identity("123", "123")
     .expectSucceed((result: TResult) => {
         const t: string = result.data;
-    })
-    .expectFail((error: TError) => {
-        const t: string = error.message;
-    })
-    .expectResolve((result: TResult) => {
-        const t: string = result.data;
-    })
-    .expectReject((error: TError) => {
-        const t: string = error.message;
-    })
-    .expectResult((result: TResult) => {
-        const t: string = result.data;
-    })
-    .expectError((error: TError) => {
-        const t: string = error.message;
     });
+
+lambdaTesterInstance().expectFail((error: TError) => {
+    const t: string = error.message;
+});
+
+lambdaTesterInstance().expectResolve((result: TResult) => {
+    const t: string = result.data;
+});
+
+lambdaTesterInstance().expectReject((error: TError) => {
+    const t: string = error.message;
+});
+
+lambdaTesterInstance().expectResult((result: TResult) => {
+    const t: string = result.data;
+});
+
+lambdaTesterInstance().expectError((error: TError) => {
+    const t: string = error.message;
+});
diff --git a/types/leaflet-gpx/tsconfig.json b/types/leaflet-gpx/tsconfig.json
index 08f5612820..4709cad61c 100644
--- a/types/leaflet-gpx/tsconfig.json
+++ b/types/leaflet-gpx/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/leaflet-polylinedecorator/tsconfig.json b/types/leaflet-polylinedecorator/tsconfig.json
index f84b2a3913..f0e38870f0 100644
--- a/types/leaflet-polylinedecorator/tsconfig.json
+++ b/types/leaflet-polylinedecorator/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/leaflet-providers/tsconfig.json b/types/leaflet-providers/tsconfig.json
index bb2349b7d5..2847026daf 100644
--- a/types/leaflet-providers/tsconfig.json
+++ b/types/leaflet-providers/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/leakage/index.d.ts b/types/leakage/index.d.ts
new file mode 100644
index 0000000000..ebec8a8951
--- /dev/null
+++ b/types/leakage/index.d.ts
@@ -0,0 +1,25 @@
+// Type definitions for leakage 0.4
+// Project: https://github.com/andywer/leakage#readme
+// Definitions by: Arne Schubert <https://github.com/atd-schubert>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export class MemoryLeakError extends Error {}
+
+export interface IterateOptions {
+    iterations?: number;
+    gcollections?: number;
+}
+
+export function iterate(iteratorFn: () => void, options?: IterateOptions): Result;
+
+export namespace iterate {
+    function async(iteratorFn: () => Promise<void>, options?: IterateOptions): Promise<Result>;
+}
+
+export interface Result {
+    heapDiffs: any[];
+    gcollections: number;
+    iterations: number;
+
+    printSummary(title: string, log?: (msg: string) => void): void;
+}
diff --git a/types/leakage/leakage-tests.ts b/types/leakage/leakage-tests.ts
new file mode 100644
index 0000000000..9a734ce93a
--- /dev/null
+++ b/types/leakage/leakage-tests.ts
@@ -0,0 +1,15 @@
+import { iterate, IterateOptions, Result } from "leakage";
+
+let optionalNumber: number | undefined;
+let num = 1;
+const iterateFn: () => void = () => {};
+const promiseIterate: () => Promise<void> = () => Promise.resolve();
+const iterateOptions: IterateOptions | undefined = { iterations: optionalNumber, gcollections: optionalNumber };
+
+let result: Result = iterate(iterateFn, iterateOptions);
+optionalNumber = 1;
+
+iterate.async(promiseIterate, iterateOptions).then((res: Result) => result = res);
+
+num = result.gcollections;
+num = result.iterations;
diff --git a/types/leakage/tsconfig.json b/types/leakage/tsconfig.json
new file mode 100644
index 0000000000..48f77ecea7
--- /dev/null
+++ b/types/leakage/tsconfig.json
@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "baseUrl": "../",
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "leakage-tests.ts"
+    ]
+}
+
diff --git a/types/leakage/tslint.json b/types/leakage/tslint.json
new file mode 100644
index 0000000000..03f37e72ca
--- /dev/null
+++ b/types/leakage/tslint.json
@@ -0,0 +1,2 @@
+{ "extends": "dtslint/dt.json" }
+
diff --git a/types/less/index.d.ts b/types/less/index.d.ts
index 7d69273a52..5068a49e16 100644
--- a/types/less/index.d.ts
+++ b/types/less/index.d.ts
@@ -1,18 +1,29 @@
-// Type definitions for LESS
+// Type definitions for LESS 3.x
 // Project: http://lesscss.org/
 // Definitions by: Tom Hasner <https://github.com/thasner>
 //                 Pranay Prakash <https://github.com/pranaygp>
 //                 Daniel Waxweiler <https://github.com/dwaxweiler>
+//                 Richard Lea <https://github.com/chigix>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 declare namespace Less {
+    // https://github.com/less/less.js/blob/master/lib/less/import-manager.js#L10
     interface RootFileInfo {
+        /** whether to adjust URL's to be relative */
+        rewriteUrls?: boolean;
+        /** full resolved filename of current file */
         filename: string;
         relativeUrls: boolean;
+        /** path to append to normal URLs for this node */
         rootpath: string;
+        /** path to the current file, absolute */
         currentDirectory: string;
+        /** absolute path to the entry file */
         entryPath: string;
+        /** filename of the base file */
         rootFilename: string;
+        /** whether the file should not be output and only output parts that are referenced */
+        reference: boolean;
     }
 
     class PluginManager {
@@ -59,11 +70,54 @@ declare namespace Less {
         contents: { [fileName: string]: string };
     }
 
+    /**
+     * Reference to:
+     * * https://github.com/less/less.js/blob/master/bin/lessc
+     * * http://lesscss.org/usage/#less-options
+     *
+     * @interface Options
+     */
     interface Options {
         sourceMap?: SourceMapOption;
+        /** Filename of the main file to be passed to less.render() */
         filename?: string;
+        /** The locations for less looking for files in @import rules */
+        paths?: string[];
+        /** True, if run the less parser and just reports errors without any output. */
+        lint?: boolean;
+        /** Pre-load global Less.js plugins */
         plugins?: Plugin[];
-        rootFileInfo?: RootFileInfo;
+        /** @deprecated If true, compress using less built-in compression. */
+        compress?: boolean;
+        strictImports?: boolean;
+        /** If true, allow imports from insecure https hosts. */
+        insecure?: boolean;
+        depends?: boolean;
+        maxLineLen?: number;
+        /** @deprecated If false, No color in compiling. */
+        color?: boolean;
+        /** @deprecated False by default. */
+        ieCompat?: boolean;
+        /** @deprecated If true, enable evaluation of JavaScript inline in `.less` files. */
+        javascriptEnabled?: boolean;
+        /** Whether output file information and line numbers in compiled CSS code. */
+        dumpLineNumbers?: "comment" | string;
+        /** Add a path to every generated import and url in output css files. */
+        rootpath?: string;
+        /** Math mode options for avoiding symbol conficts on math expressions. */
+        math?: 'always' | 'strict' | 'parens-division' | 'parens' | 'strict-legacy' | number;
+        /** If true, stops any warnings from being shown. */
+        silent?: boolean;
+        /** Without this option, Less attempts to guess at the output unit when it does maths. */
+        strictUnits?: boolean;
+        /** Defines a variable that can be referenced by the file. */
+        globalVars?: {
+          [key: string] : string,
+        };
+        /** Puts Var declaration at the end of base file. */
+        modifyVars?: {
+          [key: string] : string,
+        };
     }
 
     interface RenderError {
@@ -109,7 +163,7 @@ interface LessStatic {
     refresh(reload?: boolean, modifyVars?: { [variable: string]: string }, clearFileCache?: boolean): Promise<Less.RefreshOutput>;
 
     version: number[];
-    
+
     watch(): void;
 }
 
diff --git a/types/less/less-tests.ts b/types/less/less-tests.ts
index 20a1f587a9..625db93e44 100644
--- a/types/less/less-tests.ts
+++ b/types/less/less-tests.ts
@@ -30,8 +30,47 @@ var myPlugin: Less.Plugin = {
     }
 };
 
+/** Reference to: 
+  * https://github.com/less/less.js/blob/master/lib/less/default-options.js
+  */
 var options: Less.Options = {
-    plugins: [myPlugin]
+    plugins: [myPlugin],
+    /** Tells less to generate a sourcemap. */
+    sourceMap: {},
+    /* Inline Javascript - @plugin still allowed */
+    javascriptEnabled: false,
+    /* Outputs a makefile import dependency list to stdout. */
+    depends: false,
+    /** (DEPRECATED) This does not utilise all the tricks of css compression. */
+    compress: false,
+    /* Runs the less parser and just reports errors without any output. */
+    lint: false,
+    /** Less will look for the file in @import rules through locations here. */
+    paths: [],
+    /* color output in the terminal */
+    color: true,
+    /** See: https://github.com/less/less.js/issues/656 */
+    strictImports: false,
+    /* Allow Imports from Insecure HTTPS Hosts */
+    insecure: true,
+    /** Add a path to every generated import and url in your css */
+    rootpath: '',
+    /** 
+      * How to process math
+      * 0 always           - eagerly try to solve all operations
+      * 1 parens-division  - require parens for division "/"
+      * 2 parens | strict  - require parens for all operations
+      * 3 strict-legacy    - legacy strict behavior (super-strict)
+      * https://github.com/less/less.js/blob/master/lib/less/constants.js#L2
+      * https://github.com/less/less.js/blob/master/lib/less/utils.js#L54
+    */
+    math: 0,
+    /* Guess at the output unit when it does maths. */
+    strictUnits: false,
+    /** Put declaration at the top of base less file. */
+    globalVars: null,
+    /** Put the declaration at the end of base file. */
+    modifyVars: null
 };
 
 less.render("h1 { background: red; }", options);
diff --git a/types/libpq/index.d.ts b/types/libpq/index.d.ts
index 2897eb3aab..09c358d6a6 100644
--- a/types/libpq/index.d.ts
+++ b/types/libpq/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/brianc/node-libpq#readme
 // Definitions by: Vlad Rindevich <https://github.com/Lodin>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.2
+// TypeScript Version: 2.3
 
 /// <reference types="node" />
 
diff --git a/types/lingui__core/index.d.ts b/types/lingui__core/index.d.ts
index c0aa933bee..e70f62f969 100644
--- a/types/lingui__core/index.d.ts
+++ b/types/lingui__core/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://lingui.github.io/js-lingui/
 // Definitions by: Jeow Li Huan <https://github.com/huan086>
 // Definitions: https://github.com/huan086/lingui-typings
+// TypeScript Version: 2.2
 
 export {
     i18n,
diff --git a/types/linkify-it/index.d.ts b/types/linkify-it/index.d.ts
index e3696e09c4..ae12f98524 100644
--- a/types/linkify-it/index.d.ts
+++ b/types/linkify-it/index.d.ts
@@ -45,7 +45,7 @@ declare namespace LinkifyIt {
 
     interface LinkifyIt {
         add(schema: string, rule: Rule): LinkifyIt;
-        match(text: string): Match[];
+        match(text: string): Match[] | null;
         normalize(raw: string): string;
         pretest(text: string): boolean;
         set(options: Options): LinkifyIt;
diff --git a/types/linkify-it/linkify-it-tests.ts b/types/linkify-it/linkify-it-tests.ts
index 1768bd5efb..6186fe2b7f 100644
--- a/types/linkify-it/linkify-it-tests.ts
+++ b/types/linkify-it/linkify-it-tests.ts
@@ -30,7 +30,9 @@ linkifier
 const matches = linkifier.match(
     "https://github.com/DefinitelyTyped/DefinitelyTyped/"
 );
-matches.forEach(({ index, lastIndex, raw, schema, text, url }) => {});
+if (matches !== null) {
+    matches.forEach(({ index, lastIndex, raw, schema, text, url }) => {});
+}
 
 // complex rule
 linkifier.add("@", {
diff --git a/types/lowdb/tslint.json b/types/lowdb/tslint.json
index dfea11be1a..c56e92eedb 100644
--- a/types/lowdb/tslint.json
+++ b/types/lowdb/tslint.json
@@ -1,6 +1,10 @@
 {
     "extends": "dtslint/dt.json",
     "rules": {
-        "no-misused-new": false
+        // All are TODOs
+        "max-line-length": false,
+        "no-misused-new": false,
+        "no-unnecessary-generics": false,
+        "unified-signatures": false
     }
 }
diff --git a/types/ltx/tslint.json b/types/ltx/tslint.json
index 3db14f85ea..5bb1e8735d 100644
--- a/types/ltx/tslint.json
+++ b/types/ltx/tslint.json
@@ -1 +1,9 @@
-{ "extends": "dtslint/dt.json" }
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        // All are TODOs
+        "jsdoc-format": false,
+        "no-consecutive-blank-lines": false,
+        "strict-export-declare-modifiers": false
+    }
+}
diff --git a/types/materialize-css/carousel.d.ts b/types/materialize-css/carousel.d.ts
index fd660694d1..6c762ec830 100644
--- a/types/materialize-css/carousel.d.ts
+++ b/types/materialize-css/carousel.d.ts
@@ -110,8 +110,6 @@ declare namespace M {
 
 interface JQuery {
     carousel(method: keyof Pick<M.Carousel, "destroy">): JQuery;
-    carousel(method: keyof Pick<M.Carousel, "next">, n?: number): JQuery;
-    carousel(method: keyof Pick<M.Carousel, "prev">, n?: number): JQuery;
-    carousel(method: keyof Pick<M.Carousel, "set">, n?: number): JQuery;
+    carousel(method: keyof Pick<M.Carousel, "next"> | keyof Pick<M.Carousel, "prev"> | keyof Pick<M.Carousel, "set">, n?: number): JQuery;
     carousel(options?: Partial<M.CarouselOptions>): JQuery;
 }
diff --git a/types/materialize-css/character-counter.d.ts b/types/materialize-css/character-counter.d.ts
index 4d34ac170e..7634075a9b 100644
--- a/types/materialize-css/character-counter.d.ts
+++ b/types/materialize-css/character-counter.d.ts
@@ -20,6 +20,5 @@ declare namespace M {
 }
 
 interface JQuery {
-    characterCounter(method: keyof Pick<M.CharacterCounter, "destroy">): JQuery;
-    characterCounter(): JQuery;
+    characterCounter(method?: keyof Pick<M.CharacterCounter, "destroy">): JQuery;
 }
diff --git a/types/materialize-css/collapsible.d.ts b/types/materialize-css/collapsible.d.ts
index 649a59e9bb..d69e958730 100644
--- a/types/materialize-css/collapsible.d.ts
+++ b/types/materialize-css/collapsible.d.ts
@@ -77,7 +77,6 @@ declare namespace M {
 
 interface JQuery {
     collapsible(method: keyof Pick<M.Collapsible, "destroy">): JQuery;
-    collapsible(method: keyof Pick<M.Collapsible, "open">, n: number): JQuery;
-    collapsible(method: keyof Pick<M.Collapsible, "close">, n: number): JQuery;
+    collapsible(method: keyof Pick<M.Collapsible, "open"> | keyof Pick<M.Collapsible, "close">, n: number): JQuery;
     collapsible(options?: Partial<M.CollapsibleOptions>): JQuery;
 }
diff --git a/types/materialize-css/range.d.ts b/types/materialize-css/range.d.ts
index dac7a7edf2..a1de53baa9 100644
--- a/types/materialize-css/range.d.ts
+++ b/types/materialize-css/range.d.ts
@@ -20,6 +20,5 @@ declare namespace M {
 }
 
 interface JQuery {
-    range(): JQuery;
-    range(method: keyof Pick<M.Range, "destroy">): JQuery;
+    range(method?: keyof Pick<M.Range, "destroy">): JQuery;
 }
diff --git a/types/mdurl/format.d.ts b/types/mdurl/format.d.ts
index 2638c76007..a7cc04cd48 100644
--- a/types/mdurl/format.d.ts
+++ b/types/mdurl/format.d.ts
@@ -1,4 +1,4 @@
-import { Url } from './'
+import { Url } from './';
 
 declare function format(url: Url): string;
 
diff --git a/types/mdurl/parse.d.ts b/types/mdurl/parse.d.ts
index cd2c012caa..30c377f35a 100644
--- a/types/mdurl/parse.d.ts
+++ b/types/mdurl/parse.d.ts
@@ -1,4 +1,4 @@
-import { Url } from './'
+import { Url } from './';
 
 declare function parse(input: string, slashesDenoteHost?: boolean): Url;
 
diff --git a/types/meteor-collection-hooks/meteor-mongo.d.ts b/types/meteor-collection-hooks/meteor-mongo.d.ts
index d45bd7582a..45092a89fd 100644
--- a/types/meteor-collection-hooks/meteor-mongo.d.ts
+++ b/types/meteor-collection-hooks/meteor-mongo.d.ts
@@ -151,4 +151,4 @@ declare module 'meteor/mongo' {
       all?: LocalHookOptions;
     }
   }
-}
\ No newline at end of file
+}
diff --git a/types/meteor/react-meteor-data.d.ts b/types/meteor/react-meteor-data.d.ts
new file mode 100644
index 0000000000..517c10ff8f
--- /dev/null
+++ b/types/meteor/react-meteor-data.d.ts
@@ -0,0 +1,5 @@
+import * as React from 'react';
+
+export function withTracker<TDataProps, TOwnProps>(
+    options: (props: TOwnProps) => TDataProps | {getMeteorData: (props: TOwnProps) => TDataProps, pure?: boolean}
+): (reactComponent: React.ComponentType<TOwnProps & TDataProps>) => React.ComponentClass<TOwnProps>;
diff --git a/types/meteor/test/globals/meteor-tests.ts b/types/meteor/test/globals/meteor-tests.ts
index c2145be0a6..b902019aca 100644
--- a/types/meteor/test/globals/meteor-tests.ts
+++ b/types/meteor/test/globals/meteor-tests.ts
@@ -380,7 +380,7 @@ Comments.find({ $and: [
     { $or: [{ tags: "tag-1" }, { tags: "tag-2" }] }
 ]});
 
-Comments.find({ inlineLinks: { $exists: true, $type: "array" } });
+Comments.find({ $query: {inlineLinks: { $exists: true, $type: "array" } } });
 Comments.find({ inlineLinks: { $elemMatch: { 
     objectType: InlineObjectType.Image, 
     objectUrl: { $regex: "https://(www\.?)youtube\.com" } 
diff --git a/types/meteor/test/meteor-tests.ts b/types/meteor/test/meteor-tests.ts
index c7fde5b8be..4901e810c5 100644
--- a/types/meteor/test/meteor-tests.ts
+++ b/types/meteor/test/meteor-tests.ts
@@ -392,7 +392,7 @@ Comments.find({ $and: [
     { $or: [{ tags: "tag-1" }, { tags: "tag-2" }] }
 ]});
 
-Comments.find({ inlineLinks: { $exists: true, $type: "array" } });
+Comments.find({ $query: { inlineLinks: { $exists: true, $type: "array" } } });
 Comments.find({ inlineLinks: { $elemMatch: { 
     objectType: InlineObjectType.Image, 
     objectUrl: { $regex: "https://(www\.?)youtube\.com" } 
diff --git a/types/meteor/test/react-meteor-data-tests.tsx b/types/meteor/test/react-meteor-data-tests.tsx
new file mode 100644
index 0000000000..cea13d6030
--- /dev/null
+++ b/types/meteor/test/react-meteor-data-tests.tsx
@@ -0,0 +1,27 @@
+import * as React from 'react';
+import { withTracker } from 'meteor/react-meteor-data';
+
+interface DemoComponentContainerProps {
+    status: string;
+}
+
+interface DemoComponentData {
+    data: string;
+    result: string;
+}
+
+const DemoComponent: React.SFC<DemoComponentContainerProps & DemoComponentData> = (props) => (
+    <div>{props.data}</div>
+);
+
+const DemoComponentContainer: React.ComponentClass<DemoComponentContainerProps> = withTracker<
+    DemoComponentData,
+    DemoComponentContainerProps
+>(() => ({
+    data: 'some data',
+    result: 'success',
+}))(DemoComponent);
+
+const RootComponent = () => (
+    <DemoComponentContainer status="ok" />
+);
diff --git a/types/meteor/tsconfig.json b/types/meteor/tsconfig.json
index ed6a9e0e77..42295d06e1 100644
--- a/types/meteor/tsconfig.json
+++ b/types/meteor/tsconfig.json
@@ -63,6 +63,8 @@
         "test/meteor-tests.ts",
         "test/globals/meteor-tests.ts",
         "test/meteor-tests-module-only.ts",
-        "test/server-render.tsx"
+        "test/server-render.tsx",
+        "react-meteor-data.d.ts",
+        "test/react-meteor-data-tests.tsx"
     ]
 }
diff --git a/types/micro/index.d.ts b/types/micro/index.d.ts
index f3787b1010..251e42ee46 100644
--- a/types/micro/index.d.ts
+++ b/types/micro/index.d.ts
@@ -4,6 +4,8 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.2
 
+/// <reference types="node" />
+
 import { IncomingMessage, ServerResponse, Server } from 'http';
 
 export type RequestHandler = (req: IncomingMessage, res: ServerResponse) => any;
diff --git a/types/mobx-apollo/index.d.ts b/types/mobx-apollo/index.d.ts
index 54818cd846..fe976af2d2 100644
--- a/types/mobx-apollo/index.d.ts
+++ b/types/mobx-apollo/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/sonaye/mobx-apollo#readme
 // Definitions by: Paul Selden <https://github.com/pselden>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.6
 
 import {
     ApolloClient,
diff --git a/types/mobx-apollo/tsconfig.json b/types/mobx-apollo/tsconfig.json
index cff69dc655..c7ab33e386 100644
--- a/types/mobx-apollo/tsconfig.json
+++ b/types/mobx-apollo/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "esnext.asynciterable"
         ],
         "target": "es5",
         "noImplicitAny": true,
diff --git a/types/mobx-cookie/index.d.ts b/types/mobx-cookie/index.d.ts
new file mode 100644
index 0000000000..fbf3cc58fd
--- /dev/null
+++ b/types/mobx-cookie/index.d.ts
@@ -0,0 +1,17 @@
+// Type definitions for mobx-cookie 1.1
+// Project: https://github.com/will-stone/mobx-cookie#readme
+// Definitions by: Duong Tran <https://github.com/t49tran>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+import { CookieAttributes } from 'js-cookie';
+
+declare class MobxCookie {
+    constructor(name: string, options?: CookieAttributes);
+
+    get(): any;
+    set(value: any, options?: CookieAttributes): void;
+    remove(): void;
+}
+
+export default MobxCookie;
diff --git a/types/mobx-cookie/mobx-cookie-tests.ts b/types/mobx-cookie/mobx-cookie-tests.ts
new file mode 100644
index 0000000000..66965a9f31
--- /dev/null
+++ b/types/mobx-cookie/mobx-cookie-tests.ts
@@ -0,0 +1,11 @@
+import MobxCookie from 'mobx-cookie';
+
+// Declare a reactive mobx cookie that last for 20 days
+const mobxCookie = new MobxCookie('TEST_MOBX_COOKIE', {expires: 20});
+
+// Set a new value for the cookie that last for 10 days
+mobxCookie.set('MY_VALUE', {expires: 10});
+
+const cookieValue = mobxCookie.get();
+
+mobxCookie.remove();
diff --git a/types/mobx-cookie/tsconfig.json b/types/mobx-cookie/tsconfig.json
new file mode 100644
index 0000000000..4222165feb
--- /dev/null
+++ b/types/mobx-cookie/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictFunctionTypes": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "mobx-cookie-tests.ts"
+    ]
+}
diff --git a/types/mobx-cookie/tslint.json b/types/mobx-cookie/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/mobx-cookie/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/mock-aws-s3/index.d.ts b/types/mock-aws-s3/index.d.ts
index 754629f5a2..437c785f98 100644
--- a/types/mock-aws-s3/index.d.ts
+++ b/types/mock-aws-s3/index.d.ts
@@ -4,6 +4,8 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/mock-aws-s3
 // TypeScript Version: 2.2
 
+/// <reference types="node" />
+
 // This is a mocking library, types should reflect that of the actual library.
 export * from "aws-sdk";
 import { GlobalConfigInstance } from "aws-sdk/lib/config";
diff --git a/types/mongration/index.d.ts b/types/mongration/index.d.ts
new file mode 100644
index 0000000000..7f46f3edc3
--- /dev/null
+++ b/types/mongration/index.d.ts
@@ -0,0 +1,35 @@
+// Type definitions for mongration 1.0
+// Project: https://github.com/awapps/mongration#readme
+// Definitions by: Anton Lobashev <https://github.com/soulthreads>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+import { Db } from 'mongodb';
+
+export interface DbConfig {
+    hosts?: string;
+    db?: string;
+    user?: string;
+    password?: string;
+    mongoUri?: string;
+    migrationCollection: string;
+    replicaSet?: string;
+}
+
+export interface MigrationResponse {
+    id: string;
+    status: 'not-run' | 'skipped' | 'pending' | 'ok' | 'error' | 'rollback' | 'rollback-error';
+}
+
+export class Migration {
+    constructor(dbConfig: DbConfig);
+    add: (paths: string | string[]) => void;
+    addAllFromPath: (path: string) => void;
+    migrate: (doneCb?: (err: Error | null, response: MigrationResponse[]) => void) => void;
+}
+
+export interface MigrationStep {
+    id: string;
+    up: (db: Db, cb: (err?: Error) => void) => void;
+    down?: (db: Db, cb: (err?: Error) => void) => void;
+}
diff --git a/types/mongration/mongration-tests.ts b/types/mongration/mongration-tests.ts
new file mode 100644
index 0000000000..735aa6436a
--- /dev/null
+++ b/types/mongration/mongration-tests.ts
@@ -0,0 +1,28 @@
+import { Migration, DbConfig, MigrationStep } from 'mongration';
+
+const dbConfig: DbConfig = {
+  hosts: 'localhost:27017',
+  db: 'testdb',
+  migrationCollection: 'migrationversions'
+};
+
+const migration = new Migration(dbConfig);
+migration.add('1-add-foo.js');
+migration.add(['2-add-bar.js', '3-add-foobar.js']);
+migration.addAllFromPath('migrations');
+migration.migrate((err, response) => {
+  if (!err) {
+    return response;
+  }
+});
+
+// from https://github.com/awapps/mongration#creating-migration-steps
+const step: MigrationStep = {
+  id: '1-step',
+  up: (db, cb) => {
+    db.collection('testcolleciton').insert({ name: 'initial-setup' }, cb);
+  },
+  down: (db, cb) => {
+    db.collection('testcollection').remove({ name: 'initial-setup' }, cb);
+  }
+};
diff --git a/types/mongration/tsconfig.json b/types/mongration/tsconfig.json
new file mode 100644
index 0000000000..c47e0d78b6
--- /dev/null
+++ b/types/mongration/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+	"strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "mongration-tests.ts"
+    ]
+}
diff --git a/types/mongration/tslint.json b/types/mongration/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/mongration/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/mozilla-readability/index.d.ts b/types/mozilla-readability/index.d.ts
index a30925fb0b..7a7c26fdb8 100644
--- a/types/mozilla-readability/index.d.ts
+++ b/types/mozilla-readability/index.d.ts
@@ -7,21 +7,13 @@
 export = Readability;
 
 declare class Readability {
-    constructor(uri: Readability.Uri, doc: Document, options?: Readability.Options);
+    constructor(doc: Document, options?: Readability.Options);
 
     parse(): Readability.ParseResult;
     isProbablyReaderable(helperIsVisible?: (node: any) => boolean): boolean;
 }
 
 declare namespace Readability {
-    interface Uri {
-        spec: string;
-        host: string;
-        prePath: string;
-        scheme: string;
-        pathBase: string;
-    }
-
     interface Options {
         debug?: boolean;
         maxElemsToParse?: number;
@@ -31,7 +23,6 @@ declare namespace Readability {
     }
 
     interface ParseResult {
-        uri: Uri;
         title: string;
         byline: string;
         dir: string;
diff --git a/types/mozilla-readability/mozilla-readability-tests.ts b/types/mozilla-readability/mozilla-readability-tests.ts
index e5431dd14e..0dec719559 100644
--- a/types/mozilla-readability/mozilla-readability-tests.ts
+++ b/types/mozilla-readability/mozilla-readability-tests.ts
@@ -5,42 +5,25 @@ import { JSDOM } from 'jsdom';
 // because issue https://github.com/mozilla/readability/issues/346
 // requires global variable `Node` when using nodejs.
 
-const fakeUri: Readability.Uri = {
-    spec: "http://fakehost/test/page.html",
-    host: "fakehost",
-    prePath: "http://fakehost",
-    scheme: "http",
-    pathBase: "http://fakehost/test/"
-};
-
 function test_basic_usage() {
     const dom = new JSDOM(`<p>Hello</p><p><strong>Hi!</strong>`);
-    // Required until https://github.com/mozilla/readability/issues/346
-    // is fixed.
-    Node = dom.window.Node;
 
-    const reader = new Readability(fakeUri, dom.window.document);
+    const reader = new Readability(dom.window.document);
     const article = reader.parse();
 }
 
 function test_readability_with_options() {
     const dom = new JSDOM(`<p>Hello</p><p><strong>Hi!</strong>`);
-    // Required until https://github.com/mozilla/readability/issues/346
-    // is fixed.
-    Node = dom.window.Node;
 
     const options: Readability.Options = {
         debug: true,
         maxElemsToParse: 100,
     };
-    const article = new Readability(fakeUri, dom.window.document, options).parse();
+    const article = new Readability(dom.window.document, options).parse();
 }
 
 function test_is_probably_readerable() {
     const dom = new JSDOM(`<p>Hello</p><p><strong>Hi!</strong>`);
-    // Required until https://github.com/mozilla/readability/issues/346
-    // is fixed.
-    Node = dom.window.Node;
 
-    const isReadable = new Readability(fakeUri, dom.window.document).isProbablyReaderable();
+    const isReadable = new Readability(dom.window.document).isProbablyReaderable();
 }
diff --git a/types/multer-gridfs-storage/index.d.ts b/types/multer-gridfs-storage/index.d.ts
index 42f02c024b..9e6f5efcf3 100644
--- a/types/multer-gridfs-storage/index.d.ts
+++ b/types/multer-gridfs-storage/index.d.ts
@@ -58,7 +58,7 @@ declare namespace MulterGridfsStorage {
     }
 
     interface DbStorageOptions extends MulterGfsOptions {
-        db: Mongoose | Connection | Db | Promise<Mongoose | Connection | Db>;
+        db: Mongoose | Connection | Db | MongoClient | Promise<Mongoose | Connection | Db | MongoClient>;
     }
 
     interface FileConfig {
diff --git a/types/multer-gridfs-storage/tsconfig.json b/types/multer-gridfs-storage/tsconfig.json
index 1daa734d97..4729416ff1 100644
--- a/types/multer-gridfs-storage/tsconfig.json
+++ b/types/multer-gridfs-storage/tsconfig.json
@@ -4,11 +4,6 @@
         "lib": [
             "es6"
         ],
-        "paths": {
-            "mongodb": [
-                "mongodb/v2"
-            ]
-        },
         "noImplicitAny": true,
         "noImplicitThis": true,
         "strictNullChecks": true,
diff --git a/types/murmurhash/index.d.ts b/types/murmurhash/index.d.ts
index 31c663fd33..eac6b500b7 100644
--- a/types/murmurhash/index.d.ts
+++ b/types/murmurhash/index.d.ts
@@ -9,21 +9,27 @@ export = murmurhash;
  * JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
  *
  * @param key - ASCII only
- * @param seed - Positive integer only
- * @return - 32-bit positive integer hash
+ * @param seed - (optional) positive integer
+ * @returns 32-bit positive integer hash
  */
-declare function murmurhash(key: string, seed: number): number;
+declare function murmurhash(key: string, seed?: number): number;
 
 declare namespace murmurhash {
-    // Circular reference from murmurhash
-    function v3(key: string, seed: number): number;
+    /**
+     * JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
+     *
+     * @param key - ASCII only
+     * @param seed - (optional) positive integer
+     * @returns 32-bit positive integer hash
+     */
+    function v3(key: string, seed?: number): number;
 
     /**
      * JS Implementation of MurmurHash2
      *
      * @param str - ASCII only
-     * @param seed - Positive integer only
-     * @return - 32-bit positive integer hash
+     * @param seed - (optional) positive integer
+     * @returns 32-bit positive integer hash
      */
-    function v2(str: string, seed: number): number;
+    function v2(str: string, seed?: number): number;
 }
diff --git a/types/murmurhash/murmurhash-tests.ts b/types/murmurhash/murmurhash-tests.ts
index ebbbf09cab..fe7fc9c501 100644
--- a/types/murmurhash/murmurhash-tests.ts
+++ b/types/murmurhash/murmurhash-tests.ts
@@ -3,6 +3,11 @@ import murmurhash = require('murmurhash');
 const stringValue = "test";
 let numberValue = 123;
 
+numberValue = murmurhash(stringValue);
 numberValue = murmurhash(stringValue, numberValue);
+
+numberValue = murmurhash.v2(stringValue);
 numberValue = murmurhash.v2(stringValue, numberValue);
+
+numberValue = murmurhash.v3(stringValue);
 numberValue = murmurhash.v3(stringValue, numberValue);
diff --git a/types/n3/index.d.ts b/types/n3/index.d.ts
index a9438616c2..31a2975bb0 100644
--- a/types/n3/index.d.ts
+++ b/types/n3/index.d.ts
@@ -140,6 +140,7 @@ export interface N3StreamParser extends RDF.Stream, NodeJS.WritableStream, RDF.S
 export interface WriterOptions {
     format?: string;
     prefixes?: Prefixes;
+    end?: boolean;
 }
 
 export interface WriterConstructor {
diff --git a/types/n3/n3-tests.ts b/types/n3/n3-tests.ts
index d24960a112..a061777ad7 100644
--- a/types/n3/n3-tests.ts
+++ b/types/n3/n3-tests.ts
@@ -113,7 +113,7 @@ function test_doc_from_triples_to_string() {
 }
 
 function test_doc_from_triples_to_rdf_stream() {
-    const writer: N3.N3Writer = new N3.Writer(process.stdout, { prefixes: { c: N3.DataFactory.namedNode('http://example.org/cartoons#') } });
+    const writer: N3.N3Writer = new N3.Writer(process.stdout, { end: false, prefixes: { c: N3.DataFactory.namedNode('http://example.org/cartoons#') } });
     writer.addQuad(N3.DataFactory.quad(
       N3.DataFactory.namedNode('http://example.org/cartoons#Tom'),
       N3.DataFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'),
diff --git a/types/net-keepalive/tsconfig.json b/types/net-keepalive/tsconfig.json
index 7a0277396e..e3f703b220 100644
--- a/types/net-keepalive/tsconfig.json
+++ b/types/net-keepalive/tsconfig.json
@@ -2,7 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es5"
+            "es6"
         ],
         "baseUrl": "../",
         "typeRoots": [
diff --git a/types/newrelic/index.d.ts b/types/newrelic/index.d.ts
index 0c674e4646..a5fd434d99 100644
--- a/types/newrelic/index.d.ts
+++ b/types/newrelic/index.d.ts
@@ -1,6 +1,7 @@
-// Type definitions for newrelic 3.3
+// Type definitions for newrelic 3.4
 // Project: http://github.com/newrelic/node-newrelic
 // Definitions by: Matt R. Wilson <https://github.com/mastermatt>
+//                 Brooks Patton <https://github.com/brookspatton>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 // https://docs.newrelic.com/docs/agents/nodejs-agent/api-guides/nodejs-agent-api
@@ -64,14 +65,14 @@ export function setControllerName(name: string, action: string): void;
  *
  * Most recently set value wins.
  */
-export function addCustomAttribute(key: string, value: string): void;
+export function addCustomAttribute(key: string, value: string|number): void;
 
 /**
  * Adds all custom attributes in an object to the current transaction.
  *
  * See documentation for `addCustomAttribute` for more information on setting custom attributes.
  */
-export function addCustomAttributes(atts: { [key: string]: string }): void;
+export function addCustomAttributes(atts: { [key: string]: string|number }): void;
 
 /**
  * Tell the tracer whether to ignore the current transaction.
diff --git a/types/newrelic/newrelic-tests.ts b/types/newrelic/newrelic-tests.ts
index 3f99152c66..29eabfeb21 100644
--- a/types/newrelic/newrelic-tests.ts
+++ b/types/newrelic/newrelic-tests.ts
@@ -14,7 +14,9 @@ newrelic.setDispatcher("foo", "42"); // $ExpectType void
 newrelic.setControllerName("foo", "GET"); // $ExpectType void
 
 newrelic.addCustomAttribute("foo", "bar"); // $ExpectType void
+newrelic.addCustomAttribute("foo", 42); // $ExpectType void
 newrelic.addCustomAttributes({ foo: "bar", baz: "bang" }); // $ExpectType void
+newrelic.addCustomAttributes({ foo: "bar", baz: 42 }); // $ExpectType void
 
 newrelic.setIgnoreTransaction(true); // $ExpectType void
 
diff --git a/types/next-server/asset.d.ts b/types/next-server/asset.d.ts
new file mode 100644
index 0000000000..d021de3929
--- /dev/null
+++ b/types/next-server/asset.d.ts
@@ -0,0 +1,2 @@
+export function setAssetPrefix(url: string): void;
+export default function(path: string): string;
diff --git a/types/next-server/config.d.ts b/types/next-server/config.d.ts
new file mode 100644
index 0000000000..d2cc3cf6e2
--- /dev/null
+++ b/types/next-server/config.d.ts
@@ -0,0 +1,6 @@
+export interface RuntimeConfig {
+    serverRuntimeConfig: any;
+    publicRuntimeConfig?: any;
+}
+export function setConfig(configValue: any): void;
+export default function(): RuntimeConfig;
diff --git a/types/next-server/constants.d.ts b/types/next-server/constants.d.ts
new file mode 100644
index 0000000000..d2dc74dad0
--- /dev/null
+++ b/types/next-server/constants.d.ts
@@ -0,0 +1,23 @@
+export const PHASE_EXPORT: string;
+export const PHASE_PRODUCTION_BUILD: string;
+export const PHASE_PRODUCTION_SERVER: string;
+export const PHASE_DEVELOPMENT_SERVER: string;
+export const PAGES_MANIFEST: string;
+export const BUILD_MANIFEST: string;
+export const REACT_LOADABLE_MANIFEST: string;
+export const SERVER_DIRECTORY: string;
+export const CONFIG_FILE: string;
+export const BUILD_ID_FILE: string;
+export const BLOCKED_PAGES: string[];
+
+export const CLIENT_STATIC_FILES_PATH: string;
+export const CLIENT_STATIC_FILES_RUNTIME: string;
+export const CLIENT_STATIC_FILES_RUNTIME_PATH: string;
+/** static/runtime/main.js */
+export const CLIENT_STATIC_FILES_RUNTIME_MAIN: string;
+/** static/runtime/webpack.js */
+export const CLIENT_STATIC_FILES_RUNTIME_WEBPACK: string;
+/** matches static/<buildid>/pages/<page>.js */
+export const IS_BUNDLED_PAGE_REGEX: RegExp;
+/** matches static/<buildid>/pages/:page*.js */
+export const ROUTE_NAME_REGEX: RegExp;
diff --git a/types/next-server/dynamic.d.ts b/types/next-server/dynamic.d.ts
new file mode 100644
index 0000000000..38a85bf77e
--- /dev/null
+++ b/types/next-server/dynamic.d.ts
@@ -0,0 +1,42 @@
+import * as React from "react";
+import {
+    LoadableComponent,
+    CommonOptions as LoadableOptions,
+    LoadingComponentProps as LoadableLoadingComponentProps
+} from "react-loadable";
+
+type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
+
+type AsyncComponent<P = any> = Promise<React.ComponentType<P>>;
+type AsyncComponentLoader<P = any> = () => AsyncComponent<P>;
+type ModuleMapping = Record<string, AsyncComponent>;
+type LoadedModuleMapping = Record<string, React.ComponentType>;
+
+interface NextDynamicOptions<P = {}> extends Omit<LoadableOptions, "loading" | "modules"> {
+    modules?: () => ModuleMapping; // overridden
+    loading?: LoadableOptions["loading"]; // optional
+    loader?: AsyncComponentLoader<P>; // optional, overriden
+    render?: (props: P, loaded: LoadedModuleMapping) => React.ReactNode; // optional, overriden
+    ssr?: boolean;
+    loadableGenerated?: {
+        webpack?: any;
+        modules?: any;
+    };
+}
+
+type DynamicComponent<P> = React.ComponentType<P> & LoadableComponent;
+
+/**
+ * Overloaded dynamic function.
+ * https://github.com/zeit/next.js/blob/7.0.0/lib/dynamic.js#L55
+ */
+declare function dynamic<P = {}>(
+    options: AsyncComponent<P> | NextDynamicOptions<P>
+): DynamicComponent<P>;
+declare function dynamic<P = {}>(
+    asyncModule: AsyncComponent<P>,
+    options: NextDynamicOptions<P>
+): DynamicComponent<P>;
+
+export type LoadingComponentProps = LoadableLoadingComponentProps;
+export default dynamic;
diff --git a/types/next-server/head.d.ts b/types/next-server/head.d.ts
new file mode 100644
index 0000000000..8a8be730f8
--- /dev/null
+++ b/types/next-server/head.d.ts
@@ -0,0 +1,8 @@
+import * as React from "react";
+
+export function defaultHead(className?: string): JSX.Element[];
+export default class Head extends React.Component {
+    static canUseDOM: boolean;
+    static peek(): Array<React.ReactElement<any>>;
+    static rewind(): Array<React.ReactElement<any>>;
+}
diff --git a/types/next-server/index.d.ts b/types/next-server/index.d.ts
new file mode 100644
index 0000000000..6e8fcd3ed6
--- /dev/null
+++ b/types/next-server/index.d.ts
@@ -0,0 +1,125 @@
+// Type definitions for next-server 7.0
+// Project: https://github.com/zeit/next.js/packages/next-server
+// Definitions by: Drew Hays <https://github.com/dru89>
+//                 Brice BERNARD <https://github.com/brikou>
+//                 James Hegedus <https://github.com/jthegedus>
+//                 Resi Respati <https://github.com/resir014>
+//                 Scott Jones <https://github.com/scottdj92>
+//                 Joao Vieira <https://github.com/joaovieira>
+//                 AJ Livingston <https://github.com/ajliv>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+/// <reference types="node" />
+
+import * as http from "http";
+import { NextConfig } from "./next-config";
+import { UrlLike, DefaultQuery } from "./router";
+
+declare namespace next {
+    interface RenderOptions {
+        staticMarkup: boolean;
+        distDir: string;
+        buildId: string;
+        generateETags: boolean;
+        runtimeConfig?: Record<any, any>;
+    }
+
+    /**
+     * Options passed to the Server constructor in Node.js.
+     */
+    interface ServerOptions {
+        dev?: boolean;
+        dir?: string;
+        staticMarkup?: boolean;
+        quiet?: boolean;
+        conf?: NextConfig;
+    }
+
+    interface ServerRoute<P = DefaultQuery> {
+        match(pathname: string, params?: Partial<P>): P | false;
+        fn(req: http.IncomingMessage, res: http.ServerResponse, params: P, parsedUrl: UrlLike): Promise<void>;
+    }
+
+    interface ServerRouter {
+        routes: ServerRoute[];
+        add(route: ServerRoute): void;
+        match(req: http.IncomingMessage, res: http.ServerResponse, parsedUrl: UrlLike): (() => Promise<void>) | undefined;
+    }
+
+    /**
+     * Next.js server instance API.
+     */
+    interface Server {
+        dir: string;
+        quiet: boolean;
+        router: ServerRouter;
+        nextConfig: NextConfig;
+        distDir: string;
+        buildId: string;
+        renderOpts: RenderOptions;
+
+        currentPhase(): string;
+        handleRequest(
+            req: http.IncomingMessage,
+            res: http.ServerResponse,
+            parsedUrl?: UrlLike
+        ): Promise<void>;
+        getRequestHandler(): (
+            req: http.IncomingMessage,
+            res: http.ServerResponse,
+            parsedUrl?: UrlLike
+        ) => Promise<void>;
+
+        setAssetPrefix(prefix: string): void;
+        prepare(): Promise<void>;
+        close(): Promise<void>;
+        setImmutableAssetCacheControl(res: http.ServerResponse): void;
+        generateRoutes(): ServerRoute[];
+        run(req: http.IncomingMessage, res: http.ServerResponse, parsedUrl: UrlLike): Promise<void>;
+
+        render(
+            req: http.IncomingMessage,
+            res: http.ServerResponse,
+            pathname: string,
+            query?: DefaultQuery,
+            parsedUrl?: UrlLike
+        ): Promise<void>;
+        renderToHTML(
+            req: http.IncomingMessage,
+            res: http.ServerResponse,
+            pathname: string,
+            query?: DefaultQuery
+        ): Promise<string>;
+        renderError(
+            err: any,
+            req: http.IncomingMessage,
+            res: http.ServerResponse,
+            pathname: string,
+            query?: DefaultQuery
+        ): Promise<void>;
+        renderErrorToHTML(
+            err: any,
+            req: http.IncomingMessage,
+            res: http.ServerResponse,
+            pathname: string,
+            query?: DefaultQuery
+        ): Promise<string>;
+        render404(
+            req: http.IncomingMessage,
+            res: http.ServerResponse,
+            parsedUrl?: UrlLike
+        ): Promise<void>;
+
+        serveStatic(
+            req: http.IncomingMessage,
+            res: http.ServerResponse,
+            path: string
+        ): Promise<void>;
+        isServeableUrl(path: string): boolean;
+        readBuildId(): string;
+    }
+}
+
+declare function next(options?: next.ServerOptions): next.Server;
+export = next;
diff --git a/types/next-server/link.d.ts b/types/next-server/link.d.ts
new file mode 100644
index 0000000000..520868f05f
--- /dev/null
+++ b/types/next-server/link.d.ts
@@ -0,0 +1,17 @@
+import * as url from "url";
+import * as React from "react";
+import { UrlLike } from "./router";
+
+export interface LinkProps {
+    prefetch?: boolean;
+    shallow?: boolean;
+    scroll?: boolean;
+    replace?: boolean;
+    onError?(error: any): void;
+    href?: string | UrlLike;
+    as?: string | UrlLike;
+    passHref?: boolean;
+    children: React.ReactElement<any>;
+}
+
+export default class Link extends React.Component<LinkProps> {}
diff --git a/types/next-server/next-config.d.ts b/types/next-server/next-config.d.ts
new file mode 100644
index 0000000000..5a542abf29
--- /dev/null
+++ b/types/next-server/next-config.d.ts
@@ -0,0 +1,23 @@
+/**
+ * Next.js config schema.
+ * https://github.com/zeit/next.js/blob/7.0.0/server/config.js#L9
+ */
+export interface NextConfig {
+    webpack?: any;
+    webpackDevMiddleware?: any;
+    poweredByHeader?: boolean;
+    distDir?: string;
+    assetPrefix?: string;
+    configOrigin?: string;
+    useFileSystemPublicRoutes?: boolean;
+    generateBuildId?: () => string;
+    generateEtags?: boolean;
+    pageExtensions?: string[];
+    publicRuntimeConfig?: object;
+    serverRuntimeConfig?: object;
+
+    // Plugin can define their own keys.
+    [key: string]: any;
+}
+
+export default function(phase: string, dir: string, customConfig?: NextConfig): NextConfig;
diff --git a/types/next-server/router.d.ts b/types/next-server/router.d.ts
new file mode 100644
index 0000000000..dff4f13a79
--- /dev/null
+++ b/types/next-server/router.d.ts
@@ -0,0 +1,94 @@
+import * as React from "react";
+import * as url from "url";
+
+type EventName =
+    | "routeChangeStart"
+    | "routeChangeComplete"
+    | "routeChangeError"
+    | "beforeHistoryChange"
+    | "hashChangeStart"
+    | "hashChangeComplete";
+
+interface RouteChangeError {
+    cancelled: boolean;
+}
+
+type EventHandler = (url: string) => any;
+type ErrorEventHandler = (err: RouteChangeError, url: string) => any;
+
+export type UrlLike = url.UrlObject | url.Url;
+
+export interface EventChangeOptions {
+    shallow?: boolean;
+    [key: string]: any;
+}
+
+export type PopStateCallback = (state: any) => boolean | undefined;
+
+export type RouterCallback = () => void;
+
+export type DefaultQuery = Record<string, string | string[] | undefined>;
+
+export interface RouterProps<Q = DefaultQuery> {
+    // url property fields
+    readonly pathname: string;
+    readonly route: string;
+    readonly asPath?: string;
+    readonly query?: Q;
+
+    // property fields
+    readonly components: {
+        [key: string]: { Component: React.ComponentType<any>; err: any };
+    };
+
+    // core method fields
+    back(): void;
+    beforePopState(cb: PopStateCallback): boolean;
+    prefetch(url: string): Promise<React.ComponentType<any>>;
+    push(
+        url: string | UrlLike,
+        as?: string | UrlLike,
+        options?: EventChangeOptions
+    ): Promise<boolean>;
+    reload(route: string): Promise<void>;
+    replace(
+        url: string | UrlLike,
+        as?: string | UrlLike,
+        options?: EventChangeOptions
+    ): Promise<boolean>;
+
+    // events (deprecated soonish)
+    onBeforeHistoryChange?(as: string): void;
+    onHashChangeStart?(url: string): void;
+    onHashChangeComplete?(url: string): void;
+    onRouteChangeComplete?(url: string): void;
+    onRouteChangeError?(error: RouteChangeError, url: string): void;
+    onRouteChangeStart?(url: string): void;
+
+    // events API (6.1.1+)
+    readonly events: {
+        on: (eventName: EventName, handler: EventHandler | ErrorEventHandler) => void;
+        off: (eventName: EventName, handler: (url: string) => any) => void;
+    };
+}
+
+export interface SingletonRouter<Q = DefaultQuery> extends RouterProps<Q> {
+    router: RouterProps<Q> | null;
+    readyCallbacks: RouterCallback[];
+    ready(cb: RouterCallback): void;
+}
+
+export interface WithRouterProps<Q = DefaultQuery> {
+    router: SingletonRouter<Q>;
+}
+
+// Manually disabling the no-unnecessary-generics rule so users can
+// retain type inference if they warp their component in withRouter
+// without defining props explicitly
+export function withRouter<T extends {}, Q = DefaultQuery>(
+    // tslint:disable-next-line:no-unnecessary-generics
+    Component: React.ComponentType<T & WithRouterProps<Q>>
+): React.ComponentType<T>;
+
+declare const Router: SingletonRouter;
+export default Router;
diff --git a/types/next-server/test/next-server-constants-tests.ts b/types/next-server/test/next-server-constants-tests.ts
new file mode 100644
index 0000000000..6ebade7c9f
--- /dev/null
+++ b/types/next-server/test/next-server-constants-tests.ts
@@ -0,0 +1,30 @@
+import {
+    PHASE_DEVELOPMENT_SERVER,
+    IS_BUNDLED_PAGE_REGEX
+} from "next-server/constants";
+
+const isIndexPage = IS_BUNDLED_PAGE_REGEX.test(
+    "static/CjW0mFnyG80HdP4eSUiy7/pages/index.js"
+);
+
+// Example taken from: https://github.com/cyrilwanner/next-compose-plugins/blob/a25b313899638912cc9defc0be072f4fe4a1e855/README.md
+const config = (nextConfig: any = {}) => {
+    return {
+        ...nextConfig,
+
+        // define in which phases this plugin should get applied.
+        // you can also use multiple phases or negate them.
+        // however, users can still overwrite them in their configuration if they really want to.
+        phases: [PHASE_DEVELOPMENT_SERVER],
+
+        webpack(config: any, options: any) {
+            // do something here which only gets applied during development server phase
+
+            if (typeof nextConfig.webpack === "function") {
+                return nextConfig.webpack(config, options);
+            }
+
+            return config;
+        }
+    };
+};
diff --git a/types/next-server/test/next-server-dynamic-tests.tsx b/types/next-server/test/next-server-dynamic-tests.tsx
new file mode 100644
index 0000000000..b6e0b86fe6
--- /dev/null
+++ b/types/next-server/test/next-server-dynamic-tests.tsx
@@ -0,0 +1,65 @@
+import * as React from "react";
+import dynamic, { LoadingComponentProps } from "next-server/dynamic";
+
+// You'd typically do this via import('./MyComponent')
+interface MyComponentProps {
+    foo: string;
+}
+const MyComponent: React.StatelessComponent<MyComponentProps> = () => <div>I'm async!</div>;
+const asyncComponent = Promise.resolve(MyComponent);
+
+// Examples from
+// https://github.com/zeit/next.js/#dynamic-import
+
+const LoadingComponent: React.StatelessComponent<LoadingComponentProps> = ({
+    isLoading,
+    error
+}) => <p>loading...</p>;
+
+// 1. Basic Usage (Also does SSR)
+const DynamicComponent = dynamic(asyncComponent);
+const dynamicComponentJSX = <DynamicComponent foo="bar" />;
+
+// 2. With Custom Loading Component
+const DynamicComponentWithCustomLoading = dynamic(asyncComponent, {
+    loading: LoadingComponent
+});
+const dynamicComponentWithCustomLoadingJSX = <DynamicComponentWithCustomLoading foo="bar" />;
+
+// 3. With No SSR
+const DynamicComponentWithNoSSR = dynamic(asyncComponent, {
+    ssr: false
+});
+
+// 4. With Multiple Modules At Once
+const HelloBundle = dynamic<MyComponentProps>({
+    modules: () => {
+        const components = {
+            Hello1: asyncComponent,
+            Hello2: asyncComponent
+        };
+
+        return components;
+    },
+    render: (props, { Hello1, Hello2 }) => (
+        <div>
+            <h1>{props.foo}</h1>
+            <Hello1 />
+            <Hello2 />
+        </div>
+    )
+});
+const helloBundleJSX = <HelloBundle foo="bar" />;
+
+// 5. With plain Loadable options
+const LoadableComponent = dynamic({
+    loader: () => asyncComponent,
+    loading: LoadingComponent,
+    delay: 200,
+    timeout: 10000
+});
+
+// 6. No loading
+const DynamicComponentWithNoLoading = dynamic(asyncComponent, {
+    loading: () => null
+});
diff --git a/types/next-server/test/next-server-head-tests.tsx b/types/next-server/test/next-server-head-tests.tsx
new file mode 100644
index 0000000000..bea5643cad
--- /dev/null
+++ b/types/next-server/test/next-server-head-tests.tsx
@@ -0,0 +1,11 @@
+import Head, * as head from "next-server/head";
+import * as React from "react";
+
+const elements: JSX.Element[] = head.defaultHead();
+const jsx = <Head>{elements}</Head>;
+
+if (!Head.canUseDOM) {
+    Head.rewind().map(x => [x.key, x.props, x.type]);
+}
+
+Head.peek().map(x => [x.key, x.props, x.type]);
diff --git a/types/next-server/test/next-server-link-tests.tsx b/types/next-server/test/next-server-link-tests.tsx
new file mode 100644
index 0000000000..3d34ac54b4
--- /dev/null
+++ b/types/next-server/test/next-server-link-tests.tsx
@@ -0,0 +1,23 @@
+import Link from "next-server/link";
+import * as React from "react";
+
+const links = (
+    <div>
+        <Link
+            as="foo"
+            href="https://www.example.com"
+            onError={(e: any) => {
+                console.log("Handled error!", e);
+            }}
+            prefetch
+            replace
+            scroll
+            shallow
+        >
+            <a>Gotta link to somewhere!</a>
+        </Link>
+        <Link>
+            <a>All props are optional!</a>
+        </Link>
+    </div>
+);
diff --git a/types/next-server/test/next-server-router-tests.tsx b/types/next-server/test/next-server-router-tests.tsx
new file mode 100644
index 0000000000..8b4397baad
--- /dev/null
+++ b/types/next-server/test/next-server-router-tests.tsx
@@ -0,0 +1,108 @@
+import Router, { withRouter, WithRouterProps } from "next-server/router";
+import * as React from "react";
+import * as qs from "querystring";
+
+Router.readyCallbacks.push(() => {
+    console.log("I'll get called when the router initializes.");
+});
+Router.ready(() => {
+    console.log(
+        "I'll get called immediately if the router initializes, or when it eventually does.",
+    );
+});
+
+// Access readonly properties of the router.
+
+Object.keys(Router.components).forEach(key => {
+    const c = Router.components[key];
+    c.err.isAnAny;
+
+    return <c.Component />;
+});
+
+function split(routeLike: string) {
+    routeLike.split("/").forEach(part => {
+        console.log("path part: ", part);
+    });
+}
+
+if (Router.asPath) {
+    split(Router.asPath);
+    split(Router.asPath);
+}
+
+split(Router.pathname);
+
+const query = `?${qs.stringify(Router.query)}`;
+
+// Assign some callback methods.
+Router.events.on('routeChangeStart', (url: string) => console.log("Route is starting to change.", url));
+Router.events.on('beforeHistoryChange', (as: string) => console.log("History hasn't changed yet.", as));
+Router.events.on('routeChangeComplete', (url: string) => console.log("Route change is complete.", url));
+Router.events.on('routeChangeError', (err: any, url: string) => console.log("Route change errored.", err, url));
+
+// Call methods on the router itself.
+Router.reload("/route").then(() => console.log("route was reloaded"));
+Router.back();
+Router.beforePopState(({ url }) => !!url);
+
+Router.push("/route").then((success: boolean) =>
+    console.log("route push success: ", success),
+);
+Router.push("/route", "/asRoute").then((success: boolean) =>
+    console.log("route push success: ", success),
+);
+Router.push("/route", "/asRoute", { shallow: false }).then((success: boolean) =>
+    console.log("route push success: ", success),
+);
+
+Router.replace("/route").then((success: boolean) =>
+    console.log("route replace success: ", success),
+);
+Router.replace("/route", "/asRoute").then((success: boolean) =>
+    console.log("route replace success: ", success),
+);
+Router.replace("/route", "/asRoute", {
+    shallow: false,
+}).then((success: boolean) => console.log("route replace success: ", success));
+
+Router.prefetch("/route").then(Component => {
+    const element = <Component />;
+});
+
+interface TestComponentProps {
+    testValue: string;
+}
+
+class TestComponent extends React.Component<TestComponentProps & WithRouterProps> {
+    state = { ready: false };
+
+    constructor(props: TestComponentProps & WithRouterProps) {
+        super(props);
+        props.router.ready(() => {
+            this.setState({ ready: true });
+        });
+    }
+
+    render() {
+        return (
+            <div>
+                <h1>{this.state.ready ? 'Ready' : 'Not Ready'}</h1>
+                <h2>Route: {this.props.router.route}</h2>
+                <p>Another prop: {this.props.testValue}</p>
+            </div>
+        );
+    }
+}
+
+withRouter(TestComponent);
+
+interface TestSFCQuery {
+    test?: string;
+}
+
+interface TestSFCProps extends WithRouterProps<TestSFCQuery> { }
+
+const TestSFC: React.SFC<TestSFCProps> = ({ router }) => {
+    return <div>{router.query && router.query.test}</div>;
+};
diff --git a/types/next-server/test/next-server-tests.ts b/types/next-server/test/next-server-tests.ts
new file mode 100644
index 0000000000..7b4bfcca74
--- /dev/null
+++ b/types/next-server/test/next-server-tests.ts
@@ -0,0 +1,92 @@
+import createServer = require("next-server");
+import * as http from "http";
+import * as url from "url";
+
+const defaultServer: createServer.Server = createServer();
+const server = createServer({
+    dir: "..",
+    quiet: true,
+    conf: {
+        distDir: "./dist",
+        useFileSystemPublicRoutes: false,
+        anotherProperty: {
+            key: true
+        }
+    }
+});
+
+const devServer = createServer({
+    dev: true,
+    dir: "..",
+    quiet: true,
+    conf: {
+        distDir: "./dist",
+        useFileSystemPublicRoutes: false,
+        anotherProperty: {
+            key: true
+        }
+    }
+});
+
+const {
+    dir,
+    quiet,
+    router,
+    nextConfig,
+    distDir,
+    buildId
+ } = server;
+ const { assetPrefix } = nextConfig;
+ const voidFunc = () => {};
+
+server.prepare().then(voidFunc);
+server.close().then(voidFunc);
+
+const parsedUrl = url.parse("https://www.example.com");
+const handler = server.getRequestHandler();
+
+function handle(req: http.IncomingMessage, res: http.ServerResponse) {
+    handler(req, res);
+    handler(req, res, parsedUrl).then(voidFunc);
+    server.run(req, res, parsedUrl).then(voidFunc);
+
+    server.render(req, res, "/path/to/resource").then(voidFunc);
+    server.render(req, res, "/path/to/resource", {}, parsedUrl).then(voidFunc);
+    server
+        .render(req, res, "/path/to/resource", { key: "value" }, parsedUrl)
+        .then(voidFunc);
+    server
+        .renderError(new Error(), req, res, "/path/to/resource")
+        .then(voidFunc);
+    server
+        .renderError(new Error(), req, res, "/path/to/resource", {
+            key: "value",
+        })
+        .then(voidFunc);
+    server
+        .renderError(
+            "this can be an error, too!",
+            req,
+            res,
+            "/path/to/resource",
+            { key: "value" },
+        )
+        .then(voidFunc);
+    server.render404(req, res, parsedUrl).then(voidFunc);
+
+    server
+        .renderToHTML(req, res, "/path/to/resource", { foo: "bar" })
+        .then(x => x.split("\n"));
+    server
+        .renderErrorToHTML(new Error(), req, res, "/path/to/resource", {
+            foo: "bar",
+        })
+        .then(x => x.split("\n"));
+
+    server.serveStatic(req, res, "/path/to/thing").then(voidFunc);
+
+    let b: boolean;
+    b = server.isServeableUrl("/path/to/thing");
+
+    const s: string = server.readBuildId();
+}
diff --git a/types/next-server/tsconfig.json b/types/next-server/tsconfig.json
new file mode 100644
index 0000000000..4d72dadef2
--- /dev/null
+++ b/types/next-server/tsconfig.json
@@ -0,0 +1,38 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "target": "es6",
+        "jsx": "react",
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "asset.d.ts",
+        "config.d.ts",
+        "constants.d.ts",
+        "dynamic.d.ts",
+        "head.d.ts",
+        "link.d.ts",
+        "next-config.d.ts",
+        "router.d.ts",
+        "test/next-server-tests.ts",
+        "test/next-server-constants-tests.ts",
+        "test/next-server-head-tests.tsx",
+        "test/next-server-link-tests.tsx",
+        "test/next-server-dynamic-tests.tsx",
+        "test/next-server-router-tests.tsx"
+    ]
+}
diff --git a/types/next-server/tslint.json b/types/next-server/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/next-server/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/next/config.d.ts b/types/next/config.d.ts
index 8466b60a4f..f9fea12cbd 100644
--- a/types/next/config.d.ts
+++ b/types/next/config.d.ts
@@ -1 +1,2 @@
-export default function(): { serverRuntimeConfig: any; publicRuntimeConfig: any };
+export * from 'next-server/config';
+export { default } from 'next-server/config';
diff --git a/types/next/constants.d.ts b/types/next/constants.d.ts
index d2dc74dad0..d0d2e2361e 100644
--- a/types/next/constants.d.ts
+++ b/types/next/constants.d.ts
@@ -1,23 +1 @@
-export const PHASE_EXPORT: string;
-export const PHASE_PRODUCTION_BUILD: string;
-export const PHASE_PRODUCTION_SERVER: string;
-export const PHASE_DEVELOPMENT_SERVER: string;
-export const PAGES_MANIFEST: string;
-export const BUILD_MANIFEST: string;
-export const REACT_LOADABLE_MANIFEST: string;
-export const SERVER_DIRECTORY: string;
-export const CONFIG_FILE: string;
-export const BUILD_ID_FILE: string;
-export const BLOCKED_PAGES: string[];
-
-export const CLIENT_STATIC_FILES_PATH: string;
-export const CLIENT_STATIC_FILES_RUNTIME: string;
-export const CLIENT_STATIC_FILES_RUNTIME_PATH: string;
-/** static/runtime/main.js */
-export const CLIENT_STATIC_FILES_RUNTIME_MAIN: string;
-/** static/runtime/webpack.js */
-export const CLIENT_STATIC_FILES_RUNTIME_WEBPACK: string;
-/** matches static/<buildid>/pages/<page>.js */
-export const IS_BUNDLED_PAGE_REGEX: RegExp;
-/** matches static/<buildid>/pages/:page*.js */
-export const ROUTE_NAME_REGEX: RegExp;
+export * from 'next-server/constants';
diff --git a/types/next/dynamic.d.ts b/types/next/dynamic.d.ts
index 38a85bf77e..0b10e6238e 100644
--- a/types/next/dynamic.d.ts
+++ b/types/next/dynamic.d.ts
@@ -1,42 +1,2 @@
-import * as React from "react";
-import {
-    LoadableComponent,
-    CommonOptions as LoadableOptions,
-    LoadingComponentProps as LoadableLoadingComponentProps
-} from "react-loadable";
-
-type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
-
-type AsyncComponent<P = any> = Promise<React.ComponentType<P>>;
-type AsyncComponentLoader<P = any> = () => AsyncComponent<P>;
-type ModuleMapping = Record<string, AsyncComponent>;
-type LoadedModuleMapping = Record<string, React.ComponentType>;
-
-interface NextDynamicOptions<P = {}> extends Omit<LoadableOptions, "loading" | "modules"> {
-    modules?: () => ModuleMapping; // overridden
-    loading?: LoadableOptions["loading"]; // optional
-    loader?: AsyncComponentLoader<P>; // optional, overriden
-    render?: (props: P, loaded: LoadedModuleMapping) => React.ReactNode; // optional, overriden
-    ssr?: boolean;
-    loadableGenerated?: {
-        webpack?: any;
-        modules?: any;
-    };
-}
-
-type DynamicComponent<P> = React.ComponentType<P> & LoadableComponent;
-
-/**
- * Overloaded dynamic function.
- * https://github.com/zeit/next.js/blob/7.0.0/lib/dynamic.js#L55
- */
-declare function dynamic<P = {}>(
-    options: AsyncComponent<P> | NextDynamicOptions<P>
-): DynamicComponent<P>;
-declare function dynamic<P = {}>(
-    asyncModule: AsyncComponent<P>,
-    options: NextDynamicOptions<P>
-): DynamicComponent<P>;
-
-export type LoadingComponentProps = LoadableLoadingComponentProps;
-export default dynamic;
+export * from 'next-server/dynamic';
+export { default } from 'next-server/dynamic';
diff --git a/types/next/head.d.ts b/types/next/head.d.ts
index d46b371d11..616f88775c 100644
--- a/types/next/head.d.ts
+++ b/types/next/head.d.ts
@@ -1,8 +1,2 @@
-import * as React from "react";
-
-export function defaultHead(): JSX.Element[];
-export default class Head extends React.Component {
-    static canUseDOM: boolean;
-    static peek(): Array<React.ReactElement<any>>;
-    static rewind(): Array<React.ReactElement<any>>;
-}
+export * from 'next-server/head';
+export { default } from 'next-server/head';
diff --git a/types/next/index.d.ts b/types/next/index.d.ts
index d788ddd941..4dc0b49d07 100644
--- a/types/next/index.d.ts
+++ b/types/next/index.d.ts
@@ -1,11 +1,12 @@
 // Type definitions for next 7.0
-// Project: https://github.com/zeit/next.js
+// Project: https://github.com/zeit/next.js/packages/next
 // Definitions by: Drew Hays <https://github.com/dru89>
 //                 Brice BERNARD <https://github.com/brikou>
 //                 James Hegedus <https://github.com/jthegedus>
 //                 Resi Respati <https://github.com/resir014>
 //                 Scott Jones <https://github.com/scottdj92>
 //                 Joao Vieira <https://github.com/joaovieira>
+//                 AJ Livingston <https://github.com/ajliv>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.8
 
@@ -13,10 +14,18 @@
 
 import * as http from "http";
 import * as url from "url";
+import { Server as NextServer, ServerOptions as NextServerOptions, RenderOptions } from 'next-server';
+import { NextConfig as NextServerConfig } from 'next-server/next-config';
 import { Response as NodeResponse } from "node-fetch";
 import { SingletonRouter, DefaultQuery, UrlLike } from "./router";
 
 declare namespace next {
+    // Moved to next-server
+    type NextConfig = NextServerConfig;
+    type Server = NextServer;
+    type ServerOptions = NextServerOptions;
+    // End Moved to next-server
+
     // Deprecated
     type QueryStringMapObject = DefaultQuery;
     type ServerConfig = NextConfig;
@@ -47,126 +56,21 @@ declare namespace next {
     }
 
     /**
-     * Next.js config schema.
-     * https://github.com/zeit/next.js/blob/7.0.0/server/config.js#L9
+     * Next.js dev server instance API.
      */
-    interface NextConfig {
-        webpack?: any;
-        webpackDevMiddleware?: any;
-        poweredByHeader?: boolean;
-        distDir?: string;
-        assetPrefix?: string;
-        configOrigin?: string;
-        useFileSystemPublicRoutes?: boolean;
-        generateBuildId?: () => string;
-        generateEtags?: boolean;
-        pageExtensions?: string[];
-        publicRuntimeConfig?: object;
-        serverRuntimeConfig?: object;
-
-        // Plugin can define their own keys.
-        [key: string]: any;
-    }
-
-    /**
-     * Options passed to the Server constructor in Node.js.
-     * https://github.com/zeit/next.js/blob/7.0.0/server/index.js#L25
-     */
-    interface ServerOptions {
-        dir?: string;
-        dev?: boolean;
-        staticMarkup?: boolean;
-        quiet?: boolean;
-        conf?: NextConfig;
-    }
-
-    /**
-     * Next.js server instance API.
-     */
-    interface Server {
-        // From constructor
-        // https://github.com/zeit/next.js/blob/7.0.0/server/index.js#L25
-        dir: string;
-        dev: boolean;
-        quiet: boolean;
-        router: SingletonRouter;
-        http: null | http.Server;
-        nextConfig: NextConfig;
-        distDir: string;
-        buildId: string;
+    interface DevServer extends Server {
         hotReloader: any;
-        renderOpts: {
-            dev: string;
-            staticMarkup: boolean;
-            distDir: string;
+        renderOpts: RenderOptions & {
+            dev: true;
             hotReloader: any;
-            buildId: string;
-            generateETags: boolean;
-            runtimeConfig?: object;
         };
 
         getHotReloader(
             dir: string,
             options: { quiet: boolean; config: NextConfig; buildId: string }
         ): any;
-        handleRequest(
-            req: http.IncomingMessage,
-            res: http.ServerResponse,
-            parsedUrl?: UrlLike
-        ): Promise<void>;
-        getRequestHandler(): (
-            req: http.IncomingMessage,
-            res: http.ServerResponse,
-            parsedUrl?: UrlLike
-        ) => Promise<void>;
-        setAssetPrefix(prefix: string): void;
 
-        prepare(): Promise<void>;
-        close(): Promise<void>;
-        defineRoutes(): Promise<void>;
-        start(): Promise<void>;
-        run(req: http.IncomingMessage, res: http.ServerResponse, parsedUrl: UrlLike): Promise<void>;
-
-        render(
-            req: http.IncomingMessage,
-            res: http.ServerResponse,
-            pathname: string,
-            query?: DefaultQuery,
-            parsedUrl?: UrlLike
-        ): Promise<void>;
-        renderToHTML(
-            req: http.IncomingMessage,
-            res: http.ServerResponse,
-            pathname: string,
-            query?: DefaultQuery
-        ): Promise<string>;
-        renderError(
-            err: any,
-            req: http.IncomingMessage,
-            res: http.ServerResponse,
-            pathname: string,
-            query?: DefaultQuery
-        ): Promise<void>;
-        renderErrorToHTML(
-            err: any,
-            req: http.IncomingMessage,
-            res: http.ServerResponse,
-            pathname: string,
-            query?: DefaultQuery
-        ): Promise<string>;
-        render404(
-            req: http.IncomingMessage,
-            res: http.ServerResponse,
-            parsedUrl?: UrlLike
-        ): Promise<void>;
-
-        serveStatic(
-            req: http.IncomingMessage,
-            res: http.ServerResponse,
-            path: string
-        ): Promise<void>;
-        isServeableUrl(path: string): boolean;
-        readBuildId(): string;
+        addExportPathMapRoutes(): Promise<void>;
         getCompilationError(): Promise<any>;
     }
 
@@ -214,5 +118,6 @@ declare namespace next {
     }
 }
 
+declare function next(options?: next.ServerOptions & { dev: true }): next.DevServer;
 declare function next(options?: next.ServerOptions): next.Server;
 export = next;
diff --git a/types/next/link.d.ts b/types/next/link.d.ts
index 12e3ee5419..04c383e914 100644
--- a/types/next/link.d.ts
+++ b/types/next/link.d.ts
@@ -1,21 +1,8 @@
-import * as url from "url";
-import * as React from "react";
-import { UrlLike } from "./router";
+import { LinkProps } from 'next-server/link';
 
 // Deprecated
 export type LinkState = LinkProps;
 // End Deprecated
 
-export interface LinkProps {
-    prefetch?: boolean;
-    shallow?: boolean;
-    scroll?: boolean;
-    replace?: boolean;
-    onError?(error: any): void;
-    href?: string | UrlLike;
-    as?: string | UrlLike;
-    passHref?: boolean;
-    children: React.ReactElement<any>;
-}
-
-export default class Link extends React.Component<LinkProps> {}
+export * from 'next-server/link';
+export { default } from 'next-server/link';
diff --git a/types/next/router.d.ts b/types/next/router.d.ts
index 4232f356c9..8fd3df698b 100644
--- a/types/next/router.d.ts
+++ b/types/next/router.d.ts
@@ -1,95 +1,2 @@
-import * as React from "react";
-import * as url from "url";
-
-type EventName =
-    | "routeChangeStart"
-    | "routeChangeComplete"
-    | "routeChangeError"
-    | "beforeHistoryChange"
-    | "hashChangeStart"
-    | "hashChangeComplete";
-
-interface RouteChangeError {
-    cancelled: boolean;
-}
-
-type EventHandler = (url: string) => any;
-type ErrorEventHandler = (err: RouteChangeError, url: string) => any;
-
-export type UrlLike = url.UrlObject | url.Url;
-
-export interface EventChangeOptions {
-    shallow?: boolean;
-    [key: string]: any;
-}
-
-export type PopStateCallback = (state: any) => boolean | undefined;
-
-export type RouterCallback = () => void;
-
-export type DefaultQuery = Record<string, string | string[] | undefined>;
-
-export interface RouterProps<Q = DefaultQuery> {
-    // url property fields
-    readonly pathname: string;
-    readonly route: string;
-    readonly asPath?: string;
-    readonly query?: Q;
-
-    // property fields
-    readonly components: {
-        [key: string]: { Component: React.ComponentType<any>; err: any };
-    };
-
-    // core method fields
-    back(): void;
-    beforePopState(cb: PopStateCallback): boolean;
-    prefetch(url: string): Promise<React.ComponentType<any>>;
-    push(
-        url: string | UrlLike,
-        as?: string | UrlLike,
-        options?: EventChangeOptions
-    ): Promise<boolean>;
-    reload(route: string): Promise<void>;
-    replace(
-        url: string | UrlLike,
-        as?: string | UrlLike,
-        options?: EventChangeOptions
-    ): Promise<boolean>;
-
-    // events (deprecated soonish)
-    onAppUpdated?(nextRoute: string): void;
-    onBeforeHistoryChange?(as: string): void;
-    onHashChangeStart?(url: string): void;
-    onHashChangeComplete?(url: string): void;
-    onRouteChangeComplete?(url: string): void;
-    onRouteChangeError?(error: RouteChangeError, url: string): void;
-    onRouteChangeStart?(url: string): void;
-
-    // events API (6.1.1+)
-    readonly events: {
-        on: (eventName: EventName, handler: EventHandler | ErrorEventHandler) => void;
-        off: (eventName: EventName, handler: (url: string) => any) => void;
-    };
-}
-
-export interface SingletonRouter<Q = DefaultQuery> extends RouterProps<Q> {
-    router: RouterProps<Q> | null;
-    readyCallbacks: RouterCallback[];
-    ready(cb: RouterCallback): void;
-}
-
-export interface WithRouterProps<Q = DefaultQuery> {
-    router: SingletonRouter<Q>;
-}
-
-// Manually disabling the no-unnecessary-generics rule so users can
-// retain type inference if they warp their component in withRouter
-// without defining props explicitly
-export function withRouter<T extends {}, Q = DefaultQuery>(
-    // tslint:disable-next-line:no-unnecessary-generics
-    Component: React.ComponentType<T & WithRouterProps<Q>>
-): React.ComponentType<T>;
-
-declare const Router: SingletonRouter;
-export default Router;
+export * from 'next-server/router';
+export { default } from 'next-server/router';
diff --git a/types/next/test/next-tests.ts b/types/next/test/next-tests.ts
index 646b110c0d..3c8a403e46 100644
--- a/types/next/test/next-tests.ts
+++ b/types/next/test/next-tests.ts
@@ -15,9 +15,21 @@ const server = createServer({
     }
 });
 
+const devServer = createServer({
+    dev: true,
+    dir: "..",
+    quiet: true,
+    conf: {
+        distDir: "./dist",
+        useFileSystemPublicRoutes: false,
+        anotherProperty: {
+            key: true
+        }
+    }
+});
+
 const {
     dir,
-    dev,
     quiet,
     router,
     nextConfig,
@@ -29,8 +41,6 @@ const {
 
 server.prepare().then(voidFunc);
 server.close().then(voidFunc);
-server.defineRoutes().then(voidFunc);
-server.start().then(voidFunc);
 
 const parsedUrl = url.parse("https://www.example.com");
 const handler = server.getRequestHandler();
@@ -79,5 +89,5 @@ function handle(req: http.IncomingMessage, res: http.ServerResponse) {
     b = server.isServeableUrl("/path/to/thing");
 
     const s: string = server.readBuildId();
-    server.getCompilationError().then(err => err.thisIsAnAny);
+    devServer.getCompilationError().then(err => err.thisIsAnAny);
 }
diff --git a/types/ng-cordova/file.d.ts b/types/ng-cordova/file.d.ts
index 8ebe777c14..c6c71972b4 100644
--- a/types/ng-cordova/file.d.ts
+++ b/types/ng-cordova/file.d.ts
@@ -36,7 +36,10 @@ declare namespace ngCordova {
     }
 
     export interface IFilePromise<T> extends ng.IPromise<T> {
-        then<TResult>(successCallback: (promiseValue: T) => ng.IPromise<TResult> | TResult, errorCallback?: (error: IFileError) => ng.IPromise<TResult> | TResult): ng.IPromise<TResult>;
+        then<TResult = T, TResult2 = never>(
+            successCallback: (promiseValue: T) => ng.IPromise<TResult> | TResult,
+            errorCallback?: (error: IFileError) => ng.IPromise<TResult2> | TResult2
+        ): ng.IPromise<TResult | TResult2>;
         catch<TResult>(onRejected: (error: IFileError) => ng.IPromise<TResult> | TResult): ng.IPromise<TResult>;
     }
 
diff --git a/types/ng-cordova/fileTransfer.d.ts b/types/ng-cordova/fileTransfer.d.ts
index e4ef359c14..9c1d8bf3c2 100644
--- a/types/ng-cordova/fileTransfer.d.ts
+++ b/types/ng-cordova/fileTransfer.d.ts
@@ -14,7 +14,11 @@ declare namespace ngCordova {
     }
 
     export interface IFileTransferPromise<T> extends ng.IPromise<T> {
-        then<TResult>(successCallback: (promiseValue: T) => ng.IPromise<TResult> | TResult, errorCallback?: (error: FileTransferError) => ng.IPromise<TResult> | TResult, notifyCallback?: (state: any) => any): ng.IPromise<TResult>;
+        then<TResult = T, TResult2 = never>(
+            successCallback: (promiseValue: T) => ng.IPromise<TResult> | TResult,
+            errorCallback?: (error: FileTransferError) => ng.IPromise<TResult2> | TResult2,
+            notifyCallback?: (state: any) => any
+        ): ng.IPromise<TResult | TResult2>;
         catch<TResult>(onRejected: (error: FileTransferError) => ng.IPromise<TResult> | TResult): ng.IPromise<TResult>;
     }
 
diff --git a/types/ng-tags-input/tsconfig.json b/types/ng-tags-input/tsconfig.json
index 42a59350cb..09cfc54e25 100644
--- a/types/ng-tags-input/tsconfig.json
+++ b/types/ng-tags-input/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/node-crate/index.d.ts b/types/node-crate/index.d.ts
index 8fa75581e0..971c71db24 100644
--- a/types/node-crate/index.d.ts
+++ b/types/node-crate/index.d.ts
@@ -1,5 +1,5 @@
 // Type definitions for node-crate 2.0
-// Project: https://github.com/arobson/rabbot
+// Project: https://github.com/megastef/node-crate
 // Definitions by: Greg Jednaszewski <https://github.com/gjednaszewski>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.2
@@ -30,6 +30,10 @@ declare namespace crate {
          * Creates a table with the given schema.
          */
         create: (schema: object) => Promise<DBResultObject>;
+        /**
+         * Creates a table if it doesn't already exist.
+         */
+        createIfNotExists: (schema: object) => Promise<DBResultObject>;
         /**
          * Drops a table.
          */
diff --git a/types/node-crate/node-crate-tests.ts b/types/node-crate/node-crate-tests.ts
index d98f8c2694..117fdcbcdf 100644
--- a/types/node-crate/node-crate-tests.ts
+++ b/types/node-crate/node-crate-tests.ts
@@ -10,6 +10,8 @@ crate.insert('users', {id: 'test', password: 'password'});
 
 crate.create({users: {id: 'string primary key', password: 'string'}});
 
+crate.createIfNotExists({users: {id: 'string primary key', password: 'string'}});
+
 crate.drop('users');
 
 crate.update('users', {password: 'newPassword'}, "id = 'test'");
diff --git a/types/node-cron/index.d.ts b/types/node-cron/index.d.ts
index 75ddaefdde..8c6b70ec1c 100644
--- a/types/node-cron/index.d.ts
+++ b/types/node-cron/index.d.ts
@@ -1,15 +1,28 @@
-// Type definitions for node-cron 1.2
-// Project: http://merencia.com/node-cron/
-// Definitions by: morsic <https://github.com/maximelkin>
+// Type definitions for node-cron 2.0
+// Project: https://github.com/node-cron/node-cron
+// Definitions by: morsic <https://github.com/maximelkin>,
+//                 burtek <https://github.com/burtek>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-// immediateStart - default true
-export function schedule(a: string, func: () => void, immediateStart?: boolean): ScheduledTask;
+export function schedule(cronExpression: string, func: () => void, options?: ScheduleOptions): ScheduledTask;
 
-export function validate(a: string): boolean;
+export function validate(cronExpression: string): boolean;
 
 export interface ScheduledTask {
     start: () => this;
     stop: () => this;
     destroy: () => void;
 }
+
+export interface ScheduleOptions {
+    /**
+     * A boolean to set if the created task is scheduled.
+     *
+     * Defaults to `true`
+     */
+    scheduled?: boolean;
+    /**
+     * The timezone that is used for job scheduling
+     */
+    timezone?: string;
+}
diff --git a/types/node-cron/node-cron-tests.ts b/types/node-cron/node-cron-tests.ts
index c670924d27..17350b6427 100644
--- a/types/node-cron/node-cron-tests.ts
+++ b/types/node-cron/node-cron-tests.ts
@@ -17,7 +17,7 @@ cron.schedule('1-5 * * * *', () => {
 const task = cron.schedule('* * * * *', () => {
     log('immediately started');
     // because of manual call start method
-}, false);
+}, { scheduled: false });
 
 task.start();
 
diff --git a/types/node/index.d.ts b/types/node/index.d.ts
index 73558e4a8f..48d8340522 100644
--- a/types/node/index.d.ts
+++ b/types/node/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for Node.js 10.11
+// Type definitions for Node.js 10.12
 // Project: http://nodejs.org/
 // Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
 //                 DefinitelyTyped <https://github.com/DefinitelyTyped>
@@ -493,6 +493,7 @@ declare namespace NodeJS {
         maxArrayLength?: number | null;
         breakLength?: number;
         compact?: boolean;
+        sorted?: boolean | ((a: string, b: string) => number);
     }
 
     interface ConsoleConstructor {
@@ -691,6 +692,8 @@ declare namespace NodeJS {
         "SIGSTOP" | "SIGSYS" | "SIGTERM" | "SIGTRAP" | "SIGTSTP" | "SIGTTIN" | "SIGTTOU" | "SIGUNUSED" | "SIGURG" |
         "SIGUSR1" | "SIGUSR2" | "SIGVTALRM" | "SIGWINCH" | "SIGXCPU" | "SIGXFSZ" | "SIGBREAK" | "SIGLOST" | "SIGINFO";
 
+    type MultipleResolveType = 'resolve' | 'reject';
+
     type BeforeExitListener = (code: number) => void;
     type DisconnectListener = () => void;
     type ExitListener = (code: number) => void;
@@ -702,6 +705,7 @@ declare namespace NodeJS {
     type SignalsListener = (signal: Signals) => void;
     type NewListenerListener = (type: string | symbol, listener: (...args: any[]) => void) => void;
     type RemoveListenerListener = (type: string | symbol, listener: (...args: any[]) => void) => void;
+    type MultipleResolveListener = (type: MultipleResolveType, promise: Promise<any>, value: any) => void;
 
     interface Socket extends ReadWriteStream {
         isTTY?: true;
@@ -845,6 +849,7 @@ declare namespace NodeJS {
         addListener(event: Signals, listener: SignalsListener): this;
         addListener(event: "newListener", listener: NewListenerListener): this;
         addListener(event: "removeListener", listener: RemoveListenerListener): this;
+        addListener(event: "multipleResolves", listener: MultipleResolveListener): this;
 
         emit(event: "beforeExit", code: number): boolean;
         emit(event: "disconnect"): boolean;
@@ -857,6 +862,7 @@ declare namespace NodeJS {
         emit(event: Signals, signal: Signals): boolean;
         emit(event: "newListener", eventName: string | symbol, listener: (...args: any[]) => void): this;
         emit(event: "removeListener", eventName: string, listener: (...args: any[]) => void): this;
+        emit(event: "multipleResolves", listener: MultipleResolveListener): this;
 
         on(event: "beforeExit", listener: BeforeExitListener): this;
         on(event: "disconnect", listener: DisconnectListener): this;
@@ -869,6 +875,7 @@ declare namespace NodeJS {
         on(event: Signals, listener: SignalsListener): this;
         on(event: "newListener", listener: NewListenerListener): this;
         on(event: "removeListener", listener: RemoveListenerListener): this;
+        on(event: "multipleResolves", listener: MultipleResolveListener): this;
 
         once(event: "beforeExit", listener: BeforeExitListener): this;
         once(event: "disconnect", listener: DisconnectListener): this;
@@ -881,6 +888,7 @@ declare namespace NodeJS {
         once(event: Signals, listener: SignalsListener): this;
         once(event: "newListener", listener: NewListenerListener): this;
         once(event: "removeListener", listener: RemoveListenerListener): this;
+        once(event: "multipleResolves", listener: MultipleResolveListener): this;
 
         prependListener(event: "beforeExit", listener: BeforeExitListener): this;
         prependListener(event: "disconnect", listener: DisconnectListener): this;
@@ -893,6 +901,7 @@ declare namespace NodeJS {
         prependListener(event: Signals, listener: SignalsListener): this;
         prependListener(event: "newListener", listener: NewListenerListener): this;
         prependListener(event: "removeListener", listener: RemoveListenerListener): this;
+        prependListener(event: "multipleResolves", listener: MultipleResolveListener): this;
 
         prependOnceListener(event: "beforeExit", listener: BeforeExitListener): this;
         prependOnceListener(event: "disconnect", listener: DisconnectListener): this;
@@ -905,6 +914,7 @@ declare namespace NodeJS {
         prependOnceListener(event: Signals, listener: SignalsListener): this;
         prependOnceListener(event: "newListener", listener: NewListenerListener): this;
         prependOnceListener(event: "removeListener", listener: RemoveListenerListener): this;
+        prependOnceListener(event: "multipleResolves", listener: MultipleResolveListener): this;
 
         listeners(event: "beforeExit"): BeforeExitListener[];
         listeners(event: "disconnect"): DisconnectListener[];
@@ -917,6 +927,7 @@ declare namespace NodeJS {
         listeners(event: Signals): SignalsListener[];
         listeners(event: "newListener"): NewListenerListener[];
         listeners(event: "removeListener"): RemoveListenerListener[];
+        listeners(event: "multipleResolves"): MultipleResolveListener[];
     }
 
     interface Global {
@@ -1006,6 +1017,7 @@ declare namespace NodeJS {
     class Module {
         static runMain(): void;
         static wrap(code: string): string;
+        static createRequireFromPath(path: string): (path: string) => any;
         static builtinModules: string[];
 
         static Module: typeof Module;
@@ -2618,6 +2630,20 @@ declare module "url" {
     function domainToASCII(domain: string): string;
     function domainToUnicode(domain: string): string;
 
+    /**
+     * This function ensures the correct decodings of percent-encoded characters as
+     * well as ensuring a cross-platform valid absolute path string.
+     * @param url The file URL string or URL object to convert to a path.
+     */
+    function fileURLToPath(url: string | URL): string;
+
+    /**
+     * This function ensures that path is resolved absolutely, and that the URL
+     * control characters are correctly encoded when converting into a File URL.
+     * @param url The path to convert to a File URL.
+     */
+    function pathToFileURL(url: string): URL;
+
     interface URLFormatOptions {
         auth?: boolean;
         fragment?: boolean;
@@ -3994,12 +4020,25 @@ declare module "fs" {
      */
     function rmdirSync(path: PathLike): void;
 
+    export interface MakeDirectoryOptions {
+        /**
+         * Indicates whether parent folders should be created.
+         * @default false
+         */
+        recursive?: boolean;
+        /**
+         * A file mode. If a string is passed, it is parsed as an octal integer. If not specified
+         * @default 0o777.
+         */
+        mode?: number;
+    }
+
     /**
      * Asynchronous mkdir(2) - create a directory.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param mode A file mode. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
      */
-    function mkdir(path: PathLike, mode: number | string | undefined | null, callback: (err: NodeJS.ErrnoException) => void): void;
+    function mkdir(path: PathLike, mode: number | string | MakeDirectoryOptions | undefined | null, callback: (err: NodeJS.ErrnoException) => void): void;
 
     /**
      * Asynchronous mkdir(2) - create a directory with a mode of `0o777`.
@@ -4014,7 +4053,7 @@ declare module "fs" {
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
          * @param mode A file mode. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
          */
-        function __promisify__(path: PathLike, mode?: number | string | null): Promise<void>;
+        function __promisify__(path: PathLike, mode?: number | string | MakeDirectoryOptions | null): Promise<void>;
     }
 
     /**
@@ -4022,7 +4061,7 @@ declare module "fs" {
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param mode A file mode. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
      */
-    function mkdirSync(path: PathLike, mode?: number | string | null): void;
+    function mkdirSync(path: PathLike, mode?: number | string | MakeDirectoryOptions | null): void;
 
     /**
      * Asynchronously creates a unique temporary directory.
@@ -6349,6 +6388,88 @@ declare module "crypto" {
     function timingSafeEqual(a: Buffer | NodeJS.TypedArray | DataView, b: Buffer | NodeJS.TypedArray | DataView): boolean;
     /** @deprecated since v10.0.0 */
     const DEFAULT_ENCODING: string;
+
+    export type KeyType = 'rsa' | 'dsa' | 'ec';
+    export type KeyFormat = 'pem' | 'der';
+
+    interface BasePrivateKeyEncodingOptions<T extends KeyFormat> {
+        format: T;
+        ciper: string;
+        passphrase: string;
+    }
+
+    interface RSAKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
+        /**
+         * Key size in bits
+         */
+        modulusLength: number;
+        /**
+         * @default 0x10001
+         */
+        publicExponent?: number;
+
+        publicKeyEncoding: {
+            type: 'pkcs1' | 'spki';
+            format: PubF;
+        };
+        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
+            type: 'pkcs1' | 'pkcs8';
+        };
+    }
+
+    interface DSAKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
+        /**
+         * Key size in bits
+         */
+        modulusLength: number;
+        /**
+         * Size of q in bits
+         */
+        divisorLength: number;
+
+        publicKeyEncoding: {
+            type: 'spki';
+            format: PubF;
+        };
+        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
+            type: 'pkcs8';
+        };
+    }
+
+    interface ECKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
+        /**
+         * Name of the curve to use.
+         */
+        namedCurve: string;
+
+        publicKeyEncoding: {
+            type: 'pkcs1' | 'spki';
+            format: PubF;
+        };
+        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
+            type: 'sec1' | 'pkcs8';
+        };
+    }
+
+    interface KeyPairSyncResult<T1 extends string | Buffer, T2 extends string | Buffer> {
+        publicKey: T1;
+        privateKey: T2;
+    }
+
+    function generateKeyPairSync(type: 'rsa', options: RSAKeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
+    function generateKeyPairSync(type: 'rsa', options: RSAKeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
+    function generateKeyPairSync(type: 'rsa', options: RSAKeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
+    function generateKeyPairSync(type: 'rsa', options: RSAKeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
+
+    function generateKeyPairSync(type: 'dsa', options: DSAKeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
+    function generateKeyPairSync(type: 'dsa', options: DSAKeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
+    function generateKeyPairSync(type: 'dsa', options: DSAKeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
+    function generateKeyPairSync(type: 'dsa', options: DSAKeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
+
+    function generateKeyPairSync(type: 'ec', options: ECKeyPairOptions<'pem', 'pem'>): KeyPairSyncResult<string, string>;
+    function generateKeyPairSync(type: 'ec', options: ECKeyPairOptions<'pem', 'der'>): KeyPairSyncResult<string, Buffer>;
+    function generateKeyPairSync(type: 'ec', options: ECKeyPairOptions<'der', 'pem'>): KeyPairSyncResult<Buffer, string>;
+    function generateKeyPairSync(type: 'ec', options: ECKeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
 }
 
 declare module "stream" {
@@ -7665,6 +7786,7 @@ declare module "http2" {
         addListener(event: "localSettings", listener: (settings: Settings) => void): this;
         addListener(event: "remoteSettings", listener: (settings: Settings) => void): this;
         addListener(event: "timeout", listener: () => void): this;
+        addListener(event: "ping", listener: () => void): this;
 
         emit(event: string | symbol, ...args: any[]): boolean;
         emit(event: "close"): boolean;
@@ -7674,6 +7796,7 @@ declare module "http2" {
         emit(event: "localSettings", settings: Settings): boolean;
         emit(event: "remoteSettings", settings: Settings): boolean;
         emit(event: "timeout"): boolean;
+        emit(event: "ping"): boolean;
 
         on(event: string, listener: (...args: any[]) => void): this;
         on(event: "close", listener: () => void): this;
@@ -7683,6 +7806,7 @@ declare module "http2" {
         on(event: "localSettings", listener: (settings: Settings) => void): this;
         on(event: "remoteSettings", listener: (settings: Settings) => void): this;
         on(event: "timeout", listener: () => void): this;
+        on(event: "ping", listener: () => void): this;
 
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: "close", listener: () => void): this;
@@ -7692,6 +7816,7 @@ declare module "http2" {
         once(event: "localSettings", listener: (settings: Settings) => void): this;
         once(event: "remoteSettings", listener: (settings: Settings) => void): this;
         once(event: "timeout", listener: () => void): this;
+        once(event: "ping", listener: () => void): this;
 
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: "close", listener: () => void): this;
@@ -7701,6 +7826,7 @@ declare module "http2" {
         prependListener(event: "localSettings", listener: (settings: Settings) => void): this;
         prependListener(event: "remoteSettings", listener: (settings: Settings) => void): this;
         prependListener(event: "timeout", listener: () => void): this;
+        prependListener(event: "ping", listener: () => void): this;
 
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: "close", listener: () => void): this;
@@ -7710,6 +7836,7 @@ declare module "http2" {
         prependOnceListener(event: "localSettings", listener: (settings: Settings) => void): this;
         prependOnceListener(event: "remoteSettings", listener: (settings: Settings) => void): this;
         prependOnceListener(event: "timeout", listener: () => void): this;
+        prependOnceListener(event: "ping", listener: () => void): this;
     }
 
     export interface ClientHttp2Session extends Http2Session {
diff --git a/types/node/node-tests.ts b/types/node/node-tests.ts
index 15d139d2f0..f243aa649e 100644
--- a/types/node/node-tests.ts
+++ b/types/node/node-tests.ts
@@ -414,6 +414,19 @@ import { Buffer as ImportedBuffer, SlowBuffer as ImportedSlowBuffer } from "buff
         const cf = util.promisify(fs.copyFile);
         cf('/path/to/src', '/path/to/dest', fs.constants.COPYFILE_EXCL).then(console.log);
     }
+
+    {
+        fs.mkdir('some/test/path', {
+            recursive: true,
+            mode: 0o777,
+        }, () => {
+        });
+
+        fs.mkdirSync('some/test/path', {
+            recursive: true,
+            mode: 0o777,
+        });
+    }
 }
 
 ///////////////////////////////////////////////////////
@@ -763,6 +776,15 @@ function bufferTests() {
         ]);
         assert.equal(params.toString(), 'user=abc&query=first&query=second');
     }
+
+    {
+        let path: string = url.fileURLToPath('file://test');
+        path = url.fileURLToPath(new url.URL('file://test'));
+    }
+
+    {
+        const path: url.URL = url.pathToFileURL('file://test');
+    }
 }
 
 /////////////////////////////////////////////////////
@@ -781,7 +803,10 @@ function bufferTests() {
             showProxy: true,
             maxArrayLength: 10,
             breakLength: 20,
-            compact: true
+            compact: true,
+            sorted(a, b) {
+                return b.localeCompare(a);
+            },
         });
         util.inspect(["This is nice"], {
             colors: true,
@@ -790,7 +815,8 @@ function bufferTests() {
             showProxy: true,
             maxArrayLength: null,
             breakLength: Infinity,
-            compact: false
+            compact: false,
+            sorted: true,
         });
         assert(typeof util.inspect.custom === 'symbol');
 
@@ -1475,6 +1501,60 @@ async function asyncStreamPipelineFinished() {
         ret = crypto.ECDH.convertKey(key, curve, "hex", "hex", "compressed");
         ret = crypto.ECDH.convertKey(key, curve, "hex", "hex", "hybrid");
     }
+
+    {
+        const rsaRes: {
+            publicKey: Buffer;
+            privateKey: string;
+        } = crypto.generateKeyPairSync('rsa', {
+            modulusLength: 123,
+            publicKeyEncoding: {
+                format: 'der',
+                type: 'pkcs1',
+            },
+            privateKeyEncoding: {
+                ciper: 'some-cipher',
+                format: 'pem',
+                passphrase: 'secret',
+                type: 'pkcs8',
+            },
+        });
+
+        const dsaRes: {
+            publicKey: string;
+            privateKey: Buffer;
+        } = crypto.generateKeyPairSync('dsa', {
+            modulusLength: 123,
+            divisorLength: 123,
+            publicKeyEncoding: {
+                format: 'pem',
+                type: 'spki',
+            },
+            privateKeyEncoding: {
+                ciper: 'some-cipher',
+                format: 'der',
+                passphrase: 'secret',
+                type: 'pkcs8',
+            },
+        });
+
+        const ecRes: {
+            publicKey: string;
+            privateKey: string;
+        } = crypto.generateKeyPairSync('ec', {
+            namedCurve: 'curve',
+            publicKeyEncoding: {
+                format: 'pem',
+                type: 'pkcs1',
+            },
+            privateKeyEncoding: {
+                ciper: 'some-cipher',
+                format: 'pem',
+                passphrase: 'secret',
+                type: 'pkcs8',
+            },
+        });
+    }
 }
 
 //////////////////////////////////////////////////
@@ -3087,6 +3167,7 @@ import * as p from "process";
         process.prependOnceListener("SIGBREAK", () => { });
         process.on("newListener", (event: string | symbol, listener: Function) => { });
         process.once("removeListener", (event: string | symbol, listener: Function) => { });
+        process.on("multipleResolves", (type: NodeJS.MultipleResolveType, prom: Promise<any>, value: any) => {});
 
         const listeners = process.listeners('uncaughtException');
         const oldHandler = listeners[listeners.length - 1];
@@ -3863,6 +3944,7 @@ import * as constants from 'constants';
         http2Session.on('remoteSettings', (settings: http2.Settings) => {});
         http2Session.on('stream', (stream: http2.Http2Stream, headers: http2.IncomingHttpHeaders, flags: number) => {});
         http2Session.on('timeout', () => {});
+        http2Session.on('ping', () => {});
 
         http2Session.destroy();
 
@@ -4440,6 +4522,7 @@ import * as constants from 'constants';
 ////////////////////////////////////////////////////
 /// module tests : http://nodejs.org/api/modules.html
 ////////////////////////////////////////////////////
+import moduleModule = require('module');
 
 {
     require.extensions[".ts"] = () => "";
@@ -4452,6 +4535,8 @@ import * as constants from 'constants';
     const b: string[] = Module.builtinModules;
     let paths: string[] = module.paths;
     paths = m1.paths;
+
+    moduleModule.createRequireFromPath('./test')('test');
 }
 
 ////////////////////////////////////////////////////
diff --git a/types/node/v8/tslint.json b/types/node/v8/tslint.json
index 5bf4b24ecc..4c1432c003 100644
--- a/types/node/v8/tslint.json
+++ b/types/node/v8/tslint.json
@@ -3,6 +3,7 @@
   "rules": {
     // All are TODOs
     "ban-types": false,
+    "dt-header": false,
     "max-line-length": false,
     "no-any-union": false,
     "no-duplicate-imports": false,
@@ -13,6 +14,7 @@
     "no-namespace": false,
     "no-redundant-jsdoc": false,
     "no-redundant-jsdoc-2": false,
+    "no-single-declare-module": false,
     "no-unnecessary-class": false,
     "no-unnecessary-generics": false,
     "no-unnecessary-qualifier": false,
diff --git a/types/node/v9/tslint.json b/types/node/v9/tslint.json
index 5bf4b24ecc..4c1432c003 100644
--- a/types/node/v9/tslint.json
+++ b/types/node/v9/tslint.json
@@ -3,6 +3,7 @@
   "rules": {
     // All are TODOs
     "ban-types": false,
+    "dt-header": false,
     "max-line-length": false,
     "no-any-union": false,
     "no-duplicate-imports": false,
@@ -13,6 +14,7 @@
     "no-namespace": false,
     "no-redundant-jsdoc": false,
     "no-redundant-jsdoc-2": false,
+    "no-single-declare-module": false,
     "no-unnecessary-class": false,
     "no-unnecessary-generics": false,
     "no-unnecessary-qualifier": false,
diff --git a/types/nookies/index.d.ts b/types/nookies/index.d.ts
new file mode 100644
index 0000000000..1eaab3ce64
--- /dev/null
+++ b/types/nookies/index.d.ts
@@ -0,0 +1,20 @@
+// Type definitions for nookies 1.1
+// Project: https://github.com/maticzav/nookies#readme
+// Definitions by: Andreas Bergqvist <https://github.com/andreasbergqvist>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+import { NextContext } from 'next';
+import { CookieParseOptions, CookieSerializeOptions } from 'cookie';
+
+export function parseCookies(ctx: NextContext, options?: CookieParseOptions): { [key: string]: string };
+export function setCookie(ctx: NextContext, name: string, value: string, options?: CookieSerializeOptions): void;
+export function destroyCookie(ctx: NextContext, name: string): void;
+
+declare const Nookies: {
+    set(ctx: NextContext, name: string, value: string, options?: CookieSerializeOptions): void;
+    get(ctx: NextContext, options?: CookieParseOptions): { [key: string]: string };
+    destroy(ctx: NextContext, name: string): void;
+};
+
+export default Nookies;
diff --git a/types/nookies/nookies-tests.ts b/types/nookies/nookies-tests.ts
new file mode 100644
index 0000000000..2fe560affc
--- /dev/null
+++ b/types/nookies/nookies-tests.ts
@@ -0,0 +1,9 @@
+import nookies, { parseCookies, setCookie, destroyCookie } from 'nookies';
+
+nookies.set({ pathname: '', query: {}, asPath: ''}, 'test-cookie', 'test-value');
+nookies.get({ pathname: '', query: {}, asPath: ''});
+nookies.destroy({ pathname: '', query: {}, asPath: ''}, 'test-cookie');
+
+parseCookies({ pathname: '', query: {}, asPath: ''});
+setCookie({ pathname: '', query: {}, asPath: ''}, 'test-cookie', 'test-value');
+destroyCookie({ pathname: '', query: {}, asPath: ''}, 'test-cookie');
diff --git a/types/nookies/tsconfig.json b/types/nookies/tsconfig.json
new file mode 100644
index 0000000000..15118a6178
--- /dev/null
+++ b/types/nookies/tsconfig.json
@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true,
+        "strictFunctionTypes": true
+    },
+    "files": [
+        "index.d.ts",
+        "nookies-tests.ts"
+    ]
+}
diff --git a/types/nookies/tslint.json b/types/nookies/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/nookies/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/oauth/index.d.ts b/types/oauth/index.d.ts
index 21b74369e9..9f747e8b84 100644
--- a/types/oauth/index.d.ts
+++ b/types/oauth/index.d.ts
@@ -1,6 +1,7 @@
 // Type definitions for oauth 0.9
 // Project: https://github.com/ciaranj/node-oauth#readme
 // Definitions by: nonAlgebraic <https://github.com/nonAlgebraic>
+//                 Eduardo AC <https://github.com/EduardoAC>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /// <reference types='node' />
@@ -25,8 +26,8 @@ export type oauth2tokenCallback = (
 
 export type dataCallback = (
   err: {statusCode: number, data?: any},
-  result: string | Buffer,
-  response: IncomingMessage
+  result?: string | Buffer,
+  response?: IncomingMessage
 ) => any;
 
 export class OAuth {
@@ -285,7 +286,7 @@ export class OAuth2 {
 
   get(url: string,
     access_token: string,
-    callback: string
+    callback: dataCallback
   ): void;
 
   protected _getAccessTokenUrl(): string;
diff --git a/types/okta__okta-vue/tsconfig.json b/types/okta__okta-vue/tsconfig.json
index f114dc0fe8..ffd7c33703 100644
--- a/types/okta__okta-vue/tsconfig.json
+++ b/types/okta__okta-vue/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/onoff/index.d.ts b/types/onoff/index.d.ts
index 72c25d11f5..55701976a9 100644
--- a/types/onoff/index.d.ts
+++ b/types/onoff/index.d.ts
@@ -1,6 +1,7 @@
-// Type definitions for onoff
+// Type definitions for onoff v3.2
 // Project: https://github.com/fivdi/onoff
 // Definitions by: Marcel Ernst <https://github.com/marcel-ernst>
+//                 Kallu609 <https://github.com/Kallu609>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /// <reference types="node" />
@@ -8,47 +9,54 @@
 export = __ONOFF;
 
 declare namespace __ONOFF {
-
-    var version:string;
-
+    var version: string;
+    
     interface GpioOptions {
-        debounceTimeout?:number;
-        activeLow?:boolean;
+        debounceTimeout?: number;
+        activeLow?: boolean;
     }
-
+    
+    type Direction = 'in' | 'out' | 'high' | 'low';
+    type Edge = 'none' | 'falling' | 'rising' | 'both';
+    
     class Gpio {
-        constructor(gpio:number, direction:string);
-        constructor(gpio:number, direction:string, edge:string);
-        constructor(gpio:number, direction:string, edge:string, options:GpioOptions);
-        constructor(gpio:number, direction:string, options:GpioOptions);
-
-        gpio:number
-        gpioPath:string;
-        opts:GpioOptions;
-        readBuffer:Buffer;
-        listeners:Array<(error:Error, value:number) => void>;
-        valueFd:number;
-
-        read(cb:(err:Error, value:number) => void):void;
-        readSync():number;
-
-        write(value:number, cb:(err:Error, value:number) => void):void;
-        writeSync(value:number):void;
-
-        watch(cb:(error:Error, value:number) => void):void;
-        unwatch():void;
-        unwatch(cb:(error:Error, value:number) => void):void;
-        unwatchAll():void;
-
-        direction():string;
-        setDirection(value:string):void;
-
-        edge():string;
-        setEdge(value:string):void;
-
-        options():GpioOptions;
-
-        unexport():void;
+        constructor(gpio: number, direction: Direction, options?: GpioOptions);
+        constructor(
+            gpio: number,
+            direction: Direction,
+            edge?: Edge,
+            options?: GpioOptions
+        );
+        
+        gpio: number;
+        gpioPath: string;
+        opts: GpioOptions;
+        readBuffer: Buffer;
+        listeners: Array<(err: Error, value: number) => void>;
+        _valueFd: number;
+        
+        read(cb: (err: Error, value: number) => void): void;
+        readSync(): number;
+        
+        write(value: number, cb: (err: Error, value: number) => void): void;
+        writeSync(value: number): void;
+        
+        watch(cb: (err: Error, value: number) => void): void;
+        unwatch(): void;
+        unwatch(cb: (err: Error, value: number) => void): void;
+        unwatchAll(): void;
+        
+        direction(): Direction;
+        setDirection(value: Direction): void;
+        
+        edge(): Edge;
+        setEdge(value: Edge): void;
+        
+        activeLow(): boolean;
+        setActiveLow(invert?: boolean): void;
+        
+        options(): GpioOptions;
+        
+        unexport(): void;
     }
-
 }
diff --git a/types/openjscad/index.d.ts b/types/openjscad/index.d.ts
index 56026967a2..4a4f84c5b4 100644
--- a/types/openjscad/index.d.ts
+++ b/types/openjscad/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/joostn/OpenJsCad
 // Definitions by: Dan Marshall <https://github.com/danmarshall>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
 
 /// <reference types="three" />
 
diff --git a/types/opossum/index.d.ts b/types/opossum/index.d.ts
index bcdc262d99..f1e14a939b 100644
--- a/types/opossum/index.d.ts
+++ b/types/opossum/index.d.ts
@@ -10,8 +10,27 @@ import * as stream from "stream";
 export type Action = () => any;
 
 export class CircuitBreaker {
+    clearCache(): void;
+    close(): void;
+    disable(): void;
+    enable(): void;
+    fallback(): CircuitBreaker;
+    fire(): Promise<any>;
+    healthCheck(func: () => Promise<any>, interval: number): Promise<any>;
+    open(): void;
     promisify(action: Action): Promise<Action>;
     stats(): stream.Transform;
+
+    static readonly name: symbol;
+    static readonly group: symbol;
+    static readonly pendingClose: symbol;
+    static readonly closed: symbol;
+    static readonly opened: symbol;
+    static readonly halfOpen: symbol;
+    static readonly status: symbol;
+    static readonly hystrixStats: symbol;
+    static readonly enabled: symbol;
+    static readonly warmUp: symbol;
 }
 
 export interface CircuitBreakerOptions {
diff --git a/types/opossum/opossum-tests.ts b/types/opossum/opossum-tests.ts
index 22778147e5..3f020eff52 100644
--- a/types/opossum/opossum-tests.ts
+++ b/types/opossum/opossum-tests.ts
@@ -2,6 +2,7 @@ import { Transform } from "stream";
 import circuitBreaker, { CircuitBreaker, CircuitBreakerOptions } from "opossum";
 
 const _blank = () => {};
+const async_blank = () => new Promise(resolve => null);
 
 const testNoOptions: CircuitBreaker = circuitBreaker(_blank);
 
@@ -22,3 +23,24 @@ const options: CircuitBreakerOptions = {
 const testWithOptions: CircuitBreaker = circuitBreaker(_blank, options);
 const shouldBeAPromise: Promise<any> = testWithOptions.promisify(_blank);
 const shouldBeATransformStream: Transform = testWithOptions.stats();
+
+const healthCheck: Promise<any> = testWithOptions.healthCheck(async_blank, 8);
+const shouldBeACircuitBreaker: CircuitBreaker = testWithOptions.fallback();
+const shouldBeAPromiseGeneric: Promise<any> = testWithOptions.fire();
+
+const shouldBeVoid = (): void => testWithOptions.enable();
+const shouldBeVoid2 = (): void => testWithOptions.disable();
+const shouldBeVoid3 = (): void => testWithOptions.close();
+const shouldBeVoid4 = (): void => testWithOptions.open();
+const shouldBeVoid5 = (): void => testWithOptions.clearCache();
+
+const shouldBeSymbol: symbol = CircuitBreaker.name;
+const shouldBeSymbol2: symbol = CircuitBreaker.group;
+const shouldBeSymbol3: symbol = CircuitBreaker.pendingClose;
+const shouldBeSymbol4: symbol = CircuitBreaker.closed;
+const shouldBeSymbol5: symbol = CircuitBreaker.opened;
+const shouldBeSymbol6: symbol = CircuitBreaker.halfOpen;
+const shouldBeSymbol7: symbol = CircuitBreaker.hystrixStats;
+const shouldBeSymbol8: symbol = CircuitBreaker.status;
+const shouldBeSymbol9: symbol = CircuitBreaker.enabled;
+const shouldBeSymbol10: symbol = CircuitBreaker.warmUp;
diff --git a/types/opossum/tsconfig.json b/types/opossum/tsconfig.json
index 7ddf39bf63..70edefe671 100644
--- a/types/opossum/tsconfig.json
+++ b/types/opossum/tsconfig.json
@@ -4,6 +4,7 @@
         "lib": [
             "es6"
         ],
+        "target": "es5",
         "noImplicitAny": true,
         "noImplicitThis": true,
         "strictNullChecks": true,
diff --git a/types/optics-agent/index.d.ts b/types/optics-agent/index.d.ts
index 2c8ae46283..0d08646a4b 100644
--- a/types/optics-agent/index.d.ts
+++ b/types/optics-agent/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/apollostack/optics-agent-js#readme
 // Definitions by: Crevil <https://github.com/crevil>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.4
+// TypeScript Version: 2.6
 
 import { GraphQLSchema } from "graphql";
 import { Request, Response } from "express";
diff --git a/types/optics-agent/tsconfig.json b/types/optics-agent/tsconfig.json
index 046bfaad81..fe309dafd3 100644
--- a/types/optics-agent/tsconfig.json
+++ b/types/optics-agent/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "esnext.asynciterable"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/p-loading/tsconfig.json b/types/p-loading/tsconfig.json
index 09fd52fdda..6f45b638aa 100644
--- a/types/p-loading/tsconfig.json
+++ b/types/p-loading/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/parcel-bundler/index.d.ts b/types/parcel-bundler/index.d.ts
index 2122bed672..c661d105cd 100644
--- a/types/parcel-bundler/index.d.ts
+++ b/types/parcel-bundler/index.d.ts
@@ -168,6 +168,10 @@ declare class ParcelBundler {
         options?: ParcelBundler.ParcelOptions
     );
 
+    addAssetType(extension: string, path: string): void;
+
+    addPackager(type: string, packager: string): void;
+
     bundle(): Promise<ParcelBundler.ParcelBundle>;
 }
 
diff --git a/types/parcel-bundler/parcel-bundler-tests.ts b/types/parcel-bundler/parcel-bundler-tests.ts
index 06a0b5a604..5833b8527b 100644
--- a/types/parcel-bundler/parcel-bundler-tests.ts
+++ b/types/parcel-bundler/parcel-bundler-tests.ts
@@ -6,4 +6,8 @@ const files = ["./index.d.ts"];
 
 const bundler = new ParcelBundler(files, parcelOption);
 
+bundler.addAssetType('md', 'markdown-asset');
+
+bundler.addPackager('md', 'markdown-packager');
+
 bundler.bundle().then(bundle => bundle.name);
diff --git a/types/passport-azure-ad/tslint.json b/types/passport-azure-ad/tslint.json
index 3db14f85ea..95d5bcf169 100644
--- a/types/passport-azure-ad/tslint.json
+++ b/types/passport-azure-ad/tslint.json
@@ -1 +1,13 @@
-{ "extends": "dtslint/dt.json" }
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        // TODOs
+        "array-type": false,
+        "ban-types": false,
+        "callable-types": false,
+        "eofline": false,
+        "interface-name": false,
+        "jsdoc-format": false,
+        "no-trailing-whitespace": false
+    }
+}
diff --git a/types/passport-oauth2/index.d.ts b/types/passport-oauth2/index.d.ts
index 7d7f3de21d..d985852bd6 100644
--- a/types/passport-oauth2/index.d.ts
+++ b/types/passport-oauth2/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/jaredhanson/passport-oauth2#readme
 // Definitions by: Pasi Eronen <https://github.com/pasieronen>
 //                 Wang Zishi <https://github.com/WangZishi>
+//                 Eduardo AC <https://github.com/EduardoAC>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
diff --git a/types/passport-oauth2/passport-oauth2-tests.ts b/types/passport-oauth2/passport-oauth2-tests.ts
index 6a5d09ef27..864b2cb9d6 100644
--- a/types/passport-oauth2/passport-oauth2-tests.ts
+++ b/types/passport-oauth2/passport-oauth2-tests.ts
@@ -51,6 +51,8 @@ const err3 = new InternalOAuthError('Hello', {});
 
 class MyStrategy extends OAuth2Strategy {
     useProtectedProperty() {
-        this._oauth2.get('http://www.example.com/profile', 'token', 'http://www.example.com/callback');
+        this._oauth2.get('http://www.example.com/profile', 'token', err => err.statusCode);
+        this._oauth2.get('http://www.example.com/profile', 'token', (err, result) => result);
+        this._oauth2.get('http://www.example.com/profile', 'token', (err, result, response) => response);
     }
 }
diff --git a/types/pixi.js/index.d.ts b/types/pixi.js/index.d.ts
index 17913f4903..985e1a77c0 100644
--- a/types/pixi.js/index.d.ts
+++ b/types/pixi.js/index.d.ts
@@ -261,7 +261,7 @@ declare namespace PIXI {
 
         getRectangle(rect?: Rectangle): Rectangle;
         addPoint(point: Point): void;
-        addQuad(vertices: number[]): Bounds | undefined;
+        addQuad(vertices: ArrayLike<number>): Bounds | undefined;
         addFrame(
             transform: Transform,
             x0: number,
@@ -271,7 +271,7 @@ declare namespace PIXI {
         ): void;
         addVertices(
             transform: Transform,
-            vertices: number[],
+            vertices: ArrayLike<number>,
             beginOffset: number,
             endOffset: number
         ): void;
@@ -289,9 +289,7 @@ declare namespace PIXI {
         height: number;
 
         protected onChildrenChange: (...args: any[]) => void;
-        addChild<T extends DisplayObject>(
-            ...children: T[]
-        ): T;
+        addChild<T extends DisplayObject>(...children: T[]): T;
         addChildAt<T extends DisplayObject>(child: T, index: number): T;
         swapChildren(child: DisplayObject, child2: DisplayObject): void;
         getChildIndex(child: DisplayObject): number;
@@ -608,6 +606,7 @@ declare namespace PIXI {
         boundsPadding: number;
         protected _localBounds: Bounds;
         dirty: number;
+        canvasTintDirty: number;
         fastRectDirty: number;
         clearDirty: number;
         boundsDirty: number;
@@ -869,6 +868,8 @@ declare namespace PIXI {
     }
     class ObservablePoint extends PointLike {
         constructor(cb: () => any, scope?: any, x?: number, y?: number);
+        clone(cb?: Function, scope?: any): ObservablePoint;
+        equals(p: Point | ObservablePoint | PointLike): boolean;
         cb: () => any;
         scope: any;
     }
@@ -1148,7 +1149,7 @@ declare namespace PIXI {
             displayObject: PIXI.DisplayObject,
             renderTexture?: PIXI.RenderTexture,
             clear?: boolean,
-            transform?: PIXI.Transform,
+            transform?: PIXI.Matrix,
             skipUpdateTransform?: boolean
         ): void;
         setBlendMode(blendMode: number): void;
@@ -1267,7 +1268,7 @@ declare namespace PIXI {
             displayObject: PIXI.DisplayObject,
             renderTexture?: PIXI.RenderTexture,
             clear?: boolean,
-            transform?: PIXI.Transform,
+            transform?: PIXI.Matrix,
             skipUpdateTransform?: boolean
         ): void;
         setObjectRenderer(objectRenderer: ObjectRenderer): void;
@@ -1281,7 +1282,7 @@ declare namespace PIXI {
         ): WebGLRenderer;
         bindRenderTexture(
             renderTexture: RenderTexture,
-            transform: Transform
+            transform: Matrix
         ): WebGLRenderer;
         bindRenderTarget(renderTarget: RenderTarget): WebGLRenderer;
         bindShader(shader: Shader, autoProject?: boolean): WebGLRenderer;
@@ -2162,7 +2163,8 @@ declare namespace PIXI {
             frame?: Rectangle,
             orig?: Rectangle,
             trim?: Rectangle,
-            rotate?: number
+            rotate?: number,
+            anchor?: Point
         );
 
         noFrame: boolean;
@@ -2173,6 +2175,7 @@ declare namespace PIXI {
         requiresUpdate: boolean;
         protected _uvs: TextureUvs;
         orig: Rectangle;
+        defaultAnchor: Point;
         protected _updateID: number;
         transform: TextureMatrix;
         textureCacheIds: string[];
@@ -2198,9 +2201,16 @@ declare namespace PIXI {
         ): Texture;
         static fromVideo(
             video: HTMLVideoElement | string,
-            scaleMode?: number
+            scaleMode?: number,
+            crossorigin?: boolean,
+            autoPlay?: boolean
+        ): Texture;
+        static fromVideoUrl(
+            videoUrl: string,
+            scaleMode?: number,
+            crossorigin?: boolean,
+            autoPlay?: boolean
         ): Texture;
-        static fromVideoUrl(videoUrl: string, scaleMode?: number): Texture;
         static from(
             source:
                 | number
@@ -2304,6 +2314,7 @@ declare namespace PIXI {
         );
 
         baseTexture: BaseTexture;
+        animations: { [key: string]: Texture };
         textures: { [key: string]: Texture };
         data: any;
         resolution: number;
@@ -2323,12 +2334,17 @@ declare namespace PIXI {
         ): void;
         protected _processFrames(initialFrameIndex: number): void;
         protected _parseComplete(): void;
+        protected _processAnimations(): void;
         protected _nextBatch(): void;
         destroy(destroyBase?: boolean): void;
     }
 
     class VideoBaseTexture extends BaseTexture {
-        constructor(source: HTMLVideoElement, scaleMode?: number);
+        constructor(
+            source: HTMLVideoElement,
+            scaleMode?: number,
+            autoPlay?: boolean
+        );
 
         autoUpdate: boolean;
         autoPlay: boolean;
@@ -2344,11 +2360,13 @@ declare namespace PIXI {
 
         static fromVideo(
             video: HTMLVideoElement,
-            scaleMode?: number
+            scaleMode?: number,
+            autoPlay?: boolean
         ): VideoBaseTexture;
         static fromUrl(
             videoSrc: string | any | string[] | any[],
-            crossOrigin?: boolean
+            crossorigin?: boolean,
+            autoPlay?: boolean
         ): VideoBaseTexture;
         static fromUrls(
             videoSrc: string | any | string[] | any[]
diff --git a/types/playcanvas/index.d.ts b/types/playcanvas/index.d.ts
index 24fe7ec6ee..fd3fbbcfbc 100644
--- a/types/playcanvas/index.d.ts
+++ b/types/playcanvas/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/playcanvas/engine
 // Definitions by: Philippe Vaillancourt <https://github.com/Neoflash1979>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 /// <reference types="webvr-api" />
 /// <reference path="./engine/scriptype.d.ts" />
diff --git a/types/playcanvas/tslint.json b/types/playcanvas/tslint.json
index 3db14f85ea..a2bb521763 100644
--- a/types/playcanvas/tslint.json
+++ b/types/playcanvas/tslint.json
@@ -1 +1,26 @@
-{ "extends": "dtslint/dt.json" }
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        // All are TODOs
+        "array-type": false,
+        "ban-types": false,
+        "eofline": false,
+        "interface-over-type-literal": false,
+        "jsdoc-format": false,
+        "max-line-length": false,
+        "member-access": false,
+        "no-consecutive-blank-lines": false,
+        "no-padding": false,
+        "no-redundant-jsdoc-2": false,
+        "no-trailing-whitespace": false,
+        "no-unnecessary-class": false,
+        "no-unnecessary-generics": false,
+        "no-unnecessary-qualifier": false,
+        "no-var-keyword": false,
+        "semicolon": false,
+        "space-before-function-paren": false,
+        "strict-export-declare-modifiers": false,
+        "unified-signatures": false,
+        "void-return": false
+    }
+}
diff --git a/types/proj4leaflet/tsconfig.json b/types/proj4leaflet/tsconfig.json
index 697b96a93a..4b2115dd9d 100644
--- a/types/proj4leaflet/tsconfig.json
+++ b/types/proj4leaflet/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/prosemirror-schema-basic/tsconfig.json b/types/prosemirror-schema-basic/tsconfig.json
index 44a2b36f28..ee4a9ce7fb 100644
--- a/types/prosemirror-schema-basic/tsconfig.json
+++ b/types/prosemirror-schema-basic/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/prosemirror-schema-list/tsconfig.json b/types/prosemirror-schema-list/tsconfig.json
index 3bc76fb24f..294d13e9a6 100644
--- a/types/prosemirror-schema-list/tsconfig.json
+++ b/types/prosemirror-schema-list/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/pumpify/tsconfig.json b/types/pumpify/tsconfig.json
index c616e0e309..2ecb43cc87 100644
--- a/types/pumpify/tsconfig.json
+++ b/types/pumpify/tsconfig.json
@@ -2,7 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es5"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/raven-for-redux/tsconfig.json b/types/raven-for-redux/tsconfig.json
index acd330dac5..87b3d6d78c 100644
--- a/types/raven-for-redux/tsconfig.json
+++ b/types/raven-for-redux/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-bootstrap/tslint.json b/types/react-bootstrap/tslint.json
index b2ecae2fd2..d974e7aa9a 100644
--- a/types/react-bootstrap/tslint.json
+++ b/types/react-bootstrap/tslint.json
@@ -1,7 +1,21 @@
 {
   "extends": "dtslint/dt.json",
   "rules": {
-    // TODO
-    "no-duplicate-imports": false
+    // All are TODOs
+    "ban-types": false,
+    "callable-types": false,
+    "jsdoc-format": false,
+    "member-access": false,
+    "no-consecutive-blank-lines": false,
+    "no-duplicate-imports": false,
+    "no-padding": false,
+    "no-self-import": false,
+    "no-unnecessary-qualifier": false,
+    "semicolon": false,
+    "space-within-parens": false,
+    "strict-export-declare-modifiers": false,
+    "trim-file": false,
+    "typedef-whitespace": false,
+    "whitespace": false
   }
 }
diff --git a/types/react-breadcrumbs/index.d.ts b/types/react-breadcrumbs/index.d.ts
index 3aa1cc3670..db70d210fb 100644
--- a/types/react-breadcrumbs/index.d.ts
+++ b/types/react-breadcrumbs/index.d.ts
@@ -1,34 +1,28 @@
-// Type definitions for react-breadcrumbs 1.3
+// Type definitions for react-breadcrumbs 2.1
 // Project: https://github.com/svenanders/react-breadcrumbs
-// Definitions by: Kostya Esmukov <https://github.com/KostyaEsmukov>
+// Definitions by: Guo Yunhe <https://github.com/guoyunhe>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.8
 
 import * as React from "react";
-import * as ReactRouter from "react-router";
+import { LocationDescriptor } from "history";
 
-export = Breadcrumbs;
-type Breadcrumbs = React.ComponentClass<Breadcrumbs.Props>;
-declare const Breadcrumbs: Breadcrumbs;
+declare module "react-breadcrumbs" {
+    interface Crumbs {}
 
-declare namespace Breadcrumbs {
-    interface Props extends React.ClassAttributes<Breadcrumbs> {
-        separator?: string | JSX.Element;
-        displayMissing?: boolean;
-        prettify?: boolean;
-        displayMissingText?: string;
-        displayName?: string;
-        breadcrumbName?: string;
-        wrapperElement?: string;
-        wrapperClass?: string;
-        itemElement?: string;
-        itemClass?: string;
-        customClass?: string;
-        activeItemClass?: string;
-        excludes?: string[];
-        hideNoPath?: boolean;
-        routes: ReactRouter.Router.RouteConfig;
-        setDocumentTitle?: boolean;
-        params?: any;  // todo make it compatible with params of the ReactRouter.RouteComponentProps<P, R>
+    interface BreadcrumbsProps {
+        className?: string;
+        hidden?: boolean;
+        setCrumbs?: (crumbs: Crumbs) => React.ReactNode;
+        wrapper?: React.StatelessComponent | React.ComponentClass;
     }
+
+    class Breadcrumbs extends React.Component<BreadcrumbsProps> {}
+
+    interface BreadcrumbProps {
+        data: LocationDescriptor & { title?: React.ReactNode };
+        hidden?: boolean;
+    }
+
+    class Breadcrumb extends React.Component<BreadcrumbProps> {}
 }
diff --git a/types/react-breadcrumbs/react-breadcrumbs-tests.tsx b/types/react-breadcrumbs/react-breadcrumbs-tests.tsx
index 980b27fe41..fbf0edcdfa 100644
--- a/types/react-breadcrumbs/react-breadcrumbs-tests.tsx
+++ b/types/react-breadcrumbs/react-breadcrumbs-tests.tsx
@@ -1,18 +1,35 @@
-import * as React from 'react';
-import * as ReactRouter from "react-router";
-import Breadcrumbs = require('react-breadcrumbs');
+import * as React from "react";
+import { Breadcrumbs, Breadcrumb } from "react-breadcrumbs";
 
-interface MyComponentProps extends ReactRouter.RouteComponentProps<{}, { id: number }> {
+class Wrapper extends React.Component {
+    render() {
+        return <div>{this.props.children}</div>;
+    }
 }
 
-class MyComponent extends React.Component<MyComponentProps> {
+function FunctionWrapper(props: { children?: React.ReactNode }) {
+    return <div>{props.children}</div>;
+}
+
+class MyComponent extends React.Component {
     render() {
         return (
             <div>
                 <Breadcrumbs
-                    routes={this.props.routes}
-                    params={this.props.params}
+                    className="demo__crumbs"
+                    hidden
+                    setCrumbs={crumbs => null}
+                    wrapper={Wrapper}
                 />
+
+                <Breadcrumbs
+                    className="demo__crumbs"
+                    wrapper={FunctionWrapper}
+                />
+
+                <Breadcrumb data={{ title: "Dashboard", pathname: "/" }} />
+
+                <Breadcrumb data={{ pathname: "/dashboard" }} hidden />
             </div>
         );
     }
diff --git a/types/react-breadcrumbs/tsconfig.json b/types/react-breadcrumbs/tsconfig.json
index 15b3328f6b..94aec8fcc1 100644
--- a/types/react-breadcrumbs/tsconfig.json
+++ b/types/react-breadcrumbs/tsconfig.json
@@ -10,14 +10,6 @@
         "strictNullChecks": false,
         "strictFunctionTypes": true,
         "baseUrl": "../",
-        "paths": {
-            "history": [
-                "history/v2"
-            ],
-            "react-router": [
-                "react-router/v2"
-            ]
-        },
         "typeRoots": [
             "../"
         ],
@@ -30,4 +22,4 @@
         "index.d.ts",
         "react-breadcrumbs-tests.tsx"
     ]
-}
\ No newline at end of file
+}
diff --git a/types/react-close-on-escape/index.d.ts b/types/react-close-on-escape/index.d.ts
new file mode 100644
index 0000000000..2718cbcd82
--- /dev/null
+++ b/types/react-close-on-escape/index.d.ts
@@ -0,0 +1,16 @@
+// Type definitions for react-close-on-escape 3.0
+// Project: https://github.com/conorhastings/react-close-on-escape#readme
+// Definitions by: Robert Baruck <https://github.com/JamesAlias>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+import * as React from "react";
+
+export interface CloseOnEscapeProps {
+    /**
+     * Callback triggered by pressing ESC
+     */
+    onEscape(): void;
+}
+
+export default class CloseOnEscape extends React.Component<CloseOnEscapeProps> {}
diff --git a/types/react-close-on-escape/react-close-on-escape-tests.tsx b/types/react-close-on-escape/react-close-on-escape-tests.tsx
new file mode 100644
index 0000000000..d86909034e
--- /dev/null
+++ b/types/react-close-on-escape/react-close-on-escape-tests.tsx
@@ -0,0 +1,12 @@
+import * as React from 'react';
+import CloseOnEscape from 'react-close-on-escape';
+
+const onEscapeCallback = () => {};
+
+// $ExpectError
+const missingRequired = <CloseOnEscape />;
+
+// $ExpectError
+const invalidExample = <CloseOnEscape onEscape={true} />;
+
+const validExample = <CloseOnEscape onEscape={onEscapeCallback} />;
diff --git a/types/react-close-on-escape/tsconfig.json b/types/react-close-on-escape/tsconfig.json
new file mode 100644
index 0000000000..5a978970ff
--- /dev/null
+++ b/types/react-close-on-escape/tsconfig.json
@@ -0,0 +1,25 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true,
+        "lib": [
+            "es6"
+        ],
+        "jsx": "react"
+    },
+    "files": [
+        "index.d.ts",
+        "react-close-on-escape-tests.tsx"
+    ]
+}
diff --git a/types/react-close-on-escape/tslint.json b/types/react-close-on-escape/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/react-close-on-escape/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/react-countup/index.d.ts b/types/react-countup/index.d.ts
new file mode 100644
index 0000000000..cae8139054
--- /dev/null
+++ b/types/react-countup/index.d.ts
@@ -0,0 +1,65 @@
+// Type definitions for react-countup 4.0
+// Project: https://react-countup.now.sh
+// Definitions by: Daniel Brodin <https://github.com/danielbrodin>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+import * as React from "react";
+
+export as namespace ReactCountUp;
+
+export = ReactCountUp;
+
+declare namespace ReactCountUp {
+    interface RenderProps {
+        countUpRef: React.RefObject<any>;
+        pauseResume(): void;
+        reset(): void;
+        start(): void;
+        update(newEnd?: number): void;
+    }
+
+    interface Props {
+        className?: string;
+        decimal?: string;
+        decimals?: number;
+        delay?: number;
+        duration?: number;
+        end?: number;
+        prefix?: string;
+        redraw?: boolean;
+        separator?: string;
+        start?: number;
+        suffix?: string;
+        useEasing?: boolean;
+        easingFn?(t: number, b: number, c: number, d: number): void;
+        formattingFn?(value: number): string;
+        onComplete?(): void;
+        onEnd?(providedFn: {
+            pauseResume(): void;
+            reset(): void;
+            start(): void;
+            update(): void;
+        }): void;
+        onStart?(providedFn: {
+            pauseResume(): void;
+            reset(): void;
+            update(): void;
+        }): void;
+        onPauseResume?(): (
+            providedFn: { reset(): void; start(): void; update(): void }
+        ) => void;
+        onReset?(): (
+            providedFn: { pauseResume(): void; start(): void; update(): void }
+        ) => void;
+        onUpdate?(providedFn: {
+            pauseResume(): void;
+            reset(): void;
+            start(): void;
+        }): void;
+        style?: React.CSSProperties;
+        children?(data: RenderProps): React.ReactElement<any>;
+    }
+}
+
+declare class ReactCountUp extends React.PureComponent<ReactCountUp.Props> {}
diff --git a/types/react-countup/react-countup-tests.tsx b/types/react-countup/react-countup-tests.tsx
new file mode 100644
index 0000000000..7e27b504b1
--- /dev/null
+++ b/types/react-countup/react-countup-tests.tsx
@@ -0,0 +1,17 @@
+import * as React from "react";
+import * as CountUp from "react-countup";
+
+export class Test extends React.Component<any> {
+    render() {
+        return (
+            <CountUp start={0} end={100}>
+                {({ countUpRef, start }) => (
+                    <div>
+                        <span ref={countUpRef} />
+                        <button onClick={start}>Start</button>
+                    </div>
+                )}
+            </CountUp>
+        );
+    }
+}
diff --git a/types/react-countup/tsconfig.json b/types/react-countup/tsconfig.json
new file mode 100644
index 0000000000..fb359d894c
--- /dev/null
+++ b/types/react-countup/tsconfig.json
@@ -0,0 +1,25 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "jsx": "react",
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "react-countup-tests.tsx"
+    ]
+}
diff --git a/types/react-countup/tslint.json b/types/react-countup/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/react-countup/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/react-draft-wysiwyg/index.d.ts b/types/react-draft-wysiwyg/index.d.ts
new file mode 100644
index 0000000000..a5c6e07065
--- /dev/null
+++ b/types/react-draft-wysiwyg/index.d.ts
@@ -0,0 +1,74 @@
+// Type definitions for react-draft-wysiwyg 1.12
+// Project: https://github.com/jpuri/react-draft-wysiwyg#readme
+// Definitions by: imechZhangLY <https://github.com/imechZhangLY>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+import * as React from 'react';
+import * as Draft from 'draft-js';
+
+export type SyntheticKeyboardEvent = React.KeyboardEvent<{}>;
+export type SyntheticEvent = React.SyntheticEvent<{}>;
+export type RawDraftContentState = Draft.RawDraftContentState;
+
+export class EditorState extends Draft.EditorState {}
+export class ContentState extends Draft.ContentState {}
+export class ContentBlock extends Draft.ContentBlock {}
+export class SelectionState extends Draft.SelectionState {}
+
+export interface EditorProps {
+    onChange?(contentState: ContentState): RawDraftContentState;
+    onEditorStateChange?(editorState: EditorState): void;
+    onContentStateChange?(contentState: ContentState): RawDraftContentState;
+    initialContentState?: RawDraftContentState;
+    defaultContentState?: RawDraftContentState;
+    contentState?: RawDraftContentState;
+    editorState?: EditorState;
+    defaultEditorState?: EditorState;
+    toolbarOnFocus?: boolean;
+    spellCheck?: boolean;
+    stripPastedStyles?: boolean;
+    toolbar?: object;
+    toolbarCustomButtons?: Array<React.ReactElement<HTMLElement>>;
+    toolbarClassName?: string;
+    toolbarHidden?: boolean;
+    locale?: string;
+    localization?: object;
+    editorClassName?: string;
+    wrapperClassName?: string;
+    toolbarStyle?: object;
+    editorStyle?: React.CSSProperties;
+    wrapperStyle?: React.CSSProperties;
+    uploadCallback?(file: object): Promise<object>;
+    onFocus?(event: SyntheticEvent): void;
+    onBlur?(event: SyntheticEvent): void;
+    onTab?(event: SyntheticKeyboardEvent): void;
+    onEscape?(e: SyntheticKeyboardEvent): void;
+    onUpArrow?(e: SyntheticKeyboardEvent): void;
+    onDownArrow?(e: SyntheticKeyboardEvent): void;
+    onRightArrow?(e: SyntheticKeyboardEvent): void;
+    onLeftArrow?(e: SyntheticKeyboardEvent): void;
+    mention?: object;
+    hashtag?: object;
+    textAlignment?: string;
+    readonly?: boolean;
+    tabIndex?: number;
+    placeholder?: string;
+    ariaLabel?: string;
+    ariaOwneeID?: string;
+    ariaActiveDescendantID?: string;
+    ariaAutoComplete?: string;
+    ariaDescribedBy?: string;
+    ariaExpanded?: string;
+    ariaHasPopup?: string;
+    customBlockRenderFunc?(block: ContentBlock): any;
+    wrapperId?: number;
+    customDecorators?: object[];
+    editorRef?(ref: object): void;
+    handlePastedText?(text: string, html: string, editorState: EditorState, onChange: (editorState: EditorState) => void): boolean;
+}
+
+export class Editor extends React.Component<EditorProps> {
+    constructor(props: Readonly<EditorProps>);
+    focusEditor(): void;
+}
diff --git a/types/react-draft-wysiwyg/test/basic-content-state-tests.tsx b/types/react-draft-wysiwyg/test/basic-content-state-tests.tsx
new file mode 100644
index 0000000000..5693ff2584
--- /dev/null
+++ b/types/react-draft-wysiwyg/test/basic-content-state-tests.tsx
@@ -0,0 +1,42 @@
+// From https://github.com/jpuri/react-draft-wysiwyg/blob/master/stories/
+
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import { Editor, RawDraftContentState } from 'react-draft-wysiwyg';
+
+class BasicContentState extends React.Component<{}, {contentState: RawDraftContentState}> {
+    constructor(props: any) {
+        super(props);
+        this.state = {
+            contentState: JSON
+                .parse(`{
+                    "entityMap":{},
+                    "blocks":[{
+                        "key":"1ljs",
+                        "text":"Initializing from content state",
+                        "type":"unstyled",
+                        "depth":0,
+                        "inlineStyleRanges":[],
+                        "entityRanges":[],
+                        "data":{}
+                    }]
+                }`)
+        };
+    }
+
+    render() {
+        const {contentState} = this.state;
+        return (<div>
+            <span>Content state is JSON
+                <pre>
+                {'{"entityMap":{},"blocks":[{"key":"1ljs","text":"Initializing from content state","type":"unstyled","depth":0,"inlineStyleRanges":[],"entityRanges":[],"data":{}}]}'}
+                </pre>
+            </span>
+            <Editor
+                defaultContentState={contentState}
+            />
+        </div>);
+    }
+}
+
+ReactDOM.render(<BasicContentState />, document.getElementById('target'));
diff --git a/types/react-draft-wysiwyg/test/basic-controlled-tests.tsx b/types/react-draft-wysiwyg/test/basic-controlled-tests.tsx
new file mode 100644
index 0000000000..1b5987d331
--- /dev/null
+++ b/types/react-draft-wysiwyg/test/basic-controlled-tests.tsx
@@ -0,0 +1,30 @@
+// From https://github.com/jpuri/react-draft-wysiwyg/blob/master/stories/
+
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import { Editor, EditorState } from 'react-draft-wysiwyg';
+
+class BasicControlled extends React.Component<{}, {editorState: EditorState}> {
+    constructor(props: any) {
+        super(props);
+        this.state = {
+            editorState: EditorState.createEmpty()
+        };
+    }
+
+    render() {
+        const {editorState} = this.state;
+        return (<div>
+            <Editor
+                editorState={editorState}
+                onEditorStateChange={this.onEditorStateChange}
+            />
+        </div>);
+    }
+
+    onEditorStateChange(editorState: EditorState): void {
+        this.setState({editorState});
+    }
+}
+
+ReactDOM.render(<BasicControlled />, document.getElementById('target'));
diff --git a/types/react-draft-wysiwyg/test/basic-tests.tsx b/types/react-draft-wysiwyg/test/basic-tests.tsx
new file mode 100644
index 0000000000..30121f122a
--- /dev/null
+++ b/types/react-draft-wysiwyg/test/basic-tests.tsx
@@ -0,0 +1,15 @@
+// From https://github.com/jpuri/react-draft-wysiwyg/blob/master/stories/
+
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import { Editor } from 'react-draft-wysiwyg';
+
+const Basic = () => (<div>
+  <Editor
+      ref={(ref: Editor): void => {
+        console.log('hey ref', ref.focusEditor.toString());
+      }}
+  />
+</div>);
+
+ReactDOM.render(<Basic />, document.getElementById('target'));
diff --git a/types/react-draft-wysiwyg/test/custom-toolbar-tests.tsx b/types/react-draft-wysiwyg/test/custom-toolbar-tests.tsx
new file mode 100644
index 0000000000..8dd5662bda
--- /dev/null
+++ b/types/react-draft-wysiwyg/test/custom-toolbar-tests.tsx
@@ -0,0 +1,35 @@
+// From https://github.com/jpuri/react-draft-wysiwyg/blob/master/stories/
+
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import { Editor } from 'react-draft-wysiwyg';
+import { RichUtils } from 'draft-js';
+
+class CustomOption extends React.Component<any, any> {
+    toggleBold(): void {
+        const {editorState, onChange} = this.props;
+        const newState = RichUtils.toggleInlineStyle(
+            editorState,
+            'BOLD',
+        );
+        if (newState) {
+            onChange(newState);
+        }
+    }
+
+    render() {
+        return (
+            <div className="rdw-storybook-custom-option" onClick={this.toggleBold}>B</div>
+        );
+    }
+}
+
+const CustomToolbar = () =>
+    (<div>
+        <h3>Last option marked as B is custom option for making test BOLD.</h3>
+        <Editor
+            toolbarCustomButtons={[<CustomOption />]}
+        />
+    </div>);
+
+ReactDOM.render(<CustomToolbar />, document.getElementById('target'));
diff --git a/types/react-draft-wysiwyg/test/focus-blur-callbacks-tests.tsx b/types/react-draft-wysiwyg/test/focus-blur-callbacks-tests.tsx
new file mode 100644
index 0000000000..d29f7ab073
--- /dev/null
+++ b/types/react-draft-wysiwyg/test/focus-blur-callbacks-tests.tsx
@@ -0,0 +1,42 @@
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import { Editor } from 'react-draft-wysiwyg';
+
+class FocusBlurCallbacks extends React.Component<any, any> {
+    constructor(props: any) {
+        super(props);
+
+        this.state = {
+            state: 'blurred'
+        };
+    }
+
+    onFocus(): void {
+        console.log('into onFocus');
+        this.setState({
+            state: 'focused',
+        });
+    }
+
+    onBlur(): void {
+        console.log('into onBlur');
+        this.setState({
+            state: 'blurred',
+        });
+    }
+
+    render() {
+        const { state } = this.state;
+        return (
+            <div>
+                <h3>State right now <span style={{ color: 'blue' }}>{state}</span></h3>
+                <Editor
+                    onBlur={this.onBlur}
+                    onFocus={this.onFocus}
+                />
+            </div>
+        );
+    }
+}
+
+ReactDOM.render(<FocusBlurCallbacks />, document.getElementById('target'));
diff --git a/types/react-draft-wysiwyg/tsconfig.json b/types/react-draft-wysiwyg/tsconfig.json
new file mode 100644
index 0000000000..35720c1979
--- /dev/null
+++ b/types/react-draft-wysiwyg/tsconfig.json
@@ -0,0 +1,29 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true,
+        "jsx": "preserve"
+    },
+    "files": [
+        "index.d.ts",
+        "test/basic-content-state-tests.tsx",
+        "test/basic-controlled-tests.tsx",
+        "test/basic-tests.tsx",
+        "test/custom-toolbar-tests.tsx",
+        "test/focus-blur-callbacks-tests.tsx"
+    ]
+}
diff --git a/types/react-draft-wysiwyg/tslint.json b/types/react-draft-wysiwyg/tslint.json
new file mode 100644
index 0000000000..6746359dda
--- /dev/null
+++ b/types/react-draft-wysiwyg/tslint.json
@@ -0,0 +1,3 @@
+{ 
+    "extends": "dtslint/dt.json"
+}
diff --git a/types/react-foundation/tslint.json b/types/react-foundation/tslint.json
index 0e4acb22ee..6b376d1fe2 100644
--- a/types/react-foundation/tslint.json
+++ b/types/react-foundation/tslint.json
@@ -1,12 +1,14 @@
 {
   "extends": "dtslint/dt.json",
   "rules": {
+    // All are TODOs
     "strict-export-declare-modifiers": false,
     "no-trailing-whitespace": false,
     "jsdoc-format": false,
     "no-reference-import": false,
     "prefer-declare-function": false,
     "no-duplicate-imports": false,
-    "no-empty-interface": false
+    "no-empty-interface": false,
+    "no-redundant-jsdoc-2": false
   }
 }
diff --git a/types/react-i18next/src/props.d.ts b/types/react-i18next/src/props.d.ts
index 62a201049a..8435a7cc45 100644
--- a/types/react-i18next/src/props.d.ts
+++ b/types/react-i18next/src/props.d.ts
@@ -1,4 +1,4 @@
-import {i18n as I18n, TranslationFunction} from "i18next";
+import { i18n as I18n, TranslationFunction } from "i18next";
 
 /**
  * Extend your component's Prop interface with this one to get access to `this.props.t`
@@ -7,9 +7,9 @@ import {i18n as I18n, TranslationFunction} from "i18next";
  * your own interface just like this one, but with your name of the translation function.
  *
  * interface MyComponentProps extends ReactI18next.InjectedTranslateProps {}
- * 
+ *
  * Then specify the name of the translate function as generic argument
- * 
+ *
  * const translated = translate<string, "_">("view", { translateFuncName: "_" })(YourComponent);
  */
 export interface InjectedTranslateProps {
@@ -20,5 +20,5 @@ export interface InjectedTranslateProps {
  * Extend your component's Prop interface with this one to get access to `this.props.i18n`
  */
 export interface InjectedI18nProps {
-    i18n: I18n
+    i18n: I18n;
 }
diff --git a/types/react-infinite-scroll-component/index.d.ts b/types/react-infinite-scroll-component/index.d.ts
index f43fc50e24..4380c2f11a 100644
--- a/types/react-infinite-scroll-component/index.d.ts
+++ b/types/react-infinite-scroll-component/index.d.ts
@@ -3,6 +3,7 @@
 // Definitions by: Stephanie Roy <https://github.com/sroy3>
 //                 Bartosz Dotryw <https://github.com/burtek>
 //                 David Kevork <https://github.com/davidkevork>
+//                 Joshua R. <https://github.com/JoshuaScript>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.8
 
@@ -30,7 +31,7 @@ declare namespace InfiniteScroll {
         /**
          * This message is shown to the user when he has seen all the records which means he's at the bottom and hasMore is false
          */
-        endMessage: React.ReactNode;
+        endMessage?: React.ReactNode;
 
         /**
          * You can send a loader component to show while the component waits for the next load of data. e.g. <h3>Loading...</h3> or any fancy loader element
diff --git a/types/react-lifecycle-component/package.json b/types/react-lifecycle-component/package.json
index bb0e2b57d2..7f5b19d45b 100644
--- a/types/react-lifecycle-component/package.json
+++ b/types/react-lifecycle-component/package.json
@@ -3,4 +3,4 @@
     "dependencies": {
         "redux": "^4.0.0"
     }
-}
\ No newline at end of file
+}
diff --git a/types/react-mentions/index.d.ts b/types/react-mentions/index.d.ts
new file mode 100644
index 0000000000..ff10bbc013
--- /dev/null
+++ b/types/react-mentions/index.d.ts
@@ -0,0 +1,112 @@
+// Type definitions for react-mentions 2.3
+// Project: https://github.com/signavio/react-mentions
+// Definitions by: Scott Willeke <https://github.com/activescott>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+import * as React from "react";
+
+/**
+ * MentionsInput is the main component rendering the textarea control. It takes one or multiple Mention components as its children.
+ */
+export const MentionsInput: MentionsInputClass;
+
+/**
+ * Each Mention component represents a data source for a specific class of mentionable objects, such as users, template variables, issues, etc.
+ */
+export const Mention: React.SFC<MentionProps>;
+
+/**
+ * The properties for the @see MentionsInput component.
+ */
+export interface MentionsInputProps {
+    /**
+     * If set to `true` a regular text input element will be rendered
+     * instead of a textarea
+     */
+    singleLine?: boolean;
+    /**
+     * If set to `true` spaces will not interrupt matching suggestions
+     */
+    allowSpaceInQuery?: boolean;
+    markup?: string;
+    value?: string;
+    displayTransform?: DisplayTransformFunc;
+    onChange?: OnChangeHandlerFunc;
+    placeholder?: string;
+    onBlur?: (event: React.FocusEvent<HTMLInputElement> | React.FocusEvent<HTMLTextAreaElement>, clickedSuggestion: boolean) => void;
+    onSelect?: (event: React.UIEvent) => void;
+    onKeyDown?: (event: React.KeyboardEvent<HTMLTextAreaElement> | React.KeyboardEvent<HTMLInputElement>) => void;
+    children: React.ReactElement<MentionProps> | Array<React.ReactElement<MentionProps>>;
+    className?: string;
+    style?: any;
+    regex?: RegExp;
+    suggestionsPortalHost?: Element;
+}
+
+/**
+ * Exposes the type for use with the @see MentionsInputComponent.wrappedInstance which is added by react-mentions' use of substyle (https://github.com/jfschwarz/substyle).
+ */
+export interface MentionsInputComponentUnrwapped extends React.Component<MentionsInputProps> {
+    inputRef?: HTMLInputElement | HTMLTextAreaElement;
+}
+
+/**
+ * Used with @see React.RefObject<MentionsInputComponent>.
+ */
+export interface MentionsInputComponent extends React.Component<MentionsInputProps> {
+    // MentionsInput uses substyle (https://github.com/jfschwarz/substyle) which adds this wrappedInstance
+    wrappedInstance?: MentionsInputComponentUnrwapped;
+}
+
+/**
+ * Used to reference MentionsInput element in a TSX file.
+ */
+export interface MentionsInputClass extends React.ComponentClass<MentionsInputProps> {
+}
+
+/**
+ * Props definition for a mention subelement.
+ */
+export interface MentionProps {
+    type?: string;
+    onAdd?: (id: string | number, display: string) => void;
+    renderSuggestion?: (suggestion: SuggestionDataItem, search: string, highlightedDisplay: React.ReactNode, index: number, focused: boolean) => React.ReactNode;
+    className?: string;
+    trigger: string | RegExp;
+    isLoading?: boolean;
+    data: SuggestionDataItem[] | DataFunc;
+    style?: any;
+    appendSpaceOnAdd?: boolean;
+}
+
+/**
+ * The shape of a mention.
+ */
+export interface MentionItem {
+    display: string;
+    id: string;
+    type: null;
+}
+
+/**
+ * The shape of suggestion items.
+ */
+export interface SuggestionDataItem {
+    id: string | number;
+    display: string;
+}
+
+/**
+ * Defines the function signature for implementing @see MentionsInputProps.displayTransform
+ */
+export type DisplayTransformFunc = (id: string, display: string, type: string) => string;
+
+/**
+ * Defines the function signature for implementing @see MentionsInputProps.onChange
+ */
+export type OnChangeHandlerFunc = (event: { target: { value: string } }, newValue: string, newPlainTextValue: string, mentions: MentionItem[]) => void;
+
+/**
+ * The function to implement asynchronous loading of suggestions in @see MentionProps.data .
+ */
+export type DataFunc = (query: string, callback: (data: SuggestionDataItem[]) => void) => void | SuggestionDataItem[];
diff --git a/types/react-mentions/lib/utils.d.ts b/types/react-mentions/lib/utils.d.ts
new file mode 100644
index 0000000000..ab0d1e7aed
--- /dev/null
+++ b/types/react-mentions/lib/utils.d.ts
@@ -0,0 +1,17 @@
+import { DisplayTransformFunc } from "../";
+
+/**
+ * For the passed character index in the plain text string, returns the corresponding index in the marked up value string.
+ * If the passed character index lies inside a mention, the value of `inMarkupCorrection` defines the correction to apply:
+ * - 'START' to return the index of the mention markup's first char (default)
+ * - 'END' to return the index after its last char
+ * - 'NULL' to return null
+ */
+export function mapPlainTextIndex(
+    value: string,
+    markup: string,
+    indexInPlainText: number,
+    inMarkupCorrection: string,
+    displayTransform: DisplayTransformFunc,
+    regex: RegExp
+): number;
diff --git a/types/react-mentions/react-mentions-tests.tsx b/types/react-mentions/react-mentions-tests.tsx
new file mode 100644
index 0000000000..49f5180720
--- /dev/null
+++ b/types/react-mentions/react-mentions-tests.tsx
@@ -0,0 +1,60 @@
+import * as React from "react";
+import { MentionsInput, Mention, SuggestionDataItem } from "react-mentions";
+import { mapPlainTextIndex } from "react-mentions/lib/utils";
+
+interface TestProps {
+    data: SuggestionDataItem[];
+    value?: string;
+    onChange?: () => void;
+    onAdd?: () => void;
+    regex: RegExp;
+}
+
+export const TestSimple: React.SFC<TestProps> = (props) => {
+    return (
+        <MentionsInput
+            value={props.value}
+            onChange={props.onChange}
+            placeholder={"Mention people using '@'"}
+            displayTransform={login => `@${login}`}
+        >
+        <Mention
+            trigger="@"
+            data={props.data}
+            onAdd={props.onAdd}
+        />
+        </MentionsInput>
+    );
+};
+
+export const TestMultipleTrigger: React.SFC<TestProps> = (props) => {
+    return (
+        <MentionsInput
+            value={props.value}
+            onChange={props.onChange}
+            markup="@[__display__](__type__:__id__)"
+            placeholder={"Mention people using '@'"}
+        >
+            <Mention
+                type="user"
+                trigger="@"
+                data={props.data}
+                renderSuggestion={(suggestion: SuggestionDataItem, search: string, highlightedDisplay: React.ReactNode, index: number, focused: boolean) => (
+                    <div className={`user ${focused ? 'focused' : ''}`}>
+                    {highlightedDisplay}
+                    </div>
+                )}
+                onAdd={props.onAdd}
+            />
+
+            <Mention
+                type="email"
+                trigger={props.regex}
+                data={search => [{ id: search, display: search }]}
+                onAdd={props.onAdd}
+            />
+        </MentionsInput>
+    );
+};
+
+mapPlainTextIndex("foo", "bar", 1, "NULL", login => `@${login}`, /.*/); // $ExpectType number
diff --git a/types/react-mentions/tsconfig.json b/types/react-mentions/tsconfig.json
new file mode 100644
index 0000000000..260c003e2d
--- /dev/null
+++ b/types/react-mentions/tsconfig.json
@@ -0,0 +1,25 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true,
+        "jsx": "react"
+    },
+    "files": [
+        "index.d.ts",
+        "lib/utils.d.ts",
+        "react-mentions-tests.tsx"
+    ]
+}
diff --git a/types/react-mentions/tslint.json b/types/react-mentions/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/react-mentions/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/react-native-bluetooth-serial/tsconfig.json b/types/react-native-bluetooth-serial/tsconfig.json
index 213f3fd025..80b4865dd3 100644
--- a/types/react-native-bluetooth-serial/tsconfig.json
+++ b/types/react-native-bluetooth-serial/tsconfig.json
@@ -1,10 +1,7 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": [
-            "es6",
-            "dom"
-        ],
+        "lib": ["es6"],
         "noImplicitAny": true,
         "noImplicitThis": true,
         "strictNullChecks": true,
diff --git a/types/react-native-datepicker/tsconfig.json b/types/react-native-datepicker/tsconfig.json
index b1dd56e20d..875993fd09 100644
--- a/types/react-native-datepicker/tsconfig.json
+++ b/types/react-native-datepicker/tsconfig.json
@@ -1,10 +1,7 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": [
-            "es6",
-            "dom"
-        ],
+        "lib": ["es6"],
         "noImplicitAny": true,
         "noImplicitThis": true,
         "strictNullChecks": true,
diff --git a/types/react-native-doc-viewer/tsconfig.json b/types/react-native-doc-viewer/tsconfig.json
index 86d578084a..e49d63b19e 100644
--- a/types/react-native-doc-viewer/tsconfig.json
+++ b/types/react-native-doc-viewer/tsconfig.json
@@ -1,10 +1,7 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": [
-            "es6",
-            "dom"
-        ],
+        "lib": ["es6"],
         "noImplicitAny": true,
         "noImplicitThis": true,
         "strictNullChecks": true,
diff --git a/types/react-native-drawer-layout/tsconfig.json b/types/react-native-drawer-layout/tsconfig.json
index a0d6721b68..acad3b04bc 100644
--- a/types/react-native-drawer-layout/tsconfig.json
+++ b/types/react-native-drawer-layout/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-drawer/tsconfig.json b/types/react-native-drawer/tsconfig.json
index 1617e4715b..2624c7bb76 100644
--- a/types/react-native-drawer/tsconfig.json
+++ b/types/react-native-drawer/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-fbsdk/react-native-fbsdk-tests.tsx b/types/react-native-fbsdk/react-native-fbsdk-tests.tsx
index 7d1210f06a..5d4abb0117 100644
--- a/types/react-native-fbsdk/react-native-fbsdk-tests.tsx
+++ b/types/react-native-fbsdk/react-native-fbsdk-tests.tsx
@@ -2,6 +2,8 @@ import * as React from 'react';
 import * as FBSDK from 'react-native-fbsdk';
 import { View } from 'react-native';
 
+declare function alert(s: string): void;
+
 const {
     LoginButton,
     AccessToken,
diff --git a/types/react-native-fbsdk/tsconfig.json b/types/react-native-fbsdk/tsconfig.json
index 0eae296778..e01b522313 100644
--- a/types/react-native-fbsdk/tsconfig.json
+++ b/types/react-native-fbsdk/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-fs/tsconfig.json b/types/react-native-fs/tsconfig.json
index f491bb6a7a..5e4ae5b88a 100644
--- a/types/react-native-fs/tsconfig.json
+++ b/types/react-native-fs/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-google-signin/index.d.ts b/types/react-native-google-signin/index.d.ts
index 8bb895ce90..a114a06882 100644
--- a/types/react-native-google-signin/index.d.ts
+++ b/types/react-native-google-signin/index.d.ts
@@ -1,7 +1,8 @@
-// Type definitions for react-native-google-signin 0.13
+// Type definitions for react-native-google-signin 1.0
 // Project: https://github.com/devfd/react-native-google-signin
 // Definitions by: Jacob Froman <https://github.com/j-fro>
 //                 Michele Bombardi <https://github.com/bm-software>
+//                 Christian Chown <https://github.com/christianchown>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.8
 
@@ -11,6 +12,7 @@ import { ViewProps } from 'react-native';
 export interface GoogleSigninButtonProps extends ViewProps {
     size?: GoogleSigninButton.Size;
     color?: GoogleSigninButton.Color;
+    disabled?: boolean;
     onPress?(): void;
 }
 
@@ -33,10 +35,11 @@ export namespace GoogleSigninButton {
 
 export interface HasPlayServicesParams {
     /**
-     * When autoresolve is true, the user will be prompted to install Play
-     * Services if on Android and they are not installed.
+     * When showPlayServicesUpdateDialog is true, the user will be prompted to
+     * install Play Services if on Android and they are not installed.
+     * Default is true
      */
-    autoResolve?: boolean;
+    showPlayServicesUpdateDialog?: boolean;
 }
 
 export interface ConfigureParams {
@@ -45,11 +48,6 @@ export interface ConfigureParams {
      */
     scopes?: string[];
 
-    /**
-     * iOS client ID from Developer Console. Required for iOS.
-     */
-    iosClientId?: string;
-
     /**
      * Web client ID from Developer Console. Required for offline access
      */
@@ -78,22 +76,21 @@ export interface ConfigureParams {
 }
 
 export interface User {
-    id: string | null;
-    name: string | null;
-    email: string | null;
+    user: {
+        id: string | null;
+        name: string | null;
+        email: string | null;
+        photo: string | null;
+        familyName: string | null;
+        givenName: string | null;
+    };
     scopes?: string[];
-    photo: string | null;
-    familyName: string | null;
-    givenName: string | null;
     idToken: string | null;
+    accessToken: string | null;
     /**
-     * IOS ONLY. Use getAccessToken() on Android
+     * Deprecated
      */
-    accessToken: string;
-    /**
-     * IOS ONLY. Use getAccessToken() on Android
-     */
-    accessTokenExpirationDate: number;
+    accessTokenExpirationDate: number | null;
     /**
      * Not null only if a valid webClientId and offlineAccess: true was
      * specified in configure().
@@ -111,18 +108,13 @@ export namespace GoogleSignin {
     /**
      * Configures the library for login. MUST be called before attempting login
      */
-    function configure(params?: ConfigureParams): Promise<void>;
+    function configure(params?: ConfigureParams): void;
 
     /**
-     * Returns the current signed in user, or null if not signed in.
-     */
-    function currentUser(): User | null;
-
-    /**
-     * Returns a Promise that resolves with the current signed in user, or null
+     * Returns a Promise that resolves with the current signed in user or rejects
      * if not signed in.
      */
-    function currentUserAsync(): Promise<User | null>;
+    function signInSilently(): Promise<User>;
 
     /**
      * Prompts the user to sign in with their Google account. Resolves with the
@@ -135,20 +127,20 @@ export namespace GoogleSignin {
      */
     function signOut(): Promise<void>;
 
-    /**
-     * ANDROID ONLY. Resolves with the current signed in user's access token.
-     */
-    function getAccessToken(): Promise<string | null>;
-
     /**
      * Removes your application from the user's authorized applications
      */
     function revokeAccess(): Promise<void>;
+
+    /**
+     * Returns whether the user is currently signed in
+     */
+    function isSignedIn(): Promise<boolean>;
 }
 
-export enum StatusCodes {
-    SIGN_IN_CANCELLED = '12501',
-    IN_PROGRESS = 'ASYNC_OP_IN_PROGRESS',
-    PLAY_SERVICES_NOT_AVAILABLE = 'PLAY_SERVICES_NOT_AVAILABLE',
-    SIGN_IN_REQUIRED = '4',
-}
+export const statusCodes: {
+    SIGN_IN_CANCELLED: string;
+    IN_PROGRESS: string;
+    PLAY_SERVICES_NOT_AVAILABLE: string;
+    SIGN_IN_REQUIRED: string;
+};
diff --git a/types/react-native-google-signin/react-native-google-signin-tests.tsx b/types/react-native-google-signin/react-native-google-signin-tests.tsx
index a8de31f0eb..f4f26bcc89 100644
--- a/types/react-native-google-signin/react-native-google-signin-tests.tsx
+++ b/types/react-native-google-signin/react-native-google-signin-tests.tsx
@@ -1,6 +1,6 @@
 import * as React from 'react';
-import { GoogleSignin, GoogleSigninButton, User } from 'react-native-google-signin';
-import { StyleSheet, ViewStyle, View, Text, TouchableHighlight } from 'react-native';
+import { GoogleSignin, GoogleSigninButton, User, statusCodes } from 'react-native-google-signin';
+import { StyleSheet, View, Text, TouchableHighlight } from 'react-native';
 
 interface State {
     user?: User;
@@ -9,15 +9,25 @@ interface State {
 export default class Signin extends React.Component<{}, State> {
     state: State = {};
 
-    componentDidMount() {
+    async componentDidMount() {
         GoogleSignin.configure({
             scopes: ['https://www.googleapis.com/auth/drive.readonly']
-        }).then(() => GoogleSignin.hasPlayServices({ autoResolve: true }));
+        });
+        await GoogleSignin.hasPlayServices({ showPlayServicesUpdateDialog: true });
     }
 
     async handleSigninPress(): Promise<void> {
-        const user = await GoogleSignin.signIn();
-        this.setState({ user });
+        let user;
+        try {
+            user = await GoogleSignin.signInSilently();
+        } catch (error) {
+            if (error.code === statusCodes.SIGN_IN_REQUIRED) {
+                user = await GoogleSignin.signIn();
+            }
+        }
+        if (user) {
+            this.setState({ user });
+        }
     }
 
     handleSignoutPress(): Promise<void> {
@@ -28,7 +38,7 @@ export default class Signin extends React.Component<{}, State> {
         if (this.state.user) {
             return (
                 <View>
-                    <Text>{this.state.user.name}</Text>
+                    <Text>{this.state.user.user.name}</Text>
                     <TouchableHighlight onPress={() => this.handleSignoutPress()}>
                         <Text>Sign Out</Text>
                     </TouchableHighlight>
diff --git a/types/react-native-material-design-searchbar/tsconfig.json b/types/react-native-material-design-searchbar/tsconfig.json
index 41e6dc8bab..ad0e5ff24f 100644
--- a/types/react-native-material-design-searchbar/tsconfig.json
+++ b/types/react-native-material-design-searchbar/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-material-kit/tsconfig.json b/types/react-native-material-kit/tsconfig.json
index f18bd089b8..5ec874cdac 100644
--- a/types/react-native-material-kit/tsconfig.json
+++ b/types/react-native-material-kit/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-material-textfield/tsconfig.json b/types/react-native-material-textfield/tsconfig.json
index b3c2a6ebba..93b14898f2 100644
--- a/types/react-native-material-textfield/tsconfig.json
+++ b/types/react-native-material-textfield/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-material-ui/tsconfig.json b/types/react-native-material-ui/tsconfig.json
index 7c215a4a8b..770ecbe42c 100644
--- a/types/react-native-material-ui/tsconfig.json
+++ b/types/react-native-material-ui/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-modalbox/tsconfig.json b/types/react-native-modalbox/tsconfig.json
index 1c41f2e346..8b996efbab 100644
--- a/types/react-native-modalbox/tsconfig.json
+++ b/types/react-native-modalbox/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-popup-dialog/tsconfig.json b/types/react-native-popup-dialog/tsconfig.json
index f870dbf139..a2cc61cfc5 100644
--- a/types/react-native-popup-dialog/tsconfig.json
+++ b/types/react-native-popup-dialog/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-qrcode/tsconfig.json b/types/react-native-qrcode/tsconfig.json
index b21253194b..3747539935 100644
--- a/types/react-native-qrcode/tsconfig.json
+++ b/types/react-native-qrcode/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-scrollable-tab-view/tsconfig.json b/types/react-native-scrollable-tab-view/tsconfig.json
index 6b88cdde66..cc48436c97 100644
--- a/types/react-native-scrollable-tab-view/tsconfig.json
+++ b/types/react-native-scrollable-tab-view/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-snap-carousel/tsconfig.json b/types/react-native-snap-carousel/tsconfig.json
index 4cba7b2f97..5fb352c2ca 100644
--- a/types/react-native-snap-carousel/tsconfig.json
+++ b/types/react-native-snap-carousel/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-sortable-list/tsconfig.json b/types/react-native-sortable-list/tsconfig.json
index 52474bc36f..a431d58043 100644
--- a/types/react-native-sortable-list/tsconfig.json
+++ b/types/react-native-sortable-list/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-svg-charts/tsconfig.json b/types/react-native-svg-charts/tsconfig.json
index ea66ecf6b7..73c13515f8 100644
--- a/types/react-native-svg-charts/tsconfig.json
+++ b/types/react-native-svg-charts/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-swiper/tsconfig.json b/types/react-native-swiper/tsconfig.json
index 68d1350773..3f5a191dc8 100644
--- a/types/react-native-swiper/tsconfig.json
+++ b/types/react-native-swiper/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-tab-navigator/tsconfig.json b/types/react-native-tab-navigator/tsconfig.json
index b8e913c472..eacb5b77da 100644
--- a/types/react-native-tab-navigator/tsconfig.json
+++ b/types/react-native-tab-navigator/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-text-input-mask/tsconfig.json b/types/react-native-text-input-mask/tsconfig.json
index c9b3f10fc3..812d310366 100644
--- a/types/react-native-text-input-mask/tsconfig.json
+++ b/types/react-native-text-input-mask/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-toast-native/tsconfig.json b/types/react-native-toast-native/tsconfig.json
index 656114c120..e4f36e018d 100644
--- a/types/react-native-toast-native/tsconfig.json
+++ b/types/react-native-toast-native/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-vector-icons/tsconfig.json b/types/react-native-vector-icons/tsconfig.json
index 993aae3195..31ca0d3dce 100644
--- a/types/react-native-vector-icons/tsconfig.json
+++ b/types/react-native-vector-icons/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "dom",
-            "es6"
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native-video/index.d.ts b/types/react-native-video/index.d.ts
index ad1be7a0b4..190d731394 100644
--- a/types/react-native-video/index.d.ts
+++ b/types/react-native-video/index.d.ts
@@ -68,6 +68,7 @@ export interface VideoProperties extends ViewProps {
     currentTime?: number;
     progressUpdateInterval?: number;
     useTextureView?: boolean;
+    allowsExternalPlayback?: boolean;
     onLoadStart?(): void;
     onLoad?(data: OnLoadData): void;
     onBuffer?(): void;
@@ -99,7 +100,7 @@ export interface VideoProperties extends ViewProps {
 }
 
 export default class Video extends React.Component<VideoProperties> {
-    seek(time: number): void;
+    seek(time: number, tolerance?: number): void;
     presentFullscreenPlayer(): void;
     dismissFullscreenPlayer(): void;
 }
diff --git a/types/react-native-video/react-native-video-tests.tsx b/types/react-native-video/react-native-video-tests.tsx
index c6fb3cd955..2df7edfccd 100644
--- a/types/react-native-video/react-native-video-tests.tsx
+++ b/types/react-native-video/react-native-video-tests.tsx
@@ -1,67 +1,12 @@
 import * as React from 'react';
-import {
-    StyleSheet,
-    Text,
-    View,
-    ViewStyle
-} from 'react-native';
 import Video from 'react-native-video';
 
-class VideoTest extends React.Component {
-    constructor(props: {}) {
-        super(props);
-    }
-
-    render(): React.ReactElement<any> {
-        return (
-            <Video
-                source={{ uri: '//:example.com/test.mp4' }}
-                onProgress={this.onProgress}
-                onError={this.onError}
-                onLoad={this.onLoad}
-            />
-        );
-    }
-
-    onError = (error: {
-      error: {
-        '': string,
-        errorString: string
-      }
-    }): void => {
-        console.log(error.error[''], error.error.errorString);
-    }
-
-    onLoad = (data: {
-      canPlayFastForward: boolean,
-      canPlayReverse: boolean,
-      canPlaySlowForward: boolean,
-      canPlaySlowReverse: boolean,
-      canStepBackward: boolean,
-      canStepForward: boolean,
-      currentTime: number,
-      duration: number,
-      naturalSize: {
-        height: number;
-        width: number;
-        orientation: 'horizontal' | 'landscape';
-      }
-    }): void => {
-      console.log(data.canPlayFastForward, data.canPlayReverse, data.canPlaySlowForward, data.canPlaySlowReverse,
-      data.canStepBackward, data.canStepForward, data.currentTime, data.duration, data.naturalSize.height, data.naturalSize.width, data.naturalSize.orientation);
-    }
-
-    onProgress = (data: {
-        currentTime: number,
-        playableDuration: number,
-        seekableDuration: number
-    }): void => {
-        console.log(data.currentTime, data.playableDuration, data.seekableDuration);
-    }
-}
-
-const styles = StyleSheet.create({
-    wrapper: {
-        flex: 1,
-    },
-});
+<Video
+    source={{ uri: '//:example.com/test.mp4' }}
+    onProgress={data => console.log(data.currentTime, data.playableDuration, data.seekableDuration)}
+    onError={error => console.log(error.error[''], error.error.errorString)}
+    onLoad={data => {
+        console.log(data.canPlayFastForward, data.canPlayReverse, data.canPlaySlowForward, data.canPlaySlowReverse,
+        data.canStepBackward, data.canStepForward, data.currentTime, data.duration, data.naturalSize.height, data.naturalSize.width, data.naturalSize.orientation);
+    }}
+/>;
diff --git a/types/react-native-video/tsconfig.json b/types/react-native-video/tsconfig.json
index a2e2a80edd..88fbe1aa83 100644
--- a/types/react-native-video/tsconfig.json
+++ b/types/react-native-video/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-native/index.d.ts b/types/react-native/index.d.ts
index 697d5de39d..7953210507 100644
--- a/types/react-native/index.d.ts
+++ b/types/react-native/index.d.ts
@@ -14,6 +14,7 @@
 //                 Alexander T. <https://github.com/a-tarasyuk>
 //                 Martin van Dam <https://github.com/mvdam>
 //                 Kacper Wiszczuk <https://github.com/esemesek>
+//                 Ryan Nickel <https://github.com/mrnickel>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.8
 
@@ -1062,6 +1063,11 @@ export interface TextInputIOSProps {
         "nickname" | "organizationName" | "postalCode" | "streetAddressLine1" |
         "streetAddressLine2" | "sublocality" | "telephoneNumber" | "username" |
         "password";
+
+    /**
+     * If false, scrolling of the text view will be disabled. The default value is true. Only works with multiline={true}
+     */
+    scrollEnabled?: boolean
 }
 
 /**
diff --git a/types/react-native/tsconfig.json b/types/react-native/tsconfig.json
index c577fb0d8b..d982fe1be7 100644
--- a/types/react-native/tsconfig.json
+++ b/types/react-native/tsconfig.json
@@ -1,9 +1,7 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": [
-            "es6"
-        ],
+        "lib": ["es6"],
         "noImplicitAny": true,
         "noImplicitThis": true,
         "strictNullChecks": false,
diff --git a/types/react-native/tslint.json b/types/react-native/tslint.json
index 57266aecfb..f4e06d9245 100644
--- a/types/react-native/tslint.json
+++ b/types/react-native/tslint.json
@@ -9,11 +9,14 @@
         "comment-format": false,
         "interface-over-type-literal": false,
         "jsdoc-format": false,
+        "max-line-length": false,
+        "no-declare-current-package": false,
         "no-misused-new": false,
         "no-consecutive-blank-lines": false,
         "no-duplicate-imports": false,
         "no-empty-interface": false,
         "no-padding": false,
+        "no-self-import": false,
         "no-var": false,
         "no-var-keyword": false,
         "prefer-declare-function": false,
diff --git a/types/react-navigation/tsconfig.json b/types/react-navigation/tsconfig.json
index c1d4d83209..b0cf7029db 100644
--- a/types/react-navigation/tsconfig.json
+++ b/types/react-navigation/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-navigation/v1/tsconfig.json b/types/react-navigation/v1/tsconfig.json
index 3fc9fba7ce..289b5c4924 100644
--- a/types/react-navigation/v1/tsconfig.json
+++ b/types/react-navigation/v1/tsconfig.json
@@ -2,8 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/react-notify-toast/index.d.ts b/types/react-notify-toast/index.d.ts
index 1feb26ef61..ff4e52c616 100644
--- a/types/react-notify-toast/index.d.ts
+++ b/types/react-notify-toast/index.d.ts
@@ -23,8 +23,17 @@ declare class reactNotifyToast {
     createShowQueue(): reactNotifyToast;
 }
 
+interface Options {
+    wrapperId?: string;
+    animationDuration?: number;
+    timeout?: number;
+    zIndex?: number;
+    top?: number | string;
+    colors?: any;
+}
+
 interface NotificationProps {
-    options: any;
+    options?: Options;
 }
 
 export class Notification extends React.Component<NotificationProps, any> {}
diff --git a/types/react-onsenui/index.d.ts b/types/react-onsenui/index.d.ts
index 8d2f751492..5124683d48 100644
--- a/types/react-onsenui/index.d.ts
+++ b/types/react-onsenui/index.d.ts
@@ -3,11 +3,16 @@
 // Definitions by: Ozytis <https://ozytis.fr>,
 //                 Salim <https://github.com/salim7>,
 //                 Jemmyw <https://github.com/jemmyw>
+//                 Mikael Lirbank <https://github.com/lirbank>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.8
 
 import * as React from 'react';
-import Component = React.Component;
+
+export type HTMLAttributes<K extends keyof React.HTMLAttributes<{}>> = Partial<Pick<React.HTMLAttributes<{}>, K>>;
+export type InputHTMLAttributes<K extends keyof React.InputHTMLAttributes<{}>> = Partial<Pick<React.InputHTMLAttributes<{}>, K>>;
+
+export class Component<P = {}, S = {}> extends React.Component<HTMLAttributes<'id' | 'className' | 'style'> & P, S> {}
 
 export interface Modifiers_string {
     default?: string;
@@ -61,7 +66,6 @@ export class SplitterSide extends Component<{
     animationOptions?: AnimationOptions,
     openThreshold?: number,
     mode?: "collapse" | "split",
-    className?: string
 }, any> { }
 
 export class SplitterContent extends Component { }
@@ -111,14 +115,10 @@ export class Page extends Component<{
 export class Col extends Component<{
     verticalAlign?: "top" | "bottom" | "center",
     width?: string,
-    className?: string,
-    style?: React.CSSProperties,
 }, any> {}
 
 export class Row extends Component<{
     verticalAlign?: "top" | "bottom" | "center",
-    className?: string,
-    style?: React.CSSProperties,
 }, any> {}
 
 /*** Navigation ***/
@@ -238,8 +238,6 @@ export class Toast extends Component<{
     onPreHide?(): void,
     onPostHide?(): void,
     onDeviceBackButton?(): void,
-    className?: string,
-    style?: React.CSSProperties,
 }, any> {}
 
 export class ActionSheet extends Component<{
@@ -294,7 +292,6 @@ export class Fab extends Component<{
     disabled?: boolean,
     onClick?(e?: React.MouseEvent<HTMLElement>): void,
     name?: string,
-    className?: string
 }, any> {}
 
 export class Button extends Component<{
@@ -302,11 +299,10 @@ export class Button extends Component<{
     disabled?: boolean,
     ripple?: boolean,
     name?: string,
-    className?: string,
     onClick?(e?: React.MouseEvent<HTMLElement>): void
 }, any> {}
 
-export class Input extends Component<{
+export class Input extends Component<InputHTMLAttributes<'min' | 'max' | 'step'> & {
     modifier?: string,
     disabled?: boolean,
     readOnly?: boolean,
@@ -321,7 +317,6 @@ export class Input extends Component<{
     inputId?: string,
     float?: boolean,
     name?: string,
-    className?: string
 }, any> {}
 
 export class Radio extends Component<{
@@ -333,7 +328,6 @@ export class Radio extends Component<{
     defaultChecked?: boolean,
     inputId?: string,
     name?: string,
-    className?: string
 }, any> {}
 
 export class Checkbox extends Component<{
@@ -344,7 +338,6 @@ export class Checkbox extends Component<{
     checked?: boolean,
     inputId?: string,
     name?: string,
-    className?: string
 }, any> {}
 
 export class Range extends Component<{
@@ -373,7 +366,6 @@ export class Select extends Component<{
     form?: string,
     size?: string,
     name?: string,
-    className?: string
 }, any> {}
 
 export class Switch extends Component<{
@@ -383,7 +375,6 @@ export class Switch extends Component<{
     disabled?: boolean,
     inputId?: string,
     name?: string,
-    className?: string
 }, any> {}
 
 /**
@@ -436,14 +427,10 @@ export class List extends Component<{
     renderRow?(row: any, index?: number): JSX.Element | undefined,
     renderFooter?(): JSX.Element | undefined,
     renderHeader?(): JSX.Element | undefined,
-    className?: string,
-    style?: React.CSSProperties,
 }, any> {}
 
 export class ListHeader extends Component<{
     modifier?: string,
-    className?: string,
-    style?: React.CSSProperties,
 }, any> {}
 
 export class ListItem extends Component<{
@@ -452,15 +439,11 @@ export class ListItem extends Component<{
     tapBackgroundColor?: string,
     lockOnDrag?: boolean,
     onClick?: React.MouseEventHandler<any>,
-    className?: string,
-    style?: React.CSSProperties,
 }, any> {}
 
 export class ListTitle extends Component<{
     modifier?: string,
     onClick?: React.MouseEventHandler<any>,
-    className?: string,
-    style?: React.CSSProperties,
 }, any> {}
 
 export class Card extends Component<{
@@ -487,8 +470,6 @@ export class Segment extends Component<{
     tabbarId?: string,
     modifier?: string,
     onPostChange?(): void,
-    className?: string,
-    style?: React.CSSProperties,
 }, any> {}
 
 export type SpeedDialPosition = 'top' | 'right' | 'bottom' | 'left' |
@@ -500,13 +481,9 @@ export class SpeedDial extends Component<{
     position?: SpeedDialPosition,
     direction?: SpeedDialDirection,
     disabled?: boolean,
-    className?: string,
-    style?: React.CSSProperties,
 }, any> {}
 
 export class SpeedDialItem extends Component<{
     modifier?: string;
     onClick?(e?: React.MouseEvent<HTMLElement>): void,
-    className?: string,
-    style?: React.CSSProperties,
 }, any> {}
diff --git a/types/react-overlays/tslint.json b/types/react-overlays/tslint.json
index 3db14f85ea..4c842aedd2 100644
--- a/types/react-overlays/tslint.json
+++ b/types/react-overlays/tslint.json
@@ -1 +1,9 @@
-{ "extends": "dtslint/dt.json" }
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        // All are TODOs
+        "ban-types": false,
+        "member-access": false,
+        "no-self-import": false
+    }
+}
diff --git a/types/react-redux-epic/index.d.ts b/types/react-redux-epic/index.d.ts
index a059786123..948cd30c86 100644
--- a/types/react-redux-epic/index.d.ts
+++ b/types/react-redux-epic/index.d.ts
@@ -6,13 +6,14 @@
 
 import * as React from 'react';
 import { Observable } from 'rxjs/Observable';
+import { Action } from 'redux';
 import { Epic } from 'redux-observable';
 
 export interface Action {
     type: string;
 }
 
-export function wrapRootEpic<T, S, D, O extends T>(
+export function wrapRootEpic<T extends Action, S, D, O extends T>(
     epic: Epic<T, S, D, O>
 ): Epic<T, S, D, O>;
 
diff --git a/types/react-redux-epic/package.json b/types/react-redux-epic/package.json
index 807e511de4..7c18118269 100644
--- a/types/react-redux-epic/package.json
+++ b/types/react-redux-epic/package.json
@@ -2,6 +2,7 @@
     "private": true,
     "dependencies": {
         "rxjs": "^5.5.5",
+        "redux": "^3.6.0",
         "redux-observable": "^0.18.0"
     }
 }
diff --git a/types/react-redux-toastr/index.d.ts b/types/react-redux-toastr/index.d.ts
index cf81d974dd..fc11da9c43 100644
--- a/types/react-redux-toastr/index.d.ts
+++ b/types/react-redux-toastr/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for react-redux-toastr 7.1
+// Type definitions for react-redux-toastr 7.4
 // Project: https://github.com/diegoddox/react-redux-toastr
 // Definitions by: Aleksandar Ivanov <https://github.com/Smiche>
 //                 Artyom Stukans <https://github.com/artyomsv>
@@ -102,6 +102,7 @@ interface ReduxToastrProps {
     transitionIn?: transitionInType;
     transitionOut?: transitionOutType;
     className?: string;
+    closeOnToastrClick?: boolean;
 }
 
 interface ToastrEmitter {
diff --git a/types/react-router-hash-link/tsconfig.json b/types/react-router-hash-link/tsconfig.json
index fc830ac41d..a95239fba5 100644
--- a/types/react-router-hash-link/tsconfig.json
+++ b/types/react-router-hash-link/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "jsx": "react",
         "noImplicitAny": true,
diff --git a/types/react-router-native/tsconfig.json b/types/react-router-native/tsconfig.json
index 7b5d8f9fe3..48d6de4a72 100644
--- a/types/react-router-native/tsconfig.json
+++ b/types/react-router-native/tsconfig.json
@@ -7,8 +7,7 @@
         "types": [],
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "jsx": "react",
         "strictNullChecks": true,
diff --git a/types/react-router-navigation-core/tsconfig.json b/types/react-router-navigation-core/tsconfig.json
index fb95df56d6..a9ffa87aba 100644
--- a/types/react-router-navigation-core/tsconfig.json
+++ b/types/react-router-navigation-core/tsconfig.json
@@ -15,8 +15,7 @@
         },
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "jsx": "react",
         "strictNullChecks": true,
diff --git a/types/react-router-navigation/tsconfig.json b/types/react-router-navigation/tsconfig.json
index 5c345d9c7a..6b5ea55269 100644
--- a/types/react-router-navigation/tsconfig.json
+++ b/types/react-router-navigation/tsconfig.json
@@ -15,8 +15,7 @@
         },
         "module": "commonjs",
         "lib": [
-            "es6",
-            "dom"
+            "es6"
         ],
         "jsx": "react",
         "strictNullChecks": true,
diff --git a/types/react-router/v2/tslint.json b/types/react-router/v2/tslint.json
index ff9716ad87..56698b6653 100644
--- a/types/react-router/v2/tslint.json
+++ b/types/react-router/v2/tslint.json
@@ -1,8 +1,16 @@
 {
     "extends": "dtslint/dt.json",
     "rules": {
+        // TODOs
         "ban-types": false,
+        "eofline": false,
+        "jsdoc-format": false,
+        "no-consecutive-blank-lines": false,
         "no-empty-interface": false,
-        "no-unnecessary-generics": false
+        "no-padding": false,
+        "no-unnecessary-generics": false,
+        "no-unnecessary-qualifier": false,
+        "strict-export-declare-modifiers": false,
+        "trim-file": false
     }
 }
diff --git a/types/react-sortable-tree/tslint.json b/types/react-sortable-tree/tslint.json
index d9d49e375e..a2c75dc9e1 100644
--- a/types/react-sortable-tree/tslint.json
+++ b/types/react-sortable-tree/tslint.json
@@ -1,6 +1,8 @@
 {
     "extends": "dtslint/dt.json",
     "rules": {
+        // TODOs
+        "ban-types": false,
         "no-any-union": false
     }
 }
diff --git a/types/react-sortable-tree/utils/default-handlers.d.ts b/types/react-sortable-tree/utils/default-handlers.d.ts
index 5b00de104d..42dca8e8b7 100644
--- a/types/react-sortable-tree/utils/default-handlers.d.ts
+++ b/types/react-sortable-tree/utils/default-handlers.d.ts
@@ -1,4 +1,4 @@
-import { TreeIndex, SearchData } from 'react-sortable-tree';
+import { TreeIndex, SearchData } from '..';
 
 export function defaultGetNodeKey(data: TreeIndex): number;
-export function defaultSearchMethod(data: SearchData): boolean;
\ No newline at end of file
+export function defaultSearchMethod(data: SearchData): boolean;
diff --git a/types/react-sortable-tree/utils/tree-data-utils.d.ts b/types/react-sortable-tree/utils/tree-data-utils.d.ts
index 600dea727a..b9c7bb94a0 100644
--- a/types/react-sortable-tree/utils/tree-data-utils.d.ts
+++ b/types/react-sortable-tree/utils/tree-data-utils.d.ts
@@ -1,21 +1,79 @@
-import { FullTree, TreePath, TreeItem, TreeIndex, SearchData, NodeData, TreeNode } from 'react-sortable-tree';
+import { FullTree, TreePath, TreeItem, TreeIndex, SearchData, NodeData, TreeNode } from '..';
 
-type GetNodeKeyFunction = (data: TreeIndex & TreeNode) => string | number;
-type WalkAndMapFunctionParameters = FullTree & {getNodeKey: GetNodeKeyFunction, callback: Function, ignoreCollapsed?: boolean}
-type FlattenedData = (TreeNode & TreePath & {lowerSiblingsCounts: number[]})[];
+export type GetNodeKeyFunction = (data: TreeIndex & TreeNode) => string | number;
+export type WalkAndMapFunctionParameters = FullTree & {getNodeKey: GetNodeKeyFunction, callback: Function, ignoreCollapsed?: boolean};
+export type FlattenedData = Array<TreeNode & TreePath & {lowerSiblingsCounts: number[]}>;
 
 export function getDescendantCount(data: TreeNode & {ignoreCollapsed?: boolean}): number;
 export function getVisibleNodeCount(data: FullTree): number;
-export function getVisibleNodeInfoAtIndex(data: FullTree & {targetIndex: number, getNodeKey: GetNodeKeyFunction}): TreeNode & TreePath & {lowerSiblingsCounts: number[]} | null;
+export function getVisibleNodeInfoAtIndex(
+    data: FullTree & {
+        targetIndex: number,
+        getNodeKey: GetNodeKeyFunction,
+    }): TreeNode & TreePath & {lowerSiblingsCounts: number[]} | null;
 export function walk(data: WalkAndMapFunctionParameters): void;
 export function map(data: WalkAndMapFunctionParameters): TreeItem[];
-export function changeNodeAtPath(data: FullTree & TreePath & {newNode: Function | any, getNodeKey: GetNodeKeyFunction, ignoreCollapsed?: boolean}): TreeItem[];
-export function removeNodeAtPath(data: FullTree & TreePath & {getNodeKey: GetNodeKeyFunction, ignoreCollapsed?: boolean}): TreeItem[];
-export function getNodeAtPath(data: FullTree & TreePath & {getNodeKey: GetNodeKeyFunction, ignoreCollapsed?: boolean}): TreeNode & TreeIndex | null;
-export function addNodeUnderParent(data: FullTree & {newNode: TreeItem, parentKey?: number | string, getNodeKey: GetNodeKeyFunction, ignoreCollapsed?: boolean, expandParent?: boolean}): FullTree & TreeIndex;
-export function insertNode(data: FullTree & {depth: number, newNode: TreeItem, minimumTreeIndex: number, ignoreCollapsed?: boolean, expandParent?: boolean, getNodeKey: GetNodeKeyFunction}): FullTree & TreeIndex & TreePath & {parentNode: TreeItem};
-export function getFlatDataFromTree(data: FullTree & {getNodeKey: GetNodeKeyFunction, ignoreCollapsed?: boolean}): (TreeNode & TreePath & {lowerSiblingsCounts: number[], parentNode: TreeItem})[];
-export function getTreeFromFlatData(data: {flatData: FlattenedData, getKey?: GetNodeKeyFunction, getParentKey?: GetNodeKeyFunction, rootKey?: string | number}): TreeItem[]
+export function changeNodeAtPath(
+    data: FullTree & TreePath & {
+        newNode: Function | any,
+        getNodeKey: GetNodeKeyFunction,
+        ignoreCollapsed?: boolean,
+    },
+): TreeItem[];
+export function removeNodeAtPath(
+    data: FullTree & TreePath & {
+        getNodeKey: GetNodeKeyFunction,
+        ignoreCollapsed?: boolean,
+    },
+): TreeItem[];
+export function getNodeAtPath(
+    data: FullTree & TreePath & {
+        getNodeKey: GetNodeKeyFunction,
+        ignoreCollapsed?: boolean,
+    },
+): TreeNode & TreeIndex | null;
+export function addNodeUnderParent(
+    data: FullTree & {
+        newNode: TreeItem,
+        parentKey?: number | string,
+        getNodeKey: GetNodeKeyFunction,
+        ignoreCollapsed?: boolean,
+        expandParent?: boolean,
+    },
+): FullTree & TreeIndex;
+export function insertNode(
+    data: FullTree & {
+        depth: number,
+        newNode: TreeItem,
+        minimumTreeIndex: number,
+        ignoreCollapsed?: boolean,
+        expandParent?: boolean,
+        getNodeKey: GetNodeKeyFunction,
+    },
+): FullTree & TreeIndex & TreePath & {parentNode: TreeItem};
+export function getFlatDataFromTree(
+    data: FullTree & {
+        getNodeKey: GetNodeKeyFunction,
+        ignoreCollapsed?: boolean,
+    },
+): Array<TreeNode & TreePath & {lowerSiblingsCounts: number[], parentNode: TreeItem}>;
+export function getTreeFromFlatData(
+    data: {
+        flatData: FlattenedData,
+        getKey?: GetNodeKeyFunction,
+        getParentKey?: GetNodeKeyFunction,
+        rootKey?: string | number,
+    },
+): TreeItem[];
 export function isDescendant(older: TreeItem, younger: TreeItem): boolean;
 export function getDepth(node: TreeItem, depth?: number): number;
-export function find(data: FullTree & {getNodeKey: GetNodeKeyFunction, searchQuery?: string | number, searchMethod: (data: SearchData) => boolean, searchFocusOffset?: number, expandAllMatchPaths?: boolean, expandFocusMatchPaths?: boolean}): {matches: NodeData[]} & FullTree;
+export function find(
+    data: FullTree & {
+        getNodeKey: GetNodeKeyFunction,
+        searchQuery?: string | number,
+        searchMethod: (data: SearchData) => boolean,
+        searchFocusOffset?: number,
+        expandAllMatchPaths?: boolean,
+        expandFocusMatchPaths?: boolean,
+    },
+): {matches: NodeData[]} & FullTree;
diff --git a/types/react-star-rating-component/index.d.ts b/types/react-star-rating-component/index.d.ts
new file mode 100644
index 0000000000..916f5bbe4f
--- /dev/null
+++ b/types/react-star-rating-component/index.d.ts
@@ -0,0 +1,53 @@
+// Type definitions for react-star-rating-component 1.4
+// Project: https://github.com/voronianski/react-star-rating-component#readme
+// Definitions by: Cody Sand <https://github.com/marpstar>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+import * as React from "react";
+
+interface StarRatingComponentProps {
+  /** name of the radio input */
+  name: string;
+
+  /** the value of the star rating to display. i.e. the number of filled stars */
+  value: number;
+
+  /** number of icons in rating, default `5` */
+  starCount?: number;
+
+  onStarClick?: (nextValue: number, prevValue: number, name: string) => void;
+
+  onStarHover?: (nextValue: number, prevValue: number, name: string) => void;
+
+  onStarHoverOut?: (nextValue: number, prevValue: number, name: string) => void;
+
+  /** render method for the full-star icon */
+  renderStarIcon?: (
+    nextValue: number,
+    prevValue: number,
+    name: string
+  ) => React.ReactNode | string;
+
+  /** render method for the half-star icon */
+  renderStarIconHalf?: (
+    nextValue: number,
+    prevValue: number,
+    name: string
+  ) => React.ReactNode | string;
+
+  /** color of selected icons */
+  starColor?: string;
+
+  /** color of non-selected icons */
+  emptyStarColor?: string;
+
+  /** is component available for editing, default `true` */
+  editing?: boolean;
+}
+
+declare class StarRatingComponent extends React.Component<
+  StarRatingComponentProps
+> {}
+
+export = StarRatingComponent;
diff --git a/types/react-star-rating-component/react-star-rating-component-tests.tsx b/types/react-star-rating-component/react-star-rating-component-tests.tsx
new file mode 100644
index 0000000000..09f8928c8d
--- /dev/null
+++ b/types/react-star-rating-component/react-star-rating-component-tests.tsx
@@ -0,0 +1,49 @@
+import StarRatingComponent from "react-star-rating-component";
+import * as React from "react";
+
+const interactionCallback = (next: number, prev: number, name: string) => ({
+  next,
+  prev,
+  name
+});
+
+// $ExpectError
+const missingRequired = <StarRatingComponent />;
+
+// $ExpectError
+const valueIsNumber = <StarRatingComponent name="" value={"5"} />;
+
+const validExample = <StarRatingComponent name="test" value={3} />;
+
+const fullExample = (
+  <StarRatingComponent
+    name="app6"
+    starColor="#F3D954"
+    emptyStarColor="#F3D954"
+    starCount={4}
+    value={3.5}
+    onStarClick={interactionCallback}
+    onStarHover={interactionCallback}
+    onStarHoverOut={interactionCallback}
+    editing={false}
+    renderStarIcon={(index: number, value: number, _: string) => {
+      return (
+        <span>
+          <i className={index <= value ? "fas fa-star" : "far fa-star"} />
+        </span>
+      );
+    }}
+    renderStarIconHalf={(_: number, __: number, ___: string) => {
+      return (
+        <span>
+          <span style={{ position: "absolute" }}>
+            <i className="far fa-star" />
+          </span>
+          <span>
+            <i className="fas fa-star-half" />
+          </span>
+        </span>
+      );
+    }}
+  />
+);
diff --git a/types/react-star-rating-component/tsconfig.json b/types/react-star-rating-component/tsconfig.json
new file mode 100644
index 0000000000..a010cbdc61
--- /dev/null
+++ b/types/react-star-rating-component/tsconfig.json
@@ -0,0 +1,25 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "esModuleInterop": true,
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "jsx": "react",
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "react-star-rating-component-tests.tsx"
+    ]
+}
diff --git a/types/react-star-rating-component/tslint.json b/types/react-star-rating-component/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/react-star-rating-component/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/react-syntax-highlighter/index.d.ts b/types/react-syntax-highlighter/index.d.ts
index c9590f15a4..8bfd8e3756 100644
--- a/types/react-syntax-highlighter/index.d.ts
+++ b/types/react-syntax-highlighter/index.d.ts
@@ -1,9 +1,22 @@
 // Type definitions for react-syntax-highlighter
 // Project: https://github.com/conorhastings/react-syntax-highlighter
 // Definitions by: Ivo Stratev <https://github.com/NoHomey>
+//                 Aimee Gamble-Milner <https://github.com/ajgamble-milner>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.8
 
+interface SyntaxHighlighterProps {
+    language?: string;
+    style?: any;
+    customStyle?: any;
+    codeTagProps?: HTMLElement;
+    useInlineStyles?: boolean;
+    showLineNumbers?: boolean;
+    startingLineNumber?: number;
+    lineNumberStyle?: any;
+    [spread: string]: any;
+}
+
 declare module 'react-syntax-highlighter' {
     import SyntaxHighlighter from 'react-syntax-highlighter/light';
     export default SyntaxHighlighter;
@@ -11,24 +24,19 @@ declare module 'react-syntax-highlighter' {
 
 declare module 'react-syntax-highlighter/light' {
     import * as React from 'react';
-
     export function registerLanguage(name: string, func: any): void;
+    export default class SyntaxHighlighter extends React.Component<SyntaxHighlighterProps> {}
+}
 
-    interface SyntaxHighlighterProps {
-        language?: string;
-        style?: any;
-        customStyle?: any;
-        codeTagProps?: HTMLElement;
-        useInlineStyles?: boolean;
-        showLineNumbers?: boolean;
-        startingLineNumber?: number;
-        lineNumberStyle?: any;
-        [spread: string]: any;
-    }
+declare module 'react-syntax-highlighter/prism' {
+    import SyntaxHighlighter from 'react-syntax-highlighter/prism-light';
+    export default SyntaxHighlighter;
+}
 
-    export default class SyntaxHighlighter extends React.Component<SyntaxHighlighterProps> {
-
-    }
+declare module 'react-syntax-highlighter/prism-light' {
+    import * as React from 'react';
+    export function registerLanguage(name: string, func: any): void;
+    export default class SyntaxHighlighter extends React.Component<SyntaxHighlighterProps> {}
 }
 
 declare module 'react-syntax-highlighter/styles/hljs' {
@@ -513,6 +521,7 @@ declare module 'react-syntax-highlighter/styles/hljs/zenburn' {
     const style: any;
     export default style;
 }
+
 declare module 'react-syntax-highlighter/styles/prism' {
     export { default as atomDark } from 'react-syntax-highlighter/styles/prism/atom-dark';
     export { default as base16AteliersulphurpoolLight } from 'react-syntax-highlighter/styles/prism/base16-ateliersulphurpool.light';
@@ -539,118 +548,857 @@ declare module 'react-syntax-highlighter/styles/prism' {
     export { default as xonokai } from 'react-syntax-highlighter/styles/prism/xonokai';
 }
 
-declare module 'react-syntax-highlighter/styles/prism/atom-dark'  {
+declare module 'react-syntax-highlighter/styles/prism/atom-dark' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/base16-ateliersulphurpool.light'  {
+declare module 'react-syntax-highlighter/styles/prism/base16-ateliersulphurpool.light' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/cb'  {
+declare module 'react-syntax-highlighter/styles/prism/cb' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/coy'  {
+declare module 'react-syntax-highlighter/styles/prism/coy' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/darcula'  {
+declare module 'react-syntax-highlighter/styles/prism/darcula' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/dark'  {
+declare module 'react-syntax-highlighter/styles/prism/dark' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/duotone-dark'  {
+declare module 'react-syntax-highlighter/styles/prism/duotone-dark' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/duotone-earth'  {
+declare module 'react-syntax-highlighter/styles/prism/duotone-earth' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/duotone-forest'  {
+declare module 'react-syntax-highlighter/styles/prism/duotone-forest' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/duotone-light'  {
+declare module 'react-syntax-highlighter/styles/prism/duotone-light' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/duotone-sea'  {
+declare module 'react-syntax-highlighter/styles/prism/duotone-sea' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/duotone-space'  {
+declare module 'react-syntax-highlighter/styles/prism/duotone-space' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/funky'  {
+declare module 'react-syntax-highlighter/styles/prism/funky' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/ghcolors'  {
+declare module 'react-syntax-highlighter/styles/prism/ghcolors' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/hopscotch'  {
+declare module 'react-syntax-highlighter/styles/prism/hopscotch' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/okaidia'  {
+declare module 'react-syntax-highlighter/styles/prism/okaidia' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/pojoaque'  {
+declare module 'react-syntax-highlighter/styles/prism/pojoaque' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/prism'  {
+declare module 'react-syntax-highlighter/styles/prism/prism' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/solarizedlight'  {
+declare module 'react-syntax-highlighter/styles/prism/solarizedlight' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/tomorrow'  {
+declare module 'react-syntax-highlighter/styles/prism/tomorrow' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/twilight'  {
+declare module 'react-syntax-highlighter/styles/prism/twilight' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/vs'  {
+declare module 'react-syntax-highlighter/styles/prism/vs' {
     const style: any;
     export default style;
 }
 
-declare module 'react-syntax-highlighter/styles/prism/xonokai'   {
+declare module 'react-syntax-highlighter/styles/prism/xonokai' {
     const style: any;
     export default style;
 }
 
+declare module 'react-syntax-highlighter/languages/prism/abap' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/actionscript' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/ada' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/apacheconf' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/apl' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/applescript' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/arduino' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/arff' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/asciidoc' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/asm6502' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/aspnet' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/autohotkey' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/autoit' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/bash' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/basic' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/batch' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/bison' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/brainfuck' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/bro' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/c' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/clike' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/clojure' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/coffeescript' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/cpp' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/crystal' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/csharp' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/csp' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/cssExtras' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/css' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/d' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/dart' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/diff' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/django' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/docker' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/eiffel' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/elixir' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/elm' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/erb' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/erlang' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/flow' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/fortran' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/fsharp' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/gedcom' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/gherkin' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/git' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/glsl' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/go' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/graphql' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/groovy' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/haml' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/handlebars' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/haskell' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/haxe' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/hpkp' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/hsts' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/http' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/ichigojam' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/icon' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/inform7' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/ini' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/io' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/j' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/java' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/javascript' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/jolie' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/json' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/jsx' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/julia' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/keyman' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/kotlin' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/latex' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/less' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/liquid' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/lisp' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/livescript' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/lolcode' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/lua' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/makefile' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/markdown' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/markupTemplating' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/markup' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/matlab' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/mel' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/mizar' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/monkey' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/n4js' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/nasm' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/nginx' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/nim' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/nix' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/nsis' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/objectivec' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/ocaml' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/opencl' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/oz' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/parigp' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/parser' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/pascal' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/perl' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/phpExtras' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/php' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/plsql' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/powershell' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/processing' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/prolog' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/properties' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/protobuf' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/pug' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/puppet' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/pure' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/python' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/q' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/qore' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/r' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/reason' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/renpy' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/rest' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/rip' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/roboconf' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/ruby' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/rust' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/sas' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/sass' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/scala' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/scheme' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/scss' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/smalltalk' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/smarty' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/soy' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/sql' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/stylus' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/swift' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/tcl' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/textile' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/tsx' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/twig' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/typescript' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/vbnet' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/velocity' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/verilog' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/vhdl' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/vim' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/visualBasic' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/wasm' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/wiki' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/xeora' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/xojo' {
+    const language: any;
+    export default language;
+}
+
+declare module 'react-syntax-highlighter/languages/prism/yaml' {
+    const language: any;
+    export default language;
+}
diff --git a/types/react-syntax-highlighter/react-syntax-highlighter-tests.tsx b/types/react-syntax-highlighter/react-syntax-highlighter-tests.tsx
index b957aebac0..2abddb4a49 100644
--- a/types/react-syntax-highlighter/react-syntax-highlighter-tests.tsx
+++ b/types/react-syntax-highlighter/react-syntax-highlighter-tests.tsx
@@ -1,8 +1,12 @@
 import * as React from "react";
 import SyntaxHighlighter from "react-syntax-highlighter";
+import PrismSyntaxHighlighter from "react-syntax-highlighter/prism";
+import PrismLightHighlighter, { registerLanguage } from "react-syntax-highlighter/prism-light";
+import jsx from 'react-syntax-highlighter/languages/prism/jsx';
 import { docco } from "react-syntax-highlighter/styles/hljs";
+import { atomDark } from "react-syntax-highlighter/styles/prism";
 
-function highlighter(): JSX.Element {
+function hljsHighlighter(): JSX.Element {
     const codeString: string = `class CPP {
     private year: number;
     public constructor(private version: string) {
@@ -19,3 +23,41 @@ function highlighter(): JSX.Element {
         </SyntaxHighlighter>
     );
 }
+
+function prismHighlighter(): JSX.Element {
+    const codeString: string = `class CPP {
+    private year: number;
+    public constructor(private version: string) {
+        this.year = Number(version.match(/.+\d+$/));
+    }
+    public version(): string {
+        return this.version;
+    }
+}
+`;
+    return (
+        <PrismSyntaxHighlighter language="javascript" style={atomDark}>
+            {codeString}
+        </PrismSyntaxHighlighter>
+    );
+}
+
+function primsLightHighlighter(): JSX.Element {
+    const codeString: string = `class CPP {
+    private year: number;
+    public constructor(private version: string) {
+        this.year = Number(version.match(/.+\d+$/));
+    }
+    public version(): string {
+        return this.version;
+    }
+}
+`;
+    registerLanguage('jsx', jsx);
+
+    return (
+        <PrismLightHighlighter language="jsx" style={atomDark}>
+            {codeString}
+        </PrismLightHighlighter>
+    )
+}
diff --git a/types/react-tag-autocomplete/index.d.ts b/types/react-tag-autocomplete/index.d.ts
new file mode 100644
index 0000000000..15273e3918
--- /dev/null
+++ b/types/react-tag-autocomplete/index.d.ts
@@ -0,0 +1,112 @@
+// Type definitions for react-tag-autocomplete 5.6
+// Project: https://github.com/i-like-robots/react-tags#readme
+// Definitions by: James Lismore <https://github.com/jlismore>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+import { Component } from "react";
+
+export default class ReactTags extends Component<ReactTagsProps> {}
+
+export interface Tag {
+    id: string | number;
+    name: string;
+    disabled?: boolean;
+}
+
+export interface TagComponentProps {
+    tag: Tag;
+    classNames: ClassNames;
+    onDelete: (event: React.MouseEvent<HTMLButtonElement>) => void;
+}
+
+export interface ClassNames {
+    root: string;
+    rootFocused: string;
+    selected: string;
+    selectedTag: string;
+    selectedTagName: string;
+    search: string;
+    searchInput: string;
+    suggestions: string;
+    suggestionActive: string;
+    suggestionDisabled: string;
+}
+
+export interface ReactTagsProps {
+    /**
+     * Disables ability to delete the selected tags when backspace is pressed while focussed on the text input. Default: true.
+     */
+    allowBackspace?: boolean;
+    /**
+     * Allows users to add new (not suggested) tags. Default: false.
+     */
+    allowNew?: boolean;
+    /**
+     * Boolean parameter to control whether the text-input should be autofocused on mount. Default: true.
+     */
+    autofocus?: boolean;
+    /**
+     * Boolean parameter to control whether the text-input should be automatically resized to fit its value. Default: true.
+     */
+    autoresize?: boolean;
+    classNames?: ClassNames;
+    /**
+     * Array of characters matching keyboard event key values. This is useful when needing to support a specific character irrespective of the keyboard layout.
+     * Note, that this list is separate from the one specified by the delimiters option, so you'll need to set the value there to [],
+     * if you wish to disable those keys. Example usage: delimiterChars={[',', ' ']}. Default: []
+     */
+    delimiterChars?: string[];
+    /**
+     * Array of integers matching keyboard event keyCode values. When a corresponding key is pressed, the preceding string is finalised as tag. Default: [9, 13] (Tab and return keys).
+     */
+    delimiters?: number[];
+    /**
+     * Function called when the user wants to add a tag. Receives the tag
+     */
+    handleAddition: (tag: Tag) => void;
+    /**
+     * Optional event handler when focus on the input is lost. Receives no arguments.
+     */
+    handleBlur?: () => void;
+    /**
+     * Function called when the user wants to delete a tag. Receives the tag index.
+     */
+    handleDelete: (index: number) => void;
+    /**
+     * Optional event handler when the input receives focus. Receives no arguments.
+     */
+    handleFocus?: () => void;
+    /**
+     * Optional event handler when the input changes. Receives the current input value.
+     */
+    handleInputChange?: (input: string) => void;
+    /**
+     * An object containing additional attributes that will be applied to the underlying <input /> field.
+     */
+    inputAttributes?: { [key: string]: any };
+    /**
+     * Maximum number of suggestions to display. Default: 6.
+     */
+    maxSuggestionsLength?: number;
+    /**
+     * How many characters are needed for suggestions to appear. Default: 2.
+     */
+    minQueryLength?: number;
+    /**
+     * The placeholder string shown for the input. Default: 'Add new tag'.
+     */
+    placeholder?: string;
+    /**
+     * An array of suggestions that are used as basis for showing suggestions. Each suggestion must have an id and a name property and an optional disabled property. Default: []
+     */
+    suggestions?: Tag[];
+    /**
+     * Provide a custom tag component to render. Default: null.
+     */
+    tagComponent?: React.SFC<TagComponentProps>;
+    /**
+     * An array of tags that are displayed as pre-selected. Each tag must have an id and a name property. Default: []
+     */
+    tags?: Tag[];
+}
diff --git a/types/react-tag-autocomplete/react-tag-autocomplete-tests.tsx b/types/react-tag-autocomplete/react-tag-autocomplete-tests.tsx
new file mode 100644
index 0000000000..0777d682da
--- /dev/null
+++ b/types/react-tag-autocomplete/react-tag-autocomplete-tests.tsx
@@ -0,0 +1,68 @@
+import * as React from "react";
+import ReactTags, { TagComponentProps } from "react-tag-autocomplete";
+
+class TestRequired extends React.Component {
+    render() {
+        const onAddTag = (tag: { id: string | number; name: string }) => {};
+        const onDeleteTag = (i: number) => {};
+        return (
+            <ReactTags handleAddition={onAddTag} handleDelete={onDeleteTag} />
+        );
+    }
+}
+
+class TestAll extends React.Component {
+    render() {
+        const classNamesObj = {
+            root: "react-tags",
+            rootFocused: "is-focused",
+            selected: "react-tags__selected",
+            selectedTag: "react-tags__selected-tag",
+            selectedTagName: "react-tags__selected-tag-name",
+            search: "react-tags__search",
+            searchInput: "react-tags__search-input",
+            suggestions: "react-tags__suggestions",
+            suggestionActive: "is-active",
+            suggestionDisabled: "is-disabled"
+        };
+        const onAddTag = (tag: { id: string | number; name: string }) => {};
+        const onDeleteTag = (i: number) => {};
+        const onBlur = () => {};
+        const onFocus = () => {};
+        const onInputChange = (input: string) => {};
+        const inputAttributes = { maxLength: 10 };
+        const suggestions = [
+            { id: 3, name: "Bananas" },
+            { id: 4, name: "Mangos" },
+            { id: 5, name: "Lemons" },
+            { id: 6, name: "Apricots", disabled: true }
+        ];
+        const tagComponent = (props: TagComponentProps) => (
+            <button onClick={props.onDelete}>{props.tag.name}</button>
+        );
+        const tags = [{ id: 1, name: "Apples" }, { id: 2, name: "Pears" }];
+        return (
+            <ReactTags
+                allowBackspace={false}
+                allowNew={false}
+                autofocus={false}
+                autoresize={false}
+                classNames={classNamesObj}
+                delimiterChars={[",", " "]}
+                delimiters={[9, 13]}
+                handleAddition={onAddTag}
+                handleBlur={onBlur}
+                handleDelete={onDeleteTag}
+                handleFocus={onFocus}
+                handleInputChange={onInputChange}
+                inputAttributes={inputAttributes}
+                maxSuggestionsLength={10}
+                minQueryLength={5}
+                placeholder=""
+                suggestions={suggestions}
+                tagComponent={tagComponent}
+                tags={tags}
+            />
+        );
+    }
+}
diff --git a/types/react-tag-autocomplete/tsconfig.json b/types/react-tag-autocomplete/tsconfig.json
new file mode 100644
index 0000000000..70845fa5a1
--- /dev/null
+++ b/types/react-tag-autocomplete/tsconfig.json
@@ -0,0 +1,17 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": ["es6"],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "jsx": "react",
+        "typeRoots": ["../"],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": ["index.d.ts", "react-tag-autocomplete-tests.tsx"]
+}
diff --git a/types/react-tag-autocomplete/tslint.json b/types/react-tag-autocomplete/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/react-tag-autocomplete/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/react-widgets/index.d.ts b/types/react-widgets/index.d.ts
index df804235e0..a227b34e7e 100644
--- a/types/react-widgets/index.d.ts
+++ b/types/react-widgets/index.d.ts
@@ -1,10 +1,11 @@
-// Type definitions for react-widgets 4.1
+// Type definitions for react-widgets 4.2
 // Project: https://github.com/jquense/react-widgets
 // Definitions by: Rogier Schouten <https://github.com/rogierschouten>
 //                 Balázs Sándor <https://github.com/sanyatuning>
 //                 Frode Hansen <https://github.com/frodehansen2>
 //                 Andrew Makarov <https://github.com/r3nya>
 //                 Maxime Billemaz <https://github.com/MBillemaz>
+//                 Georg Steinmetz <https://github.com/georg94>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.8
 
diff --git a/types/react-widgets/lib/Calendar.d.ts b/types/react-widgets/lib/Calendar.d.ts
index 4cb97805d6..0e8fb4a773 100644
--- a/types/react-widgets/lib/Calendar.d.ts
+++ b/types/react-widgets/lib/Calendar.d.ts
@@ -29,7 +29,7 @@ interface CalendarProps extends ReactWidgetsCommonProps<CalendarClass>, AutoFocu
      * Callback fired when the Calendar navigates between views, or forward and backwards in
      * time.
      */
-    onNavigate?: (date: Date, direction: string, view: string ) => void;
+    onNavigate?: (date: Date, direction: string, view: string) => void;
     /**
      * A callback fired when the view changes.
      */
@@ -68,13 +68,11 @@ interface CalendarProps extends ReactWidgetsCommonProps<CalendarClass>, AutoFocu
     dayComponent?: React.ReactType;
     /**
      * The starting and lowest level view the calendar can navigate down to.
-     * @enum "month" "year" "decade" "century"
      */
     initialView?: "month" | "year" | "decade" | "century";
     /**
      * The highest level view the calendar can navigate up to. This value should be higher than
      * initialView
-     * @enum "month" "year" "decade" "century"
      */
     finalView?: "month" | "year" | "decade" | "century";
     /**
diff --git a/types/react-widgets/lib/CommonProps.d.ts b/types/react-widgets/lib/CommonProps.d.ts
index 85ab05f073..f357fe0068 100644
--- a/types/react-widgets/lib/CommonProps.d.ts
+++ b/types/react-widgets/lib/CommonProps.d.ts
@@ -1,6 +1,6 @@
 import * as React from 'react';
 
-interface ReactWidgetsCommonProps<C> extends React.Props<C> {
+export interface ReactWidgetsCommonProps<C> extends React.Props<C> {
     /**
      * Disable the widget, if an Array of values is passed in only those values will be disabled.
      * @default false
@@ -32,7 +32,7 @@ export interface AutoFocus {
     autoFocus?: boolean;
 }
 
-interface ReactWidgetsCommonDropdownProps<C> extends ReactWidgetsCommonProps<C> {
+export interface ReactWidgetsCommonDropdownProps<C> extends ReactWidgetsCommonProps<C> {
     /**
      * Show "drop up" not "drop down"
      * @default false
diff --git a/types/react-widgets/lib/DateTimePicker.d.ts b/types/react-widgets/lib/DateTimePicker.d.ts
index 2823a95234..a0887b0bcd 100644
--- a/types/react-widgets/lib/DateTimePicker.d.ts
+++ b/types/react-widgets/lib/DateTimePicker.d.ts
@@ -1,6 +1,5 @@
-import * as React from 'react';
+import { ComponentClass, KeyboardEvent, ReactElement, ReactType } from 'react';
 import { ReactWidgetsCommonDropdownProps, AutoFocus } from './CommonProps';
-import { KeyboardEvent } from 'react';
 
 interface DateTimePickerProps extends ReactWidgetsCommonDropdownProps<DateTimePickerClass>, AutoFocus {
     /**
@@ -10,6 +9,7 @@ interface DateTimePickerProps extends ReactWidgetsCommonDropdownProps<DateTimePi
     /**
      * Whether to show the date picker button.
      * @default true
+     * @deprecated Use `date` instead
      */
     calendar?: boolean;
     /**
@@ -20,7 +20,7 @@ interface DateTimePickerProps extends ReactWidgetsCommonDropdownProps<DateTimePi
     /**
      * A customize the rendering of times but providing a custom component.
      */
-    timeComponent?: React.ReactType | string;
+    timeComponent?: ReactType | string;
     /**
      * The minimum Date that can be selected. Min only limits selection, it doesn't constrain
      * the date values that can be typed or pasted into the widget. If you need this behavior
@@ -42,17 +42,17 @@ interface DateTimePickerProps extends ReactWidgetsCommonDropdownProps<DateTimePi
      */
     currentDate?: Date;
     /**
-     * Enable the calendar component of the picker.
-     */
-    date?: boolean;
-    /*
      * Default value for current date. Useful for suggesting a date when the caldenar opens without keep forcing it once 'value' is set.
      */
-    dateIcon?: any;
-    /*
-     * Specify the element used to render the calendar dropdown icon
+    date?: boolean;
+    /**
+     * Specify the element used to render the calendar dropdown icon.
      */
-    defaultCurrentDate?: Date;
+    dateIcon?: JSX.Element;
+    /**
+     * Specify the element used to render the time list dropdown icon.
+     */
+    timeIcon?: JSX.Element;
     /**
      * Change event Handler that is called when the currentDate is changed. The handler is
      * called with the currentDate object.
@@ -84,13 +84,11 @@ interface DateTimePickerProps extends ReactWidgetsCommonDropdownProps<DateTimePi
     parse?: ((str: string) => Date) | string[] | string;
     /**
      * The starting and lowest level view the calendar can navigate down to.
-     * @enum "month" "year" "decade" "century"
      */
     initialView?: "month" | "year" | "decade" | "century";
     /**
      * The highest level view the calendar can navigate up to. This value should be higher than
      * initialView.
-     * @enum "month" "year" "decade" "century"
      */
     finalView?: "month" | "year" | "decade" | "century";
     /**
@@ -132,16 +130,14 @@ interface DateTimePickerProps extends ReactWidgetsCommonDropdownProps<DateTimePi
     /**
      * Whether or not the DateTimePicker is open. When unset (undefined) the DateTimePicker will
      * handle the opening and closing internally.
-     * @enum false "date" "time"
      * @default false
      */
-    open?: boolean | "date" | "time";
+    open?: false | "date" | "time";
     /**
      * The defaultOpen prop can be used to set an
      * initialization value for uncontrolled widgets.
-     * @enum false "calendar" "time"
      */
-    defaultOpen?: boolean | "calendar" | "time";
+    defaultOpen?: false | "calendar" | "time";
     /**
      * Called when the DateTimePicker is about to open or close. onToggle should be used when
      * the open prop is set otherwise the widget will never open or close.
@@ -157,8 +153,8 @@ interface DateTimePickerProps extends ReactWidgetsCommonDropdownProps<DateTimePi
      */
     messages?: DateTimePickerMessages;
     /**
-    * Text to display in the input when the value is empty.
-    */
+     * Text to display in the input when the value is empty.
+     */
     placeholder?: string;
     /**
      * An object of props that is passed directly to the underlying input component.
@@ -173,7 +169,15 @@ interface DateTimePickerProps extends ReactWidgetsCommonDropdownProps<DateTimePi
      * The provided component will be used instead of the default SlideDownTransition for fully customizable animations.
      * The transition component is also injected with a dropUp prop indicating the direction it should open.
      */
-    popupTransition?: React.ReactType | string;
+    popupTransition?: ReactType | string;
+    /**
+     * Whether the Dropdown should be above the input field.
+     */
+    dropUp?: boolean;
+    /**
+     * Adds a css class to the input container element.
+     */
+    containerClassName?: string;
 }
 
 interface DateTimePickerMessages {
@@ -181,7 +185,7 @@ interface DateTimePickerMessages {
      * Title and screen reader text for the left arrow button.
      * @default "Select Date"
      */
-    calendarButton?: string;
+    dateButton?: string;
     /**
      * Title and screen reader text for the right arrow button.
      * @default "Select Time"
@@ -189,7 +193,7 @@ interface DateTimePickerMessages {
     timeButton?: string;
 }
 
-interface DateTimePicker extends React.ReactElement<DateTimePickerProps> {}
-interface DateTimePickerClass extends React.ComponentClass<DateTimePickerProps> {}
+interface DateTimePicker extends ReactElement<DateTimePickerProps> {}
+interface DateTimePickerClass extends ComponentClass<DateTimePickerProps> {}
 declare var DateTimePicker: DateTimePickerClass;
 export = DateTimePicker;
diff --git a/types/react-widgets/lib/DropdownList.d.ts b/types/react-widgets/lib/DropdownList.d.ts
index 644d0c4873..f5aa5846e6 100644
--- a/types/react-widgets/lib/DropdownList.d.ts
+++ b/types/react-widgets/lib/DropdownList.d.ts
@@ -2,11 +2,10 @@ import * as React from 'react';
 import { ReactWidgetsCommonDropdownProps, AutoFocus } from './CommonProps';
 
 interface DropdownListProps extends ReactWidgetsCommonDropdownProps<DropdownListClass>, AutoFocus {
-
     /**
      * Allow to create a new option on the data list.
      */
-    allowCreate?: boolean | 'onFilter'
+    allowCreate?: boolean | 'onFilter';
     /**
      * The current value of the DropdownList. This can be an object (such as a member of the
      * data array) or a primitive value, hinted to by the valueField. The widget value does not
@@ -14,8 +13,8 @@ interface DropdownListProps extends ReactWidgetsCommonDropdownProps<DropdownList
      */
     value?: any;
     /**
-   * Default value.
-   */
+     * Default value.
+     */
     defaultValue?: any;
     /**
      * Create event Handler that is called when a new option is added to the data list.
@@ -123,9 +122,8 @@ interface DropdownListProps extends ReactWidgetsCommonDropdownProps<DropdownList
      * There are a few built-in filtering methods that can be specified by passing the String name.
      * To handle custom filtering techniques provide a function that returns true or false
      * for each passed in item (analogous to the array.filter builtin)
-     * @enum false "startsWith" "endsWith" "contains"
      */
-    filter?: boolean | "startsWith" | "endsWith" | "contains" | ((dataItem: any, str: string) => boolean);
+    filter?: false | "startsWith" | "endsWith" | "contains" | ((dataItem: any, str: string) => boolean);
     /**
      * Use in conjunction with the filter prop. Filter the list without regard for case. This
      * only applies to non function values for filter
diff --git a/types/react-widgets/lib/Multiselect.d.ts b/types/react-widgets/lib/Multiselect.d.ts
index 34cb9306bb..56a2753d3e 100644
--- a/types/react-widgets/lib/Multiselect.d.ts
+++ b/types/react-widgets/lib/Multiselect.d.ts
@@ -122,10 +122,9 @@ interface MultiselectProps extends ReactWidgetsCommonDropdownProps<MultiselectCl
      * You can explicitly opt out of filtering by setting filter to false. To handle custom
      * filtering techniques provide a function that returns true or false for each passed in
      * item (analogous to the array.filter builtin)
-     * @enum false "startsWith" "endsWith" "contains" function(String item)
      * @default startsWith
      */
-    filter?: boolean | "startsWith" | "endsWith" | "contains" | ((dataItem: any, searchTerm: string) => boolean);
+    filter?: false | "startsWith" | "endsWith" | "contains" | ((dataItem: any, searchTerm: string) => boolean);
     /**
      * Use in conjunction with the filter prop. Filter the list without regard for case. This
      * only applies to non function values for filter.
diff --git a/types/react-widgets/lib/SelectList.d.ts b/types/react-widgets/lib/SelectList.d.ts
index cf3539a56a..74169e33f0 100644
--- a/types/react-widgets/lib/SelectList.d.ts
+++ b/types/react-widgets/lib/SelectList.d.ts
@@ -111,7 +111,7 @@ interface SelectListMessages {
     /**
      * @default: "There are no items in this list"
      */
-    emptyList?: string | ((props: SelectListProps) => string)
+    emptyList?: string | ((props: SelectListProps) => string);
 }
 
 interface SelectList extends React.ReactElement<SelectListProps> {}
diff --git a/types/react-widgets/react-widgets-tests.tsx b/types/react-widgets/react-widgets-tests.tsx
index c4e672c7b2..fced1f64e4 100644
--- a/types/react-widgets/react-widgets-tests.tsx
+++ b/types/react-widgets/react-widgets-tests.tsx
@@ -104,6 +104,9 @@ class Test extends React.Component<React.Props<{}>> {
                     name="list"
                 />
             </div>
+            <div>
+                <DateTimePicker dropUp={true} containerClassName="d-flex" timeIcon={<i className="fa fa-clock" />} />
+            </div>
         </div>
         );
     }
diff --git a/types/react-widgets/tslint.json b/types/react-widgets/tslint.json
index 2750cc0197..2c6d6947d4 100644
--- a/types/react-widgets/tslint.json
+++ b/types/react-widgets/tslint.json
@@ -1 +1,6 @@
-{ "extends": "dtslint/dt.json" }
\ No newline at end of file
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        "no-any-union": false // TODO
+    }
+}
diff --git a/types/react/global.d.ts b/types/react/global.d.ts
index 5afef3a17c..0c7a24070a 100644
--- a/types/react/global.d.ts
+++ b/types/react/global.d.ts
@@ -178,4 +178,6 @@ interface SVGTSpanElement extends SVGElement { }
 interface SVGUseElement extends SVGElement { }
 interface SVGViewElement extends SVGElement { }
 
+interface Text { }
 interface TouchList { }
+interface WebGLRenderingContext { }
diff --git a/types/react/tslint.json b/types/react/tslint.json
index 6a9d91ddbd..d2c103b50c 100644
--- a/types/react/tslint.json
+++ b/types/react/tslint.json
@@ -4,6 +4,7 @@
 		// TODOs
 		"dt-header": false,
 		"no-any-union": false,
+		"no-empty-interface": false,
 		"no-object-literal-type-assertion": false,
 		"no-unnecessary-generics": false,
 		"no-void-expression": false,
diff --git a/types/reactstrap/lib/Button.d.ts b/types/reactstrap/lib/Button.d.ts
index 326e5f88de..f19ecf4e32 100644
--- a/types/reactstrap/lib/Button.d.ts
+++ b/types/reactstrap/lib/Button.d.ts
@@ -1,7 +1,7 @@
 import * as React from 'react';
 import { CSSModule } from '../index';
 
-export type ButtonProps<T = {}> = React.HTMLProps<HTMLButtonElement> & {
+export type ButtonProps<T = {}> = React.ButtonHTMLAttributes<HTMLButtonElement> & {
   outline?: boolean;
   active?: boolean;
   block?: boolean;
diff --git a/types/reactstrap/lib/Col.d.ts b/types/reactstrap/lib/Col.d.ts
index 0d1bac535d..c52e32ec62 100644
--- a/types/reactstrap/lib/Col.d.ts
+++ b/types/reactstrap/lib/Col.d.ts
@@ -20,7 +20,7 @@ export type ColProps<T = {}> = React.HTMLProps<HTMLDivElement> & {
   lg?: ColumnProps;
   xl?: ColumnProps;
 
-  //custom widths
+  // custom widths
   widths?: string[];
 } & T;
 
diff --git a/types/reactstrap/lib/Dropdown.d.ts b/types/reactstrap/lib/Dropdown.d.ts
index 12d001accd..585a1e8693 100644
--- a/types/reactstrap/lib/Dropdown.d.ts
+++ b/types/reactstrap/lib/Dropdown.d.ts
@@ -5,7 +5,7 @@ export type Direction =
   | "up"
   | "down"
   | "left"
-  | "right"
+  | "right";
 
 export type UncontrolledProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
   isOpen?: boolean;
diff --git a/types/reactstrap/reactstrap-tests.tsx b/types/reactstrap/reactstrap-tests.tsx
index 48afb0ce31..ee8b39ae45 100644
--- a/types/reactstrap/reactstrap-tests.tsx
+++ b/types/reactstrap/reactstrap-tests.tsx
@@ -278,6 +278,11 @@ const Example13 = (
   </div>
 );
 
+interface CustomButtonProps extends ButtonProps {
+  customProp: string;
+}
+const CustomButton: React.SFC<CustomButtonProps> = props => <Button {...props} />;
+
 class Example14 extends React.Component<any, any> {
   state: any;
   constructor(props: any) {
@@ -3759,7 +3764,7 @@ import { default as Alert_ } from './lib/Alert'; /* tslint:disable-line: no-rela
 import { default as Badge_ } from './lib/Badge'; /* tslint:disable-line: no-relative-import-in-test */
 import { default as Breadcrumb_ } from './lib/Breadcrumb'; /* tslint:disable-line: no-relative-import-in-test */
 import { default as BreadcrumbItem_ } from './lib/BreadcrumbItem'; /* tslint:disable-line: no-relative-import-in-test */
-import { default as Button_ } from './lib/Button'; /* tslint:disable-line: no-relative-import-in-test */
+import { default as Button_, ButtonProps } from './lib/Button'; /* tslint:disable-line: no-relative-import-in-test */
 import { default as ButtonDropdown_ } from './lib/ButtonDropdown'; /* tslint:disable-line: no-relative-import-in-test */
 import { default as ButtonGroup_ } from './lib/ButtonGroup'; /* tslint:disable-line: no-relative-import-in-test */
 import { default as ButtonToolbar_ } from './lib/ButtonToolbar'; /* tslint:disable-line: no-relative-import-in-test */
diff --git a/types/reactstrap/v4/lib/BreadcrumbItem.d.ts b/types/reactstrap/v4/lib/BreadcrumbItem.d.ts
index 0277305b21..6c6b68d3c3 100644
--- a/types/reactstrap/v4/lib/BreadcrumbItem.d.ts
+++ b/types/reactstrap/v4/lib/BreadcrumbItem.d.ts
@@ -12,4 +12,3 @@ interface Props {
 
 declare var BreadcrumbItem: React.StatelessComponent<Props>;
 export default BreadcrumbItem;
-
diff --git a/types/reactstrap/v4/lib/ButtonDropdown.d.ts b/types/reactstrap/v4/lib/ButtonDropdown.d.ts
index 9ab54c7502..28ab35b7cf 100644
--- a/types/reactstrap/v4/lib/ButtonDropdown.d.ts
+++ b/types/reactstrap/v4/lib/ButtonDropdown.d.ts
@@ -9,4 +9,4 @@ export interface UncontrolledProps extends DropdownUncontrolledProps { }
 interface Props extends DropdownProps { }
 
 declare var ButtonDropdown: React.StatelessComponent<Props>;
-export default ButtonDropdown;
\ No newline at end of file
+export default ButtonDropdown;
diff --git a/types/reactstrap/v4/lib/Card.d.ts b/types/reactstrap/v4/lib/Card.d.ts
index 0dbde7f879..aa271eea80 100644
--- a/types/reactstrap/v4/lib/Card.d.ts
+++ b/types/reactstrap/v4/lib/Card.d.ts
@@ -13,4 +13,3 @@ interface Props {
 
 declare var Card: React.StatelessComponent<Props>;
 export default Card;
-
diff --git a/types/reactstrap/v4/lib/CardBlock.d.ts b/types/reactstrap/v4/lib/CardBlock.d.ts
index 0aa31a63a7..6aa41abb2f 100644
--- a/types/reactstrap/v4/lib/CardBlock.d.ts
+++ b/types/reactstrap/v4/lib/CardBlock.d.ts
@@ -8,4 +8,3 @@ interface Props {
 
 declare var CardBlock: React.StatelessComponent<Props>;
 export default CardBlock;
-
diff --git a/types/reactstrap/v4/lib/Col.d.ts b/types/reactstrap/v4/lib/Col.d.ts
index a2ea76d607..2740f95ef0 100644
--- a/types/reactstrap/v4/lib/Col.d.ts
+++ b/types/reactstrap/v4/lib/Col.d.ts
@@ -16,7 +16,7 @@ interface Props extends React.HTMLProps<HTMLDivElement> {
   lg?: ColumnProps;
   xl?: ColumnProps;
 
-  //custom widths
+  // custom widths
   widths?: string[];
 }
 
diff --git a/types/reactstrap/v4/lib/ListGroupItem.d.ts b/types/reactstrap/v4/lib/ListGroupItem.d.ts
index b2241998dc..58bf40fff3 100644
--- a/types/reactstrap/v4/lib/ListGroupItem.d.ts
+++ b/types/reactstrap/v4/lib/ListGroupItem.d.ts
@@ -9,7 +9,7 @@ interface Props {
   className?: string;
   cssModule?: CSSModule;
   href?: string;
-    
+
   onClick?: React.MouseEventHandler<any>;
 }
 
diff --git a/types/reactstrap/v4/lib/NavDropdown.d.ts b/types/reactstrap/v4/lib/NavDropdown.d.ts
index 6b480d495a..e28dbe4732 100644
--- a/types/reactstrap/v4/lib/NavDropdown.d.ts
+++ b/types/reactstrap/v4/lib/NavDropdown.d.ts
@@ -9,4 +9,4 @@ export interface UncontrolledProps extends DropdownUncontrolledProps { }
 interface Props extends DropdownProps { }
 
 declare var NavDropdown: React.StatelessComponent<Props>;
-export default NavDropdown;
\ No newline at end of file
+export default NavDropdown;
diff --git a/types/reactstrap/v4/lib/Tooltip.d.ts b/types/reactstrap/v4/lib/Tooltip.d.ts
index 9dba615084..11b80e0543 100644
--- a/types/reactstrap/v4/lib/Tooltip.d.ts
+++ b/types/reactstrap/v4/lib/Tooltip.d.ts
@@ -37,7 +37,5 @@ interface Props extends UncontrolledProps {
   isOpen?: boolean;
 }
 
-
-
 declare var Tooltip: React.StatelessComponent<Props>;
 export default Tooltip;
diff --git a/types/reactstrap/v4/lib/Uncontrolled.d.ts b/types/reactstrap/v4/lib/Uncontrolled.d.ts
index 151ee012d3..5443238f0b 100644
--- a/types/reactstrap/v4/lib/Uncontrolled.d.ts
+++ b/types/reactstrap/v4/lib/Uncontrolled.d.ts
@@ -14,16 +14,8 @@ import {
   UncontrolledProps as TooltipUncontrolledProps
 } from './Tooltip';
 
-declare var UncontrolledAlert: React.StatelessComponent<AlertUncontrolledProps>;
-declare var UncontrolledButtonDropdown: React.StatelessComponent<ButtonDropdownUncontrolledProps>;
-declare var UncontrolledDropdown: React.StatelessComponent<DropdownUncontrolledProps>;
-declare var UncontrolledNavDropdown: React.StatelessComponent<NavDropdownUncontrolledProps>;
-declare var UncontrolledTooltip: React.StatelessComponent<TooltipUncontrolledProps>;
-
-export {
-  UncontrolledAlert,
-  UncontrolledButtonDropdown,
-  UncontrolledDropdown,
-  UncontrolledNavDropdown,
-  UncontrolledTooltip
-}
\ No newline at end of file
+export const UncontrolledAlert: React.StatelessComponent<AlertUncontrolledProps>;
+export const UncontrolledButtonDropdown: React.StatelessComponent<ButtonDropdownUncontrolledProps>;
+export const UncontrolledDropdown: React.StatelessComponent<DropdownUncontrolledProps>;
+export const UncontrolledNavDropdown: React.StatelessComponent<NavDropdownUncontrolledProps>;
+export const UncontrolledTooltip: React.StatelessComponent<TooltipUncontrolledProps>;
diff --git a/types/rebass__grid/tsconfig.json b/types/rebass__grid/tsconfig.json
index ce26e72a5f..419413e066 100644
--- a/types/rebass__grid/tsconfig.json
+++ b/types/rebass__grid/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/redux-form/index.d.ts b/types/redux-form/index.d.ts
index bbddfbd744..dd5572cac0 100644
--- a/types/redux-form/index.d.ts
+++ b/types/redux-form/index.d.ts
@@ -10,6 +10,7 @@
 //                 Ethan Resnick <https://github.com/ethanresnick>
 //                 Tim de Koning <https://github.com/reggino>
 //                 Maddi Joyce <https://github.com/maddijoyce>
+//                 Kamil Wojcik <https://github.com/smifun>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.8
 import {
diff --git a/types/redux-form/lib/FormName.d.ts b/types/redux-form/lib/FormName.d.ts
index 20fd50dae8..6cfc6f3708 100644
--- a/types/redux-form/lib/FormName.d.ts
+++ b/types/redux-form/lib/FormName.d.ts
@@ -1,7 +1,7 @@
 import { ReactNode, StatelessComponent } from "react";
 
 export interface FormNameProps {
-    children: (props: { form: string }) => ReactNode,
+    children: (props: { form: string }) => ReactNode;
 }
 
 export const FormName: StatelessComponent<FormNameProps>;
diff --git a/types/redux-form/lib/reduxForm.d.ts b/types/redux-form/lib/reduxForm.d.ts
index 5d0d90d7b8..e37214f5d0 100644
--- a/types/redux-form/lib/reduxForm.d.ts
+++ b/types/redux-form/lib/reduxForm.d.ts
@@ -111,7 +111,7 @@ export interface ConfigProps<FormData = {}, P = {}, ErrorType = string> {
     initialValues?: Partial<FormData>;
     keepDirtyOnReinitialize?: boolean;
     updateUnregisteredFields?: boolean;
-    onChange?(values: Partial<FormData>, dispatch: Dispatch<any>, props: P & InjectedFormProps<FormData, P, ErrorType>): void;
+    onChange?(values: Partial<FormData>, dispatch: Dispatch<any>, props: P & InjectedFormProps<FormData, P, ErrorType>, previousValues: Partial<FormData>): void;
     onSubmit?: FormSubmitHandler<FormData, P & InjectedFormProps<FormData, P, ErrorType>, ErrorType> | SubmitHandler<FormData, P & InjectedFormProps<FormData, P, ErrorType>, ErrorType>;
     onSubmitFail?(
         errors: FormErrors<FormData, ErrorType> | undefined,
diff --git a/types/redux-form/redux-form-tests.tsx b/types/redux-form/redux-form-tests.tsx
index 3d177a7a8f..fc6e97fb6a 100644
--- a/types/redux-form/redux-form-tests.tsx
+++ b/types/redux-form/redux-form-tests.tsx
@@ -231,6 +231,14 @@ const testFormWithInitialValuesAndValidationDecorator = reduxForm<MultivalueForm
     }
 });
 
+const testFormWithChangeFunctionDecorator = reduxForm<TestFormData, TestFormComponentProps>({
+    form: "testWithValidation",
+    onChange: (values: Partial<TestFormData>,
+        dispatch: Dispatch<any>,
+        props: TestFormComponentProps & InjectedFormProps<TestFormData, TestFormComponentProps>,
+        previousValues: Partial<TestFormData>) => {}
+});
+
 type TestProps = {} & InjectedFormProps<TestFormData>;
 const Test = reduxForm<TestFormData>({
     form : "test"
diff --git a/types/redux-form/v6/tslint.json b/types/redux-form/v6/tslint.json
index 054167e539..8afc03ea50 100644
--- a/types/redux-form/v6/tslint.json
+++ b/types/redux-form/v6/tslint.json
@@ -1,11 +1,15 @@
 {
     "extends": "dtslint/dt.json",
     "rules": {
+        // All are TODOs
         "adjacent-overload-signatures": false,
+        "ban-types": false,
         "callable-types": false,
+        "jsdoc-format": false,
         "no-empty-interface": false,
         "no-object-literal-type-assertion": false,
         "no-unnecessary-generics": false,
+        "semicolon": false,
         "strict-export-declare-modifiers": false
     }
 }
diff --git a/types/redux-persist-transform-encrypt/index.d.ts b/types/redux-persist-transform-encrypt/index.d.ts
index 354ee043b0..18611cfcf9 100644
--- a/types/redux-persist-transform-encrypt/index.d.ts
+++ b/types/redux-persist-transform-encrypt/index.d.ts
@@ -3,6 +3,7 @@
 // Definitions by: Karol Janyst <https://github.com/LKay>
 //                 Gaurav Lahoti <https://github.com/dante-101>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { Transform } from "redux-persist";
 
diff --git a/types/redux-persist-transform-filter/index.d.ts b/types/redux-persist-transform-filter/index.d.ts
index 9619c07df7..4ca98d7520 100644
--- a/types/redux-persist-transform-filter/index.d.ts
+++ b/types/redux-persist-transform-filter/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/edy/redux-persist-transform-filter
 // Definitions by: Karol Janyst <https://github.com/LKay>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { Transform } from "redux-persist";
 
diff --git a/types/redux-testkit/index.d.ts b/types/redux-testkit/index.d.ts
index 9e574e7ebf..f747996afb 100644
--- a/types/redux-testkit/index.d.ts
+++ b/types/redux-testkit/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/wix/redux-testkit#readme
 // Definitions by: Andrey Kizimov <https://github.com/Bookler96>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
+// TypeScript Version: 2.3
 
 import * as Redux from 'redux';
 import { ThunkAction } from 'redux-thunk';
@@ -20,7 +20,7 @@ export interface ThunkTestkit {
 	execute(...args: any[]): any;
 }
 
-export function Reducer(action: Redux.Reducer<any>): ReducerTestkit & {
+export function Reducer(action: Redux.Reducer): ReducerTestkit & {
 	withState(state: any): ReducerTestkit;
 };
 
diff --git a/types/redux-testkit/package.json b/types/redux-testkit/package.json
index 7f874d66e7..900548677e 100644
--- a/types/redux-testkit/package.json
+++ b/types/redux-testkit/package.json
@@ -1,7 +1,7 @@
 {
 	"private": true,
 	"dependencies": {
-		"redux": "^3.6.0",
-		"redux-thunk": "^2.3.0"
+		"redux": "*",
+		"redux-thunk": "*"
 	}
 }
diff --git a/types/response-time/index.d.ts b/types/response-time/index.d.ts
index 8a06ba04fd..f4e43543a1 100644
--- a/types/response-time/index.d.ts
+++ b/types/response-time/index.d.ts
@@ -1,6 +1,7 @@
 // Type definitions for response-time 2.3.2
 // Project: https://github.com/expressjs/response-time
 // Definitions by: Uros Smolnik <https://github.com/urossmolnik>, TonyYang <https://github.com/TonyPythoneer>
+//                 Dan Manastireanu <https://github.com/danmana>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.2
 
@@ -17,6 +18,7 @@
 
 
 import http = require("http");
+import express = require("express");
 
 
 export = responseTime;
@@ -29,6 +31,8 @@ declare function responseTime(options?: responseTime.ResponseTimeOptions):
     (request: http.IncomingMessage, response: http.ServerResponse, callback: (err: any) => void) => any;
 declare function responseTime(fn: responseTime.ResponseTimeFunction):
     (request: http.IncomingMessage, response: http.ServerResponse, callback: (err: any) => void) => any;
+declare function responseTime(fn: (request: express.Request, response: express.Response, time: number) => any):
+    express.RequestHandler;
 
 
 declare namespace responseTime {
diff --git a/types/response-time/response-time-tests.ts b/types/response-time/response-time-tests.ts
index 9b75aa2fec..46010f3f0d 100644
--- a/types/response-time/response-time-tests.ts
+++ b/types/response-time/response-time-tests.ts
@@ -34,8 +34,8 @@ import http = require('http')
 // response time metrics tests https://github.com/expressjs/response-time#response-time-metrics //
 //////////////////////////////////////////////////////////////////////////////////////////////////
 {
-    const app = express()
-    app.use(responseTime(function (req, res, time) {
+    const app = express();
+    app.use(responseTime((req: express.Request, res: express.Response, time: number) => {
         let num: number = time;
     }));
 }
diff --git a/types/rollup-plugin-json/index.d.ts b/types/rollup-plugin-json/index.d.ts
index 795f24a005..b6b61b25e5 100644
--- a/types/rollup-plugin-json/index.d.ts
+++ b/types/rollup-plugin-json/index.d.ts
@@ -5,6 +5,7 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
+/// <reference types="node" />
 import { Plugin } from 'rollup';
 
 export interface Options {
diff --git a/types/rx-lite/index.d.ts b/types/rx-lite/index.d.ts
index 16646b0473..9487683dce 100644
--- a/types/rx-lite/index.d.ts
+++ b/types/rx-lite/index.d.ts
@@ -244,8 +244,8 @@ declare namespace Rx {
         merge(maxConcurrent: number): T;
         merge(other: Observable<T>): Observable<T>;
         merge(other: IPromise<T>): Observable<T>;
-        mergeAll(): Observable<T>;
-        mergeObservable(): Observable<T>;    // alias for mergeAll
+        mergeAll(): T;
+        mergeObservable(): T;    // alias for mergeAll
         skipUntil<T2>(other: Observable<T2>): Observable<T>;
         skipUntil<T2>(other: IPromise<T2>): Observable<T>;
         switch(): T;
diff --git a/types/rx-lite/rx-lite-tests.ts b/types/rx-lite/rx-lite-tests.ts
index 17f0bbe726..755a2b2443 100644
--- a/types/rx-lite/rx-lite-tests.ts
+++ b/types/rx-lite/rx-lite-tests.ts
@@ -86,14 +86,19 @@ function test_concatAll() {
 		});
 }
 
+// https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/mergeall.md
 function test_mergeAll() {
-	/* mergeAll example */
+    /* mergeAll example */
+
+    // $ExpectType Observable<number>
 	const source = Rx.Observable.range(0, 3)
 		.map(x => Rx.Observable.range(x, 3))
-		.mergeAll();
+        .mergeAll();
 
 	const subscription = source.subscribe(
 		x => {
+            // $ExpectType number
+            x;
 			console.log('Next: %s', x);
 		},
 		err => {
diff --git a/types/seamless-immutable/index.d.ts b/types/seamless-immutable/index.d.ts
index b781523ef2..21474f3a6d 100644
--- a/types/seamless-immutable/index.d.ts
+++ b/types/seamless-immutable/index.d.ts
@@ -3,8 +3,9 @@
 // Definitions by: alex3165 <https://github.com/alex3165>
 //                 Stepan Burguchev <https://github.com/xsburg>
 //                 Geir Sagberg <https://github.com/geirsagberg>
+//                 Richard Honor <https://github.com/RMHonor>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.4
+// TypeScript Version: 2.8
 
 export = SeamlessImmutable;
 
@@ -31,17 +32,17 @@ declare namespace SeamlessImmutable {
     }
 
     interface ImmutableObjectMixin<T> {
-        set<K extends keyof T>(property: K, value: T[K]): ImmutableObject<T>;
-        set<TValue>(property: string, value: TValue): ImmutableObject<T>;
+        set<K extends keyof T>(property: K, value: T[K]): Immutable<T>;
+        set<TValue>(property: string, value: TValue): Immutable<T>;
 
-        setIn<K extends keyof T>(propertyPath: [ K ], value: T[K]): ImmutableObject<T>;
-        setIn<K extends keyof T, L extends keyof T[K]>(propertyPath: [ K, L ], value: T[K][L]): ImmutableObject<T>;
-        setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L]>(propertyPath: [ K, L, M ], value: T[K][L][M]): ImmutableObject<T>;
+        setIn<K extends keyof T>(propertyPath: [ K ], value: T[K]): Immutable<T>;
+        setIn<K extends keyof T, L extends keyof T[K]>(propertyPath: [ K, L ], value: T[K][L]): Immutable<T>;
+        setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L]>(propertyPath: [ K, L, M ], value: T[K][L][M]): Immutable<T>;
         setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M]>(
-            propertyPath: [ K, L, M, N ], value: T[K][L][M][N]): ImmutableObject<T>;
+            propertyPath: [ K, L, M, N ], value: T[K][L][M][N]): Immutable<T>;
         setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M], O extends keyof T[K][L][M][N]>(
-            propertyPath: [ K, L, M, N, O ], value: T[K][L][M][N][O]): ImmutableObject<T>;
-        setIn<TValue>(propertyPath: string[], value: TValue): ImmutableObject<T>;
+            propertyPath: [ K, L, M, N, O ], value: T[K][L][M][N][O]): Immutable<T>;
+        setIn<TValue>(propertyPath: string[], value: TValue): Immutable<T>;
 
         getIn<K extends keyof T>(propertyPath: [ K ]): Immutable<T[K]>;
         getIn<K extends keyof T>(propertyPath: [ K ], defaultValue: T[K]): Immutable<T[K]>;
@@ -59,48 +60,48 @@ declare namespace SeamlessImmutable {
 
         asMutable(opts?: AsMutableOptions): T;
 
-        merge(part: DeepPartial<T>, config?: MergeConfig): ImmutableObject<T>;
+        merge(part: DeepPartial<T>, config?: MergeConfig): Immutable<T>;
 
-        update<K extends keyof T>(property: K, updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
-        update<TValue>(property: string, updaterFunction: (value: TValue, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+        update<K extends keyof T>(property: K, updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): Immutable<T>;
+        update<TValue>(property: string, updaterFunction: (value: TValue, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): Immutable<T>;
 
         updateIn<K extends keyof T>(
-            propertyPath: [ K ], updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+            propertyPath: [ K ], updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): Immutable<T>;
         updateIn<K extends keyof T, L extends keyof T[K]>(
-            propertyPath: [ K, L ], updaterFunction: (value: T[K][L], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+            propertyPath: [ K, L ], updaterFunction: (value: T[K][L], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): Immutable<T>;
         updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L]>(
-            propertyPath: [ K, L, M ], updaterFunction: (value: T[K][L][M], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+            propertyPath: [ K, L, M ], updaterFunction: (value: T[K][L][M], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): Immutable<T>;
         updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M]>(
-            propertyPath: [ K, L, M, N ], updaterFunction: (value: T[K][L][M][N], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+            propertyPath: [ K, L, M, N ], updaterFunction: (value: T[K][L][M][N], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): Immutable<T>;
         updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M], O extends keyof T[K][L][M][N]>(
-            propertyPath: [ K, L, M, N, O ], updaterFunction: (value: T[K][L][M][N][O], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
-        updateIn<TValue>(propertyPath: string[], updaterFunction: (value: TValue, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+            propertyPath: [ K, L, M, N, O ], updaterFunction: (value: T[K][L][M][N][O], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): Immutable<T>;
+        updateIn<TValue>(propertyPath: string[], updaterFunction: (value: TValue, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): Immutable<T>;
 
-        without<K extends keyof T>(property: K): ImmutableObject<T>;
-        without<K extends keyof T>(...properties: K[]): ImmutableObject<T>;
-        without<K extends keyof T>(filter: (value: T[K], key: K) => boolean): ImmutableObject<T>;
+        without<K extends keyof T>(property: K): Immutable<T>;
+        without<K extends keyof T>(...properties: K[]): Immutable<T>;
+        without<K extends keyof T>(filter: (value: T[K], key: K) => boolean): Immutable<T>;
 
-        replace<S>(valueObj: S, options?: ReplaceConfig): ImmutableObject<S>;
+        replace<S>(valueObj: S, options?: ReplaceConfig): Immutable<S>;
     }
 
-    interface ImmutableArrayMixin<T> {
-        asMutable(opts?: AsMutableOptions): T[];
-        asObject(toKeyValue: (item: T) => [string, any]): ImmutableObject<any>;
-        flatMap<TTarget>(mapFunction: (item: T) => TTarget[]): ImmutableArray<TTarget>;
+    interface ImmutableArrayMixin<T extends Array<T[0]>> {
+        asMutable(opts?: AsMutableOptions): T;
+        asObject(toKeyValue: (item: T[0]) => [string, any]): Immutable<object>;
+        flatMap<TTarget>(mapFunction: (item: T[0]) => TTarget): Immutable<TTarget extends any[] ? TTarget : TTarget[]>;
     }
 
-    type ImmutableObject<T> = T & ImmutableObjectMixin<T>;
-    type ImmutableArray<T> = T[] & ImmutableArrayMixin<T>;
-    type Immutable<T> = ImmutableObject<T> | ImmutableArray<T>;
+    type BaseImmutable<T> = (T extends any[] ? ImmutableArrayMixin<T> : ImmutableObjectMixin<T>) & T;
 
-    function from<T>(obj: T[], options?: Options): ImmutableArray<T>;
-    function from<T>(obj: T, options?: Options): ImmutableObject<T>;
+    type Immutable<T> = {
+        readonly [P in keyof T]: T[P] extends object ? Immutable<T[P]> : T[P]
+    } & BaseImmutable<T>;
+
+    function from<T>(obj: T, options?: Options): Immutable<T>;
 
     function isImmutable(target: any): boolean;
     function ImmutableError(message: string): Error;
 
-    function replace<T, S>(obj: ImmutableObject<T>, valueObj: S, options?: ReplaceConfig): ImmutableObject<S>;
+    function replace<T, S>(obj: Immutable<T>, valueObj: S, options?: ReplaceConfig): Immutable<S>;
 }
 
-declare function SeamlessImmutable<T>(obj: T[], options?: SeamlessImmutable.Options): SeamlessImmutable.ImmutableArray<T>;
-declare function SeamlessImmutable<T>(obj: T, options?: SeamlessImmutable.Options): SeamlessImmutable.ImmutableObject<T>;
+declare function SeamlessImmutable<T>(obj: T, options?: SeamlessImmutable.Options): SeamlessImmutable.Immutable<T>;
diff --git a/types/seamless-immutable/seamless-immutable-tests.ts b/types/seamless-immutable/seamless-immutable-tests.ts
index cccb2d7f96..54136f46db 100644
--- a/types/seamless-immutable/seamless-immutable-tests.ts
+++ b/types/seamless-immutable/seamless-immutable-tests.ts
@@ -25,13 +25,13 @@ interface ExtendedUser extends User {
         lastName: string;
     }
 
-    const arrayOfNumbers1: Immutable.ImmutableArray<number> = Immutable.from([0, 2]);
-    const arrayOfNumbers2: Immutable.ImmutableArray<number> = Immutable([0, 2]);
-    const user1: Immutable.ImmutableObject<User> = Immutable.from({
+    const arrayOfNumbers1: Immutable.Immutable<number[]> = Immutable.from([0, 2]);
+    const arrayOfNumbers2: Immutable.Immutable<number[]> = Immutable([0, 2]);
+    const user1: Immutable.Immutable<User> = Immutable.from({
         firstName: 'Angry',
         lastName: 'Monkey'
     });
-    const user2: Immutable.ImmutableObject<User> = Immutable({
+    const user2: Immutable.Immutable<User> = Immutable({
         firstName: 'Angry',
         lastName: 'Monkey'
     });
@@ -44,7 +44,7 @@ interface ExtendedUser extends User {
 
 {
     const isImmutable: boolean = Immutable.isImmutable(Immutable.from([0, 2]));
-    const user1: Immutable.ImmutableObject<User> = Immutable.from({
+    const user1: Immutable.Immutable<User> = Immutable.from({
         firstName: 'Angry',
         lastName: 'Monkey'
     });
@@ -56,19 +56,23 @@ interface ExtendedUser extends User {
 // Instance syntax: immutable array
 // ---------------------------------------------------------------
 {
-    const array: Immutable.ImmutableArray<User> = Immutable.from<User>([ { firstName: 'Angry', lastName: 'Monkey' } ]);
+    const array: Immutable.Immutable<User[]> = Immutable.from([ { firstName: 'Angry', lastName: 'Monkey' } ]);
 
     // asMutable
     const mutableArray1: User[] = array.asMutable();
     const mutableArray2: User[] = array.asMutable({ deep: true });
 
     // flatMap
-    const flatMappedArray: Immutable.ImmutableArray<User> = array.flatMap((value: User) =>
+    const flatMappedArray: Immutable.Immutable<User[]> = array.flatMap((value: User) =>
         [value, value]
     );
 
+    const flatMappedArrayStrings: Immutable.Immutable<string[]> = array.flatMap((value: User) =>
+        value.firstName
+    );
+
     // asObject
-    const arrayToObject1: Immutable.ImmutableObject<any> = array.asObject((value) => [value.toString(), value]);
+    const arrayToObject1: Immutable.Immutable<object> = array.asObject((value) => [value.toString(), value]);
 }
 
 //
@@ -76,11 +80,11 @@ interface ExtendedUser extends User {
 // ---------------------------------------------------------------
 
 {
-    const immutableUser: Immutable.ImmutableObject<User> = Immutable.from({
+    const immutableUser: Immutable.Immutable<User> = Immutable.from({
         firstName: 'Pure',
         lastName: 'Gold'
     });
-    const immutableUserEx: Immutable.ImmutableObject<ExtendedUser> = Immutable.from({
+    const immutableUserEx: Immutable.Immutable<ExtendedUser> = Immutable.from({
         firstName: 'Hairy',
         lastName: 'Dog',
         address: {
@@ -94,37 +98,37 @@ interface ExtendedUser extends User {
     };
 
     // set: property name is strongly checked
-    const updatedUser01: Immutable.ImmutableObject<User> = immutableUser.set('firstName', 'Whirlwind');
-    const updatedUser02: Immutable.ImmutableObject<User> = immutableUser.set(data.propertyId, 'Whirlwind');
+    const updatedUser01: Immutable.Immutable<User> = immutableUser.set('firstName', 'Whirlwind');
+    const updatedUser02: Immutable.Immutable<User> = immutableUser.set(data.propertyId, 'Whirlwind');
 
     // setIn: property path is strongly checked for up to 5 arguments (helps with refactoring and intellisense)
     // but will fall back to any[] if there are dynamic arguments on the way
-    const updatedUser11: Immutable.ImmutableObject<ExtendedUser> = immutableUserEx.setIn(['address', 'line1'], 'Small house');
-    const updatedUser12: Immutable.ImmutableObject<ExtendedUser> = immutableUserEx.setIn([ data.propertyId, 'line1' ], 'Small house');
+    const updatedUser11: Immutable.Immutable<ExtendedUser> = immutableUserEx.setIn(['address', 'line1'], 'Small house');
+    const updatedUser12: Immutable.Immutable<ExtendedUser> = immutableUserEx.setIn([ data.propertyId, 'line1' ], 'Small house');
 
     // asMutable
     const mutableUser21: User = immutableUser.asMutable();
     const mutableUser22: User = immutableUser.asMutable({ deep: true });
 
     // merge: merged part is strongly checked as a deeply partial object
-    const mergedUser: Immutable.ImmutableObject<User> = immutableUserEx.merge({ address: { line1: 'Small house' }, firstName: 'Jack' });
+    const mergedUser: Immutable.Immutable<User> = immutableUserEx.merge({ address: { line1: 'Small house' }, firstName: 'Jack' });
 
     // update: property name is strongly checked
-    const updatedUser41: Immutable.ImmutableObject<User> = immutableUser.update('firstName', x => x.toLowerCase() + ' Whirlwind');
+    const updatedUser41: Immutable.Immutable<User> = immutableUser.update('firstName', x => x.toLowerCase() + ' Whirlwind');
     // the type of the updated value must be explicity specified in case of fallback
-    const updatedUser42: Immutable.ImmutableObject<User> = immutableUser.update<string>(data.propertyId, x => x.toLowerCase() + ' Whirlwind');
+    const updatedUser42: Immutable.Immutable<User> = immutableUser.update<string>(data.propertyId, x => x.toLowerCase() + ' Whirlwind');
 
     // updateIn: property path is strongly checked for up to 5 arguments (helps with refactoring and intellisense)
     // but will fall back to any[] if there are dynamic arguments on the way
-    const updatedUser51: Immutable.ImmutableObject<User> = immutableUserEx.updateIn([ 'address', 'line1' ], x => x.toLowerCase() + ' 43');
+    const updatedUser51: Immutable.Immutable<User> = immutableUserEx.updateIn([ 'address', 'line1' ], x => x.toLowerCase() + ' 43');
     // the type of the updated value must be explicity specified in case of fallback
-    const updatedUser52: Immutable.ImmutableObject<User> = immutableUserEx.updateIn<string>([ data.propertyId, 'line1' ], x => x.toLowerCase() + ' 43');
+    const updatedUser52: Immutable.Immutable<User> = immutableUserEx.updateIn<string>([ data.propertyId, 'line1' ], x => x.toLowerCase() + ' 43');
 
     // without
-    const simpleUser1: Immutable.ImmutableObject<User> = immutableUserEx.without('address');
+    const simpleUser1: Immutable.Immutable<User> = immutableUserEx.without('address');
 
     // getIn: propertyPath is strongly typed up to 5 parameters
-    const firstNameWithoutDefault = immutableUser.getIn(['firstName']); // infers Immutable<string>
+    const firstNameWithoutDefault: string = immutableUser.getIn(['firstName']); // infers Immutable<string>
     const firstNameWithDefault = immutableUser.getIn(['firstName'], ''); // infers Immutable<string>
     const firstNameWithDynamicPathWithoutDefault = immutableUser.getIn(['first' + 'name']);
     const firstNameWithDynamicPathWithDefault = immutableUser.getIn(['first' + 'name'], '');
diff --git a/types/sequelize-cursor-pagination/index.d.ts b/types/sequelize-cursor-pagination/index.d.ts
index 6c5b82bc56..09c3d1b653 100644
--- a/types/sequelize-cursor-pagination/index.d.ts
+++ b/types/sequelize-cursor-pagination/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for sequelize-cursor-pagination 1.1
+// Type definitions for sequelize-cursor-pagination 1.2
 // Project: https://github.com/Kaltsoon/sequelize-cursor-pagination
 // Definitions by: pilagod <https://github.com/pilagod>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped/
@@ -23,6 +23,7 @@ declare namespace SequelizeCursorPagination {
         before?: string; // the before cursor
         after?: string; // the after cursor
         paginationField?: string; // [default: primaryKeyField]
+        subQuery?: boolean; // [default: undefined]
     }
 
     interface PaginateRawOptions<T> extends BasicPaginateOptions<T> {
diff --git a/types/sequelize-cursor-pagination/sequelize-cursor-pagination-tests.ts b/types/sequelize-cursor-pagination/sequelize-cursor-pagination-tests.ts
index b8a4fd95c6..989d2c9ac8 100644
--- a/types/sequelize-cursor-pagination/sequelize-cursor-pagination-tests.ts
+++ b/types/sequelize-cursor-pagination/sequelize-cursor-pagination-tests.ts
@@ -38,7 +38,8 @@ withPaginationModel.paginate({
     limit: 10,
     desc: true,
     paginationField: 'id',
-    raw: false
+    raw: false,
+    subQuery: false
 });
 
 // when 'raw' option is false or undefined
@@ -99,5 +100,6 @@ withPaginationCustomModel.customPaginate({
     limit: 10,
     desc: true,
     paginationField: 'id',
-    raw: false
+    raw: false,
+    subQuery: false
 });
diff --git a/types/serialize-javascript/index.d.ts b/types/serialize-javascript/index.d.ts
index b0331a3d03..ae1829b0bf 100644
--- a/types/serialize-javascript/index.d.ts
+++ b/types/serialize-javascript/index.d.ts
@@ -1,6 +1,7 @@
-// Type definitions for serialize-javascript 1.3
+// Type definitions for serialize-javascript 1.5
 // Project: https://github.com/yahoo/serialize-javascript
 // Definitions by: François Nguyen <https://github.com/lith-light-g>
+//                 Pochodaydayup <https://github.com/Pochodaydayup>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 declare namespace serializeJavascript {
@@ -16,6 +17,12 @@ declare namespace serializeJavascript {
          * If you're serializing a lot of data, and know its pure JSON, then you can enable this option for a speed-up.
          */
         isJSON?: boolean;
+        /**
+         * This option is to signal serialize() that we want to do a straight conversion, without the XSS protection.
+         * This options needs to be explicitly set to true. HTML characters and JavaScript line terminators will not be escaped.
+         * You will have to roll your own.
+         */
+        unsafe?: boolean;
     }
 }
 
diff --git a/types/sharp/index.d.ts b/types/sharp/index.d.ts
index 97b9ea6f86..f461f4c429 100644
--- a/types/sharp/index.d.ts
+++ b/types/sharp/index.d.ts
@@ -1,13 +1,17 @@
-// Type definitions for sharp 0.17
+// Type definitions for sharp 0.21
 // Project: https://github.com/lovell/sharp
 // Definitions by: François Nguyen <https://github.com/lith-light-g>
 //                 Wooseop Kim <https://github.com/wooseopkim>
+//                 Bradley Odell <https://github.com/BTOdell>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 /// <reference types="node" />
 
 import { Duplex } from "stream";
 
+//#region Constructor functions
+
 /**
  * Creates a sharp instance from an image
  * @param 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.
@@ -15,42 +19,13 @@ import { Duplex } from "stream";
  * @throws {Error} Invalid parameters
  * @returns A sharp instance that can be used to chain operations
  */
-declare function sharp(options?: sharp.SharpOptions): sharp.SharpInstance;
-declare function sharp(input?: string | Buffer, options?: sharp.SharpOptions): sharp.SharpInstance;
+declare function sharp(options?: sharp.SharpOptions): sharp.Sharp;
+declare function sharp(input?: string | Buffer, options?: sharp.SharpOptions): sharp.Sharp;
+
 declare namespace sharp {
-    const gravity: GravityEnum;
-    const strategy: 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 options Object with the cache options, or Boolean where true uses default cache settings and false removes all caching.
-     */
-    function cache(options?: boolean | CacheOptions): CacheResult;
-    /**
-     * Gets, or when a concurrency is provided sets, the number of threads libvips' should create to process each image.
-     * @param concurrency concurrency value
-     */
-    function concurrency(threads?: number): number;
-    /**
-     * Provides access to internal task counters.
-     * @returns Object containing task counters
-     */
-    function counters(): SharpCounters;
-    /**
-     * Get and set use of SIMD vector unit instructions.
-     * @param enable enable or disable use of SIMD vector unit instructions
-     * @returns true if usage of SIMD vector unit instructions is enabled
-     */
-    function simd(enable?: boolean): boolean;
-    const kernel: KernelEnum;
-    const interpolator: InterpolatorEnum;
-    /**
-     * Object containing nested boolean values representing the available input and output formats/methods.
-     */
+    /** Object containing nested boolean values representing the available input and output formats/methods. */
     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 */
-    const queue: NodeJS.EventEmitter;
+
     /** An Object containing the version numbers of libvips and its dependencies. */
     const versions: {
         vips: string;
@@ -78,187 +53,105 @@ declare namespace sharp {
         xml?: string;
         zlib?: string;
     };
+
+    /** An EventEmitter that emits a change event when a task is either queued, waiting for libuv to provide a worker thread, complete */
+    const queue: NodeJS.EventEmitter;
+
+    //#endregion
+
+    //#region Utility functions
+
+    /**
+     * 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 options Object with the following attributes, or Boolean where true uses default cache settings and false removes all caching (optional, default true)
+     * @returns The cache results.
+     */
+    function cache(options?: boolean | CacheOptions): CacheResult;
+
+    /**
+     * Gets or sets the number of threads libvips' should create to process each image.
+     * The default value is the number of CPU cores. A value of 0 will reset to this default.
+     * The maximum number of images that can be processed in parallel is limited by libuv's UV_THREADPOOL_SIZE environment variable.
+     * @param concurrency The new concurrency value.
+     * @returns The current concurrency value.
+     */
+    function concurrency(concurrency?: number): number;
+
+    /**
+     * Provides access to internal task counters.
+     * @returns Object containing task counters
+     */
+    function counters(): SharpCounters;
+
+    /**
+     * Get and set use of SIMD vector unit instructions. Requires libvips to have been compiled with liborc support.
+     * Improves the performance of resize, blur and sharpen operations by taking advantage of the SIMD vector unit of the CPU, e.g. Intel SSE and ARM NEON.
+     * @param enable enable or disable use of SIMD vector unit instructions
+     * @returns true if usage of SIMD vector unit instructions is enabled
+     */
+    function simd(enable?: boolean): boolean;
+
+    //#endregion
+
+    const gravity: GravityEnum;
+    const strategy: StrategyEnum;
+    const kernel: KernelEnum;
     const bool: BoolEnum;
 
-    interface SharpInstance extends Duplex {
+    interface Sharp extends Duplex {
+        //#region Channel functions
+
         /**
-         * Fast access to image metadata without decoding any compressed image data.
+         * Remove alpha channel, if any. This is a no-op if the image does not have an alpha channel.
          * @returns A sharp instance that can be used to chain operations
          */
-        metadata(callback: (err: Error, metadata: Metadata) => void): SharpInstance;
+        removeAlpha(): Sharp;
+
         /**
-         * Fast access to image metadata without decoding any compressed image data.
-         * @returns A promise that fulfills with a metadata object.
-         */
-        metadata(): Promise<Metadata>;
-        /**
-         * Take a "snapshot" of the Sharp instance, returning a new instance.
+         * Extract a single channel from a multi-channel image.
+         * @param 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 A sharp instance that can be used to chain operations
          */
-        clone(): SharpInstance;
+        extractChannel(channel: number | string): Sharp;
+
         /**
-         * An advanced setting that switches the libvips access method to VIPS_ACCESS_SEQUENTIAL.
-         * @param sequentialRead true to enable and false to disable (defaults to true)
-         * @returns 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 pixels An integral Number of pixels, zero or false to remove limit, true to use default limit.
-         * @throws {Error} Invalid limit
-         * @returns 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 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 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 options resize options
+         * Join one or more channels to the image. The meaning of the added channels depends on the output colourspace, set with toColourspace().
+         * By default the output image will be web-friendly sRGB, with additional channels interpreted as alpha channels. Channel ordering follows vips convention:
+         *  - sRGB: 0: Red, 1: Green, 2: Blue, 3: Alpha.
+         *  - CMYK: 0: Magenta, 1: Cyan, 2: Yellow, 3: Black, 4: Alpha.
+         *
+         * Buffers may be any of the image formats supported by sharp: JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data.
+         * For raw pixel input, the options object should contain a raw attribute, which follows the format of the attribute of the same name in the sharp() constructor.
+         * @param images one or more images (file paths, Buffers).
+         * @param options image options, see sharp() constructor.
          * @throws {Error} Invalid parameters
          * @returns A sharp instance that can be used to chain operations
          */
-        resize(width?: number, height?: number, options?: ResizeOptions): SharpInstance;
+        joinChannel(images: string | Buffer | ArrayLike<string|Buffer>, options?: SharpOptions): Sharp;
+
         /**
-         * Crop the resized image to the exact size specified, the default behaviour.
-         * @param crop A member of sharp.gravity to crop to an edge/corner or sharp.strategy to crop dynamically. (optional, default 'centre')
+         * Perform a bitwise boolean operation on all input image channels (bands) to produce a single channel output image.
+         * @param boolOp one of "and", "or" or "eor" to perform that bitwise operation, like the C logic operators &, | and ^ respectively.
          * @throws {Error} Invalid parameters
          * @returns A sharp instance that can be used to chain operations
          */
-        crop(crop?: number | string): SharpInstance;
+        bandbool(boolOp: string): Sharp;
+
+        //#endregion
+
+        //#region Color functions
+
         /**
-         * 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.
+         * Tint the image using the provided chroma while preserving the image luminance.
+         * An alpha channel may be present and will be unchanged by the operation.
+         * @param rgb Parsed by the color module to extract chroma values.
          * @returns 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 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 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 withoutEnlargement true to enable and false to disable (defaults to true)
-         * @returns 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 to extract
-         * @throws {Error} Invalid parameters
-         * @returns 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 tolerance value between 1 and 99 representing the percentage similarity. (optional, default 10)
-         * @throws {Error} Invalid parameters
-         * @returns 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 or Object parsed by the color module to extract values for red, green, blue and alpha.
-         * @throws {Error} Invalid parameter
-         * @returns 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 flatten true to enable and false to disable (defaults to true)
-         * @returns 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 extend single pixel count to add to all edges or an Object with per-edge counts
-         * @throws {Error} Invalid parameters
-         * @returns A sharp instance that can be used to chain operations
-         */
-        extend(extend: number | ExtendOptions): SharpInstance;
-        /**
-         * Produce the "negative" of the image.
-         * @param negate true to enable and false to disable (defaults to true)
-         * @returns 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 angle 0, 90, 180 or 270. (optional, default auto)
-         * @throws {Error} Invalid parameters
-         * @returns A sharp instance that can be used to chain operations
-         */
-        rotate(angle?: number): SharpInstance;
-        /**
-         * Flip the image about the vertical Y axis.
-         * @param flip true to enable and false to disable (defaults to true)
-         * @returns A sharp instance that can be used to chain operations
-         */
-        flip(flip?: boolean): SharpInstance;
-        /**
-         * Flop the image about the horizontal X axis.
-         * @param flop true to enable and false to disable (defaults to true)
-         * @returns A sharp instance that can be used to chain operations
-         */
-        flop(flop?: boolean): SharpInstance;
-        /**
-         * Blur the image.
-         * @param 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 A sharp instance that can be used to chain operations
-         */
-        blur(sigma?: number): SharpInstance;
-        /**
-         * Convolve the image with the specified kernel.
-         * @param kernel the specified kernel
-         * @throws {Error} Invalid parameters
-         * @returns A sharp instance that can be used to chain operations
-         */
-        convolve(kernel: Kernel): SharpInstance;
-        /**
-         * Sharpen the image.
-         * @param sigma the sigma of the Gaussian mask, where sigma = 1 + radius / 2.
-         * @param flat the level of sharpening to apply to "flat" areas. (optional, default 1.0)
-         * @param jagged the level of sharpening to apply to "jagged" areas. (optional, default 2.0)
-         * @throws {Error} Invalid parameters
-         * @returns 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 threshold a value in the range 0-255 representing the level at which the threshold will be applied. (optional, default 128)
-         * @param options threshold options
-         * @throws {Error} Invalid parameters
-         * @returns 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 gamma value between 1.0 and 3.0. (optional, default 2.2)
-         * @throws {Error} Invalid parameters
-         * @returns 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 grayscale true to enable and false to disable (defaults to true)
-         * @returns A sharp instance that can be used to chain operations
-         */
-        grayscale(grayscale?: boolean): SharpInstance;
+        tint(rgb: Color): Sharp;
+
         /**
          * Convert to 8-bit greyscale; 256 shades of grey.
          * This is a linear operation.
@@ -269,87 +162,265 @@ declare namespace sharp {
          * @param greyscale true to enable and false to disable (defaults to true)
          * @returns A sharp instance that can be used to chain operations
          */
-        greyscale(greyscale?: boolean): SharpInstance;
+        greyscale(greyscale?: boolean): Sharp;
+
         /**
-         * Enhance output image contrast by stretching its luminance to cover the full dynamic range.
-         * @param normalize true to enable and false to disable (defaults to true)
+         * Alternative spelling of greyscale().
+         * @param grayscale true to enable and false to disable (defaults to true)
          * @returns 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 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 image Buffer containing image data or String containing the path to an image file.
-         * @param options overlay options
-         * @returns A sharp instance that can be used to chain operations
-         */
-        overlayWith(image: string | Buffer, options?: OverlayOptions): SharpInstance;
+        grayscale(grayscale?: boolean): Sharp;
+
         /**
          * Set the output colourspace.
+         * By default output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
          * @param colourspace output colourspace e.g. srgb, rgb, cmyk, lab, b-w ...
          * @throws {Error} Invalid parameters
          * @returns A sharp instance that can be used to chain operations
          */
-        toColourspace(colourspace?: string): SharpInstance;
+        toColourspace(colourspace?: string): Sharp;
+
         /**
-         * Alternative spelling of toColourspace.
-         * Set the output colorspace.
-         * @param colorspace output colourspace e.g. srgb, rgb, cmyk, lab, b-w ...
+         * Alternative spelling of toColourspace().
+         * @param colorspace output colorspace e.g. srgb, rgb, cmyk, lab, b-w ...
          * @throws {Error} Invalid parameters
          * @returns A sharp instance that can be used to chain operations
          */
-        toColorspace(colorspace: string): SharpInstance;
+        toColorspace(colorspace: string): Sharp;
+
+        //#endregion
+
+        //#region Composite functions
+
         /**
-         * Extract a single channel from a multi-channel image.
-         * @param 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 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 channels one or more images (file paths, Buffers).
-         * @param options image options
+         * Overlay (composite) an image over the processed (resized, extracted etc.) image.
+         *
+         * The overlay image must be the same size or smaller than the processed image.
+         * If both top and left options are provided, they take precedence over gravity.
+         *
+         * If the overlay image contains an alpha channel then composition with premultiplication will occur.
+         * @param image Buffer containing image data or String containing the path to an image file.
+         * @param options overlay options
          * @throws {Error} Invalid parameters
          * @returns A sharp instance that can be used to chain operations
          */
-        joinChannel(channels: string | string[] | Buffer | Buffer[], options?: { raw: Raw }): SharpInstance;
+        overlayWith(image: string | Buffer, options?: OverlayOptions): Sharp;
+
+        //#endregion
+
+        //#region Input functions
+
         /**
-         * Perform a bitwise boolean operation on all input image channels (bands) to produce a single channel output image.
-         * @param boolOp one of and, or or eor to perform that bitwise operation, like the C logic operators &, | and ^ respectively.
+         * Take a "snapshot" of the Sharp instance, returning a new instance.
+         * Cloned instances inherit the input of their parent instance.
+         * This allows multiple output Streams and therefore multiple processing pipelines to share a single input Stream.
          * @returns A sharp instance that can be used to chain operations
          */
-        bandbool(boolOp: string): SharpInstance;
+        clone(): Sharp;
+
+        /**
+         * Fast access to (uncached) image metadata without decoding any compressed image data.
+         * @returns A sharp instance that can be used to chain operations
+         */
+        metadata(callback: (err: Error, metadata: Metadata) => void): Sharp;
+
+        /**
+         * Fast access to (uncached) image metadata without decoding any compressed image data.
+         * @returns A promise that resolves with a metadata object
+         */
+        metadata(): Promise<Metadata>;
+
+        /**
+         * Access to pixel-derived image statistics for every channel in the image.
+         * @returns A sharp instance that can be used to chain operations
+         */
+        stats(callback: (err: Error, stats: Stats) => void): Sharp;
+
+        /**
+         * Access to pixel-derived image statistics for every channel in the image.
+         * @returns A promise that resolves with a stats object
+         */
+        stats(): Promise<Stats>;
+
+        /**
+         * Do not process input images where the number of pixels (width _ height) exceeds this limit.
+         * Assumes image dimensions contained in the input metadata can be trusted.
+         * The default limit is 268402689 (0x3FFF _ 0x3FFF) pixels.
+         * @param limit An integral Number of pixels, zero or false to remove limit, true to use default limit.
+         * @throws {Error} Invalid limit
+         * @returns A sharp instance that can be used to chain operations
+         */
+        limitInputPixels(limit: number | boolean): Sharp;
+
+        /**
+         * An advanced setting that switches the libvips access method to VIPS_ACCESS_SEQUENTIAL.
+         * This will reduce memory usage and can improve performance on some systems.
+         * The default behaviour before function call is false, meaning the libvips access method is not sequential.
+         * @param sequentialRead true to enable and false to disable (defaults to true)
+         * @returns A sharp instance that can be used to chain operations
+         */
+        sequentialRead(sequentialRead?: boolean): Sharp;
+
+        //#endregion
+
+        //#region Operation functions
+
+        /**
+         * Rotate the output image by either an explicit angle or auto-orient based on the EXIF Orientation tag.
+         *
+         * If an angle is provided, it is converted to a valid positive degree rotation. For example, -450 will produce a 270deg rotation.
+         *
+         * When rotating by an angle other than a multiple of 90, the background colour can be provided with the background option.
+         *
+         * If no angle is provided, it is determined from the EXIF data. Mirroring is supported and may infer the use of a flip operation.
+         *
+         * The use of rotate implies the removal of the EXIF Orientation tag, if any.
+         *
+         * Method order is important when both rotating and extracting regions, for example rotate(x).extract(y) will produce a different result to extract(y).rotate(x).
+         * @param angle angle of rotation. (optional, default auto)
+         * @param options if present, is an Object with optional attributes.
+         * @throws {Error} Invalid parameters
+         * @returns A sharp instance that can be used to chain operations
+         */
+        rotate(angle?: number, options?: RotateOptions): Sharp;
+
+        /**
+         * Flip the image about the vertical Y axis. This always occurs after rotation, if any.
+         * The use of flip implies the removal of the EXIF Orientation tag, if any.
+         * @param flip true to enable and false to disable (defaults to true)
+         * @returns A sharp instance that can be used to chain operations
+         */
+        flip(flip?: boolean): Sharp;
+
+        /**
+         * Flop the image about the horizontal X axis. This always occurs after rotation, if any.
+         * The use of flop implies the removal of the EXIF Orientation tag, if any.
+         * @param flop true to enable and false to disable (defaults to true)
+         * @returns A sharp instance that can be used to chain operations
+         */
+        flop(flop?: boolean): Sharp;
+
+        /**
+         * Sharpen the image.
+         * When used without parameters, performs a fast, mild sharpen of the output image.
+         * When a sigma is provided, performs a slower, more accurate sharpen of the L channel in the LAB colour space.
+         * Separate control over the level of sharpening in "flat" and "jagged" areas is available.
+         * @param sigma the sigma of the Gaussian mask, where sigma = 1 + radius / 2.
+         * @param flat the level of sharpening to apply to "flat" areas. (optional, default 1.0)
+         * @param jagged the level of sharpening to apply to "jagged" areas. (optional, default 2.0)
+         * @throws {Error} Invalid parameters
+         * @returns A sharp instance that can be used to chain operations
+         */
+        sharpen(sigma?: number, flat?: number, jagged?: number): Sharp;
+
+        /**
+         * Apply median filter. When used without parameters the default window is 3x3.
+         * @param size square mask size: size x size (optional, default 3)
+         * @throws {Error} Invalid parameters
+         * @returns A sharp instance that can be used to chain operations
+         */
+        median(size?: number): Sharp;
+
+        /**
+         * Blur the image.
+         * When used without parameters, performs a fast, mild blur of the output image.
+         * When a sigma is provided, performs a slower, more accurate Gaussian blur.
+         * @param 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 A sharp instance that can be used to chain operations
+         */
+        blur(sigma?: number): Sharp;
+
+        /**
+         * Merge alpha transparency channel, if any, with background.
+         * @param flatten true to enable and false to disable (defaults to true)
+         * @returns A sharp instance that can be used to chain operations
+         */
+        flatten(flatten?: boolean | FlattenOptions): Sharp;
+
+        /**
+         * 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.
+         * This can improve the perceived brightness of a resized image in non-linear colour spaces.
+         * JPEG and WebP input images will not take advantage of the shrink-on-load performance optimisation when applying a gamma correction.
+         * @param gamma value between 1.0 and 3.0. (optional, default 2.2)
+         * @throws {Error} Invalid parameters
+         * @returns A sharp instance that can be used to chain operations
+         */
+        gamma(gamma?: number): Sharp;
+
+        /**
+         * Produce the "negative" of the image.
+         * @param negate true to enable and false to disable (defaults to true)
+         * @returns A sharp instance that can be used to chain operations
+         */
+        negate(negate?: boolean): Sharp;
+
+        /**
+         * Enhance output image contrast by stretching its luminance to cover the full dynamic range.
+         * @param normalise true to enable and false to disable (defaults to true)
+         * @returns A sharp instance that can be used to chain operations
+         */
+        normalise(normalise?: boolean): Sharp;
+
+        /**
+         * Alternative spelling of normalise.
+         * @param normalize true to enable and false to disable (defaults to true)
+         * @returns A sharp instance that can be used to chain operations
+         */
+        normalize(normalize?: boolean): Sharp;
+
+        /**
+         * Convolve the image with the specified kernel.
+         * @param kernel the specified kernel
+         * @throws {Error} Invalid parameters
+         * @returns A sharp instance that can be used to chain operations
+         */
+        convolve(kernel: Kernel): Sharp;
+
+        /**
+         * Any pixel value greather than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
+         * @param threshold a value in the range 0-255 representing the level at which the threshold will be applied. (optional, default 128)
+         * @param options threshold options
+         * @throws {Error} Invalid parameters
+         * @returns A sharp instance that can be used to chain operations
+         */
+        threshold(threshold?: number, options?: ThresholdOptions): Sharp;
+
         /**
          * Perform a bitwise boolean operation with operand image.
-         * @param image Buffer containing image data or String containing the path to an image file.
-         * @param operator one of and, or or eor to perform that bitwise operation, like the C logic operators &, | and ^ respectively.
+         * This operation creates an output image where each pixel is the result of the selected bitwise boolean operation between the corresponding pixels of the input images.
+         * @param operand Buffer containing image data or String containing the path to an image file.
+         * @param operator one of "and", "or" or "eor" to perform that bitwise operation, like the C logic operators &, | and ^ respectively.
          * @param options describes operand when using raw pixel data.
          * @throws {Error} Invalid parameters
          * @returns A sharp instance that can be used to chain operations
          */
-        linear(multiplier?: number, offset?: number): SharpInstance;
+        boolean(operand: string | Buffer, operator: string, options?: { raw: Raw }): Sharp;
+
         /**
-         * 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 multiplier value between 0.0 and 1.0. (optional, default 1.0)
-         * @param offset value between 0.0 and 1.0. (optional, default 0.0)
+         * Apply the linear formula a * input + b to the image (levels adjustment)
+         * @param a multiplier (optional, default 1.0)
+         * @param b offset (optional, default 0.0)
          * @throws {Error} Invalid parameters
          * @returns A sharp instance that can be used to chain operations
          */
-        boolean(operand: string | Buffer, operator: string, options?: { raw: Raw }): SharpInstance;
+        linear(a?: number, b?: number): Sharp;
+
+        //#endregion
+
+        //#region Output functions
+
         /**
          * Write output image data to a file.
+         * If an explicit output format is not selected, it will be inferred from the extension, with JPEG, PNG, WebP, TIFF, DZI, and libvips' V format supported.
+         * Note that raw pixel data is only supported for buffer output.
          * @param fileOut The path to write the image data to.
          * @param 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 A sharp instance that can be used to chain operations
          */
-        toFile(fileOut: string, callback: (err: Error, info: OutputInfo) => void): SharpInstance;
+        toFile(fileOut: string, callback: (err: Error, info: OutputInfo) => void): Sharp;
+
         /**
          * Write output image data to a file.
          * @param fileOut The path to write the image data to.
@@ -357,61 +428,82 @@ declare namespace sharp {
          * @returns 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.
+         * Write output to a Buffer. JPEG, PNG, WebP, TIFF and RAW output are supported.
+         * By default, the format will match the input image, except GIF and SVG input which become PNG output.
          * @param 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 A sharp instance that can be used to chain operations
          */
-        toBuffer(callback: (err: Error, buffer: Buffer, info: OutputInfo) => void): SharpInstance;
+        toBuffer(callback: (err: Error, buffer: Buffer, info: OutputInfo) => void): Sharp;
+
         /**
-         * 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.
+         * Write output to a Buffer. JPEG, PNG, WebP, TIFF and RAW output are supported.
+         * By default, the format will match the input image, except GIF and SVG input which become PNG output.
          * @param options resolve options
-         * @returns A promise that fulfills with the resulting Buffer
+         * @param options.resolveWithObject Resolve the Promise with an Object containing data and info properties instead of resolving only with data.
+         * @returns A promise that resolves with the Buffer data.
          */
         toBuffer(options?: { resolveWithObject: false }): Promise<Buffer>;
+
         /**
-         * 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.
+         * Write output to a Buffer. JPEG, PNG, WebP, TIFF and RAW output are supported.
+         * By default, the format will match the input image, except GIF and SVG input which become PNG output.
          * @param options resolve options
-         * @returns A promise that fulfills with an object containing the Buffer data and an info object containing the output image format, size (bytes), width, height and channels
+         * @param options.resolveWithObject Resolve the Promise with an Object containing data and info properties instead of resolving only with data.
+         * @returns A promise that resolves with an object containing the Buffer data and an info object containing the output image format, size (bytes), width, height and channels
          */
         toBuffer(options: { resolveWithObject: true }): Promise<{ data: Buffer, info: OutputInfo }>;
+
+        /**
+         * 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 withMetadata
+         * @throws {Error} Invalid parameters.
+         */
+        withMetadata(withMetadata?: WriteableMetadata): Sharp;
+
         /**
          * Use these JPEG options for output image.
          * @param options Output options.
          * @throws {Error} Invalid options
          * @returns A sharp instance that can be used to chain operations
          */
-        jpeg(options?: JpegOptions): SharpInstance;
+        jpeg(options?: JpegOptions): Sharp;
+
         /**
          * Use these PNG options for output image.
+         * PNG output is always full colour at 8 or 16 bits per pixel.
+         * Indexed PNG input at 1, 2 or 4 bits per pixel is converted to 8 bits per pixel.
          * @param options Output options.
          * @throws {Error} Invalid options
          * @returns A sharp instance that can be used to chain operations
          */
-        png(options?: PngOptions): SharpInstance;
+        png(options?: PngOptions): Sharp;
+
         /**
          * Use these WebP options for output image.
          * @param options Output options.
          * @throws {Error} Invalid options
          * @returns A sharp instance that can be used to chain operations
          */
-        webp(options?: WebpOptions): SharpInstance;
+        webp(options?: WebpOptions): Sharp;
+
         /**
          * Use these TIFF options for output image.
          * @param options Output options.
          * @throws {Error} Invalid options
          * @returns A sharp instance that can be used to chain operations
          */
-        tiff(options?: TiffOptions): SharpInstance;
+        tiff(options?: TiffOptions): Sharp;
+
         /**
          * Force output to be raw, uncompressed uint8 pixel data.
          * @returns A sharp instance that can be used to chain operations
          */
-        raw(): SharpInstance;
+        raw(): Sharp;
+
         /**
          * Force output to a given format.
          * @param format a String or an Object with an 'id' attribute
@@ -419,85 +511,219 @@ declare namespace sharp {
          * @throws {Error} Unsupported format or options
          * @returns A sharp instance that can be used to chain operations
          */
-        toFormat(format: string | AvailableFormatInfo, options?: OutputOptions | JpegOptions | PngOptions): SharpInstance;
+        toFormat(format: string | AvailableFormatInfo, options?: OutputOptions | JpegOptions | PngOptions | WebpOptions | TiffOptions): Sharp;
+
         /**
-         * 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.
-         * @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 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 options options
+         *
+         * Warning: multiple sharp instances concurrently producing tile output can expose a possible race condition in some versions of libgsf.
+         * @param tile tile options
+         * @throws {Error} Invalid options
+         * @returns A sharp instance that can be used to chain operations
          */
-        tile(options: TileOptions): SharpInstance;
+        tile(tile?: TileOptions): Sharp;
+
+        //#endregion
+
+        //#region Resize functions
+
+        /**
+         * Resize image to width, height or width x height.
+         *
+         * When both a width and height are provided, the possible methods by which the image should fit these are:
+         *  - cover: Crop to cover both provided dimensions (the default).
+         *  - contain: Embed within both provided dimensions.
+         *  - fill: Ignore the aspect ratio of the input and stretch to both provided dimensions.
+         *  - inside: Preserving aspect ratio, resize the image to be as large as possible while ensuring its dimensions are less than or equal to both those specified.
+         *  - outside: Preserving aspect ratio, resize the image to be as small as possible while ensuring its dimensions are greater than or equal to both those specified.
+         *             Some of these values are based on the object-fit CSS property.
+         *
+         * When using a fit of cover or contain, the default position is centre. Other options are:
+         *  - sharp.position: top, right top, right, right bottom, bottom, left bottom, left, left top.
+         *  - sharp.gravity: north, northeast, east, southeast, south, southwest, west, northwest, center or centre.
+         *  - sharp.strategy: cover only, dynamically crop using either the entropy or attention strategy. Some of these values are based on the object-position CSS property.
+         *
+         * The experimental strategy-based approach resizes so one dimension is at its target length then repeatedly ranks edge regions,
+         * discarding the edge with the lowest score based on the selected strategy.
+         *  - entropy: focus on the region with the highest Shannon entropy.
+         *  - attention: focus on the region with the highest luminance frequency, colour saturation and presence of skin tones.
+         *
+         * Possible interpolation kernels are:
+         *  - nearest: Use nearest neighbour interpolation.
+         *  - cubic: Use a Catmull-Rom spline.
+         *  - lanczos2: Use a Lanczos kernel with a=2.
+         *  - lanczos3: Use a Lanczos kernel with a=3 (the default).
+         *
+         * @param width pixels wide the resultant image should be. Use null or undefined to auto-scale the width to match the height.
+         * @param height pixels high the resultant image should be. Use null or undefined to auto-scale the height to match the width.
+         * @param options resize options
+         * @throws {Error} Invalid parameters
+         * @returns A sharp instance that can be used to chain operations
+         */
+        resize(width?: number|null, height?: number|null, options?: ResizeOptions): Sharp;
+
+        /**
+         * Extends/pads the edges of the image with the provided background colour.
+         * This operation will always occur after resizing and extraction, if any.
+         * @param extend single pixel count to add to all edges or an Object with per-edge counts
+         * @throws {Error} Invalid parameters
+         * @returns A sharp instance that can be used to chain operations
+         */
+        extend(extend: number | ExtendOptions): Sharp;
+
+        /**
+         * Extract a region of the image.
+         *  - Use extract() before resize() for pre-resize extraction.
+         *  - Use extract() after resize() for post-resize extraction.
+         *  - Use extract() before and after for both.
+         *
+         * @param region The region to extract
+         * @throws {Error} Invalid parameters
+         * @returns A sharp instance that can be used to chain operations
+         */
+        extract(region: Region): Sharp;
+
+        /**
+         * Trim "boring" pixels from all edges that contain values similar to the top-left pixel.
+         * The info response Object will contain trimOffsetLeft and trimOffsetTop properties.
+         * @param threshold The allowed difference from the top-left pixel, a number greater than zero. (optional, default 10)
+         * @throws {Error} Invalid parameters
+         * @returns A sharp instance that can be used to chain operations
+         */
+        trim(threshold?: number): Sharp;
+
+        //#endregion
     }
 
     interface SharpOptions {
-        /** integral number representing the DPI for vector images. */
+        /**
+         * By default apply a "best effort" to decode images, even if the data is corrupt or invalid.
+         * Set this flag to true if you'd rather halt processing and raise an error when loading invalid images.
+         * (optional, default false)
+         */
+        failOnError?: boolean;
+        /** Number representing the DPI for vector images. (optional, default 72) */
         density?: number;
-        /** describes raw pixel image data. */
+        /** Page number to extract for multi-page input (GIF, TIFF). (optional, default 0) */
+        page?: number;
+        /** Describes raw pixel input image data. See raw() for pixel ordering. */
         raw?: Raw;
-        /** describes a blank overlay to be created. */
+        /** Describes a new image to be created. */
         create?: Create;
     }
 
     interface CacheOptions {
-        /** is the maximum memory in MB to use for this cache */
+        /** Is the maximum memory in MB to use for this cache (optional, default 50) */
         memory?: number;
-        /** is the maximum number of files to hold open */
+        /** Is the maximum number of files to hold open (optional, default 20) */
         files?: number;
-        /** is the maximum number of operations to cache */
+        /** Is the maximum number of operations to cache (optional, default 100) */
         items?: number;
     }
 
     interface SharpCounters {
+        /** The number of tasks this module has queued waiting for libuv to provide a worker thread from its pool. */
         queue: number;
+        /** The number of resize tasks currently being processed. */
         process: number;
     }
 
     interface Raw {
         width: number;
         height: number;
-        channels: number;
+        channels: 1 | 2 | 3 | 4;
     }
 
     interface Create {
-        /** Number of pixels wide */
+        /** Number of pixels wide. */
         width: number;
-        /** Number of pixels high */
+        /** Number of pixels high. */
         height: number;
         /** Number of bands e.g. 3 for RGB, 4 for RGBA */
-        channels: number;
-        /** parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha. */
-        background: string | RGBA;
+        channels: Channels;
+        /** Parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha. */
+        background: Color;
     }
 
-    interface Metadata {
+    interface WriteableMetadata {
+        /** Number value of the EXIF Orientation header, if present */
+        orientation?: number;
+    }
+
+    interface Metadata extends WriteableMetadata {
         /** Name of decoder used to decompress image data e.g. jpeg, png, webp, gif, svg */
         format?: string;
-        /** Number of pixels wide */
+        /** Total size of image in bytes, for Stream and Buffer input only */
+        size?: number;
+        /** Number of pixels wide (EXIF orientation is not taken into consideration) */
         width?: number;
-        /** Number of pixels high */
+        /** Number of pixels high (EXIF orientation is not taken into consideration) */
         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;
+        channels?: Channels;
+        /** Name of pixel depth format e.g. uchar, char, ushort, float ... */
+        depth?: string;
         /** Number of pixels per inch (DPI), if present */
         density?: number;
+        /** String containing JPEG chroma subsampling, 4:2:0 or 4:4:4 for RGB, 4:2:0:4 or 4:4:4:4 for CMYK */
+        chromaSubsampling: string;
+        /** Boolean indicating whether the image is interlaced using a progressive scan */
+        isProgressive?: boolean;
         /** 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;
+        /** Buffer containing raw IPTC data, if present */
+        iptc?: Buffer;
+        /** Buffer containing raw XMP data, if present */
+        xmp?: Buffer;
+    }
+
+    interface Stats {
+        /** Array of channel statistics for each channel in the image. */
+        channels: ChannelStats[];
+        /** Value to identify if the image is opaque or transparent, based on the presence and use of alpha channel */
+        isOpaque: boolean;
+        /** Histogram-based estimation of greyscale entropy, discarding alpha channel if any (experimental) */
+        entropy: number;
+    }
+
+    interface ChannelStats {
+        /** minimum value in the channel */
+        min: number;
+        /** maximum value in the channel */
+        max: number;
+        /** sum of all values in a channel */
+        sum: number;
+        /** sum of squared values in a channel */
+        squaresSum: number;
+        /** mean of the values in a channel */
+        mean: number;
+        /** standard deviation for the values in a channel */
+        stdev: number;
+        /** x-coordinate of one of the pixel where the minimum lies */
+        minX: number;
+        /** y-coordinate of one of the pixel where the minimum lies */
+        minY: number;
+        /** x-coordinate of one of the pixel where the maximum lies */
+        maxX: number;
+        /** y-coordinate of one of the pixel where the maximum lies */
+        maxY: number;
+    }
+
+    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;
     }
 
     interface JpegOptions extends OutputOptions {
@@ -513,6 +739,14 @@ declare namespace sharp {
         optimiseScans?: boolean;
         /** Alternative spelling of optimiseScans (optional, default false) */
         optimizeScans?: boolean;
+        /** Optimise Huffman coding tables (optional, default true) */
+        optimiseCoding?: boolean;
+        /** Alternative spelling of optimiseCoding (optional, default true) */
+        optimizeCoding?: boolean;
+        /** Quantization table to use, integer 0-8, requires mozjpeg (optional, default 0) */
+        quantisationTable?: number;
+        /** Alternative spelling of quantisationTable (optional, default 0) */
+        quantizationTable?: number;
     }
 
     interface WebpOptions extends OutputOptions {
@@ -525,9 +759,9 @@ declare namespace sharp {
     }
 
     interface TiffOptions extends OutputOptions {
-        /** Compression options: lzw, deflate, jpeg (optional, default 'jpeg') */
+        /** Compression options: lzw, deflate, jpeg, ccittfax4 (optional, default 'jpeg') */
         compression?: string;
-        /** Compression predictor options: none, horizontal, float (optional, default  'horizontal') */
+        /** Compression predictor options: none, horizontal, float (optional, default 'horizontal') */
         predictor?: string;
         /** Horizontal resolution in pixels/mm (optional, default 1.0) */
         xres?: number;
@@ -540,41 +774,52 @@ declare namespace sharp {
     interface PngOptions {
         /** Use progressive (interlace) scan (optional, default false) */
         progressive?: boolean;
-        /** zlib compression level (optional, default 6) */
+        /** zlib compression level, 0-9 (optional, default 9) */
         compressionLevel?: number;
-        /** Use adaptive row filtering (optional, default true) */
+        /** use adaptive row filtering (optional, default false) */
         adaptiveFiltering?: boolean;
         /** Force PNG output, otherwise attempt to use input format (optional, default  true) */
         force?: boolean;
     }
 
-    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;
+    interface RotateOptions {
+        /** parsed by the color module to extract values for red, green, blue and alpha. (optional, default "#000000") */
+        background?: Color;
+    }
+
+    interface FlattenOptions {
+        /** background colour, parsed by the color module, defaults to black. (optional, default {r:0,g:0,b:0}) */
+        background?: Color;
     }
 
     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;
+        /** Alternative means of specifying width. If both are present this take priority. */
+        width?: number;
+        /** Alternative means of specifying height. If both are present this take priority. */
+        height?: number;
+        /** How the image should be resized to fit both provided dimensions, one of cover, contain, fill, inside or outside. (optional, default 'cover') */
+        fit?: keyof FitEnum;
+        /** Position, gravity or strategy to use when fit is cover or contain. (optional, default 'centre') */
+        position?: number | string;
+        /** Background colour when using a fit of contain, parsed by the color module, defaults to black without transparency. (optional, default {r:0,g:0,b:0,alpha:1}) */
+        background?: Color;
+        /** The kernel to use for image reduction. (optional, default 'lanczos3') */
+        kernel?: keyof KernelEnum;
+        /** Do not enlarge if the width or height are already less than the specified dimensions, equivalent to GraphicsMagick's > geometry option. (optional, default false) */
+        withoutEnlargement?: boolean;
+        /** Take greater advantage of the JPEG and WebP shrink-on-load feature, which can lead to a slight moiré pattern on some images. (optional, default true) */
+        fastShrinkOnLoad?: boolean;
     }
 
     interface Region {
         /** zero-indexed offset from left edge */
-        left?: number;
+        left: number;
         /** zero-indexed offset from top edge */
-        top?: number;
+        top: number;
         /** dimension of extracted image */
-        width?: number;
+        width: number;
         /** dimension of extracted image */
-        height?: number;
+        height: number;
     }
 
     interface ExtendOptions {
@@ -582,8 +827,13 @@ declare namespace sharp {
         left?: number;
         bottom?: number;
         right?: number;
+        /** Background colour, parsed by the color module, defaults to black without transparency. (optional, default {r:0,g:0,b:0,alpha:1}) */
+        background?: Color;
     }
 
+    /** 3 for sRGB, 4 for CMYK */
+    type Channels = 3 | 4;
+
     interface RGBA {
         r?: number;
         g?: number;
@@ -591,13 +841,15 @@ declare namespace sharp {
         alpha?: number;
     }
 
+    type Color = string | RGBA;
+
     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[];
+        kernel: ArrayLike<number>;
         /** the scale of the kernel in pixels. (optional, default sum) */
         scale?: number;
         /** the offset of the kernel in pixels. (optional, default 0) */
@@ -613,7 +865,7 @@ declare namespace sharp {
 
     interface OverlayOptions {
         /** gravity at which to place the overlay. (optional, default 'centre') */
-        gravity?: number;
+        gravity?: Gravity;
         /** the pixel offset from the top edge. */
         top?: number;
         /** the pixel offset from the left edge. */
@@ -622,8 +874,12 @@ declare namespace sharp {
         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;
+        /** number representing the DPI for vector overlay image. (optional, default 72) */
+        density?: number;
         /** describes overlay when using raw pixel data. */
         raw?: Raw;
+        /** describes a blank overlay to be created. */
+        create?: Create;
     }
 
     interface TileOptions {
@@ -631,9 +887,13 @@ declare namespace sharp {
         size?: number;
         /** Tile overlap in pixels, a value between 0 and 8192. (optional, default 0) */
         overlap?: number;
+        /** Tile angle of rotation, must be a multiple of 90. (optional, default 0) */
+        angle?: number;
+        /** How deep to make the pyramid, possible values are "onepixel", "onetile" or "one" (default based on layout) */
+        depth?: string;
         /** 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') */
+        /** Filesystem layout, possible values are dz, zoomify or google. (optional, default 'dz') */
         layout?: string;
     }
 
@@ -643,6 +903,12 @@ declare namespace sharp {
         width: number;
         height: number;
         channels: number;
+        /** indicating if premultiplication was used */
+        premultiplied: boolean;
+        /** Only defined when using a crop strategy */
+        cropOffsetLeft?: number;
+        /** Only defined when using a crop strategy */
+        cropOffsetTop?: number;
     }
 
     interface AvailableFormatInfo {
@@ -651,27 +917,25 @@ declare namespace sharp {
         output: { file: boolean; buffer: boolean; stream: boolean; };
     }
 
-    interface KernelEnum {
-        cubic: string;
-        lanczos2: string;
-        lanczos3: string;
+    interface FitEnum {
+        contain: "contain";
+        cover: "cover";
+        fill: "fill";
+        inside: "inside";
+        outside: "outside";
     }
 
-    interface InterpolatorEnum {
-        nearest: string;
-        bilinear: string;
-        bicubic: string;
-        nohalo: string;
-        lbb: string;
-        locallyBoundedBicubic: string;
-        vsqbs: string;
-        vertexSplitQuadraticBasisSpline: string;
+    interface KernelEnum {
+        nearest: "nearest";
+        cubic: "cubic";
+        lanczos2: "lanczos2";
+        lanczos3: "lanczos3";
     }
 
     interface BoolEnum {
-        and: string;
-        or: string;
-        eor: string;
+        and: "and";
+        or: "or";
+        eor: "eor";
     }
 
     interface ColourspaceEnum {
@@ -682,6 +946,8 @@ declare namespace sharp {
         srgb: string;
     }
 
+    type Gravity = number | string;
+
     interface GravityEnum {
         north: number;
         northeast: number;
diff --git a/types/sharp/sharp-tests.ts b/types/sharp/sharp-tests.ts
index f3c2c8a7ce..8c02e8c98f 100644
--- a/types/sharp/sharp-tests.ts
+++ b/types/sharp/sharp-tests.ts
@@ -25,8 +25,7 @@ sharp('3-channel-rgb-input.png')
 sharp('input.png')
     .rotate(180)
     .resize(300)
-    .flatten()
-    .background('#ff6600')
+    .flatten({ background: "#ff6600" })
     .overlayWith('overlay.png', { gravity: sharp.gravity.southeast })
     .sharpen()
     .withMetadata()
@@ -72,14 +71,14 @@ sharp.queue.on('change', (queueLength: number) => {
     console.log(`Queue contains ${queueLength} task(s)`);
 });
 
-let pipeline: sharp.SharpInstance = sharp().rotate();
+let pipeline: sharp.Sharp = 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);
+const image: sharp.Sharp = sharp(input);
 image
     .metadata()
     .then<Buffer|undefined>((metadata: sharp.Metadata) => {
@@ -121,8 +120,7 @@ sharp(input)
 // 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 })
+    .resize(140, null, { background: { r: 0, g: 0, b: 0, alpha: 0 } })
     .extend({ top: 10, bottom: 20, left: 10, right: 10 });
 
 sharp(input)
@@ -149,11 +147,11 @@ sharp('input.tiff')
 
 sharp(input)
     .resize(200, 300, {
+        fit: "contain",
+        position: "north",
         kernel: sharp.kernel.lanczos2,
-        interpolator: sharp.interpolator.nohalo
+        background: "white"
     })
-    .background('white')
-    .embed()
     .toFile('output.tiff')
     .then(() => {
         // output.tiff is a 200 pixels wide and 300 pixels high image
@@ -162,8 +160,10 @@ sharp(input)
     });
 
 transformer = sharp()
-    .resize(200, 200)
-    .crop(sharp.strategy.entropy)
+    .resize(200, 200, {
+        fit: "cover",
+        position: sharp.strategy.entropy
+    })
     .on('error', (err: Error) => {
         console.log(err);
     });
@@ -172,9 +172,11 @@ transformer = sharp()
 readableStream.pipe(transformer).pipe(writableStream);
 
 sharp('input.gif')
-    .resize(200, 300)
-    .background({ r: 0, g: 0, b: 0, alpha: 0 })
-    .embed()
+    .resize(200, 300, {
+        fit: "contain",
+        position: "north",
+        background: { r: 0, g: 0, b: 0, alpha: 0 }
+    })
     .toFormat(sharp.format.webp)
     .toBuffer((err: Error, outputBuffer: Buffer) => {
         if (err) {
@@ -185,8 +187,7 @@ sharp('input.gif')
     });
 
 sharp(input)
-    .resize(200, 200)
-    .max()
+    .resize(200, 200, { fit: "inside" })
     .toFormat('jpeg')
     .toBuffer()
     .then((outputBuffer: Buffer) => {
diff --git a/types/shuffle-seed/index.d.ts b/types/shuffle-seed/index.d.ts
new file mode 100644
index 0000000000..a2559d0eea
--- /dev/null
+++ b/types/shuffle-seed/index.d.ts
@@ -0,0 +1,9 @@
+// Type definitions for shuffle-seed 1.1
+// Project: https://github.com/webcaetano/shuffle-seed#readme
+// Definitions by: Leonardo Donelli <https://github.com/LeartS>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export as namespace shuffleSeed;
+
+export function shuffle<T>(arr: ReadonlyArray<T>, seed: any): T[];
+export function unshuffle<T>(arr: ReadonlyArray<T>, seed: any): T[];
diff --git a/types/shuffle-seed/shuffle-seed-tests.ts b/types/shuffle-seed/shuffle-seed-tests.ts
new file mode 100644
index 0000000000..d8d1e4d8d4
--- /dev/null
+++ b/types/shuffle-seed/shuffle-seed-tests.ts
@@ -0,0 +1,8 @@
+import { shuffle, unshuffle } from "shuffle-seed";
+
+const originalArray = [1, "hello world", 132.81];
+const shuffled1 = shuffle(originalArray, "randomseed");
+const shuffled2 = shuffle(originalArray, "randomseed");
+const unshuffled = unshuffle(shuffled2, "randomseed");
+// shuffled1 === shuffled2
+// unshuffled === originalArray
diff --git a/types/shuffle-seed/tsconfig.json b/types/shuffle-seed/tsconfig.json
new file mode 100644
index 0000000000..8e2a81c6c5
--- /dev/null
+++ b/types/shuffle-seed/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+	"strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "shuffle-seed-tests.ts"
+    ]
+}
diff --git a/types/shuffle-seed/tslint.json b/types/shuffle-seed/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/shuffle-seed/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/single-spa-react/tsconfig.json b/types/single-spa-react/tsconfig.json
index 3ccb45cf0c..4204827d4d 100644
--- a/types/single-spa-react/tsconfig.json
+++ b/types/single-spa-react/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/skatejs/tslint.json b/types/skatejs/tslint.json
index d88586e5bd..f6b9fabaee 100644
--- a/types/skatejs/tslint.json
+++ b/types/skatejs/tslint.json
@@ -1,3 +1,12 @@
 {
-  "extends": "dtslint/dt.json"
-}
+    "extends": "dtslint/dt.json",
+    "rules": {
+        // All are TODOs
+        "array-type": false,
+        "interface-over-type-literal": false,
+        "no-redundant-undefined": false,
+        "no-unnecessary-generics": false,
+        "prefer-declare-function": false,
+        "strict-export-declare-modifiers": false
+    }
+}
\ No newline at end of file
diff --git a/types/skatejs/types.d.ts b/types/skatejs/types.d.ts
index 3c368bd67f..0e6d304996 100644
--- a/types/skatejs/types.d.ts
+++ b/types/skatejs/types.d.ts
@@ -107,6 +107,6 @@ export interface EventOptions extends CustomEventInit {
   composed?: boolean;
 }
 export interface ComposedCustomEvent extends CustomEvent {
-  composed?: boolean;
-  composedPath?: () => Array<Node>;
+  composed: boolean;
+  composedPath: () => Array<Node>;
 }
diff --git a/types/slate/package.json b/types/slate/package.json
index 67c9c004ef..12231bb461 100644
--- a/types/slate/package.json
+++ b/types/slate/package.json
@@ -3,4 +3,4 @@
     "dependencies": {
         "immutable": "^3.8.2"
     }
-}
\ No newline at end of file
+}
diff --git a/types/snappy/tsconfig.json b/types/snappy/tsconfig.json
index d9d466288e..a566b85ef2 100644
--- a/types/snappy/tsconfig.json
+++ b/types/snappy/tsconfig.json
@@ -2,7 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es5"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/snowball-stemmers/index.d.ts b/types/snowball-stemmers/index.d.ts
new file mode 100644
index 0000000000..f5012068ef
--- /dev/null
+++ b/types/snowball-stemmers/index.d.ts
@@ -0,0 +1,12 @@
+// Type definitions for snowball-stemmers 0.6
+// Project: https://github.com/mazko/jssnowball#readme
+// Definitions by: Ryan Volum <https://github.com/ryanvolum>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export interface Stemmer {
+    stem(term: string): string;
+}
+
+export function newStemmer(locale: string): Stemmer;
+
+export function algorithms(): string[];
diff --git a/types/snowball-stemmers/snowball-stemmers-tests.ts b/types/snowball-stemmers/snowball-stemmers-tests.ts
new file mode 100644
index 0000000000..518b586fb8
--- /dev/null
+++ b/types/snowball-stemmers/snowball-stemmers-tests.ts
@@ -0,0 +1,4 @@
+import { newStemmer, Stemmer } from 'snowball-stemmers';
+
+const snowballStemmer = newStemmer('english');
+const stem = snowballStemmer.stem("swimmingly");
diff --git a/types/snowball-stemmers/tsconfig.json b/types/snowball-stemmers/tsconfig.json
new file mode 100644
index 0000000000..234ced0829
--- /dev/null
+++ b/types/snowball-stemmers/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "snowball-stemmers-tests.ts"
+    ]
+}
diff --git a/types/snowball-stemmers/tslint.json b/types/snowball-stemmers/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/snowball-stemmers/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/sprintf-js/index.d.ts b/types/sprintf-js/index.d.ts
index 67d6bba4a8..e825228429 100644
--- a/types/sprintf-js/index.d.ts
+++ b/types/sprintf-js/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://www.npmjs.com/package/sprintf-js
 // Definitions by: Jason Swearingen <https://github.com/jasonswearingen>
 //                 BendingBender <https://github.com/BendingBender>
+//                 Caner Dagli <https://github.com/cdagli>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /**
@@ -161,8 +162,3 @@ export function sprintf(format: string, ...args: any[]): string;
  * @param args: the arguments for the format string
  */
 export function vsprintf(format: string, args: any[]): string;
-
-declare global {
-    function sprintf(format: string, ...args: any[]): string;
-    function vsprintf(format: string, args: any[]): string;
-}
diff --git a/types/storage-helper/index.d.ts b/types/storage-helper/index.d.ts
new file mode 100644
index 0000000000..2711ef40d1
--- /dev/null
+++ b/types/storage-helper/index.d.ts
@@ -0,0 +1,22 @@
+// Type definitions for storage-helper 1.4
+// Project: https://github.com/MatteoGabriele/storage-helper#readme
+// Definitions by: Klaus Meinhardt <https://github.com/ajafff>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+export function clear(): void;
+export function showStorageLogger(enabled: boolean): void;
+export function setItem(key: string, value: string, permanent?: boolean): void;
+export function getItem<T extends boolean | undefined = false, U = undefined>(key: string, parse?: T, fallback?: U): T extends true ? any : string | NonNullable<U> | null;
+export function removeItem(key: string): void;
+
+declare const storageHelper: {
+    setItem: typeof setItem;
+    getItem: typeof getItem;
+    removeItem: typeof removeItem;
+    clear: typeof clear;
+};
+
+export default storageHelper;
+
+export as namespace StorageHelper;
diff --git a/types/storage-helper/storage-helper-tests.ts b/types/storage-helper/storage-helper-tests.ts
new file mode 100644
index 0000000000..8a3fb9f879
--- /dev/null
+++ b/types/storage-helper/storage-helper-tests.ts
@@ -0,0 +1,26 @@
+import storageHelper, { setItem, getItem, removeItem, clear, showStorageLogger } from 'storage-helper';
+
+storageHelper.setItem('foo', 'bar');
+storageHelper.setItem('foo', 'baz', true);
+storageHelper.setItem('foo', 'bas', false);
+
+storageHelper.getItem('foo'); // $ExpectType string | null
+storageHelper.getItem('foo', false); // $ExpectType string | null
+storageHelper.getItem('foo', undefined); // $ExpectType string | null
+storageHelper.getItem('foo', false, Boolean() ? 1 : undefined); // $ExpectType string | number | null
+storageHelper.getItem('foo', false, 1); // $ExpectType string | number | null
+storageHelper.getItem('foo', false, undefined); // $ExpectType string | null
+storageHelper.getItem('foo', true); // $ExpectType any
+storageHelper.getItem('foo', true, 1); // $ExpectType any
+storageHelper.getItem('foo', Boolean()); // $ExpectType any
+
+storageHelper.removeItem('foo');
+
+storageHelper.clear();
+
+showStorageLogger(true);
+
+setItem('foo', 'bar');
+getItem('foo');
+removeItem('foo');
+clear();
diff --git a/types/storage-helper/tsconfig.json b/types/storage-helper/tsconfig.json
new file mode 100644
index 0000000000..b2b417b32f
--- /dev/null
+++ b/types/storage-helper/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true,
+        "strictFunctionTypes": true
+    },
+    "files": [
+        "index.d.ts",
+        "storage-helper-tests.ts"
+    ]
+}
diff --git a/types/storage-helper/tslint.json b/types/storage-helper/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/storage-helper/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/storybook__vue/package.json b/types/storybook__vue/package.json
index 667aabc813..881d263927 100644
--- a/types/storybook__vue/package.json
+++ b/types/storybook__vue/package.json
@@ -3,4 +3,4 @@
     "dependencies": {
         "vue": "^2.0.0"
     }
-}
\ No newline at end of file
+}
diff --git a/types/stripe/index.d.ts b/types/stripe/index.d.ts
index b28f84b9ca..732a58fc7d 100644
--- a/types/stripe/index.d.ts
+++ b/types/stripe/index.d.ts
@@ -987,7 +987,19 @@ declare namespace Stripe {
              *
              * Connect only.
              */
-            destination?: string;
+            destination?: string | {
+                /**
+                 * ID of the Stripe account this fee will be transferred to.
+                 */
+                account: string;
+
+                /**
+                 * A positive integer in the smallest currency unit (e.g 100 cents to charge
+                 * $1.00, or 1 to charge ¥1, a 0-decimal currency) reflecting the amount of the
+                 * charge to be transferred to the destination[account].
+                 */
+                amount?: number;
+            };
 
             /**
              * A string that identifies this transaction as part of a group.
@@ -5481,8 +5493,8 @@ declare namespace Stripe {
              * currency is not the Stripe account's default currency. Otherwise, you must set another external account to be the default for the currency
              * before deleting it.
              */
-            deleteExternalAccount(accId: string, id: string, options: HeaderOptions, response?: IResponseFn<cards.ICard | bankAccounts.IBankAccount>): Promise<cards.ICard | bankAccounts.IBankAccount>;
-            deleteExternalAccount(accId: string, id: string, response?: IResponseFn<cards.ICard | bankAccounts.IBankAccount>): Promise<cards.ICard | bankAccounts.IBankAccount>;
+            deleteExternalAccount(accId: string, id: string, options: HeaderOptions, response?: IResponseFn<IDeleteConfirmation>): Promise<IDeleteConfirmation>;
+            deleteExternalAccount(accId: string, id: string, response?: IResponseFn<IDeleteConfirmation>): Promise<IDeleteConfirmation>;
 
             /**
              * You can see a list of the bank accounts belonging to a managed account. Note that the 10 most recent external accounts are always
@@ -7353,7 +7365,11 @@ declare namespace Stripe {
         (err: IStripeError, value: R): void;
     }
 
-    interface IDeleteConfirmation { id: string; deleted: boolean; }
+    interface IDeleteConfirmation {
+        id: string;
+        object: string;
+        deleted: boolean;
+    }
 
     /**
      * A filter on the list based on this object field. The value can
diff --git a/types/stripejs/element.d.ts b/types/stripejs/element.d.ts
index 9a1b8b17e2..4a1e7b3c46 100644
--- a/types/stripejs/element.d.ts
+++ b/types/stripejs/element.d.ts
@@ -47,21 +47,9 @@ export interface ElementCreatorOptions {
      * The translation that should be used for the element text
      * `auto` defaults to the browser language
      *
-     * NOTE: Only use the `string` option in combination with
-     * @see isLanguageTag
-     *
      * @default 'auto'
      */
     locale?: 'auto' | 'da' | 'de' | 'en' | 'es' | 'fi' | 'fr' | 'it' | 'ja' | 'no' | 'nl' | 'sv' | 'zh' | string;
-
-    /**
-     * Whether or not the locale is written in a language code
-     * This can be used in combination with localization libraries so that language names won't have to be formatted
-     * @example `en-US`
-     *
-     * @since 0.1.0
-     */
-    isIETFLocaleTag?: boolean;
 }
 
 export interface FontCSSElement {
diff --git a/types/stripejs/stripejs-tests.ts b/types/stripejs/stripejs-tests.ts
index 06799c2df5..1c0625861c 100644
--- a/types/stripejs/stripejs-tests.ts
+++ b/types/stripejs/stripejs-tests.ts
@@ -24,7 +24,7 @@ describe('StripeJS', () => {
     it('Should be possible to create and modify elements', () => {
         const creator = stripe.elements();
         stripe.elements({fonts: [], locale: 'nl'});
-        stripe.elements({fonts: [], locale: 'nl', isIETFLocaleTag: true});
+        stripe.elements({fonts: [], locale: 'nl'});
 
         const element = creator.create("cardCvc", {value: {postalCode: '94110'}});
         element.blur();
diff --git a/types/styled-jsx/css.d.ts b/types/styled-jsx/css.d.ts
index bb50756afc..4ac7658f3a 100644
--- a/types/styled-jsx/css.d.ts
+++ b/types/styled-jsx/css.d.ts
@@ -1,8 +1,6 @@
-type Tag = {
-    (chunks: TemplateStringsArray, ...args: any[]): string;
-    global: (chunks: TemplateStringsArray, ...args: any[]) => string;
-    resolve: (chunks: TemplateStringsArray, ...args: any[]) => { className: string; styles: string };
-};
-
-declare let css: Tag;
+declare function css(chunks: TemplateStringsArray, ...args: any[]): string;
+declare namespace css {
+    function global(chunks: TemplateStringsArray, ...args: any[]): string;
+    function resolve(chunks: TemplateStringsArray, ...args: any[]): { className: string; styles: string };
+}
 export = css;
diff --git a/types/styled-jsx/server.d.ts b/types/styled-jsx/server.d.ts
index 7d67967842..16de5fbb72 100644
--- a/types/styled-jsx/server.d.ts
+++ b/types/styled-jsx/server.d.ts
@@ -1,7 +1,7 @@
 import { ReactElement } from "react";
 
 declare function flushToHTML(): string;
-declare function flushToReact<T>(): ReactElement<T>[];
+declare function flushToReact<T>(): Array<ReactElement<T>>;
 
 export { flushToHTML };
 export default flushToReact;
diff --git a/types/styled-jsx/tslint.json b/types/styled-jsx/tslint.json
index 3db14f85ea..3fc34b8203 100644
--- a/types/styled-jsx/tslint.json
+++ b/types/styled-jsx/tslint.json
@@ -1 +1,7 @@
-{ "extends": "dtslint/dt.json" }
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        // TODO
+        "no-unnecessary-generics": false
+    }
+}
diff --git a/types/styled-system/dist/styles.d.ts b/types/styled-system/dist/styles.d.ts
index b2a2a7cc27..ab045b3b4b 100644
--- a/types/styled-system/dist/styles.d.ts
+++ b/types/styled-system/dist/styles.d.ts
@@ -271,7 +271,6 @@ export type ResponsiveJustifyItemsValue = ResponsiveValue<JustifyItemsValue>;
 export interface JustifyItemsProps {
     justifyItems?: ResponsiveJustifyItemsValue;
 }
-export function alignContent(...args: any[]): any;
 
 export type JustifyContentValue =
     | "center"
diff --git a/types/styled-system/dist/util.d.ts b/types/styled-system/dist/util.d.ts
index ae90de60f8..445bb81567 100644
--- a/types/styled-system/dist/util.d.ts
+++ b/types/styled-system/dist/util.d.ts
@@ -10,7 +10,7 @@ export function cloneFunc(fn: (...args: any[]) => any): (...args: any[]) => any;
 
 export function merge(a: any, b: any): any;
 
-export function compose(...funcs: ((...args: any[]) => any)[]): (...args: any[]) => any;
+export function compose(...funcs: Array<(...args: any[]) => any>): (...args: any[]) => any;
 
 export function createMediaQuery(n: string): string;
 
diff --git a/types/stylenames/index.d.ts b/types/stylenames/index.d.ts
new file mode 100644
index 0000000000..68b32f4935
--- /dev/null
+++ b/types/stylenames/index.d.ts
@@ -0,0 +1,17 @@
+// Type definitions for stylenames 1.1
+// Project: https://github.com/kmathmann/stylenames
+// Definitions by: Ben Grynhaus <https://github.com/bengry>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.9
+
+export type StyleValueConditionFunction = () => boolean | null | undefined;
+
+export type StyleValueObject = Record<string | number, boolean | StyleValueConditionFunction>;
+
+export type StyleValue = null | undefined | string | StyleValueObject;
+
+export type StyleObject = Partial<Record<keyof CSSStyleDeclaration, StyleValue>>;
+
+declare function styleNames(styles: StyleObject): string;
+
+export default styleNames;
diff --git a/types/stylenames/stylenames-tests.ts b/types/stylenames/stylenames-tests.ts
new file mode 100644
index 0000000000..3150b55f5b
--- /dev/null
+++ b/types/stylenames/stylenames-tests.ts
@@ -0,0 +1,23 @@
+import styleNames from 'stylenames';
+
+styleNames(); // $ExpectError
+
+styleNames({ foo: 'block' }); // $ExpectError
+
+styleNames({ background: 1 }); // $ExpectError
+
+styleNames({ backgroundColor: { blue: 1 } }); // $ExpectError
+
+styleNames({
+	height: '120px',
+	width: {
+		'200px': false,
+	},
+});
+
+styleNames({
+	height: '120px',
+	width: {
+		'200px': true,
+	},
+});
diff --git a/types/stylenames/tsconfig.json b/types/stylenames/tsconfig.json
new file mode 100644
index 0000000000..8158cfaaf3
--- /dev/null
+++ b/types/stylenames/tsconfig.json
@@ -0,0 +1,16 @@
+{
+	"compilerOptions": {
+		"module": "commonjs",
+		"lib": ["es5", "dom"],
+		"noImplicitAny": true,
+		"noImplicitThis": true,
+		"strictNullChecks": true,
+		"strictFunctionTypes": true,
+		"baseUrl": "../",
+		"typeRoots": ["../"],
+		"types": [],
+		"noEmit": true,
+		"forceConsistentCasingInFileNames": true
+	},
+	"files": ["index.d.ts", "stylenames-tests.ts"]
+}
diff --git a/types/stylenames/tslint.json b/types/stylenames/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/stylenames/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/summernote/tsconfig.json b/types/summernote/tsconfig.json
index 127f97e02f..cfa86cb32d 100644
--- a/types/summernote/tsconfig.json
+++ b/types/summernote/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/superagent-bunyan/tsconfig.json b/types/superagent-bunyan/tsconfig.json
index 0118838dcd..af8c4e27dc 100644
--- a/types/superagent-bunyan/tsconfig.json
+++ b/types/superagent-bunyan/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/svg-sprite/index.d.ts b/types/svg-sprite/index.d.ts
index 82a1607d21..beef520495 100644
--- a/types/svg-sprite/index.d.ts
+++ b/types/svg-sprite/index.d.ts
@@ -2,10 +2,9 @@
 // Project: https://github.com/jkphl/svg-sprite
 // Definitions by: Qubo <https://github.com/tkqubo>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 /// <reference types="node" />
-/// <reference types="vinyl" />
-
 import File = require('vinyl');
 import { Logger } from 'winston';
 
diff --git a/types/swagger-schema-official/index.d.ts b/types/swagger-schema-official/index.d.ts
index 4722973cfb..e089d5dfe9 100644
--- a/types/swagger-schema-official/index.d.ts
+++ b/types/swagger-schema-official/index.d.ts
@@ -47,7 +47,7 @@ export interface BaseParameter {
 }
 
 export interface BodyParameter extends BaseParameter {
-  schema?: Referenceable<Schema>;
+  schema?: Schema;
 }
 
 export interface QueryParameter extends BaseParameter, BaseSchema {
@@ -87,19 +87,19 @@ export interface Path {
   options?: Operation;
   head?: Operation;
   patch?: Operation;
-  parameters?: Array<Referenceable<Parameter>>;
+  parameters?: Parameter[] | Reference[];
 }
 
 // ----------------------------- Operation -----------------------------------
 export interface Operation {
-  responses: { [responseName: string]: Referenceable<Response>};
+  responses: { [responseName: string]: Response | Reference};
   summary?: string;
   description?: string;
   externalDocs?: ExternalDocs;
   operationId?: string;
   produces?: string[];
   consumes?: string[];
-  parameters?: Array<Referenceable<Parameter>>;
+  parameters?: Parameter[] | Reference[];
   schemes?: string[];
   deprecated?: boolean;
   security?: Security[];
@@ -107,12 +107,14 @@ export interface Operation {
 }
 
 // ----------------------------- Reference -----------------------------------
-export type Referenceable<T> = { $ref: string; } | T;
+export interface Reference {
+  $ref: string;
+}
 
 // ----------------------------- Response ------------------------------------
 export interface Response {
   description: string;
-  schema?: Referenceable<Schema>;
+  schema?: Schema;
   headers?: { [headerName: string]: Header };
   examples?: { [exampleName: string]: {} };
 }
@@ -138,14 +140,14 @@ export interface BaseSchema {
   minProperties?: number;
   enum?: Array<string | boolean | number | {}>;
   type?: string;
-  items?: Referenceable<Schema>|Array<Referenceable<Schema>>;
+  items?: Schema|Schema[];
 }
 
 export interface Schema extends BaseSchema {
   $ref?: string;
-  allOf?: Array<Referenceable<Schema>>;
-  additionalProperties?: Referenceable<Schema>;
-  properties?: {[propertyName: string]: Referenceable<Schema>};
+  allOf?: Schema[];
+  additionalProperties?: Schema;
+  properties?: {[propertyName: string]: Schema};
   discriminator?: string;
   readOnly?: boolean;
   xml?: XML;
@@ -224,8 +226,8 @@ export interface Spec {
   schemes?: string[];
   consumes?: string[];
   produces?: string[];
-  paths: {[pathName: string]: Referenceable<Path>};
-  definitions?: {[definitionsName: string]: Referenceable<Schema> };
+  paths: {[pathName: string]: Path};
+  definitions?: {[definitionsName: string]: Schema };
   parameters?: {[parameterName: string]: BodyParameter|QueryParameter};
   responses?: {[responseName: string]: Response };
   security?: Array<{[securityDefinitionName: string]: string[]}>;
diff --git a/types/swig-email-templates/tsconfig.json b/types/swig-email-templates/tsconfig.json
index b25f125136..67d0c3ccdf 100644
--- a/types/swig-email-templates/tsconfig.json
+++ b/types/swig-email-templates/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/swiper/dist/js/swiper.esm.d.ts b/types/swiper/dist/js/swiper.esm.d.ts
index 32ee3b5815..8d0c49dd4b 100644
--- a/types/swiper/dist/js/swiper.esm.d.ts
+++ b/types/swiper/dist/js/swiper.esm.d.ts
@@ -1,9 +1,9 @@
-import Swiper, { DOM7Element } from '../..';
+import Swiper, { DOM7Element } from '../../index';
 
 // Reexport everything from `swiper` except the default export of the
 // `Swiper` class, which is instead provided as a named export by
 // `swiper.esm`.
-export * from '../..';
+export * from '../../index';
 export { Swiper };
 
 /*
diff --git a/types/tcp-port-used/index.d.ts b/types/tcp-port-used/index.d.ts
new file mode 100644
index 0000000000..4b715541ed
--- /dev/null
+++ b/types/tcp-port-used/index.d.ts
@@ -0,0 +1,24 @@
+// Type definitions for tcp-port-used 1.0
+// Project: https://github.com/stdarg/tcp-port-used
+// Definitions by: Gaute Johansen <https://github.com/gautejohan>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export interface TcpPortUsedOptions {
+    port: number;
+    host: string;
+    status: boolean;
+    retryTimeMs: number;
+    timeOutMs: number;
+}
+
+export function check(port: number | TcpPortUsedOptions, host?: string): Promise<boolean>;
+
+export function waitForStatus(port: number | TcpPortUsedOptions, host?: string, inUse?: boolean, retryTimeMs?: number, timeOutMs?: number): Promise<void>;
+
+export function waitUntilFree(port: number | TcpPortUsedOptions, retryTimeMs?: number, timeOutMs?: number): Promise<void>;
+
+export function waitUntilFreeOnHost(port: number | TcpPortUsedOptions, host?: string, retryTimeMs?: number, timeOutMs?: number): Promise<void>;
+
+export function waitUntilUsed(port: number | TcpPortUsedOptions, retryTimeMs?: number, timeOutMs?: number): Promise<void>;
+
+export function waitUntilUsedOnHost(port: number | TcpPortUsedOptions, host?: string, retryTimeMs?: number, timeOutMs?: number): Promise<void>;
diff --git a/types/tcp-port-used/tcp-port-used-tests.ts b/types/tcp-port-used/tcp-port-used-tests.ts
new file mode 100644
index 0000000000..9d1592bf59
--- /dev/null
+++ b/types/tcp-port-used/tcp-port-used-tests.ts
@@ -0,0 +1,103 @@
+import * as tpu from 'tcp-port-used';
+
+// $ExpectedType boolean
+tpu.check(20000).then((isUsed: boolean) => {
+    // $ExpectedType boolean
+    isUsed;
+});
+
+// $ExpectedType boolean
+tpu.check(20000, 'localhost').then((isUsed: boolean) => {
+    // $ExpectedType boolean
+    isUsed;
+});
+
+// $ExpectedType boolean
+tpu.check({
+    port: 20000,
+    host: '127.0.0.1',
+    status: false,
+    retryTimeMs: 2000,
+    timeOutMs: 2000
+}).then((isUsed: boolean) => {
+    // $ExpectedType boolean
+    isUsed;
+});
+
+// $ExpectError
+tpu.check();
+
+// $Expected promise void
+tpu.waitForStatus(20000, '127.0.0.1', true, 1000, 2000).then(() => { });
+
+// $Expected promise void
+tpu.waitForStatus({
+    port: 20000,
+    host: '127.0.0.1',
+    status: true,
+    retryTimeMs: 2000,
+    timeOutMs: 2000
+}).then(() => { });
+
+// $ExpectError
+tpu.waitForStatus();
+
+// $Expected promise void
+tpu.waitUntilFree(20000, 1000, 2000);
+
+// $Expected promise void
+tpu.waitUntilFree({
+    port: 20000,
+    host: '127.0.0.1',
+    status: true,
+    retryTimeMs: 2000,
+    timeOutMs: 2000
+}).then(() => { });
+
+// $ExpectError
+tpu.waitUntilFree();
+
+// $Expected promise void
+tpu.waitUntilFreeOnHost(20000, '127.0.0.1', 1000, 2000).then(() => { });
+
+// $Expected promise void
+tpu.waitUntilFreeOnHost({
+    port: 20000,
+    host: '127.0.0.1',
+    status: true,
+    retryTimeMs: 2000,
+    timeOutMs: 2000
+}).then(() => { });
+
+// $ExpectError
+tpu.waitUntilFreeOnHost();
+
+// $Expected promise void
+tpu.waitUntilUsed(20000, 1000, 2000).then(() => { });
+
+// $Expected promise void
+tpu.waitUntilUsed({
+    port: 20000,
+    host: '127.0.0.1',
+    status: true,
+    retryTimeMs: 2000,
+    timeOutMs: 2000
+}).then(() => { });
+
+// $ExpectError
+tpu.waitUntilUsed();
+
+// $Expected promise void
+tpu.waitUntilUsedOnHost(20000, '127.0.0.1', 1000, 2000).then(() => { });
+
+// $Expected promise void
+tpu.waitUntilUsedOnHost({
+    port: 20000,
+    host: '127.0.0.1',
+    status: true,
+    retryTimeMs: 2000,
+    timeOutMs: 2000
+}).then(() => { });
+
+// $ExpectError
+tpu.waitUntilUsedOnHost();
diff --git a/types/tcp-port-used/tsconfig.json b/types/tcp-port-used/tsconfig.json
new file mode 100644
index 0000000000..ac4cc2290f
--- /dev/null
+++ b/types/tcp-port-used/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "tcp-port-used-tests.ts"
+    ]
+}
\ No newline at end of file
diff --git a/types/tcp-port-used/tslint.json b/types/tcp-port-used/tslint.json
new file mode 100644
index 0000000000..f93cf8562a
--- /dev/null
+++ b/types/tcp-port-used/tslint.json
@@ -0,0 +1,3 @@
+{
+    "extends": "dtslint/dt.json"
+}
diff --git a/types/test-console/index.d.ts b/types/test-console/index.d.ts
new file mode 100644
index 0000000000..cc4ed8e5a0
--- /dev/null
+++ b/types/test-console/index.d.ts
@@ -0,0 +1,32 @@
+// Type definitions for test-console 1.1
+// Project: https://github.com/jamesshore/test-console
+// Definitions by:  Roberto Soares <https://github.com/roberto>
+//                  Pedro Guidoux <https://github.com/guidoux>
+//                  Guilherme Moretti <https://github.com/gbmoretti>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export const stdout: TestStream;
+export const stderr: TestStream;
+
+export type Output = ReadonlyArray<string>;
+export type OutputCallback = (output: Output) => void;
+export type NoOutputCallback = () => void;
+export type Restore = () => void;
+
+export interface Options {
+    isTTY?: boolean;
+}
+
+export interface Inspector {
+    output: Output;
+    restore: Restore;
+}
+
+export interface TestStream {
+    inspect(options?: Options): Inspector;
+    inspectSync(fn: OutputCallback): Output;
+    inspectSync(options: Options, fn: OutputCallback): Output;
+    ignore(options?: Options): Restore;
+    ignoreSync(fn: NoOutputCallback): void;
+    ignoreSync(options: Options, fn: NoOutputCallback): void;
+}
diff --git a/types/test-console/test-console-tests.ts b/types/test-console/test-console-tests.ts
new file mode 100644
index 0000000000..8b450eff43
--- /dev/null
+++ b/types/test-console/test-console-tests.ts
@@ -0,0 +1,53 @@
+import { stdout, stderr } from 'test-console';
+
+// $ExpectType Inspector
+stdout.inspect();
+// $ExpectType Inspector
+stdout.inspect({isTTY: true});
+
+// $ExpectError
+stdout.inspectSync();
+// $ExpectError
+stdout.inspectSync({});
+// $ExpectType ReadonlyArray<string>
+stdout.inspectSync({isTTY: false}, (output) => output);
+
+// $ExpectType Restore
+stdout.ignore();
+// $ExpectType Restore
+stdout.ignore({isTTY: false});
+
+// $ExpectError
+stdout.ignoreSync();
+// $ExpectType void
+stdout.ignoreSync(() => {});
+// $ExpectError
+stdout.ignoreSync({}, (output) => output);
+// $ExpectType void
+stdout.ignoreSync({}, () => {});
+
+// $ExpectType Inspector
+stderr.inspect();
+// $ExpectType Inspector
+stderr.inspect({isTTY: true});
+
+// $ExpectError
+stderr.inspectSync();
+// $ExpectError
+stderr.inspectSync({});
+// $ExpectType ReadonlyArray<string>
+stderr.inspectSync({isTTY: false}, (output) => output);
+
+// $ExpectType Restore
+stderr.ignore();
+// $ExpectType Restore
+stderr.ignore({isTTY: false});
+
+// $ExpectError
+stderr.ignoreSync();
+// $ExpectType void
+stderr.ignoreSync(() => {});
+// $ExpectError
+stderr.ignoreSync({}, (output) => output);
+// $ExpectType void
+stderr.ignoreSync({}, () => {});
diff --git a/types/test-console/tsconfig.json b/types/test-console/tsconfig.json
new file mode 100644
index 0000000000..70923f723b
--- /dev/null
+++ b/types/test-console/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "test-console-tests.ts"
+    ]
+}
diff --git a/types/test-console/tslint.json b/types/test-console/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/test-console/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/texzilla/index.d.ts b/types/texzilla/index.d.ts
new file mode 100644
index 0000000000..5b368c967e
--- /dev/null
+++ b/types/texzilla/index.d.ts
@@ -0,0 +1,100 @@
+// Type definitions for texzilla 0.9
+// Project: https://github.com/fred-wang/TeXZilla/
+// Definitions by: Michal Grňo <https://github.com/m93a>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/**
+ * Sets TeXZilla's DOMParser to the `parser` object. Note that TeXZilla tries to automatically initialize
+ * its DOMParser to `new DOMParser()` and otherwise create a dummy instance throwing exception when used.
+ * @param parser - the DOMParser object
+ * @see https://w3c.github.io/DOM-Parsing/#the-domparser-interface
+ */
+export function setDOMParser(parser: DOMParser): void;
+
+/**
+ * Sets TeXZilla's XMLSerializer to the `serializer` object. Note that TeXZilla tries to automatically
+ * initialize its XMLSerializer to `new XMLSerializer()` and otherwise create a dummy instance throwing
+ * exception when used.
+ * @param serializer - the XMLSerializer object
+ * @see https://w3c.github.io/DOM-Parsing/#the-xmlserializer-interface
+ */
+export function setXMLSerializer(serializer: XMLSerializer): void;
+
+/**
+ * Enables or disables TeXZilla's safe mode. By default safe mode is disabled but if you enable it,
+ * MathML features like href or maction that are known to be usable for XSS injections will be ignored.
+ * @param enabled - pass `true` if you don't trust the LaTeX source string to be safe
+ */
+export function setSafeMode(enabled: boolean): void;
+
+/**
+ * Enables or disables itex identifier mode. By default this is disabled but if you enable it,
+ * a sequence of basic latin letters (a, b, ... z, A, B, C, ..., Z) such as `$pin$` will generate
+ * a single MathML token `<mi>pin</mi>`. Other letters e.g. Greek or Arabic will still be treated
+ * as individual tokens.
+ * @param enabled - pass `true` to treat groups of latin letters as words
+ */
+export function setItexIdentifierMode(enabled: boolean): void;
+
+/**
+ * Returns the TeX source attached to `el` via a semantics annotation or null if none is found.
+ * This requires to have a DOMParser instance available and the corresponding DOM API to handle trees.
+ * @see setDOMParser
+ * @param el - either a string or a MathML DOM element
+ */
+export function getTeXSource(el: string | Element): string | null;
+
+/**
+ * Converts a TeX string into a MathML source and returns the corresponding string.
+ * @param str - TeX string
+ * @param displayMode - indicates whether the MathML output should be in display mode
+ * @param rightToLeft - indicates whether the MathML output should be in RTL direction
+ * @param throwOnError - indicates whether TeXZilla should throw an exception when parsing fails
+ */
+export function toMathMLString(str: string, displayMode?: boolean, rightToLeft?: boolean, throwOnError?: boolean): string;
+
+/**
+ * Converts a TeX string into a MathML source and returns a MathML DOM element.
+ * This requires to have a DOMParser instance supporting the `application/xml` type.
+ * @see setDOMParser
+ * @param str - TeX string
+ * @param displayMode - indicates whether the MathML output should be in display mode
+ * @param rightToLeft - indicates whether the MathML output should be in RTL direction
+ * @param throwOnError - indicates whether TeXZilla should throw an exception when parsing fails
+ */
+export function toMathML(str: string, displayMode?: boolean, rightToLeft?: boolean, throwOnError?: boolean): Element;
+
+/**
+ * This function first converts a TeX string into a display MathML element which
+ * is temporarily inserted into a HTML document. The MathML element is then measured
+ * and moved from the HTML document to a SVG document. This SVG document is in turn
+ * serialized as a base64 string which is finally used as the `src` attribute value
+ * of an `<img>` element. The function returns that `<img>` element.
+ * This requires to have DOMParser and XMLSerializer instances available as well as
+ * the corresponding DOM Level 1 API and will likely only work in a browser.
+ * @see setDOMParser
+ * @see setXMLSerializer
+ * @see https://github.com/fred-wang/TeXZilla/wiki/Public-API#texzillatoimage
+ * @param str - TeX string
+ * @param rightToLeft - indicates the directionality of the MathML element
+ * @param roundToPowerOfTwo - indicates whether the size of the images should be rounded to a power of two and is useful for use in a WebGL context
+ * @param size - indicates the font-size in pixels of the MathML element and defaults to 64px
+ * @param document - indicates the host HTML document to use for the measuring step and defaults to window.document
+ */
+export function toImage(str: string, rightToLeft?: boolean, roundToPowerOfTwo?: boolean, size?: number, document?: Document): HTMLImageElement;
+
+/**
+ * Applies the stream filter to `str` and returns the output string.
+ * @param str - the filtered string
+ * @param throwOnError - indicates whether TeXZilla should throw an exception when parsing fails
+ */
+export function filterString(str: string, throwOnError?: boolean): string;
+
+/**
+ * Applies the stream filter to each text node inside descendant elements of `el`.
+ * This requires to have a DOMParser instance available as well as the corresponding DOM Level 1 API.
+ * @see setDOMParser
+ * @param el - the filtered element
+ * @param throwOnError - indicates whether TeXZilla should throw an exception when parsing fails
+ */
+export function filterElement(el: Element, throwOnError?: boolean): void;
diff --git a/types/texzilla/texzilla-tests.ts b/types/texzilla/texzilla-tests.ts
new file mode 100644
index 0000000000..42e82de416
--- /dev/null
+++ b/types/texzilla/texzilla-tests.ts
@@ -0,0 +1,24 @@
+import * as TZ from 'texzilla';
+
+TZ.setDOMParser(new DOMParser());
+TZ.setXMLSerializer(new XMLSerializer());
+
+TZ.setSafeMode(false);
+TZ.setItexIdentifierMode(true);
+
+const mml1: string = TZ.toMathMLString('e^x');
+const mml2: string = TZ.toMathMLString('e^x', true, true, true);
+const el1: Element = TZ.toMathML('e^x');
+const el2: Element = TZ.toMathML('e^x', true, true, true);
+
+const test = TZ.getTeXSource(el1) === TZ.getTeXSource(mml1);
+
+declare let document: Document;
+const img1: HTMLImageElement = TZ.toImage('e^x');
+const img2: HTMLImageElement = TZ.toImage('e^x', false, false, 32, document);
+
+const str1: string = TZ.filterString(mml1);
+const str2: string = TZ.filterString(mml2, true);
+
+TZ.filterElement(el1);
+TZ.filterElement(el2);
diff --git a/types/texzilla/tsconfig.json b/types/texzilla/tsconfig.json
new file mode 100644
index 0000000000..1d3ca94967
--- /dev/null
+++ b/types/texzilla/tsconfig.json
@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "texzilla-tests.ts"
+    ]
+}
diff --git a/types/texzilla/tslint.json b/types/texzilla/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/texzilla/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/three/test/webgl/webgl_helpers.ts b/types/three/test/webgl/webgl_helpers.ts
index 9033ed5279..bbb9d72040 100644
--- a/types/three/test/webgl/webgl_helpers.ts
+++ b/types/three/test/webgl/webgl_helpers.ts
@@ -50,9 +50,10 @@
             scene.add(new THREE.VertexNormalsHelper(mesh, 10));
 
             var helper = new THREE.WireframeHelper(mesh);
-            helper.material.depthTest = false;
-            helper.material.opacity = 0.25;
-            helper.material.transparent = true;
+            var wireframeMaterial = helper.material as THREE.Material;
+            wireframeMaterial.depthTest = false;
+            wireframeMaterial.opacity = 0.25;
+            wireframeMaterial.transparent = true;
             scene.add(helper);
 
             scene.add(new THREE.BoxHelper(mesh));
@@ -92,4 +93,4 @@
 
     }
 
-}
\ No newline at end of file
+}
diff --git a/types/three/test/webgl/webgl_sprites.ts b/types/three/test/webgl/webgl_sprites.ts
index 103d3065c3..30ad890a65 100644
--- a/types/three/test/webgl/webgl_sprites.ts
+++ b/types/three/test/webgl/webgl_sprites.ts
@@ -129,7 +129,7 @@
         var width = window.innerWidth / 2;
         var height = window.innerHeight / 2;
 
-        var material = spriteTL.material;
+        var material = spriteTL.material as THREE.SpriteMaterial;
 
         var imageWidth = material.map.image.width / 2;
         var imageHeight = material.map.image.height / 2;
@@ -176,7 +176,7 @@
         for ( var i = 0, l = group.children.length; i < l; i ++ ) {
 
             var sprite = group.children[ i ] as THREE.Sprite;
-            var material = sprite.material;
+            var material = sprite.material as THREE.SpriteMaterial;
             var scale = Math.sin( time + sprite.position.x * 0.01 ) * 0.3 + 1.0;
 
             var imageWidth = 1;
@@ -189,7 +189,7 @@
 
             }
 
-            sprite.material.rotation += 0.1 * ( i / l );
+            material.rotation += 0.1 * ( i / l );
             sprite.scale.set( scale * imageWidth, scale * imageHeight, 1.0 );
 
             if ( material.map !== mapC ) {
@@ -210,4 +210,4 @@
         renderer.render( sceneOrtho, cameraOrtho );
 
     }
-}
\ No newline at end of file
+}
diff --git a/types/three/three-core.d.ts b/types/three/three-core.d.ts
index 3dea5e474f..3ab89ea5a9 100755
--- a/types/three/three-core.d.ts
+++ b/types/three/three-core.d.ts
@@ -324,7 +324,7 @@ export namespace AnimationUtils {
 }
 
 export class KeyframeTrack {
-    constructor(name: string, times: any[], values: any[], interpolation: InterpolationModes);
+    constructor(name: string, times: any[], values: any[], interpolation?: InterpolationModes);
 
     name: string;
     times: any[];
@@ -411,23 +411,23 @@ export class BooleanKeyframeTrack extends KeyframeTrack {
 }
 
 export class ColorKeyframeTrack extends KeyframeTrack {
-    constructor(name: string, times: any[], values: any[], interpolation: InterpolationModes);
+    constructor(name: string, times: any[], values: any[], interpolation?: InterpolationModes);
 }
 
 export class NumberKeyframeTrack extends KeyframeTrack {
-    constructor(name: string, times: any[], values: any[], interpolation: InterpolationModes);
+    constructor(name: string, times: any[], values: any[], interpolation?: InterpolationModes);
 }
 
 export class QuaternionKeyframeTrack extends KeyframeTrack {
-    constructor(name: string, times: any[], values: any[], interpolation: InterpolationModes);
+    constructor(name: string, times: any[], values: any[], interpolation?: InterpolationModes);
 }
 
 export class StringKeyframeTrack extends KeyframeTrack {
-    constructor(name: string, times: any[], values: any[], interpolation: InterpolationModes);
+    constructor(name: string, times: any[], values: any[], interpolation?: InterpolationModes);
 }
 
 export class VectorKeyframeTrack extends KeyframeTrack {
-    constructor(name: string, times: any[], values: any[], interpolation: InterpolationModes);
+    constructor(name: string, times: any[], values: any[], interpolation?: InterpolationModes);
 }
 
 // Cameras ////////////////////////////////////////////////////////////////////////////////////////
@@ -1059,7 +1059,7 @@ export class DirectGeometry extends EventDispatcher {
 
     // EventDispatcher mixins
     addEventListener(type: string, listener: (event: Event) => void ): void;
-    hasEventListener(type: string, listener: (event: Event) => void): void;
+    hasEventListener(type: string, listener: (event: Event) => void): boolean;
     removeEventListener(type: string, listener: (event: Event) => void): void;
     dispatchEvent(event: { type: string; [attachment: string]: any; }): void;
 }
@@ -1099,17 +1099,17 @@ export class EventDispatcher {
 
     /**
      * Adds a listener to an event type.
-     * @param type The type of the listener that gets removed.
-     * @param listener The listener function that gets removed.
+     * @param type The type of event to listen to.
+     * @param listener The function that gets called when the event is fired.
      */
     addEventListener(type: string, listener: (event: Event) => void ): void;
 
     /**
-     * Adds a listener to an event type.
-     * @param type The type of the listener that gets removed.
-     * @param listener The listener function that gets removed.
+     * Checks if listener is added to an event type.
+     * @param type The type of event to listen to.
+     * @param listener The function that gets called when the event is fired.
      */
-    hasEventListener(type: string, listener: (event: Event) => void): void;
+    hasEventListener(type: string, listener: (event: Event) => void): boolean;
 
     /**
      * Removes a listener from an event type.
@@ -1442,7 +1442,7 @@ export class Geometry extends EventDispatcher {
 
     // EventDispatcher mixins
     addEventListener(type: string, listener: (event: Event) => void ): void;
-    hasEventListener(type: string, listener: (event: Event) => void): void;
+    hasEventListener(type: string, listener: (event: Event) => void): boolean;
     removeEventListener(type: string, listener: (event: Event) => void): void;
     dispatchEvent(event: { type: string; [attachment: string]: any; }): void;
 }
@@ -1857,7 +1857,7 @@ export interface Intersection {
     face?: Face3 | null;
     faceIndex?: number;
     object: Object3D;
-    uv: Vector2;
+    uv?: Vector2;
 }
 
 export interface RaycasterParameters {
@@ -5233,26 +5233,15 @@ export class LOD extends Object3D {
     objects: any[];
 }
 
-
-/**
- * An intermediate material type that casts more precisely the possible materials assignable to a [[Line]] object.
- *
- * [[LineDashedMaterial]] is omitted as it extends [[LineBasicMaterial]].
- *
- * // Todo:
- * // - can [[Line]] take in an array of materials ?
- */
-export type LineMaterialType = LineBasicMaterial | ShaderMaterial | MeshDepthMaterial;
-
 export class Line extends Object3D {
     constructor(
         geometry?: Geometry | BufferGeometry,
-        material?: LineMaterialType | LineMaterialType[],
+        material?: Material | Material[],
         mode?: number
     );
 
-    geometry: Geometry|BufferGeometry;
-    material: LineBasicMaterial | LineDashedMaterial | ShaderMaterial;
+    geometry: Geometry | BufferGeometry;
+    material: Material | Material[];
 
     type: "Line";
     isLine: true;
@@ -5273,23 +5262,16 @@ export const LinePieces: number;
 export class LineSegments extends Line {
     constructor(
         geometry?: Geometry | BufferGeometry,
-        material?: LineMaterialType | LineMaterialType[],
+        material?: Material | Material[],
         mode?: number
     );
 }
 
-/**
- * An intermediate material type that casts more precisely the possible materials assignable to a [[Mesh]] object.
- *
- * `MeshToonMaterial` and [[MeshPhysicalMaterial]] are omitted as they extend [[MeshPhongMaterial]] and [[MeshStandardMaterial]] respectively.
- */
-export type MeshMaterialType = MeshBasicMaterial | MeshDepthMaterial | MeshFaceMaterial | MeshLambertMaterial | MeshNormalMaterial | MeshPhongMaterial | MeshStandardMaterial | ShaderMaterial | ShadowMaterial;
-
 export class Mesh extends Object3D {
-    constructor(geometry?: Geometry | BufferGeometry, material?: MeshMaterialType | MeshMaterialType[]);
+    constructor(geometry?: Geometry | BufferGeometry, material?: Material | Material[]);
 
-    geometry: Geometry|BufferGeometry;
-    material: MeshMaterialType | MeshMaterialType[];
+    geometry: Geometry | BufferGeometry;
+    material: Material | Material[];
     drawMode: TrianglesDrawModes;
     morphTargetInfluences?: number[];
     morphTargetDictionary?: { [key: string]: number; };
@@ -5302,14 +5284,6 @@ export class Mesh extends Object3D {
     copy(source: this, recursive?: boolean): this;
 }
 
-/**
- * An intermediate material type that casts more precisely the possible materials assignable to a [[Points]] object.
- *
- * // Todo:
- * // - can [[Points]] take in an array of materials ?
- */
-export type PointsMaterialType = PointsMaterial | ShaderMaterial | MeshDepthMaterial;
-
 /**
  * A class for displaying particles in the form of variable size points. For example, if using the WebGLRenderer, the particles are displayed using GL_POINTS.
  *
@@ -5323,7 +5297,7 @@ export class Points extends Object3D {
      */
     constructor(
         geometry?: Geometry | BufferGeometry,
-        material?: PointsMaterialType | PointsMaterialType[]
+        material?: Material | Material[]
     );
 
     type: "Points";
@@ -5337,7 +5311,7 @@ export class Points extends Object3D {
     /**
      * An instance of Material, defining the object's appearance. Default is a PointsMaterial with randomised colour.
      */
-    material: PointsMaterial | ShaderMaterial;
+    material: Material | Material[];
 
     raycast(raycaster: Raycaster, intersects: Intersection[]): void;
 }
@@ -5373,13 +5347,7 @@ export class Skeleton {
 }
 
 export class SkinnedMesh extends Mesh {
-    constructor(geometry?: Geometry|BufferGeometry, material?: MeshBasicMaterial, useVertexTexture?: boolean);
-    constructor(geometry?: Geometry|BufferGeometry, material?: MeshDepthMaterial, useVertexTexture?: boolean);
-    constructor(geometry?: Geometry|BufferGeometry, material?: MultiMaterial, useVertexTexture?: boolean);
-    constructor(geometry?: Geometry|BufferGeometry, material?: MeshLambertMaterial, useVertexTexture?: boolean);
-    constructor(geometry?: Geometry|BufferGeometry, material?: MeshNormalMaterial, useVertexTexture?: boolean);
-    constructor(geometry?: Geometry|BufferGeometry, material?: MeshPhongMaterial, useVertexTexture?: boolean);
-    constructor(geometry?: Geometry|BufferGeometry, material?: ShaderMaterial, useVertexTexture?: boolean);
+    constructor(geometry?: Geometry | BufferGeometry, material?: Material | Material[], useVertexTexture?: boolean);
 
     bindMode: string;
     bindMatrix: Matrix4;
@@ -5398,7 +5366,7 @@ export class Sprite extends Object3D {
     type: "Sprite";
     isSprite: true;
 
-    material: SpriteMaterial;
+    material: Material;
     center: Vector2;
 
     raycast(raycaster: Raycaster, intersects: Intersection[]): void;
diff --git a/types/three/three-orbitcontrols.d.ts b/types/three/three-orbitcontrols.d.ts
index 272b8410c4..1d4979217f 100644
--- a/types/three/three-orbitcontrols.d.ts
+++ b/types/three/three-orbitcontrols.d.ts
@@ -61,7 +61,7 @@ export class OrbitControls {
     // EventDispatcher mixins
     addEventListener(type: string, listener: (event: any) => void): void;
 
-    hasEventListener(type: string, listener: (event: any) => void): void;
+    hasEventListener(type: string, listener: (event: any) => void): boolean;
 
     removeEventListener(type: string, listener: (event: any) => void): void;
 
diff --git a/types/trianglify/index.d.ts b/types/trianglify/index.d.ts
new file mode 100644
index 0000000000..784d78ae00
--- /dev/null
+++ b/types/trianglify/index.d.ts
@@ -0,0 +1,48 @@
+// Type definitions for trianglify 1.2
+// Project: https://github.com/qrohlf/trianglify
+// Definitions by: Daniel Perez Alvarez <https://github.com/unindented>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
+
+declare namespace trianglify {
+    interface Options {
+        /** Width of pattern */
+        width?: number;
+        /** Height of pattern */
+        height?: number;
+        /** Size of the cells used to generate a randomized grid */
+        cell_size?: number;
+        /** how much to randomize the grid */
+        variance?: number;
+        /** Seed for the RNG */
+        seed?: number | string | null;
+        /** X color stops */
+        x_colors?: false | string | string[];
+        /** Y color stops */
+        y_colors?: false | string | string[];
+        /** Color space used for gradient construction & interpolation */
+        color_space?: string;
+        /** Color function f(x, y) that returns a color specification that is consumable by chroma-js */
+        color_function?: ((x: number, y: number) => string) | null;
+        /** Width of stroke. Defaults to 1.51 to fix an issue with canvas antialiasing. */
+        stroke_width?: number;
+        /** An array of [x,y] coordinates to trianglulate. Defaults to undefined, and points are generated. */
+        points?: number[];
+    }
+
+    interface SVGOptions {
+        includeNamespace: boolean;
+    }
+
+    interface Pattern {
+        opts: Options;
+        polys: any;
+        svg(opts?: SVGOptions): SVGElement;
+        canvas(canvas?: HTMLCanvasElement): HTMLCanvasElement;
+        png(): string;
+    }
+}
+
+declare function Trianglify(opts?: trianglify.Options): trianglify.Pattern;
+
+export = Trianglify;
diff --git a/types/trianglify/trianglify-tests.ts b/types/trianglify/trianglify-tests.ts
new file mode 100644
index 0000000000..f427d03f02
--- /dev/null
+++ b/types/trianglify/trianglify-tests.ts
@@ -0,0 +1,18 @@
+import Trianglify = require("trianglify");
+
+const pattern = Trianglify({
+    width: 1920,
+    height: 1080,
+    cell_size: 75,
+    variance: 0.75,
+    seed: "someseed",
+    x_colors: ["#2c2541", "#2c2541"],
+    y_colors: ["#6441a4", "#000000"],
+    color_space: "lab",
+    color_function: null,
+    stroke_width: 1.51
+});
+
+const svg = pattern.svg({ includeNamespace: true });
+const result = '<?xml version="1.0" encoding="UTF-8"?>\n' + svg.outerHTML;
+console.log(result);
diff --git a/types/trianglify/tsconfig.json b/types/trianglify/tsconfig.json
new file mode 100644
index 0000000000..de3bddc6f6
--- /dev/null
+++ b/types/trianglify/tsconfig.json
@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "dom",
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "trianglify-tests.ts"
+    ]
+}
diff --git a/types/trianglify/tslint.json b/types/trianglify/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/trianglify/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/twit/index.d.ts b/types/twit/index.d.ts
index ce8484bbe1..a66e75bab7 100644
--- a/types/twit/index.d.ts
+++ b/types/twit/index.d.ts
@@ -292,6 +292,7 @@ declare module 'twit' {
       app_only_auth?: boolean,
       timeout_ms?: number,
       trusted_cert_fingerprints?: string[],
+      strictSSL?: boolean
     }
     export interface Stream extends EventEmitter {
       start(): void;
diff --git a/types/uglify-js/index.d.ts b/types/uglify-js/index.d.ts
index 7589ba8e86..add459c62d 100644
--- a/types/uglify-js/index.d.ts
+++ b/types/uglify-js/index.d.ts
@@ -165,7 +165,7 @@ export interface OutputOptions {
     indent_start?: boolean;
     inline_script?: boolean;
     keep_quoted_props?: boolean;
-    max_line_len?: boolean;
+    max_line_len?: boolean | number;
     preamble?: string;
     preserve_line?: boolean;
     quote_keys?: boolean;
diff --git a/types/uglify-js/v2/index.d.ts b/types/uglify-js/v2/index.d.ts
index d9410070a9..2813ec45b0 100644
--- a/types/uglify-js/v2/index.d.ts
+++ b/types/uglify-js/v2/index.d.ts
@@ -159,7 +159,7 @@ declare namespace UglifyJS {
         /**
          * Maximum line length (for non-beautified output)
          */
-        max_line_len?: number;
+        max_line_len?: boolean | number;
 
         /**
          * Output IE-safe code?
diff --git a/types/upng-js/index.d.ts b/types/upng-js/index.d.ts
index a6b31f54a6..ab9462e107 100644
--- a/types/upng-js/index.d.ts
+++ b/types/upng-js/index.d.ts
@@ -1,20 +1,82 @@
 // Type definitions for upng-js 2.1
 // Project: https://github.com/photopea/UPNG.js
-// Definitions by: York Yao <https://github.com/plantain-00>
+// Definitions by: York Yao <https://github.com/plantain-00>, Sophie Kirschner <https://github.com/pineapplemachine>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-export function decode(buff: ArrayBuffer): PngData;
+export interface ImageFrameRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
 
-export function encode(bufs: ArrayBuffer, width: number, height: number, ps?: number, dels?: any[]): ArrayBuffer;
+export interface ImageFrame {
+    rect: ImageFrameRect;
+    delay: number;
+    dispose: number;
+    blend: number;
+}
 
-export function toRGBA8(out: PngData): ArrayBuffer;
+export interface ImageTabACTL {
+    num_frames: number;
+    num_plays: number;
+}
 
-export interface PngData {
+export interface ImageTabText {
+    [key: string]: string;
+}
+
+export interface ImageTabs {
+    acTL?: ImageTabACTL;
+    pHYs?: number[];
+    cHRM?: number[];
+    tEXt?: ImageTabText;
+    iTXt?: ImageTabText;
+    PLTE?: number[];
+    hIST?: number[];
+    tRNS?: (number | number[]); // Depends on ctype
+    gAMA?: number;
+    sRGB?: number;
+    bKGD?: (number | number[]); // Depends on ctype
+}
+
+export interface Image {
     width: number;
     height: number;
     depth: number;
-    ctype: any;
-    frames: any;
-    tabs: any;
+    ctype: number;
+    frames: ImageFrame[];
+    tabs: ImageTabs;
     data: ArrayBuffer;
 }
+
+export interface QuantizeResult {
+    abuf: ArrayBuffer;
+    inds: Uint8Array;
+    // Type is complicated and I am too lazy to work it out right now, sorry!
+    plte: any[];
+}
+
+export function encode(
+    imgs: ArrayBuffer[],
+    w: number,
+    h: number,
+    cnum: number,
+    dels?: number[]
+): ArrayBuffer;
+
+export function encodeLL(
+    imgs: ArrayBuffer[],
+    w: number,
+    h: number,
+    cc: number,
+    ac: number,
+    depth: number,
+    dels?: number[]
+): ArrayBuffer;
+
+export function decode(buffer: ArrayBuffer): Image;
+
+export function toRGBA8(out: Image): ArrayBuffer[];
+
+export function quantize(data: ArrayBuffer, psize: number): QuantizeResult;
diff --git a/types/upng-js/upng-js-tests.ts b/types/upng-js/upng-js-tests.ts
index 4b0823baa0..ccd3cb2d19 100644
--- a/types/upng-js/upng-js-tests.ts
+++ b/types/upng-js/upng-js-tests.ts
@@ -1,5 +1,12 @@
 import * as UPNG from 'upng-js';
 
-declare const buff: ArrayBuffer;
-const img = UPNG.decode(buff);
-const rgba = UPNG.toRGBA8(img);
+declare const buffer: ArrayBuffer;
+
+const image: UPNG.Image = UPNG.decode(buffer);
+const rgba: ArrayBuffer[] = UPNG.toRGBA8(image);
+const quantized: UPNG.QuantizeResult = UPNG.quantize(rgba[0], 256);
+
+const png1: ArrayBuffer = UPNG.encode([buffer], 32, 32, 0);
+const png2: ArrayBuffer = UPNG.encode([buffer, buffer], 32, 32, 0, [10, 10]);
+const png3: ArrayBuffer = UPNG.encodeLL([buffer], 32, 32, 3, 1, 8);
+const png4: ArrayBuffer = UPNG.encodeLL([buffer, buffer], 32, 32, 3, 1, 8, [10, 10]);
diff --git a/types/vue-color/index.d.ts b/types/vue-color/index.d.ts
index 8c85b6238d..758d823589 100644
--- a/types/vue-color/index.d.ts
+++ b/types/vue-color/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/xiaokaike/vue-color#readme
 // Definitions by: My Self <https://github.com/me>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.4
 
 import Vue from 'vue';
 
diff --git a/types/vue-markdown/index.d.ts b/types/vue-markdown/index.d.ts
index 58482a0870..ff6447efe9 100644
--- a/types/vue-markdown/index.d.ts
+++ b/types/vue-markdown/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/miaolz123/vue-markdown#readme
 // Definitions by: James Barton <https://github.com/neodon>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
 export default vue_markdown;
 export const vue_markdown: {
diff --git a/types/vue2-datepicker/tsconfig.json b/types/vue2-datepicker/tsconfig.json
index 56e16426be..d6c4ca0d7c 100644
--- a/types/vue2-datepicker/tsconfig.json
+++ b/types/vue2-datepicker/tsconfig.json
@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
diff --git a/types/webappsec-credential-management/index.d.ts b/types/webappsec-credential-management/index.d.ts
index 3c608e2202..4c47ee7cc8 100644
--- a/types/webappsec-credential-management/index.d.ts
+++ b/types/webappsec-credential-management/index.d.ts
@@ -391,7 +391,7 @@ type UserVerificationRequirement = "required" | "preferred" | "discouraged";
  */
 interface PublicKeyCredentialRequestOptions {
     challenge: BufferSource;
-    timeout: number;
+    timeout?: number;
     rpId?: string;
     allowCredentials?: PublicKeyCredentialDescriptor[];
     userVerification?: UserVerificationRequirement;
diff --git a/types/webdriverio/index.d.ts b/types/webdriverio/index.d.ts
index 945de64846..27be7e973f 100644
--- a/types/webdriverio/index.d.ts
+++ b/types/webdriverio/index.d.ts
@@ -4,6 +4,7 @@
 //                 Tim Brust <https://github.com/timbru31>
 //                 Fredrik Smedberg <https://github.com/fsmedberg-tc>
 //                 Tanvir ul Islam <https://github.com/tanvirislam06>
+//                 Dave Parslow <https://github.com/daveparslow>
 //                 Phil Leger <https://github.com/phil-lgr>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
@@ -343,65 +344,66 @@ declare namespace WebdriverIO {
     }
 
     interface Hooks {
-        onError?<T>(error: Error): Promise<T> & undefined;
+        onError?(error: Error): Promise<any> | void;
 
-        onPrepare?<T>(
+        onPrepare?(
             config: Options,
             capabilities: DesiredCapabilities
-        ): Promise<T> & undefined;
+        ): Promise<any> | void;
 
-        onComplete?<T>(exitCode: number): Promise<T> & undefined;
+        onComplete?(exitCode: number): Promise<any> | void;
 
-        before?<T>(
+        before?(
             capabilities: DesiredCapabilities,
             specs: string[]
-        ): Promise<T> & undefined;
+        ): Promise<any> | undefined;
 
-        beforeCommand?<T>(
+        beforeCommand?(
             commandName: string,
             args: any[]
-        ): Promise<T> & undefined;
+        ): Promise<any> | void;
 
-        beforeFeature?<T>(feature: string): Promise<T> & undefined;
-        beforeHook?<T>(): Promise<T> & undefined;
-        beforeScenario?<T>(scenario: string): Promise<T> & undefined;
+        beforeHook?(): Promise<any> | void;
 
-        beforeSession?<T>(
+        beforeSession?(
             config: Options,
             capabilities: DesiredCapabilities,
             specs: string[]
-        ): Promise<T> & undefined;
+        ): Promise<any> | void;
 
-        beforeStep?<T>(step: string): Promise<T> & undefined;
-        beforeSuite?<T>(suite: Suite): Promise<T> & undefined;
-        beforeTest?<T>(test: Test): Promise<T> & undefined;
-        afterHook?<T>(): Promise<T> & undefined;
+        beforeSuite?(suite: Suite): Promise<any> | void;
+        beforeTest?(test: Test): Promise<any> | void;
+        afterHook?(): Promise<any> | void;
 
-        after?<T>(
+        after?(
             result: number,
             capabilities: DesiredCapabilities,
             specs: string[]
-        ): Promise<T> & undefined;
+        ): Promise<any> | void;
 
-        afterCommand?<T>(
+        afterCommand?(
             commandName: string,
             args: any[],
             result: any,
             error?: Error
-        ): Promise<T> & undefined;
+        ): Promise<any> | undefined;
 
-        afterScenario?<T>(scenario: any): Promise<T> & undefined;
-
-        afterSession?<T>(
+        afterSession?(
             config: Options,
             capabilities: DesiredCapabilities,
             specs: string[]
-        ): Promise<T> & undefined;
+        ): Promise<any> | void;
 
-        afterStep?<T>(stepResult: any): Promise<T> & undefined;
-        afterSuite?<T>(suite: Suite): Promise<T> & undefined;
-        afterTest?<T>(test: Test): Promise<T> & undefined;
-        afterFeature?<T>(feature: string): Promise<T> & undefined;
+        afterSuite?(suite: Suite): Promise<any> | void;
+        afterTest?(test: Test): Promise<any> | void;
+
+         // cucumber specific hooks
+         beforeFeature?(feature: string): Promise<any> | void;
+         beforeScenario?(scenario: string): Promise<any> | void;
+         beforeStep?(step: string): Promise<any> | void;
+         afterFeature?(feature: string): Promise<any> | void;
+         afterScenario?(scenario: any): Promise<any> | void;
+         afterStep?(stepResult: any): Promise<any> | void;
     }
 
     interface Options {
diff --git a/types/webdriverio/webdriverio-tests.ts b/types/webdriverio/webdriverio-tests.ts
index 56dc3ddfda..11b473066b 100644
--- a/types/webdriverio/webdriverio-tests.ts
+++ b/types/webdriverio/webdriverio-tests.ts
@@ -118,3 +118,22 @@ webdriverio
         console.log(visible); // Should return true
     })
     .end();
+
+let hooks: webdriverio.Hooks  = {};
+
+hooks = {
+  // Hooks can be a noop function
+  onPrepare: () => undefined,
+  onError() {
+    // Hooks don't have to return a value
+  }
+};
+
+hooks.onComplete = async () => {
+    // Hooks can return a promise but the promise can be void
+};
+
+hooks.afterTest = async () => {
+    // Hooks can have a promise with a result but it is not typically used
+    return false;
+};
diff --git a/types/webpack/index.d.ts b/types/webpack/index.d.ts
index 1aa7f03608..92113449e8 100644
--- a/types/webpack/index.d.ts
+++ b/types/webpack/index.d.ts
@@ -25,7 +25,6 @@ import { Tapable, HookMap,
          AsyncParallelBailHook, AsyncParallelHook, AsyncSeriesBailHook, AsyncSeriesHook, AsyncSeriesWaterfallHook } from 'tapable';
 import * as UglifyJS from 'uglify-js';
 import { RawSourceMap } from 'source-map';
-import * as WebpackDevServer from 'webpack-dev-server';
 
 export = webpack;
 
@@ -113,8 +112,6 @@ declare namespace webpack {
         parallelism?: number;
         /** Optimization options */
         optimization?: Options.Optimization;
-        /** A set of options picked up by `webpack-dev-server` to change the dev server's default behavior. */
-        devServer?: WebpackDevServer.Configuration;
     }
 
     interface Entry {
diff --git a/types/webpack/v3/index.d.ts b/types/webpack/v3/index.d.ts
index 72126e056d..79a2d4eed4 100644
--- a/types/webpack/v3/index.d.ts
+++ b/types/webpack/v3/index.d.ts
@@ -20,7 +20,6 @@
 import Tapable = require('tapable');
 import * as UglifyJS from 'uglify-js';
 import { RawSourceMap } from 'source-map';
-import * as WebpackDevServer from 'webpack-dev-server';
 
 export = webpack;
 
@@ -106,8 +105,6 @@ declare namespace webpack {
         performance?: Options.Performance;
         /** Limit the number of parallel processed modules. Can be used to fine tune performance or to get more reliable profiling results */
         parallelism?: number;
-        /** A set of options picked up by `webpack-dev-server` to change the dev server's default behavior. */
-        devServer?: WebpackDevServer.Configuration;
     }
 
     interface Entry {
diff --git a/types/wegame-api/index.d.ts b/types/wegame-api/index.d.ts
index 18480ed2ea..4ac4e7fbc5 100644
--- a/types/wegame-api/index.d.ts
+++ b/types/wegame-api/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for wegame 2.2
+// Type definitions for wegame 2.3
 // Project: https://developers.weixin.qq.com/minigame/dev/index.html
 // Definitions by: J.C <https://github.com/jcyuan>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -242,7 +242,7 @@ declare class FileSystemManager {
     getFileInfo(param: wx.types.FileinfoParams): void;
 
     /**
-     * 删除该小程序下已保存的本地缓存文件
+     * 删除该小程序下已保存的本地缓存文件（新版本应使用unlink）
      */
     removeSavedFile(param: wx.types.RemovefileParams): void;
 
@@ -1079,12 +1079,12 @@ declare namespace wx {
             zipFilePath: string;
             targetPath: string;
             success?: () => void;
-            fail?: (e?: any) => void;
+            fail?: (res: { errMsg: string }) => void;
             complete?: () => void;
         }
 
         interface AccessfileParams {
-            filePath: string;
+            path: string;
             success?: () => void;
             fail?: (res: { errMsg: string }) => void;
             complete?: () => void;
@@ -1108,7 +1108,7 @@ declare namespace wx {
 
         interface FileinfoParams {
             filePath: string;
-            success?: (res: { size: number }) => void;
+            success?: (res: { size: number, digest: string }) => void;
             fail?: (res: { errMsg: string }) => void;
             complete?: () => void;
         }
@@ -1318,13 +1318,20 @@ declare namespace wx {
 
         interface DownfileParams {
             url: string;
-            filePath: string;
+            /**
+             * 在指定filePath之后success回调中将不会有res.tempFilePath路径值，下载的文件会直接写入filePath指定的路径（有写入权限的情况下，根目录请使用wx.env.USER_DATA_PATH，路径文件夹必须存在，否则写入失败）
+             */
+            filePath?: string;
             /**
              * 	HTTP 请求的 Header，Header 中不能设置 Referer
              */
             header?: { [key: string]: string };
+            /**
+             * res.tempFilePath 临时文件路径。如果没传入 filePath 指定文件存储路径，则下载后的文件会存储到一个临时文件
+             * res.statusCode 开发者服务器返回的 HTTP 状态码
+             */
             success?: (res: { tempFilePath: string, statusCode: number }) => void;
-            fail?: () => void;
+            fail?: (res: { errMsg: string }) => void;
             complete?: () => void;
         }
 
diff --git a/types/weixin-app/index.d.ts b/types/weixin-app/index.d.ts
index 376d8955e1..df1263f1b2 100644
--- a/types/weixin-app/index.d.ts
+++ b/types/weixin-app/index.d.ts
@@ -3099,7 +3099,7 @@ declare namespace wx {
 	 */
 	function getUserInfo(options: GetUserInfoOptions): void;
 	// 开放接口-----微信支付
-	type PaymentSignType = "MD5";
+	type PaymentSignType = "MD5" | "HMAC-SHA256";
 	interface RequestPaymentOptions extends BaseOptions {
 		/** 时间戳从1970年1月1日00:00:00至今的秒数,即当前的时间 */
 		timeStamp: string | number;
@@ -3107,7 +3107,7 @@ declare namespace wx {
 		nonceStr: string;
 		/** 统一下单接口返回的 prepay_id 参数值，提交格式如：prepay_id=* */
 		package: string;
-		/** 签名算法，暂支持 MD5 */
+		/** 签名算法，默认为MD5，支持HMAC-SHA256和MD5 */
 		signType: PaymentSignType;
 		/** 签名,具体签名方案参见微信公众号支付帮助文档; */
 		paySign: string;
diff --git a/types/wepy-redux/index.d.ts b/types/wepy-redux/index.d.ts
index be516d18eb..f7e1c8262f 100644
--- a/types/wepy-redux/index.d.ts
+++ b/types/wepy-redux/index.d.ts
@@ -19,6 +19,6 @@ export function connect(
     mapDispatchToProps: MapDispatchToProps
 ): (<T extends wepy.Component>(original: T) => T);
 
-export function setStore(store: Store): void;
+export function setStore(store: Store<any, any>): void;
 
 export function getStore(): Store;
diff --git a/types/winston-dynamodb/package.json b/types/winston-dynamodb/package.json
index 33e1a4f018..a39b614c7e 100644
--- a/types/winston-dynamodb/package.json
+++ b/types/winston-dynamodb/package.json
@@ -1,6 +1,6 @@
 {
     "private": true,
     "dependencies": {
-        "@types/winston": "^2.3.9"
+        "@types/winston": "2.3.9"
     }
 }
diff --git a/types/winston-mail/package.json b/types/winston-mail/package.json
index 33e1a4f018..a39b614c7e 100644
--- a/types/winston-mail/package.json
+++ b/types/winston-mail/package.json
@@ -1,6 +1,6 @@
 {
     "private": true,
     "dependencies": {
-        "@types/winston": "^2.3.9"
+        "@types/winston": "2.3.9"
     }
 }
diff --git a/types/zui/package.json b/types/zui/package.json
deleted file mode 100644
index 19e5fb0d14..0000000000
--- a/types/zui/package.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-    "private": true,
-    "dependencies": {
-        "moment": ">=2.14.0"
-    }
-}