Clean up the minification stuff a bit; still not really in use.
[remoteglot] / 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