git.sesse.net Git - remoteglot/blob - externs/jquery-1.9.js

   1 /*
   2  * Copyright 2011 The Closure Compiler Authors.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * @fileoverview Externs for jQuery 1.9.1
  19  *
  20  * Note that some functions use different return types depending on the number
  21  * of parameters passed in. In these cases, you may need to annotate the type
  22  * of the result in your code, so the JSCompiler understands which type you're
  23  * expecting. For example:
  24  *    <code>var elt = /** @type {Element} * / (foo.get(0));</code>
  25  *
  26  * @see http://api.jquery.com/
  27  * @externs
  28  */
  29
  30 /**
  31  * @typedef {(Window|Document|Element|Array.<Element>|string|jQuery|
  32  *     NodeList)}
  33  */
  34 var jQuerySelector;
  35
  36 /** @typedef {function(...)|Array.<function(...)>} */
  37 var jQueryCallback;
  38
  39 /** @typedef {
  40               {
  41                accepts: (Object.<string, string>|undefined),
  42                async: (?boolean|undefined),
  43                beforeSend: (function(jQuery.jqXHR, (jQueryAjaxSettings|Object.<string, *>))|undefined),
  44                cache: (?boolean|undefined),
  45                complete: (function(jQuery.jqXHR, string)|undefined),
  46                contents: (Object.<string, RegExp>|undefined),
  47                contentType: (?string|undefined),
  48                context: (Object.<?, ?>|jQueryAjaxSettings|undefined),
  49                converters: (Object.<string, Function>|undefined),
  50                crossDomain: (?boolean|undefined),
  51                data: (Object.<?, ?>|?string|Array.<?>|undefined),
  52                dataFilter: (function(string, string):?|undefined),
  53                dataType: (?string|undefined),
  54                error: (function(jQuery.jqXHR, string, string)|undefined),
  55                global: (?boolean|undefined),
  56                headers: (Object.<?, ?>|undefined),
  57                ifModified: (?boolean|undefined),
  58                isLocal: (?boolean|undefined),
  59                jsonp: (?string|undefined),
  60                jsonpCallback: (?string|function()|undefined),
  61                mimeType: (?string|undefined),
  62                password: (?string|undefined),
  63                processData: (?boolean|undefined),
  64                scriptCharset: (?string|undefined),
  65                statusCode: (Object.<number, function()>|undefined),
  66                success: (function(?, string, jQuery.jqXHR)|undefined),
  67                timeout: (?number|undefined),
  68                traditional: (?boolean|undefined),
  69                type: (?string|undefined),
  70                url: (?string|undefined),
  71                username: (?string|undefined),
  72                xhr: (function():(ActiveXObject|XMLHttpRequest)|undefined),
  73                xhrFields: (Object.<?, ?>|undefined)
  74               }} */
  75 var jQueryAjaxSettings;
  76
  77 /**
  78  * @constructor
  79  * @param {(jQuerySelector|Element|Object|Array.<Element>|jQuery|string|
  80  *     function())=} arg1
  81  * @param {(Element|jQuery|Document|
  82  *     Object.<string, (string|function(!jQuery.event=))>)=} arg2
  83  * @return {!jQuery}
  84  */
  85 function jQuery(arg1, arg2) {}
  86
  87 /**
  88  * @constructor
  89  * @extends {jQuery}
  90  * @param {(jQuerySelector|Element|Object|Array.<Element>|jQuery|string|
  91  *     function())=} arg1
  92  * @param {(Element|jQuery|Document|
  93  *     Object.<string, (string|function(!jQuery.event=))>)=} arg2
  94  * @return {!jQuery}
  95  */
  96 function $(arg1, arg2) {}
  97
  98 /**
  99  * @param {(jQuerySelector|Array.<Element>|string|jQuery)} arg1
 100  * @param {Element=} context
 101  * @return {!jQuery}
 102  * @nosideeffects
 103  */
 104 jQuery.prototype.add = function(arg1, context) {};
 105
 106 /**
 107  * @param {(jQuerySelector|Array.<Element>|string|jQuery)=} arg1
 108  * @return {!jQuery}
 109  * @nosideeffects
 110  */
 111 jQuery.prototype.addBack = function(arg1) {};
 112
 113 /**
 114  * @param {(string|function(number,String))} arg1
 115  * @return {!jQuery}
 116  */
 117 jQuery.prototype.addClass = function(arg1) {};
 118
 119 /**
 120  * @param {(string|Element|jQuery|function(number))} arg1
 121  * @param {(string|Element|Array.<Element>|jQuery)=} content
 122  * @return {!jQuery}
 123  */
 124 jQuery.prototype.after = function(arg1, content) {};
 125
 126 /**
 127  * @param {(string|jQueryAjaxSettings|Object.<string,*>)} arg1
 128  * @param {(jQueryAjaxSettings|Object.<string, *>)=} settings
 129  * @return {jQuery.jqXHR}
 130  */
 131 jQuery.ajax = function(arg1, settings) {};
 132
 133 /**
 134  * @param {(string|jQueryAjaxSettings|Object.<string, *>)} arg1
 135  * @param {(jQueryAjaxSettings|Object.<string, *>)=} settings
 136  * @return {jQuery.jqXHR}
 137  */
 138 $.ajax = function(arg1, settings) {};
 139
 140 /**
 141  * @param {function(!jQuery.event,XMLHttpRequest,(jQueryAjaxSettings|Object.<string, *>))} handler
 142  * @return {!jQuery}
 143  */
 144 jQuery.prototype.ajaxComplete = function(handler) {};
 145
 146 /**
 147  * @param {function(!jQuery.event,jQuery.jqXHR,(jQueryAjaxSettings|Object.<string, *>),*)} handler
 148  * @return {!jQuery}
 149  */
 150 jQuery.prototype.ajaxError = function(handler) {};
 151
 152 /**
 153  * @param {(string|function((jQueryAjaxSettings|Object.<string, *>),(jQueryAjaxSettings|Object.<string, *>),jQuery.jqXHR))} dataTypes
 154  * @param {function((jQueryAjaxSettings|Object.<string, *>),(jQueryAjaxSettings|Object.<string, *>),jQuery.jqXHR)=} handler
 155  */
 156 jQuery.ajaxPrefilter = function(dataTypes, handler) {};
 157
 158 /**
 159  * @param {(string|function((jQueryAjaxSettings|Object.<string, *>),(jQueryAjaxSettings|Object.<string, *>),jQuery.jqXHR))} dataTypes
 160  * @param {function((jQueryAjaxSettings|Object.<string, *>),(jQueryAjaxSettings|Object.<string, *>),jQuery.jqXHR)=} handler
 161  */
 162 $.ajaxPrefilter = function(dataTypes, handler) {};
 163
 164 /**
 165  * @param {function(!jQuery.event,jQuery.jqXHR,(jQueryAjaxSettings|Object.<string, *>))} handler
 166  * @return {!jQuery}
 167  */
 168 jQuery.prototype.ajaxSend = function(handler) {};
 169
 170 /** @const {jQueryAjaxSettings|Object.<string, *>} */
 171 jQuery.ajaxSettings;
 172
 173 /** @const {jQueryAjaxSettings|Object.<string, *>} */
 174 $.ajaxSettings = {};
 175
 176 /** @type {Object.<string, boolean>} */
 177 jQuery.ajaxSettings.flatOptions = {};
 178
 179 /** @type {Object.<string, boolean>} */
 180 $.ajaxSettings.flatOptions = {};
 181
 182 /** @type {boolean} */
 183 jQuery.ajaxSettings.processData;
 184
 185 /** @type {boolean} */
 186 $.ajaxSettings.processData;
 187
 188 /** @type {Object.<string, string>} */
 189 jQuery.ajaxSettings.responseFields = {};
 190
 191 /** @type {Object.<string, string>} */
 192 $.ajaxSettings.responseFields = {};
 193
 194 /** @param {jQueryAjaxSettings|Object.<string, *>} options */
 195 jQuery.ajaxSetup = function(options) {};
 196
 197 /** @param {jQueryAjaxSettings|Object.<string, *>} options */
 198 $.ajaxSetup = function(options) {};
 199
 200 /**
 201  * @param {function()} handler
 202  * @return {!jQuery}
 203  */
 204 jQuery.prototype.ajaxStart = function(handler) {};
 205
 206 /**
 207  * @param {function()} handler
 208  * @return {!jQuery}
 209  */
 210 jQuery.prototype.ajaxStop = function(handler) {};
 211
 212 /**
 213  * @param {function(!jQuery.event,XMLHttpRequest,(jQueryAjaxSettings|Object.<string, *>), ?)} handler
 214  * @return {!jQuery}
 215  */
 216 jQuery.prototype.ajaxSuccess = function(handler) {};
 217
 218 /**
 219  * @deprecated Please use .addBack(selector) instead.
 220  * @return {!jQuery}
 221  * @nosideeffects
 222  */
 223 jQuery.prototype.andSelf = function() {};
 224
 225 /**
 226  * @param {Object.<string,*>} properties
 227  * @param {(string|number|function()|Object.<string,*>)=} arg2
 228  * @param {(string|function())=} easing
 229  * @param {function()=} complete
 230  * @return {!jQuery}
 231  */
 232 jQuery.prototype.animate = function(properties, arg2, easing, complete) {};
 233
 234 /**
 235  * @param {(string|Element|Array.<Element>|jQuery|function(number,string))} arg1
 236  * @param {...(string|Element|Array.<Element>|jQuery)} content
 237  * @return {!jQuery}
 238  */
 239 jQuery.prototype.append = function(arg1, content) {};
 240
 241 /**
 242  * @param {(jQuerySelector|Element|jQuery)} target
 243  * @return {!jQuery}
 244  */
 245 jQuery.prototype.appendTo = function(target) {};
 246
 247 /**
 248  * @param {(string|Object.<string,*>)} arg1
 249  * @param {(string|number|boolean|function(number,string))=} arg2
 250  * @return {(string|!jQuery)}
 251  */
 252 jQuery.prototype.attr = function(arg1, arg2) {};
 253
 254 /**
 255  * @param {(string|Element|jQuery|function())} arg1
 256  * @param {(string|Element|Array.<Element>|jQuery)=} content
 257  * @return {!jQuery}
 258  */
 259 jQuery.prototype.before = function(arg1, content) {};
 260
 261 /**
 262  * @param {(string|Object.<string, function(!jQuery.event=)>)} arg1
 263  * @param {(Object.<string, *>|function(!jQuery.event=)|boolean)=} eventData
 264  * @param {(function(!jQuery.event=)|boolean)=} arg3
 265  * @return {!jQuery}
 266  */
 267 jQuery.prototype.bind = function(arg1, eventData, arg3) {};
 268
 269 /**
 270  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
 271  * @param {function(!jQuery.event=)=} handler
 272  * @return {!jQuery}
 273  */
 274 jQuery.prototype.blur = function(arg1, handler) {};
 275
 276 /**
 277  * @constructor
 278  * @private
 279  */
 280 jQuery.callbacks = function () {};
 281
 282 /**
 283  * @param {string=} flags
 284  * @return {jQuery.callbacks}
 285  */
 286 jQuery.Callbacks = function (flags) {};
 287
 288 /** @param {function()} callbacks */
 289 jQuery.callbacks.prototype.add = function(callbacks) {};
 290
 291 /** @return {undefined} */
 292 jQuery.callbacks.prototype.disable = function() {};
 293
 294 /** @return {undefined} */
 295 jQuery.callbacks.prototype.empty = function() {};
 296
 297 /** @param {...*} var_args */
 298 jQuery.callbacks.prototype.fire = function(var_args) {};
 299
 300 /** @return {boolean} */
 301 jQuery.callbacks.prototype.fired = function() {};
 302
 303 /** @param {...*} var_args */
 304 jQuery.callbacks.prototype.fireWith = function(var_args) {};
 305
 306 /**
 307  * @param {function()} callback
 308  * @return {boolean}
 309  * @nosideeffects
 310  */
 311 jQuery.callbacks.prototype.has = function(callback) {};
 312
 313 /** @return {undefined} */
 314 jQuery.callbacks.prototype.lock = function() {};
 315
 316 /** @return {boolean} */
 317 jQuery.callbacks.prototype.locked = function() {};
 318
 319 /** @param {function()} callbacks */
 320 jQuery.callbacks.prototype.remove = function(callbacks) {};
 321
 322 /**
 323  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
 324  * @param {function(!jQuery.event=)=} handler
 325  * @return {!jQuery}
 326  */
 327 jQuery.prototype.change = function(arg1, handler) {};
 328
 329 /**
 330  * @param {jQuerySelector=} selector
 331  * @return {!jQuery}
 332  * @nosideeffects
 333  */
 334 jQuery.prototype.children = function(selector) {};
 335
 336 /**
 337  * @param {string=} queueName
 338  * @return {!jQuery}
 339  */
 340 jQuery.prototype.clearQueue = function(queueName) {};
 341
 342 /**
 343  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
 344  * @param {function(!jQuery.event=)=} handler
 345  * @return {!jQuery}
 346  */
 347 jQuery.prototype.click = function(arg1, handler) {};
 348
 349 /**
 350  * @param {boolean=} withDataAndEvents
 351  * @param {boolean=} deepWithDataAndEvents
 352  * @return {!jQuery}
 353  * @suppress {checkTypes} see https://code.google.com/p/closure-compiler/issues/detail?id=583
 354  */
 355 jQuery.prototype.clone = function(withDataAndEvents, deepWithDataAndEvents) {};
 356
 357 /**
 358  * @param {(jQuerySelector|jQuery|Element|string)} arg1
 359  * @param {Element=} context
 360  * @return {!jQuery}
 361  * @nosideeffects
 362  */
 363 jQuery.prototype.closest = function(arg1, context) {};
 364
 365 /**
 366  * @param {Element} container
 367  * @param {Element} contained
 368  * @return {boolean}
 369  */
 370 jQuery.contains = function(container, contained) {};
 371
 372 /**
 373  * @param {Element} container
 374  * @param {Element} contained
 375  * @return {boolean}
 376  */
 377 $.contains = function(container, contained) {};
 378
 379 /**
 380  * @return {!jQuery}
 381  * @nosideeffects
 382  */
 383 jQuery.prototype.contents = function() {};
 384
 385 /** @type {Element|Document} */
 386 jQuery.prototype.context;
 387
 388 /**
 389  * @param {(string|Object.<string,*>)} arg1
 390  * @param {(string|number|function(number,*))=} arg2
 391  * @return {(string|!jQuery)}
 392  */
 393 jQuery.prototype.css = function(arg1, arg2) {};
 394
 395 /** @type {Object.<string, *>} */
 396 jQuery.cssHooks;
 397
 398 /** @type {Object.<string, *>} */
 399 $.cssHooks;
 400
 401 /**
 402  * @param {Element} elem
 403  * @param {string=} key
 404  * @param {*=} value
 405  * @return {*}
 406  */
 407 jQuery.data = function(elem, key, value) {};
 408
 409 /**
 410  * @param {(string|Object.<string, *>)=} arg1
 411  * @param {*=} value
 412  * @return {*}
 413  */
 414 jQuery.prototype.data = function(arg1, value) {};
 415
 416 /**
 417  * @param {Element} elem
 418  * @param {string=} key
 419  * @param {*=} value
 420  * @return {*}
 421  */
 422 $.data = function(elem, key, value) {};
 423
 424 /**
 425  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
 426  * @param {function(!jQuery.event=)=} handler
 427  * @return {!jQuery}
 428  */
 429 jQuery.prototype.dblclick = function(arg1, handler) {};
 430
 431 /**
 432  * @constructor
 433  * @implements {jQuery.Promise}
 434  * @param {function()=} opt_fn
 435  * @see http://api.jquery.com/category/deferred-object/
 436  */
 437 jQuery.deferred = function(opt_fn) {};
 438
 439 /**
 440  * @constructor
 441  * @extends {jQuery.deferred}
 442  * @param {function()=} opt_fn
 443  * @return {jQuery.Deferred}
 444  */
 445 jQuery.Deferred = function(opt_fn) {};
 446
 447 /**
 448  * @constructor
 449  * @extends {jQuery.deferred}
 450  * @param {function()=} opt_fn
 451  * @see http://api.jquery.com/category/deferred-object/
 452  */
 453 $.deferred = function(opt_fn) {};
 454
 455 /**
 456  * @constructor
 457  * @extends {jQuery.deferred}
 458  * @param {function()=} opt_fn
 459  * @return {jQuery.deferred}
 460  */
 461 $.Deferred = function(opt_fn) {};
 462
 463 /**
 464  * @override
 465  * @param {jQueryCallback} alwaysCallbacks
 466  * @param {jQueryCallback=} alwaysCallbacks2
 467  * @return {jQuery.deferred}
 468  */
 469 jQuery.deferred.prototype.always
 470     = function(alwaysCallbacks, alwaysCallbacks2) {};
 471
 472 /**
 473  * @override
 474  * @param {jQueryCallback} doneCallbacks
 475  * @param {jQueryCallback=} doneCallbacks2
 476  * @return {jQuery.deferred}
 477  */
 478 jQuery.deferred.prototype.done = function(doneCallbacks, doneCallbacks2) {};
 479
 480 /**
 481  * @override
 482  * @param {jQueryCallback} failCallbacks
 483  * @param {jQueryCallback=} failCallbacks2
 484  * @return {jQuery.deferred}
 485  */
 486 jQuery.deferred.prototype.fail = function(failCallbacks, failCallbacks2) {};
 487
 488 /**
 489  * @param {...*} var_args
 490  * @return {jQuery.deferred}
 491  */
 492 jQuery.deferred.prototype.notify = function(var_args) {};
 493
 494 /**
 495  * @param {Object} context
 496  * @param {...*} var_args
 497  * @return {jQuery.deferred}
 498  */
 499 jQuery.deferred.prototype.notifyWith = function(context, var_args) {};
 500
 501 /**
 502  * @deprecated Please use deferred.then() instead.
 503  * @override
 504  * @param {function()=} doneFilter
 505  * @param {function()=} failFilter
 506  * @param {function()=} progressFilter
 507  * @return {jQuery.Promise}
 508  */
 509 jQuery.deferred.prototype.pipe =
 510     function(doneFilter, failFilter, progressFilter) {};
 511
 512 /**
 513  * @param {jQueryCallback} progressCallbacks
 514  * @return {jQuery.deferred}
 515  */
 516 jQuery.deferred.prototype.progress = function(progressCallbacks) {};
 517
 518 /**
 519  * @param {Object=} target
 520  * @return {jQuery.Promise}
 521  */
 522 jQuery.deferred.prototype.promise = function(target) {};
 523
 524 /**
 525  * @param {...*} var_args
 526  * @return {jQuery.deferred}
 527  */
 528 jQuery.deferred.prototype.reject = function(var_args) {};
 529
 530 /**
 531  * @param {Object} context
 532  * @param {Array.<*>=} args
 533  * @return {jQuery.deferred}
 534  */
 535 jQuery.deferred.prototype.rejectWith = function(context, args) {};
 536
 537 /**
 538  * @param {...*} var_args
 539  * @return {jQuery.deferred}
 540  */
 541 jQuery.deferred.prototype.resolve = function(var_args) {};
 542
 543 /**
 544  * @param {Object} context
 545  * @param {Array.<*>=} args
 546  * @return {jQuery.deferred}
 547  */
 548 jQuery.deferred.prototype.resolveWith = function(context, args) {};
 549
 550 /** @return {string} */
 551 jQuery.deferred.prototype.state = function() {};
 552
 553 /**
 554  * @override
 555  * @param {jQueryCallback} doneCallbacks
 556  * @param {jQueryCallback=} failCallbacks
 557  * @param {jQueryCallback=} progressCallbacks
 558  * @return {jQuery.deferred}
 559  */
 560 jQuery.deferred.prototype.then
 561     = function(doneCallbacks, failCallbacks, progressCallbacks) {};
 562
 563 /**
 564  * @param {number} duration
 565  * @param {string=} queueName
 566  * @return {!jQuery}
 567  */
 568 jQuery.prototype.delay = function(duration, queueName) {};
 569
 570 /**
 571  * @param {string} selector
 572  * @param {(string|Object.<string,*>)} arg2
 573  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg3
 574  * @param {function(!jQuery.event=)=} handler
 575  * @return {!jQuery}
 576  */
 577 jQuery.prototype.delegate = function(selector, arg2, arg3, handler) {};
 578
 579 /**
 580  * @param {Element} elem
 581  * @param {string=} queueName
 582  */
 583 jQuery.dequeue = function(elem, queueName) {};
 584
 585 /**
 586  * @param {string=} queueName
 587  * @return {!jQuery}
 588  */
 589 jQuery.prototype.dequeue = function(queueName) {};
 590
 591 /**
 592  * @param {Element} elem
 593  * @param {string=} queueName
 594  */
 595 $.dequeue = function(elem, queueName) {};
 596
 597 /**
 598  * @param {jQuerySelector=} selector
 599  * @return {!jQuery}
 600  */
 601 jQuery.prototype.detach = function(selector) {};
 602
 603 /**
 604  * @param {Object} collection
 605  * @param {function((number|string),?)} callback
 606  * @return {Object}
 607  */
 608 jQuery.each = function(collection, callback) {};
 609
 610 /**
 611  * @param {function(number,Element)} fnc
 612  * @return {!jQuery}
 613  */
 614 jQuery.prototype.each = function(fnc) {};
 615
 616 /**
 617  * @param {Object} collection
 618  * @param {function((number|string),?)} callback
 619  * @return {Object}
 620  */
 621 $.each = function(collection, callback) {};
 622
 623 /** @return {!jQuery} */
 624 jQuery.prototype.empty = function() {};
 625
 626 /**
 627  * @return {!jQuery}
 628  * @nosideeffects
 629  */
 630 jQuery.prototype.end = function() {};
 631
 632 /**
 633  * @param {number} arg1
 634  * @return {!jQuery}
 635  */
 636 jQuery.prototype.eq = function(arg1) {};
 637
 638 /** @param {string} message */
 639 jQuery.error = function(message) {};
 640
 641 /**
 642  * @deprecated Please use .on( "error", handler ) instead.
 643  * @param {(function(!jQuery.event=)|Object.<string, *>)} arg1
 644  * @param {function(!jQuery.event=)=} handler
 645  * @return {!jQuery}
 646  */
 647 jQuery.prototype.error = function(arg1, handler) {};
 648
 649 /** @param {string} message */
 650 $.error = function(message) {};
 651
 652 /**
 653  * @constructor
 654  * @param {string} eventType
 655  */
 656 jQuery.event = function(eventType) {};
 657
 658 /**
 659  * @constructor
 660  * @extends {jQuery.event}
 661  * @param {string} eventType
 662  * @param {Object=} properties
 663  * @return {jQuery.Event}
 664  */
 665 jQuery.Event = function(eventType, properties) {};
 666
 667 /**
 668  * @constructor
 669  * @extends {jQuery.event}
 670  * @param {string} eventType
 671  */
 672 $.event = function(eventType) {};
 673
 674 /**
 675  * @constructor
 676  * @extends {jQuery.event}
 677  * @param {string} eventType
 678  * @param {Object=} properties
 679  * @return {$.Event}
 680  */
 681 $.Event = function(eventType, properties) {};
 682
 683 /** @type {Element} */
 684 jQuery.event.prototype.currentTarget;
 685
 686 /** @type {Object.<string, *>} */
 687 jQuery.event.prototype.data;
 688
 689 /** @type {Element} */
 690 jQuery.event.prototype.delegateTarget;
 691
 692 /**
 693  * @return {boolean}
 694  * @nosideeffects
 695  */
 696 jQuery.event.prototype.isDefaultPrevented = function() {};
 697
 698 /**
 699  * @return {boolean}
 700  * @nosideeffects
 701  */
 702 jQuery.event.prototype.isImmediatePropagationStopped = function() {};
 703
 704 /**
 705  * @return {boolean}
 706  * @nosideeffects
 707  */
 708 jQuery.event.prototype.isPropagationStopped = function() {};
 709
 710 /** @type {string} */
 711 jQuery.event.prototype.namespace;
 712
 713 /** @type {Event} */
 714 jQuery.event.prototype.originalEvent;
 715
 716 /** @type {number} */
 717 jQuery.event.prototype.pageX;
 718
 719 /** @type {number} */
 720 jQuery.event.prototype.pageY;
 721
 722 /** @return {undefined} */
 723 jQuery.event.prototype.preventDefault = function() {};
 724
 725 /** @type {Object.<string, *>} */
 726 jQuery.event.prototype.props;
 727
 728 /** @type {Element} */
 729 jQuery.event.prototype.relatedTarget;
 730
 731 /** @type {*} */
 732 jQuery.event.prototype.result;
 733
 734 /** @return {undefined} */
 735 jQuery.event.prototype.stopImmediatePropagation = function() {};
 736
 737 /** @return {undefined} */
 738 jQuery.event.prototype.stopPropagation = function() {};
 739
 740 /** @type {Element} */
 741 jQuery.event.prototype.target;
 742
 743 /** @type {number} */
 744 jQuery.event.prototype.timeStamp;
 745
 746 /** @type {string} */
 747 jQuery.event.prototype.type;
 748
 749 /** @type {number} */
 750 jQuery.event.prototype.which;
 751
 752 /**
 753  * @param {(Object|boolean)} arg1
 754  * @param {...*} var_args
 755  * @return {Object}
 756  */
 757 jQuery.extend = function(arg1, var_args) {};
 758
 759 /**
 760  * @param {(Object|boolean)} arg1
 761  * @param {...*} var_args
 762  * @return {Object}
 763  */
 764 jQuery.prototype.extend = function(arg1, var_args) {};
 765
 766 /**
 767  * @param {(Object|boolean)} arg1
 768  * @param {...*} var_args
 769  * @return {Object}
 770  */
 771 $.extend = function(arg1, var_args) {};
 772
 773 /**
 774  * @param {(string|number|function())=} duration
 775  * @param {(function()|string)=} arg2
 776  * @param {function()=} callback
 777  * @return {!jQuery}
 778  */
 779 jQuery.prototype.fadeIn = function(duration, arg2, callback) {};
 780
 781 /**
 782  * @param {(string|number|function())=} duration
 783  * @param {(function()|string)=} arg2
 784  * @param {function()=} callback
 785  * @return {!jQuery}
 786  */
 787 jQuery.prototype.fadeOut = function(duration, arg2, callback) {};
 788
 789 /**
 790  * @param {(string|number)} duration
 791  * @param {number} opacity
 792  * @param {(function()|string)=} arg3
 793  * @param {function()=} callback
 794  * @return {!jQuery}
 795  */
 796 jQuery.prototype.fadeTo = function(duration, opacity, arg3, callback) {};
 797
 798 /**
 799  * @param {(string|number|function())=} duration
 800  * @param {(string|function())=} easing
 801  * @param {function()=} callback
 802  * @return {!jQuery}
 803  */
 804 jQuery.prototype.fadeToggle = function(duration, easing, callback) {};
 805
 806 /**
 807  * @param {(jQuerySelector|function(number)|Element|jQuery)} arg1
 808  * @return {!jQuery}
 809  */
 810 jQuery.prototype.filter = function(arg1) {};
 811
 812 /**
 813  * @param {(jQuerySelector|jQuery|Element)} arg1
 814  * @return {!jQuery}
 815  * @nosideeffects
 816  */
 817 jQuery.prototype.find = function(arg1) {};
 818
 819 /** @return {!jQuery} */
 820 jQuery.prototype.first = function() {};
 821
 822 /** @see http://docs.jquery.com/Plugins/Authoring */
 823 jQuery.fn = jQuery.prototype;
 824
 825 /** @see http://docs.jquery.com/Plugins/Authoring */
 826 $.fn = $.prototype;
 827
 828 /**
 829  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
 830  * @param {function(!jQuery.event=)=} handler
 831  * @return {!jQuery}
 832  */
 833 jQuery.prototype.focus = function(arg1, handler) {};
 834
 835 /**
 836  * @param {(function(!jQuery.event=)|Object.<string, *>)} arg1
 837  * @param {function(!jQuery.event=)=} handler
 838  * @return {!jQuery}
 839  */
 840 jQuery.prototype.focusin = function(arg1, handler) {};
 841
 842 /**
 843  * @param {(function(!jQuery.event=)|Object.<string, *>)} arg1
 844  * @param {function(!jQuery.event=)=} handler
 845  * @return {!jQuery}
 846  */
 847 jQuery.prototype.focusout = function(arg1, handler) {};
 848
 849 /** @const */
 850 jQuery.fx = {};
 851
 852 /** @const */
 853 $.fx = {};
 854
 855 /** @type {number} */
 856 jQuery.fx.interval;
 857
 858 /** @type {number} */
 859 $.fx.interval;
 860
 861 /** @type {boolean} */
 862 jQuery.fx.off;
 863
 864 /** @type {boolean} */
 865 $.fx.off;
 866
 867 /**
 868  * @param {string} url
 869  * @param {(Object.<string,*>|string|
 870  *     function(string,string,jQuery.jqXHR))=} data
 871  * @param {(function(string,string,jQuery.jqXHR)|string)=} success
 872  * @param {string=} dataType
 873  * @return {jQuery.jqXHR}
 874  */
 875 jQuery.get = function(url, data, success, dataType) {};
 876
 877 /**
 878  * @param {number=} index
 879  * @return {(Element|Array.<Element>)}
 880  * @nosideeffects
 881  */
 882 jQuery.prototype.get = function(index) {};
 883
 884 /**
 885  * @param {string} url
 886  * @param {(Object.<string,*>|string|
 887  *     function(string,string,jQuery.jqXHR))=} data
 888  * @param {(function(string,string,jQuery.jqXHR)|string)=} success
 889  * @param {string=} dataType
 890  * @return {jQuery.jqXHR}
 891  */
 892 $.get = function(url, data, success, dataType) {};
 893
 894 /**
 895  * @param {string} url
 896  * @param {(Object.<string,*>|
 897  *     function(Object.<string,*>,string,jQuery.jqXHR))=} data
 898  * @param {function(Object.<string,*>,string,jQuery.jqXHR)=} success
 899  * @return {jQuery.jqXHR}
 900  * @see http://api.jquery.com/jquery.getjson/#jQuery-getJSON-url-data-success
 901  */
 902 jQuery.getJSON = function(url, data, success) {};
 903
 904 /**
 905  * @param {string} url
 906  * @param {(Object.<string,*>|
 907  *     function(Object.<string,*>,string,jQuery.jqXHR))=} data
 908  * @param {function(Object.<string,*>,string,jQuery.jqXHR)=} success
 909  * @return {jQuery.jqXHR}
 910  * @see http://api.jquery.com/jquery.getjson/#jQuery-getJSON-url-data-success
 911  */
 912 $.getJSON = function(url, data, success) {};
 913
 914 /**
 915  * @param {string} url
 916  * @param {function(Node,string,jQuery.jqXHR)=} success
 917  * @return {jQuery.jqXHR}
 918  */
 919 jQuery.getScript = function(url, success) {};
 920
 921 /**
 922  * @param {string} url
 923  * @param {function(Node,string,jQuery.jqXHR)=} success
 924  * @return {jQuery.jqXHR}
 925  */
 926 $.getScript = function(url, success) {};
 927
 928 /** @param {string} code */
 929 jQuery.globalEval = function(code) {};
 930
 931 /** @param {string} code */
 932 $.globalEval = function(code) {};
 933
 934 /**
 935  * @param {Array.<*>} arr
 936  * @param {function(*,number)} fnc
 937  * @param {boolean=} invert
 938  * @return {Array.<*>}
 939  */
 940 jQuery.grep = function(arr, fnc, invert) {};
 941
 942 /**
 943  * @param {Array.<*>} arr
 944  * @param {function(*,number)} fnc
 945  * @param {boolean=} invert
 946  * @return {Array.<*>}
 947  */
 948 $.grep = function(arr, fnc, invert) {};
 949
 950 /**
 951  * @param {(string|Element)} arg1
 952  * @return {!jQuery}
 953  * @nosideeffects
 954  */
 955 jQuery.prototype.has = function(arg1) {};
 956
 957 /**
 958  * @param {string} className
 959  * @return {boolean}
 960  * @nosideeffects
 961  */
 962 jQuery.prototype.hasClass = function(className) {};
 963
 964 /**
 965  * @param {Element} elem
 966  * @return {boolean}
 967  * @nosideeffects
 968  */
 969 jQuery.hasData = function(elem) {};
 970
 971 /**
 972  * @param {Element} elem
 973  * @return {boolean}
 974  * @nosideeffects
 975  */
 976 $.hasData = function(elem) {};
 977
 978 /**
 979  * @param {(string|number|function(number,number))=} arg1
 980  * @return {(number|!jQuery)}
 981  */
 982 jQuery.prototype.height = function(arg1) {};
 983
 984 /**
 985  * @param {(string|number|function())=} duration
 986  * @param {(function()|string)=} arg2
 987  * @param {function()=} callback
 988  * @return {!jQuery}
 989  */
 990 jQuery.prototype.hide = function(duration, arg2, callback) {};
 991
 992 /** @param {boolean} hold */
 993 jQuery.holdReady = function(hold) {};
 994
 995 /** @param {boolean} hold */
 996 $.holdReady = function(hold) {};
 997
 998 /**
 999  * @param {function(!jQuery.event=)} arg1
1000  * @param {function(!jQuery.event=)=} handlerOut
1001  * @return {!jQuery}
1002  */
1003 jQuery.prototype.hover = function(arg1, handlerOut) {};
1004
1005 /**
1006  * @param {(string|function(number,string))=} arg1
1007  * @return {(string|!jQuery)}
1008  */
1009 jQuery.prototype.html = function(arg1) {};
1010
1011 /**
1012  * @param {*} value
1013  * @param {Array.<*>} arr
1014  * @param {number=} fromIndex
1015  * @return {number}
1016  * @nosideeffects
1017  */
1018 jQuery.inArray = function(value, arr, fromIndex) {};
1019
1020 /**
1021  * @param {*} value
1022  * @param {Array.<*>} arr
1023  * @param {number=} fromIndex
1024  * @return {number}
1025  * @nosideeffects
1026  */
1027 $.inArray = function(value, arr, fromIndex) {};
1028
1029 /**
1030  * @param {(jQuerySelector|Element|jQuery)=} arg1
1031  * @return {number}
1032  */
1033 jQuery.prototype.index = function(arg1) {};
1034
1035 /**
1036  * @return {number}
1037  * @nosideeffects
1038  */
1039 jQuery.prototype.innerHeight = function() {};
1040
1041 /**
1042  * @return {number}
1043  * @nosideeffects
1044  */
1045 jQuery.prototype.innerWidth = function() {};
1046
1047 /**
1048  * @param {(jQuerySelector|Element|jQuery)} target
1049  * @return {!jQuery}
1050  */
1051 jQuery.prototype.insertAfter = function(target) {};
1052
1053 /**
1054  * @param {(jQuerySelector|Element|jQuery)} target
1055  * @return {!jQuery}
1056  */
1057 jQuery.prototype.insertBefore = function(target) {};
1058
1059 /**
1060  * @param {(jQuerySelector|function(number)|jQuery|Element)} arg1
1061  * @return {boolean}
1062  */
1063 jQuery.prototype.is = function(arg1) {};
1064
1065 /**
1066  * @param {*} obj
1067  * @return {boolean}
1068  * @nosideeffects
1069  */
1070 jQuery.isArray = function(obj) {};
1071
1072 /**
1073  * @param {*} obj
1074  * @return {boolean}
1075  * @nosideeffects
1076  */
1077 $.isArray = function(obj) {};
1078
1079 /**
1080  * @param {Object} obj
1081  * @return {boolean}
1082  * @nosideeffects
1083  */
1084 jQuery.isEmptyObject = function(obj) {};
1085
1086 /**
1087  * @param {Object} obj
1088  * @return {boolean}
1089  * @nosideeffects
1090  */
1091 $.isEmptyObject = function(obj) {};
1092
1093 /**
1094  * @param {*} obj
1095  * @return {boolean}
1096  * @nosideeffects
1097  */
1098 jQuery.isFunction = function(obj) {};
1099
1100 /**
1101  * @param {*} obj
1102  * @return {boolean}
1103  * @nosideeffects
1104  */
1105 $.isFunction = function(obj) {};
1106
1107 /**
1108  * @param {*} value
1109  * @return {boolean}
1110  * @nosideeffects
1111  */
1112 jQuery.isNumeric = function(value) {};
1113
1114 /**
1115  * @param {*} value
1116  * @return {boolean}
1117  * @nosideeffects
1118  */
1119 $.isNumeric = function(value) {};
1120
1121 /**
1122  * @param {*} obj
1123  * @return {boolean}
1124  * @nosideeffects
1125  */
1126 jQuery.isPlainObject = function(obj) {};
1127
1128 /**
1129  * @param {*} obj
1130  * @return {boolean}
1131  * @nosideeffects
1132  */
1133 $.isPlainObject = function(obj) {};
1134
1135 /**
1136  * @param {*} obj
1137  * @return {boolean}
1138  * @nosideeffects
1139  */
1140 jQuery.isWindow = function(obj) {};
1141
1142 /**
1143  * @param {*} obj
1144  * @return {boolean}
1145  * @nosideeffects
1146  */
1147 $.isWindow = function(obj) {};
1148
1149 /**
1150  * @param {Element} node
1151  * @return {boolean}
1152  * @nosideeffects
1153  */
1154 jQuery.isXMLDoc = function(node) {};
1155
1156 /**
1157  * @param {Element} node
1158  * @return {boolean}
1159  * @nosideeffects
1160  */
1161 $.isXMLDoc = function(node) {};
1162
1163 /** @type {string} */
1164 jQuery.prototype.jquery;
1165
1166 /**
1167  * @constructor
1168  * @extends {XMLHttpRequest}
1169  * @implements {jQuery.Promise}
1170  * @private
1171  * @see http://api.jquery.com/jQuery.ajax/#jqXHR
1172  */
1173 jQuery.jqXHR = function () {};
1174
1175 /**
1176  * @override
1177  * @param {jQueryCallback} alwaysCallbacks
1178  * @param {jQueryCallback=} alwaysCallbacks2
1179  * @return {jQuery.jqXHR}
1180  */
1181 jQuery.jqXHR.prototype.always =
1182     function(alwaysCallbacks, alwaysCallbacks2) {};
1183
1184 /**
1185  * @deprecated
1186  * @param {function()} callback
1187  * @return {jQuery.jqXHR}
1188 */
1189 jQuery.jqXHR.prototype.complete = function (callback) {};
1190
1191 /**
1192  * @override
1193  * @param {jQueryCallback} doneCallbacks
1194  * @return {jQuery.jqXHR}
1195  */
1196 jQuery.jqXHR.prototype.done = function(doneCallbacks) {};
1197
1198 /**
1199  * @deprecated
1200  * @param {function()} callback
1201  * @return {jQuery.jqXHR}
1202 */
1203 jQuery.jqXHR.prototype.error = function (callback) {};
1204
1205 /**
1206  * @override
1207  * @param {jQueryCallback} failCallbacks
1208  * @return {jQuery.jqXHR}
1209  */
1210 jQuery.jqXHR.prototype.fail = function(failCallbacks) {};
1211
1212 /**
1213  * @deprecated
1214  * @override
1215  */
1216 jQuery.jqXHR.prototype.onreadystatechange = function (callback) {};
1217
1218 /**
1219  * @override
1220  * @param {function()=} doneFilter
1221  * @param {function()=} failFilter
1222  * @param {function()=} progressFilter
1223  * @return {jQuery.jqXHR}
1224  */
1225 jQuery.jqXHR.prototype.pipe =
1226     function(doneFilter, failFilter, progressFilter) {};
1227
1228 /**
1229  * @deprecated
1230  * @param {function()} callback
1231  * @return {jQuery.jqXHR}
1232 */
1233 jQuery.jqXHR.prototype.success = function (callback) {};
1234
1235 /**
1236  * @override
1237  * @param {jQueryCallback} doneCallbacks
1238  * @param {jQueryCallback=} failCallbacks
1239  * @param {jQueryCallback=} progressCallbacks
1240  * @return {jQuery.jqXHR}
1241  */
1242 jQuery.jqXHR.prototype.then =
1243     function(doneCallbacks, failCallbacks, progressCallbacks) {};
1244
1245 /**
1246  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
1247  * @param {function(!jQuery.event=)=} handler
1248  * @return {!jQuery}
1249  */
1250 jQuery.prototype.keydown = function(arg1, handler) {};
1251
1252 /**
1253  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
1254  * @param {function(!jQuery.event=)=} handler
1255  * @return {!jQuery}
1256  */
1257 jQuery.prototype.keypress = function(arg1, handler) {};
1258
1259 /**
1260  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
1261  * @param {function(!jQuery.event=)=} handler
1262  * @return {!jQuery}
1263  */
1264 jQuery.prototype.keyup = function(arg1, handler) {};
1265
1266 /** @return {!jQuery} */
1267 jQuery.prototype.last = function() {};
1268
1269 /** @type {number} */
1270 jQuery.prototype.length;
1271
1272 /**
1273  * @deprecated Please avoid the document loading Event invocation of
1274  *     .load() and use .on( "load", handler ) instead. (The AJAX
1275  *     module invocation signature is OK.)
1276  * @param {(function(!jQuery.event=)|Object.<string, *>|string)} arg1
1277  * @param {(function(!jQuery.event=)|Object.<string,*>|string)=} arg2
1278  * @param {function(string,string,XMLHttpRequest)=} complete
1279  * @return {!jQuery}
1280  */
1281 jQuery.prototype.load = function(arg1, arg2, complete) {};
1282
1283 /**
1284  * @param {*} obj
1285  * @return {Array.<*>}
1286  */
1287 jQuery.makeArray = function(obj) {};
1288
1289 /**
1290  * @param {*} obj
1291  * @return {Array.<*>}
1292  */
1293 $.makeArray = function(obj) {};
1294
1295 /**
1296  * @param {(Array.<*>|Object.<string, *>)} arg1
1297  * @param {(function(*,number)|function(*,(string|number)))} callback
1298  * @return {Array.<*>}
1299  */
1300 jQuery.map = function(arg1, callback) {};
1301
1302 /**
1303  * @param {function(number,Element)} callback
1304  * @return {!jQuery}
1305  */
1306 jQuery.prototype.map = function(callback) {};
1307
1308 /**
1309  * @param {(Array.<*>|Object.<string, *>)} arg1
1310  * @param {(function(*,number)|function(*,(string|number)))} callback
1311  * @return {Array.<*>}
1312  */
1313 $.map = function(arg1, callback) {};
1314
1315 /**
1316  * @param {Array.<*>} first
1317  * @param {Array.<*>} second
1318  * @return {Array.<*>}
1319  */
1320 jQuery.merge = function(first, second) {};
1321
1322 /**
1323  * @param {Array.<*>} first
1324  * @param {Array.<*>} second
1325  * @return {Array.<*>}
1326  */
1327 $.merge = function(first, second) {};
1328
1329 /**
1330  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
1331  * @param {function(!jQuery.event=)=} handler
1332  * @return {!jQuery}
1333  */
1334 jQuery.prototype.mousedown = function(arg1, handler) {};
1335
1336 /**
1337  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
1338  * @param {function(!jQuery.event=)=} handler
1339  * @return {!jQuery}
1340  */
1341 jQuery.prototype.mouseenter = function(arg1, handler) {};
1342
1343 /**
1344  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
1345  * @param {function(!jQuery.event=)=} handler
1346  * @return {!jQuery}
1347  */
1348 jQuery.prototype.mouseleave = function(arg1, handler) {};
1349
1350 /**
1351  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
1352  * @param {function(!jQuery.event=)=} handler
1353  * @return {!jQuery}
1354  */
1355 jQuery.prototype.mousemove = function(arg1, handler) {};
1356
1357 /**
1358  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
1359  * @param {function(!jQuery.event=)=} handler
1360  * @return {!jQuery}
1361  */
1362 jQuery.prototype.mouseout = function(arg1, handler) {};
1363
1364 /**
1365  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
1366  * @param {function(!jQuery.event=)=} handler
1367  * @return {!jQuery}
1368  */
1369 jQuery.prototype.mouseover = function(arg1, handler) {};
1370
1371 /**
1372  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
1373  * @param {function(!jQuery.event=)=} handler
1374  * @return {!jQuery}
1375  */
1376 jQuery.prototype.mouseup = function(arg1, handler) {};
1377
1378 /**
1379  * @param {jQuerySelector=} selector
1380  * @return {!jQuery}
1381  * @nosideeffects
1382  */
1383 jQuery.prototype.next = function(selector) {};
1384
1385 /**
1386  * @param {string=} selector
1387  * @return {!jQuery}
1388  * @nosideeffects
1389  */
1390 jQuery.prototype.nextAll = function(selector) {};
1391
1392 /**
1393  * @param {(jQuerySelector|Element)=} arg1
1394  * @param {jQuerySelector=} filter
1395  * @return {!jQuery}
1396  * @nosideeffects
1397  */
1398 jQuery.prototype.nextUntil = function(arg1, filter) {};
1399
1400 /**
1401  * @param {boolean=} removeAll
1402  * @return {Object}
1403  */
1404 jQuery.noConflict = function(removeAll) {};
1405
1406 /**
1407  * @param {boolean=} removeAll
1408  * @return {Object}
1409  */
1410 $.noConflict = function(removeAll) {};
1411
1412 /**
1413  * @return {function()}
1414  * @nosideeffects
1415  */
1416 jQuery.noop = function() {};
1417
1418 /**
1419  * @return {function()}
1420  * @nosideeffects
1421  */
1422 $.noop = function() {};
1423
1424 /**
1425  * @param {(jQuerySelector|Array.<Element>|function(number)|jQuery)} arg1
1426  * @return {!jQuery}
1427  */
1428 jQuery.prototype.not = function(arg1) {};
1429
1430 /**
1431  * @return {number}
1432  * @nosideeffects
1433  */
1434 jQuery.now = function() {};
1435
1436 /**
1437  * @return {number}
1438  * @nosideeffects
1439  */
1440 $.now = function() {};
1441
1442 /**
1443  * @param {(string|Object.<string,*>)=} arg1
1444  * @param {(string|function(!jQuery.event=))=} selector
1445  * @param {function(!jQuery.event=)=} handler
1446  * @return {!jQuery}
1447  */
1448 jQuery.prototype.off = function(arg1, selector, handler) {};
1449
1450 /**
1451  * @param {({left:number,top:number}|
1452  *     function(number,{top:number,left:number}))=} arg1
1453  * @return {({left:number,top:number}|!jQuery)}
1454  */
1455 jQuery.prototype.offset = function(arg1) {};
1456
1457 /**
1458  * @return {!jQuery}
1459  * @nosideeffects
1460  */
1461 jQuery.prototype.offsetParent = function() {};
1462
1463 /**
1464  * @param {(string|Object.<string,*>)} arg1
1465  * @param {*=} selector
1466  * @param {*=} data
1467  * @param {function(!jQuery.event=)=} handler
1468  * @return {!jQuery}
1469  */
1470 jQuery.prototype.on = function(arg1, selector, data, handler) {};
1471
1472 /**
1473  * @param {(string|Object.<string,*>)} arg1
1474  * @param {*=} arg2
1475  * @param {*=} arg3
1476  * @param {function(!jQuery.event=)=} handler
1477  * @return {!jQuery}
1478  */
1479 jQuery.prototype.one = function(arg1, arg2, arg3, handler) {};
1480
1481 /**
1482  * @param {boolean=} includeMargin
1483  * @return {number}
1484  * @nosideeffects
1485  */
1486 jQuery.prototype.outerHeight = function(includeMargin) {};
1487
1488 /**
1489  * @param {boolean=} includeMargin
1490  * @return {number}
1491  * @nosideeffects
1492  */
1493 jQuery.prototype.outerWidth = function(includeMargin) {};
1494
1495 /**
1496  * @param {(Object.<string, *>|Array.<Object.<string, *>>)} obj
1497  * @param {boolean=} traditional
1498  * @return {string}
1499  */
1500 jQuery.param = function(obj, traditional) {};
1501
1502 /**
1503  * @param {(Object.<string, *>|Array.<Object.<string, *>>)} obj
1504  * @param {boolean=} traditional
1505  * @return {string}
1506  */
1507 $.param = function(obj, traditional) {};
1508
1509 /**
1510  * @param {jQuerySelector=} selector
1511  * @return {!jQuery}
1512  * @nosideeffects
1513  */
1514 jQuery.prototype.parent = function(selector) {};
1515
1516 /**
1517  * @param {jQuerySelector=} selector
1518  * @return {!jQuery}
1519  * @nosideeffects
1520  */
1521 jQuery.prototype.parents = function(selector) {};
1522
1523 /**
1524  * @param {(jQuerySelector|Element)=} arg1
1525  * @param {jQuerySelector=} filter
1526  * @return {!jQuery}
1527  * @nosideeffects
1528  */
1529 jQuery.prototype.parentsUntil = function(arg1, filter) {};
1530
1531 /**
1532  * @param {string} data
1533  * @param {(Element|boolean)=} context
1534  * @param {boolean=} keepScripts
1535  * @return {Array.<Element>}
1536  */
1537 jQuery.parseHTML = function(data, context, keepScripts) {};
1538
1539 /**
1540  * @param {string} data
1541  * @param {(Element|boolean)=} context
1542  * @param {boolean=} keepScripts
1543  * @return {Array.<Element>}
1544  */
1545 $.parseHTML = function(data, context, keepScripts) {};
1546
1547 /**
1548  * @param {string} json
1549  * @return {string|number|Object.<string, *>|Array.<?>|boolean}
1550  */
1551 jQuery.parseJSON = function(json) {};
1552
1553 /**
1554  * @param {string} json
1555  * @return {Object.<string, *>}
1556  */
1557 $.parseJSON = function(json) {};
1558
1559 /**
1560  * @param {string} data
1561  * @return {Document}
1562  */
1563 jQuery.parseXML = function(data) {};
1564
1565 /**
1566  * @param {string} data
1567  * @return {Document}
1568  */
1569 $.parseXML = function(data) {};
1570
1571 /**
1572  * @return {{left:number,top:number}}
1573  * @nosideeffects
1574  */
1575 jQuery.prototype.position = function() {};
1576
1577 /**
1578  * @param {string} url
1579  * @param {(Object.<string,*>|string|
1580  *     function(string,string,jQuery.jqXHR))=} data
1581  * @param {(function(string,string,jQuery.jqXHR)|string)=} success
1582  * @param {string=} dataType
1583  * @return {jQuery.jqXHR}
1584  */
1585 jQuery.post = function(url, data, success, dataType) {};
1586
1587 /**
1588  * @param {string} url
1589  * @param {(Object.<string,*>|string|
1590  *     function(string,string,jQuery.jqXHR))=} data
1591  * @param {(function(string,string,jQuery.jqXHR)|string)=} success
1592  * @param {string=} dataType
1593  * @return {jQuery.jqXHR}
1594  */
1595 $.post = function(url, data, success, dataType) {};
1596
1597 /**
1598  * @param {(string|Element|jQuery|function(number,string))} arg1
1599  * @param {(string|Element|jQuery)=} content
1600  * @return {!jQuery}
1601  */
1602 jQuery.prototype.prepend = function(arg1, content) {};
1603
1604 /**
1605  * @param {(jQuerySelector|Element|jQuery)} target
1606  * @return {!jQuery}
1607  */
1608 jQuery.prototype.prependTo = function(target) {};
1609
1610 /**
1611  * @param {jQuerySelector=} selector
1612  * @return {!jQuery}
1613  * @nosideeffects
1614  */
1615 jQuery.prototype.prev = function(selector) {};
1616
1617 /**
1618  * @param {jQuerySelector=} selector
1619  * @return {!jQuery}
1620  * @nosideeffects
1621  */
1622 jQuery.prototype.prevAll = function(selector) {};
1623
1624 /**
1625  * @param {(jQuerySelector|Element)=} arg1
1626  * @param {jQuerySelector=} filter
1627  * @return {!jQuery}
1628  * @nosideeffects
1629  */
1630 jQuery.prototype.prevUntil = function(arg1, filter) {};
1631
1632 /**
1633  * @param {(string|Object)=} type
1634  * @param {Object=} target
1635  * @return {jQuery.Promise}
1636  */
1637 jQuery.prototype.promise = function(type, target) {};
1638
1639 /**
1640  * @interface
1641  * @private
1642  * @see http://api.jquery.com/Types/#Promise
1643  */
1644 jQuery.Promise = function () {};
1645
1646 /**
1647  * @param {jQueryCallback} alwaysCallbacks
1648  * @param {jQueryCallback=} alwaysCallbacks2
1649  * @return {jQuery.Promise}
1650  */
1651 jQuery.Promise.prototype.always =
1652     function(alwaysCallbacks, alwaysCallbacks2) {};
1653
1654 /**
1655  * @param {jQueryCallback} doneCallbacks
1656  * @return {jQuery.Promise}
1657  */
1658 jQuery.Promise.prototype.done = function(doneCallbacks) {};
1659
1660 /**
1661  * @param {jQueryCallback} failCallbacks
1662  * @return {jQuery.Promise}
1663  */
1664 jQuery.Promise.prototype.fail = function(failCallbacks) {};
1665
1666 /**
1667  * @param {function()=} doneFilter
1668  * @param {function()=} failFilter
1669  * @param {function()=} progressFilter
1670  * @return {jQuery.Promise}
1671  */
1672 jQuery.Promise.prototype.pipe =
1673     function(doneFilter, failFilter, progressFilter) {};
1674
1675 /**
1676  * @param {jQueryCallback} doneCallbacks
1677  * @param {jQueryCallback=} failCallbacks
1678  * @param {jQueryCallback=} progressCallbacks
1679  * @return {jQuery.Promise}
1680  */
1681 jQuery.Promise.prototype.then =
1682     function(doneCallbacks, failCallbacks, progressCallbacks) {};
1683
1684 /**
1685  * @param {(string|Object.<string,*>)} arg1
1686  * @param {(string|number|boolean|function(number,String))=} arg2
1687  * @return {(string|boolean|!jQuery)}
1688  */
1689 jQuery.prototype.prop = function(arg1, arg2) {};
1690
1691 /**
1692  * @param {...*} var_args
1693  * @return {function()}
1694  */
1695 jQuery.proxy = function(var_args) {};
1696
1697 /**
1698  * @param {...*} var_args
1699  * @return {function()}
1700  */
1701 $.proxy = function(var_args) {};
1702
1703 /**
1704  * @param {Array.<Element>} elements
1705  * @param {string=} name
1706  * @param {Array.<*>=} args
1707  * @return {!jQuery}
1708  */
1709 jQuery.prototype.pushStack = function(elements, name, args) {};
1710
1711 /**
1712  * @param {(string|Array.<function()>|function(function()))=} queueName
1713  * @param {(Array.<function()>|function(function()))=} arg2
1714  * @return {(Array.<Element>|!jQuery)}
1715  */
1716 jQuery.prototype.queue = function(queueName, arg2) {};
1717
1718 /**
1719  * @param {Element} elem
1720  * @param {string=} queueName
1721  * @param {(Array.<function()>|function())=} arg3
1722  * @return {(Array.<Element>|!jQuery)}
1723  */
1724 jQuery.queue = function(elem, queueName, arg3) {};
1725
1726 /**
1727  * @param {Element} elem
1728  * @param {string=} queueName
1729  * @param {(Array.<function()>|function())=} arg3
1730  * @return {(Array.<Element>|!jQuery)}
1731  */
1732 $.queue = function(elem, queueName, arg3) {};
1733
1734 /**
1735  * @param {function()} handler
1736  * @return {!jQuery}
1737  */
1738 jQuery.prototype.ready = function(handler) {};
1739
1740 /**
1741  * @param {string=} selector
1742  * @return {!jQuery}
1743  */
1744 jQuery.prototype.remove = function(selector) {};
1745
1746 /**
1747  * @param {string} attributeName
1748  * @return {!jQuery}
1749  */
1750 jQuery.prototype.removeAttr = function(attributeName) {};
1751
1752 /**
1753  * @param {(string|function(number,string))=} arg1
1754  * @return {!jQuery}
1755  */
1756 jQuery.prototype.removeClass = function(arg1) {};
1757
1758 /**
1759  * @param {(string|Array.<string>)=} arg1
1760  * @return {!jQuery}
1761  */
1762 jQuery.prototype.removeData = function(arg1) {};
1763
1764 /**
1765  * @param {Element} elem
1766  * @param {string=} name
1767  * @return {!jQuery}
1768  */
1769 jQuery.removeData = function(elem, name) {};
1770
1771 /**
1772  * @param {Element} elem
1773  * @param {string=} name
1774  * @return {!jQuery}
1775  */
1776 $.removeData = function(elem, name) {};
1777
1778 /**
1779  * @param {string} propertyName
1780  * @return {!jQuery}
1781  */
1782 jQuery.prototype.removeProp = function(propertyName) {};
1783
1784 /**
1785  * @param {jQuerySelector} target
1786  * @return {!jQuery}
1787  */
1788 jQuery.prototype.replaceAll = function(target) {};
1789
1790 /**
1791  * @param {(string|Element|jQuery|function())} arg1
1792  * @return {!jQuery}
1793  */
1794 jQuery.prototype.replaceWith = function(arg1) {};
1795
1796 /**
1797  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
1798  * @param {function(!jQuery.event=)=} handler
1799  * @return {!jQuery}
1800  */
1801 jQuery.prototype.resize = function(arg1, handler) {};
1802
1803 /**
1804  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
1805  * @param {function(!jQuery.event=)=} handler
1806  * @return {!jQuery}
1807  */
1808 jQuery.prototype.scroll = function(arg1, handler) {};
1809
1810 /**
1811  * @param {number=} value
1812  * @return {(number|!jQuery)}
1813  */
1814 jQuery.prototype.scrollLeft = function(value) {};
1815
1816 /**
1817  * @param {number=} value
1818  * @return {(number|!jQuery)}
1819  */
1820 jQuery.prototype.scrollTop = function(value) {};
1821
1822 /**
1823  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
1824  * @param {function(!jQuery.event=)=} handler
1825  * @return {!jQuery}
1826  */
1827 jQuery.prototype.select = function(arg1, handler) {};
1828
1829 /**
1830  * @return {string}
1831  * @nosideeffects
1832  */
1833 jQuery.prototype.serialize = function() {};
1834
1835 /**
1836  * @return {Array.<Object.<string, *>>}
1837  * @nosideeffects
1838  */
1839 jQuery.prototype.serializeArray = function() {};
1840
1841 /**
1842  * @param {(string|number|function())=} duration
1843  * @param {(function()|string)=} arg2
1844  * @param {function()=} callback
1845  * @return {!jQuery}
1846  */
1847 jQuery.prototype.show = function(duration, arg2, callback) {};
1848
1849 /**
1850  * @param {jQuerySelector=} selector
1851  * @return {!jQuery}
1852  * @nosideeffects
1853  */
1854 jQuery.prototype.siblings = function(selector) {};
1855
1856 /**
1857  * @deprecated Please use the .length property instead.
1858  * @return {number}
1859  * @nosideeffects
1860  */
1861 jQuery.prototype.size = function() {};
1862
1863 /**
1864  * @param {number} start
1865  * @param {number=} end
1866  * @return {!jQuery}
1867  */
1868 jQuery.prototype.slice = function(start, end) {};
1869
1870 /**
1871  * @param {(Object.<string,*>|string|number)=} optionsOrDuration
1872  * @param {(function()|string)=} completeOrEasing
1873  * @param {function()=} complete
1874  * @return {!jQuery}
1875  */
1876 jQuery.prototype.slideDown =
1877     function(optionsOrDuration, completeOrEasing, complete) {};
1878
1879 /**
1880  * @param {(Object.<string,*>|string|number)=} optionsOrDuration
1881  * @param {(function()|string)=} completeOrEasing
1882  * @param {function()=} complete
1883  * @return {!jQuery}
1884  */
1885 jQuery.prototype.slideToggle =
1886     function(optionsOrDuration, completeOrEasing, complete) {};
1887
1888 /**
1889  * @param {(Object.<string,*>|string|number)=} optionsOrDuration
1890  * @param {(function()|string)=} completeOrEasing
1891  * @param {function()=} complete
1892  * @return {!jQuery}
1893  */
1894 jQuery.prototype.slideUp =
1895     function(optionsOrDuration, completeOrEasing, complete) {};
1896
1897 /**
1898  * @param {(boolean|string)=} arg1
1899  * @param {boolean=} arg2
1900  * @param {boolean=} jumpToEnd
1901  * @return {!jQuery}
1902  */
1903 jQuery.prototype.stop = function(arg1, arg2, jumpToEnd) {};
1904
1905 /**
1906  * @param {(function(!jQuery.event=)|Object.<string, *>)=} arg1
1907  * @param {function(!jQuery.event=)=} handler
1908  * @return {!jQuery}
1909  */
1910 jQuery.prototype.submit = function(arg1, handler) {};
1911
1912 /** @type {Object.<string, *>}
1913  * @deprecated Please try to use feature detection instead.
1914  */
1915 jQuery.support;
1916
1917 /** @type {Object.<string, *>}
1918  * @deprecated Please try to use feature detection instead.
1919  */
1920 $.support;
1921
1922 /**
1923  * @deprecated Please try to use feature detection instead.
1924  * @type {boolean}
1925  */
1926 jQuery.support.boxModel;
1927
1928 /**
1929  * @deprecated Please try to use feature detection instead.
1930  * @type {boolean}
1931  */
1932 $.support.boxModel;
1933
1934 /** @type {boolean} */
1935 jQuery.support.changeBubbles;
1936
1937 /** @type {boolean} */
1938 $.support.changeBubbles;
1939
1940 /** @type {boolean} */
1941 jQuery.support.cors;
1942
1943 /** @type {boolean} */
1944 $.support.cors;
1945
1946 /** @type {boolean} */
1947 jQuery.support.cssFloat;
1948
1949 /** @type {boolean} */
1950 $.support.cssFloat;
1951
1952 /** @type {boolean} */
1953 jQuery.support.hrefNormalized;
1954
1955 /** @type {boolean} */
1956 $.support.hrefNormalized;
1957
1958 /** @type {boolean} */
1959 jQuery.support.htmlSerialize;
1960
1961 /** @type {boolean} */
1962 $.support.htmlSerialize;
1963
1964 /** @type {boolean} */
1965 jQuery.support.leadingWhitespace;
1966
1967 /** @type {boolean} */
1968 $.support.leadingWhitespace;
1969
1970 /** @type {boolean} */
1971 jQuery.support.noCloneEvent;
1972
1973 /** @type {boolean} */
1974 $.support.noCloneEvent;
1975
1976 /** @type {boolean} */
1977 jQuery.support.opacity;
1978
1979 /** @type {boolean} */
1980 $.support.opacity;
1981
1982 /** @type {boolean} */
1983 jQuery.support.style;
1984
1985 /** @type {boolean} */
1986 $.support.style;
1987
1988 /** @type {boolean} */
1989 jQuery.support.submitBubbles;
1990
1991 /** @type {boolean} */
1992 $.support.submitBubbles;
1993
1994 /** @type {boolean} */
1995 jQuery.support.tbody;
1996
1997 /** @type {boolean} */
1998 $.support.tbody;
1999
2000 /**
2001  * @param {(string|function(number,string))=} arg1
2002  * @return {(string|!jQuery)}
2003  */
2004 jQuery.prototype.text = function(arg1) {};
2005
2006 /**
2007  * @return {Array.<Element>}
2008  * @nosideeffects
2009  */
2010 jQuery.prototype.toArray = function() {};
2011
2012 /**
2013  * Refers to the method from the Effects category. There used to be a toggle
2014  * method on the Events category which was removed starting version 1.9.
2015  * @param {(number|string|Object.<string,*>|boolean)=} arg1
2016  * @param {(function()|string)=} arg2
2017  * @param {function()=} arg3
2018  * @return {!jQuery}
2019  */
2020 jQuery.prototype.toggle = function(arg1, arg2, arg3) {};
2021
2022 /**
2023  * @param {(string|boolean|function(number,string,boolean))=} arg1
2024  * @param {boolean=} flag
2025  * @return {!jQuery}
2026  */
2027 jQuery.prototype.toggleClass = function(arg1, flag) {};
2028
2029 /**
2030  * @param {(string|jQuery.event)} arg1
2031  * @param {...*} var_args
2032  * @return {!jQuery}
2033  */
2034 jQuery.prototype.trigger = function(arg1, var_args) {};
2035
2036 /**
2037  * @param {string|jQuery.event} eventType
2038  * @param {Array.<*>=} extraParameters
2039  * @return {*}
2040  */
2041 jQuery.prototype.triggerHandler = function(eventType, extraParameters) {};
2042
2043 /**
2044  * @param {string} str
2045  * @return {string}
2046  * @nosideeffects
2047  */
2048 jQuery.trim = function(str) {};
2049
2050 /**
2051  * @param {string} str
2052  * @return {string}
2053  * @nosideeffects
2054  */
2055 $.trim = function(str) {};
2056
2057 /**
2058  * @param {*} obj
2059  * @return {string}
2060  * @nosideeffects
2061  */
2062 jQuery.type = function(obj) {};
2063
2064 /**
2065  * @param {*} obj
2066  * @return {string}
2067  * @nosideeffects
2068  */
2069 $.type = function(obj) {};
2070
2071 /**
2072  * @param {(string|function(!jQuery.event=)|jQuery.event)=} arg1
2073  * @param {(function(!jQuery.event=)|boolean)=} arg2
2074  * @return {!jQuery}
2075  */
2076 jQuery.prototype.unbind = function(arg1, arg2) {};
2077
2078 /**
2079  * @param {string=} arg1
2080  * @param {(string|Object.<string,*>)=} arg2
2081  * @param {function(!jQuery.event=)=} handler
2082  * @return {!jQuery}
2083  */
2084 jQuery.prototype.undelegate = function(arg1, arg2, handler) {};
2085
2086 /**
2087  * @param {Array.<Element>} arr
2088  * @return {Array.<Element>}
2089  */
2090 jQuery.unique = function(arr) {};
2091
2092 /**
2093  * @param {Array.<Element>} arr
2094  * @return {Array.<Element>}
2095  */
2096 $.unique = function(arr) {};
2097
2098 /**
2099  * @deprecated Please use .on( "unload", handler ) instead.
2100  * @param {(function(!jQuery.event=)|Object.<string, *>)} arg1
2101  * @param {function(!jQuery.event=)=} handler
2102  * @return {!jQuery}
2103  */
2104 jQuery.prototype.unload = function(arg1, handler) {};
2105
2106 /** @return {!jQuery} */
2107 jQuery.prototype.unwrap = function() {};
2108
2109 /**
2110  * @param {(string|Array.<string>|function(number,*))=} arg1
2111  * @return {(string|number|Array.<string>|!jQuery)}
2112  */
2113 jQuery.prototype.val = function(arg1) {};
2114
2115 /**
2116  * Note: The official documentation (https://api.jquery.com/jQuery.when/) says
2117  * jQuery.when accepts deferreds, but it actually accepts any type, e.g.:
2118  *
2119  * jQuery.when(jQuery.ready, jQuery.ajax(''), jQuery('#my-element'), 1)
2120  *
2121  * If an argument is not an "observable" (a promise-like object) it is wrapped
2122  * into a promise.
2123  * @param {*} deferred
2124  * @param {...*} deferreds
2125  * @return {jQuery.Promise}
2126  */
2127 jQuery.when = function(deferred, deferreds) {};
2128
2129 /**
2130  * Note: See jQuery.when().
2131  * @param {*} deferred
2132  * @param {...*} deferreds
2133  * @return {jQuery.Promise}
2134  */
2135 $.when = function(deferred, deferreds) {};
2136
2137 /**
2138  * @param {(string|number|function(number,number))=} arg1
2139  * @return {(number|!jQuery)}
2140  */
2141 jQuery.prototype.width = function(arg1) {};
2142
2143 /**
2144  * @param {(string|jQuerySelector|Element|jQuery|function(number))} arg1
2145  * @return {!jQuery}
2146  */
2147 jQuery.prototype.wrap = function(arg1) {};
2148
2149 /**
2150  * @param {(string|jQuerySelector|Element|jQuery)} wrappingElement
2151  * @return {!jQuery}
2152  */
2153 jQuery.prototype.wrapAll = function(wrappingElement) {};
2154
2155 /**
2156  * @param {(string|jQuerySelector|Element|jQuery|function(number))} arg1
2157  * @return {!jQuery}
2158  */
2159 jQuery.prototype.wrapInner = function(arg1) {};
2160