1/*
2 * Copyright 2009 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 Definitions for the Chromium extensions API.
19 *
20 * This is the externs file for the Chrome Extensions API.
21 * See http://developer.chrome.com/extensions/
22 *
23 * There are several problematic issues regarding Chrome extension APIs and
24 * this externs files, including:
25 * A. When to add packages to this file
26 * B. Optional parameters
27 * C. Pseudo-types
28 * D. Events
29 * E. Nullability
30 * F. Private APIs
31 *
32 * The best practices for each are described in more detail below.  It
33 * should be noted that, due to historical reasons, and the evolutionary
34 * nature of this file, much this file currently violates the best practices
35 * described below. As changed are made, the changes should adhere to the
36 * best practices.
37 *
38 * A. When to Add Packages to this File?
39 * Packages in chrome.experimental.* should *not* be added to this file. The
40 * experimental APIs change very quickly, so rather than add them here, make a
41 * separate externs file for your project, then move the API here when it moves
42 * out of experimental.
43 *
44 * Some non-experimental APIs are still evolving or are not full documented. It
45 * is still advantageous to include these in this file as doing so avoids a
46 * proliferation of project-private externs files containing duplicated info. In
47 * these cases, use comments to describe the situation.
48 *
49 * B. Optional Parameters
50 * The Chrome extension APIs make extensive use of optional parameters that
51 * are not at the end of the parameter list, "interior optional parameters",
52 * while the JS Compiler's type system requires optional parameters to be
53 * at the end. This creates a bit of tension:
54 *
55 * 1. If a method has N required params, then the parameter declarations
56 *    should have N required params.
57 * 2. If, due to interior optional params, a parameter can be of more than
58 *    one type, its at-param should:
59 *    a. be named to indicate both possibilities, eg, extensionIdOrRequest,
60 *       or getInfoOrCallback.
61 *    b. the type should include both types, in the same order as the parts
62 *       of the name, even when one type subsumes the other, eg, {string|*}
63 *       or {Object|function(string)}.
64 * See chrome.runtime.sendMessage for a complex example as sendMessage
65 * takes three params with the first and third being optional.
66 *
67 * C. Pseudo-types
68 * The Chrome APIs define many types are that actually pseudo-types, that
69 * is, they can't be instantiated by name. The extension APIs also pass
70 * untyped objects (a bag of properties) to callbacks.
71 *
72 * The Chrome extension APIs include at least three different situations:
73 *
74 * 1. an object that must be created by an extension developer and passed
75 *    into a Chrome extension API and for which there is no constructor.
76 * 2. an instance of a type that is created inside the extension libraries
77 *    and passed out to a callback/listener or returned by an extension API
78 *    (the constructor implicity lives within the library).
79 * 3. like #2, but a bag-of-properties object that is passed out to a
80 *    callback/listener or returned by an extension API so there is no
81 *    defined type.
82 *
83 * For #1, use a typedef so object literals and objects created via goog.object
84 * are acceptable, for example, the Permissions type defined at
85 * http://developer.chrome.com/extensions/permissions.html#type-Permissions
86 * should be:
87 *
88 *   / **
89 *     * at-typedef {?{
90 *     *   permissions: (!Array.<string>|undefined),
91 *     *   origins: (!Array.<string>|undefined)
92 *     * }}
93 *     * /
94 *   chrome.permissions.Permissions;
95 *
96 * Using typedefs provides type-safety for the fields that are defined in
97 * the object literal and also defined in the typedef. Note that typedefs define
98 * a minimal interface and will not complain about extraneous (often
99 * misspelled) fields.
100 *
101 * Also, typedefs of record types are non-nullable by default. The "{?{"
102 * creates a nullable record-type typedef so ! has the same meaning in usages
103 * as it does for real types.
104 *
105 * For #2, use a standard constructor, even though no constructor is provided
106 * and extension writers will never instantiate an instance, as using a first
107 * class type provides the strongest type checking. For example, see the Port
108 * type defined at http://developer.chrome.com/apps/runtime.html#type-Port.
109 * Always qualify the type name to reduce top-level pollution in this file:
110 *
111 *   Do:
112 *        chrome.extension.Port = function() {}
113 *   Don't:
114 *        function Port() {}
115 *
116 * Note that, unfortunately, the actual Port class definition in this file
117 * does not follow this recommendation.
118 *
119 * For #3, use {!Object}, that is, a bag of properites. This is a sad reality
120 * given that the Chrome extensions do not document a real type. It is tempting
121 * to define a real-type within this file and treat this situation as identical
122 * to #2, but that means a new type is being defined in this file and developers
123 * do not expect to find required new types in extension files.
124 *
125 * If a real type is declared here, then developers will need to incorporate
126 * that type into the signature of their callback method and there will be
127 * no indication from the docs that they need to do so.
128 *
129 * D. Events
130 * Most packages define a set of events with the standard set of methods:
131 * addListener, removeListener, hasListener and hasListeners.  ChromeEvent
132 * is the appropriate type when an event's listeners do not take any
133 * parameters, however, many events take parameters specific to that event:
134 *
135 * 1. Create a pseudo-type for the event, for example,
136 *    chrome.runtime.PortEvent and define the four methods on it.
137 * 2. Fully describe the listener/callback's signature, for example,
138 *
139 *       * at-param {function(!chrome.runtime.Port): void} callback Callback.
140 *      chrome.runtime.PortEvent.prototype.addListener =
141 *          function(callback) {};
142 *    or
143 *
144 *       * at-param {function(*, !chrome.runtime.MessageSender,
145 *       *     function(*): void): (boolean|undefined)} callback Callback.
146 *      chrome.runtime.MessageSenderEvent.prototype.addListener =
147 *          function(callback) {};
148 *
149 * E. Nullability
150 * We treat the Chrome Extension API pages as "the truth".  Not-null types
151 * should be used in the following situations:
152 *
153 * 1. Parameters and return values that are not explicitly declared to handle
154 *    null.
155 * 2. Static event instances, for example, chrome.runtime.onConnect's type
156 *    should be: !chrome.runtime.PortEvent.
157 * 3. Optional params as there is little value to passing null when the
158 *    parameter can be omitted, of course, if null is explicitly declared
159 *    to be meaningful, then a nullable type should be used.
160 *
161 * F. Private APIs
162 * Private Chrome APIs (such as those that end in "Private") should go at the
163 * bottom of this file.
164 *
165 * @externs
166 *
167 */
168
169
170/**
171 * TODO(tbreisacher): Move all chrome.app.* externs into their own file.
172 * @const
173 */
174chrome.app = {};
175
176
177/**
178 * @const
179 * @see http://developer.chrome.com/apps/app.runtime.html
180 */
181chrome.app.runtime = {};
182
183
184/**
185 * @constructor
186 * @see http://developer.chrome.com/apps/app_runtime.html
187 */
188chrome.app.runtime.LaunchItem = function() {};
189
190
191/** @type {!FileEntry} */
192chrome.app.runtime.LaunchItem.prototype.entry;
193
194
195/** @type {string} */
196chrome.app.runtime.LaunchItem.prototype.type;
197
198
199/**
200 * @constructor
201 * @see http://developer.chrome.com/apps/app_runtime.html
202 */
203chrome.app.runtime.LaunchData = function() {};
204
205
206/** @type {string|undefined} */
207chrome.app.runtime.LaunchData.prototype.id;
208
209
210/** @type {!Array.<!chrome.app.runtime.LaunchItem>|undefined} */
211chrome.app.runtime.LaunchData.prototype.items;
212
213
214/** @type {string|undefined} */
215chrome.app.runtime.LaunchData.prototype.url;
216
217
218/** @type {string|undefined} */
219chrome.app.runtime.LaunchData.prototype.referrerUrl;
220
221
222/** @type {boolean|undefined} */
223chrome.app.runtime.LaunchData.prototype.isKioskSession;
224
225
226/**
227 * The type of chrome.app.runtime.onLaunched.
228 * @constructor
229 */
230chrome.app.runtime.LaunchEvent = function() {};
231
232
233/**
234 * @param {function(!chrome.app.runtime.LaunchData)} callback
235 * @see http://developer.chrome.com/apps/app.runtime.html#event-onLaunched
236 */
237chrome.app.runtime.LaunchEvent.prototype.addListener = function(callback) {};
238
239
240/**
241 * @param {function(!chrome.app.runtime.LaunchData)} callback
242 */
243chrome.app.runtime.LaunchEvent.prototype.removeListener = function(callback) {};
244
245
246/**
247 * @param {function(!chrome.app.runtime.LaunchData)} callback
248 * @return {boolean}
249 */
250chrome.app.runtime.LaunchEvent.prototype.hasListener = function(callback) {};
251
252
253/**
254 * @return {boolean}
255 */
256chrome.app.runtime.LaunchEvent.prototype.hasListeners = function() {};
257
258
259/** @type {!chrome.app.runtime.LaunchEvent} */
260chrome.app.runtime.onLaunched;
261
262
263/**
264 * @type {!ChromeEvent}
265 * @see http://developer.chrome.com/apps/app.runtime.html#event-onRestarted
266 */
267chrome.app.runtime.onRestarted;
268
269
270/**
271 * @const
272 * @see http://developer.chrome.com/apps/app.window.html
273 */
274chrome.app.window = {};
275
276
277/**
278 * @see https://developer.chrome.com/apps/app_window#method-getAll
279 * @return {!Array.<!chrome.app.window.AppWindow>}
280 */
281chrome.app.window.getAll = function() {};
282
283
284/**
285 * @see https://developer.chrome.com/apps/app_window#method-get
286 * @param {string} id
287 * @return {chrome.app.window.AppWindow}
288 */
289chrome.app.window.get = function(id) {};
290
291
292/**
293 * @constructor
294 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
295 */
296chrome.app.window.AppWindow = function() {};
297
298
299/**
300 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
301 */
302chrome.app.window.AppWindow.prototype.focus = function() {};
303
304
305/**
306 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
307 */
308chrome.app.window.AppWindow.prototype.fullscreen = function() {};
309
310
311/**
312 * @return {boolean}
313 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
314 */
315chrome.app.window.AppWindow.prototype.isFullscreen = function() {};
316
317
318/**
319 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
320 */
321chrome.app.window.AppWindow.prototype.minimize = function() {};
322
323
324/**
325 * @return {boolean}
326 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
327 */
328chrome.app.window.AppWindow.prototype.isMinimized = function() {};
329
330
331/**
332 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
333 */
334chrome.app.window.AppWindow.prototype.maximize = function() {};
335
336
337/**
338 * @return {boolean}
339 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
340 */
341chrome.app.window.AppWindow.prototype.isMaximized = function() {};
342
343
344/**
345 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
346 */
347chrome.app.window.AppWindow.prototype.restore = function() {};
348
349
350/**
351 * @param {number} left The new left position, in pixels.
352 * @param {number} top The new top position, in pixels.
353 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
354 */
355chrome.app.window.AppWindow.prototype.moveTo = function(left, top) {};
356
357
358/**
359 * @param {number} width The new width, in pixels.
360 * @param {number} height The new height, in pixels.
361 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
362 */
363chrome.app.window.AppWindow.prototype.resizeTo = function(width, height) {};
364
365
366/**
367 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
368 */
369chrome.app.window.AppWindow.prototype.drawAttention = function() {};
370
371
372/**
373 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
374 */
375chrome.app.window.AppWindow.prototype.clearAttention = function() {};
376
377
378/**
379 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
380 */
381chrome.app.window.AppWindow.prototype.close = function() {};
382
383
384/**
385 * @param {boolean=} opt_focus Should the window be focused? Defaults to true.
386 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
387 */
388chrome.app.window.AppWindow.prototype.show = function(opt_focus) {};
389
390
391/**
392 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
393 */
394chrome.app.window.AppWindow.prototype.hide = function() {};
395
396
397/**
398 * @return {!chrome.app.window.Bounds} The current window bounds.
399 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
400 */
401chrome.app.window.AppWindow.prototype.getBounds = function() {};
402
403
404/**
405 * @param {!chrome.app.window.Bounds} bounds The new window bounds.
406 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
407 */
408chrome.app.window.AppWindow.prototype.setBounds = function(bounds) {};
409
410
411/**
412 * @return {boolean}
413 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
414 */
415chrome.app.window.AppWindow.prototype.isAlwaysOnTop = function() {};
416
417
418/**
419 * @param {boolean} alwaysOnTop Set whether the window should stay above most
420 *     other windows.
421 * @see http://developer.chrome.com/apps/app.window.html#type-AppWindow
422 */
423chrome.app.window.AppWindow.prototype.setAlwaysOnTop = function(alwaysOnTop) {};
424
425
426/** @type {!ChromeEvent} */
427chrome.app.window.AppWindow.prototype.onBoundsChanged;
428
429
430/** @type {!ChromeEvent} */
431chrome.app.window.AppWindow.prototype.onClosed;
432
433
434/** @type {!ChromeEvent} */
435chrome.app.window.AppWindow.prototype.onFullscreened;
436
437
438/** @type {!ChromeEvent} */
439chrome.app.window.AppWindow.prototype.onMinimized;
440
441
442/** @type {!ChromeEvent} */
443chrome.app.window.AppWindow.prototype.onMaximized;
444
445
446/** @type {!ChromeEvent} */
447chrome.app.window.AppWindow.prototype.onRestored;
448
449
450/** @type {!Window} */
451chrome.app.window.AppWindow.prototype.contentWindow;
452
453
454/**
455 * @typedef {{
456 *   left: (number|undefined),
457 *   top: (number|undefined),
458 *   width: (number|undefined),
459 *   height: (number|undefined)
460 * }}
461 * @see http://developer.chrome.com/apps/app.window.html#type-Bounds
462 */
463chrome.app.window.Bounds;
464
465
466/**
467 * @typedef {{
468 *   id: (string|undefined),
469 *   minWidth: (number|undefined),
470 *   minHeight: (number|undefined),
471 *   maxWidth: (number|undefined),
472 *   maxHeight: (number|undefined),
473 *   frame: (string|undefined),
474 *   bounds: (!chrome.app.window.Bounds|undefined),
475 *   transparentBackground: (boolean|undefined),
476 *   state: (string|undefined),
477 *   hidden: (boolean|undefined),
478 *   resizable: (boolean|undefined),
479 *   alwaysOnTop: (boolean|undefined),
480 *   focused: (boolean|undefined)
481 * }}
482 * @see http://developer.chrome.com/apps/app.window.html#method-create
483 */
484chrome.app.window.CreateWindowOptions;
485
486
487/**
488 * @param {string} url URL to create.
489 * @param {!chrome.app.window.CreateWindowOptions=} opt_options The options for
490 *     the new window.
491 * @param {function(!chrome.app.window.AppWindow)=} opt_createWindowCallback
492 *     Callback to be run.
493 * @see http://developer.chrome.com/apps/app.window.html#method-create
494 */
495chrome.app.window.create = function(
496    url, opt_options, opt_createWindowCallback) {};
497
498
499/**
500 * Returns an AppWindow object for the current script context (ie JavaScript
501 * 'window' object).
502 * @return {!chrome.app.window.AppWindow}
503 * @see http://developer.chrome.com/apps/app.window.html#method-current
504 */
505chrome.app.window.current = function() {};
506
507
508/**
509 * @type {!ChromeEvent}
510 * @see http://developer.chrome.com/apps/app.window.html#event-onBoundsChanged
511 */
512chrome.app.window.onBoundsChanged;
513
514
515/**
516 * @type {!ChromeEvent}
517 * @see http://developer.chrome.com/apps/app.window.html#event-onClosed
518 */
519chrome.app.window.onClosed;
520
521
522/**
523 * @type {!ChromeEvent}
524 * @see http://developer.chrome.com/apps/app.window.html#event-onFullscreened
525 */
526chrome.app.window.onFullscreened;
527
528
529/**
530 * @type {!ChromeEvent}
531 * @see http://developer.chrome.com/apps/app.window.html#event-onMaximized
532 */
533chrome.app.window.onMaximized;
534
535
536/**
537 * @type {!ChromeEvent}
538 * @see http://developer.chrome.com/apps/app.window.html#event-onMinimized
539 */
540chrome.app.window.onMinimized;
541
542
543/**
544 * @type {!ChromeEvent}
545 * @see http://developer.chrome.com/apps/app.window.html#event-onRestored
546 */
547chrome.app.window.onRestored;
548
549
550/**
551 * @const
552 * @see https://developer.chrome.com/apps/bluetooth
553 */
554chrome.bluetooth = function() {};
555
556
557/**
558 * @constructor
559 * @see https://developer.chrome.com/apps/bluetooth#type-AdapterState
560 */
561chrome.bluetooth.AdapterState = function() {};
562
563
564/** @type {string} */
565chrome.bluetooth.AdapterState.prototype.address;
566
567
568/** @type {string} */
569chrome.bluetooth.AdapterState.prototype.name;
570
571
572/** @type {boolean} */
573chrome.bluetooth.AdapterState.prototype.powered;
574
575
576/** @type {boolean} */
577chrome.bluetooth.AdapterState.prototype.available;
578
579
580/** @type {boolean} */
581chrome.bluetooth.AdapterState.prototype.discovering;
582
583
584/**
585 * @constructor
586 * @see https://developer.chrome.com/apps/bluetooth#type-Device
587 */
588chrome.bluetooth.Device = function() {};
589
590
591/** @type {string} */
592chrome.bluetooth.Device.prototype.address;
593
594
595/** @type {string|undefined} */
596chrome.bluetooth.Device.prototype.name;
597
598
599/** @type {number|undefined} */
600chrome.bluetooth.Device.prototype.deviceClass;
601
602
603/** @type {string|undefined} */
604chrome.bluetooth.Device.prototype.vendorIdSource;
605
606
607/** @type {string|undefined} */
608chrome.bluetooth.Device.prototype.vendorId;
609
610
611/** @type {number|undefined} */
612chrome.bluetooth.Device.prototype.productId;
613
614
615/** @type {number|undefined} */
616chrome.bluetooth.Device.prototype.deviceId;
617
618
619/** @type {string|undefined} */
620chrome.bluetooth.Device.prototype.type;
621
622
623/** @type {boolean|undefined} */
624chrome.bluetooth.Device.prototype.paired;
625
626
627/** @type {boolean|undefined} */
628chrome.bluetooth.Device.prototype.connected;
629
630
631/** @type {!Array.<string>|undefined} */
632chrome.bluetooth.Device.prototype.uuids;
633
634
635/**
636 * @param {function(!chrome.bluetooth.AdapterState)} callback
637 * @see https://developer.chrome.com/apps/bluetooth#method-getAdapterState
638 */
639chrome.bluetooth.getAdapterState = function(callback) {};
640
641
642/**
643 * @param {string} deviceAddress
644 * @param {function(!chrome.bluetooth.Device)} callback
645 * @see https://developer.chrome.com/apps/bluetooth#method-getDevice
646 */
647chrome.bluetooth.getDevice = function(deviceAddress, callback) {};
648
649
650/**
651 * @param {function(!Array.<!chrome.bluetooth.Device>)} callback
652 * @see https://developer.chrome.com/apps/bluetooth#method-getDevices
653 */
654chrome.bluetooth.getDevices = function(callback) {};
655
656
657/**
658 * @param {function()=} opt_callback
659 * @see https://developer.chrome.com/apps/bluetooth#method-startDiscovery
660 */
661chrome.bluetooth.startDiscovery = function(opt_callback) {};
662
663
664/**
665 * @param {function()=} opt_callback
666 * @see https://developer.chrome.com/apps/bluetooth#method-stopDiscovery
667 */
668chrome.bluetooth.stopDiscovery = function(opt_callback) {};
669
670
671/**
672 * Event whose listeners take an AdapaterState parameter.
673 * @constructor
674 */
675chrome.bluetooth.AdapterStateEvent = function() {};
676
677
678/** @param {function(!chrome.bluetooth.AdapterState): void} callback */
679chrome.bluetooth.AdapterStateEvent.prototype.addListener =
680    function(callback) {};
681
682
683/** @param {function(!chrome.bluetooth.AdapterState): void} callback */
684chrome.bluetooth.AdapterStateEvent.prototype.removeListener =
685    function(callback) {};
686
687
688/**
689 * @param {function(!chrome.bluetooth.AdapterState): void} callback
690 * @return {boolean}
691 */
692chrome.bluetooth.AdapterStateEvent.prototype.hasListener =
693    function(callback) {};
694
695
696/** @return {boolean} */
697chrome.bluetooth.AdapterStateEvent.prototype.hasListeners = function() {};
698
699
700/**
701 * @type {!chrome.bluetooth.AdapterStateEvent}
702 * @see https://developer.chrome.com/apps/bluetooth#event-onAdapterStateChanged
703 */
704chrome.bluetooth.onAdapterStateChanged;
705
706
707/**
708 * Event whose listeners take an Device parameter.
709 * @constructor
710 */
711chrome.bluetooth.DeviceEvent = function() {};
712
713
714/** @param {function(!chrome.bluetooth.Device): void} callback */
715chrome.bluetooth.DeviceEvent.prototype.addListener = function(callback) {};
716
717
718/** @param {function(!chrome.bluetooth.Device): void} callback */
719chrome.bluetooth.DeviceEvent.prototype.removeListener = function(callback) {};
720
721
722/**
723 * @param {function(!chrome.bluetooth.Device): void} callback
724 * @return {boolean}
725 */
726chrome.bluetooth.DeviceEvent.prototype.hasListener = function(callback) {};
727
728
729/** @return {boolean} */
730chrome.bluetooth.DeviceEvent.prototype.hasListeners = function() {};
731
732
733/**
734 * @type {!chrome.bluetooth.DeviceEvent}
735 * @see https://developer.chrome.com/apps/bluetooth#event-onDeviceAdded
736 */
737chrome.bluetooth.onDeviceAdded;
738
739
740/**
741 * @type {!chrome.bluetooth.DeviceEvent}
742 * @see https://developer.chrome.com/apps/bluetooth#event-onDeviceChanged
743 */
744chrome.bluetooth.onDeviceChanged;
745
746
747/**
748 * @type {!chrome.bluetooth.DeviceEvent}
749 * @see https://developer.chrome.com/apps/bluetooth#event-onDeviceRemoved
750 */
751chrome.bluetooth.onDeviceRemoved;
752
753
754/**
755 * @const
756 * @see https://developer.chrome.com/apps/bluetoothSocket
757 */
758chrome.bluetoothSocket = {};
759
760
761/**
762 * @typedef {{
763 *   persistent: (boolean|undefined),
764 *   name: (string|undefined),
765 *   bufferSize: (number|undefined)
766 * }}
767 * @see https://developer.chrome.com/apps/bluetoothSocket#type-SocketProperties
768 */
769chrome.bluetoothSocket.SocketProperties;
770
771
772/**
773 * @typedef {{
774 *   channel: (number|undefined),
775 *   psm: (number|undefined),
776 *   backlog: (number|undefined)
777 * }}
778 * @see https://developer.chrome.com/apps/bluetoothSocket#type-ListenOptions
779 */
780chrome.bluetoothSocket.ListenOptions;
781
782
783/**
784 * @constructor
785 * @see https://developer.chrome.com/apps/bluetoothSocket#type-SocketInfo
786 */
787chrome.bluetoothSocket.SocketInfo = function() {};
788
789
790/** @type {number} */
791chrome.bluetoothSocket.SocketInfo.prototype.socketId;
792
793
794/** @type {boolean} */
795chrome.bluetoothSocket.SocketInfo.prototype.persistent;
796
797
798/** @type {string|undefined} */
799chrome.bluetoothSocket.SocketInfo.prototype.name;
800
801
802/** @type {number|undefined} */
803chrome.bluetoothSocket.SocketInfo.prototype.bufferSize;
804
805
806/** @type {boolean} */
807chrome.bluetoothSocket.SocketInfo.prototype.paused;
808
809
810/** @type {boolean} */
811chrome.bluetoothSocket.SocketInfo.prototype.connected;
812
813
814/** @type {string|undefined} */
815chrome.bluetoothSocket.SocketInfo.prototype.address;
816
817
818/** @type {string|undefined} */
819chrome.bluetoothSocket.SocketInfo.prototype.uuid;
820
821
822/**
823 * @param {!chrome.bluetoothSocket.SocketProperties|
824 *     function(!{socketId: number})} propertiesOrCallback
825 * @param {function(!{socketId: number})=} opt_callback
826 * @see https://developer.chrome.com/apps/bluetoothSocket#method-create
827 */
828chrome.bluetoothSocket.create = function(propertiesOrCallback, opt_callback) {};
829
830
831/**
832 * @param {number} socketId
833 * @param {!chrome.bluetoothSocket.SocketProperties} properties
834 * @param {function()=} opt_callback
835 * @see https://developer.chrome.com/apps/bluetoothSocket#method-update
836 */
837chrome.bluetoothSocket.update = function(socketId, properties, opt_callback) {};
838
839
840/**
841 * @param {number} socketId
842 * @param {boolean} paused
843 * @param {function()=} opt_callback
844 * @see https://developer.chrome.com/apps/bluetoothSocket#method-setPaused
845 */
846chrome.bluetoothSocket.setPaused = function(socketId, paused, opt_callback) {};
847
848
849/**
850 * @param {number} socketId
851 * @param {string} uuid
852 * @param {!chrome.bluetoothSocket.ListenOptions|function()} optionsOrCallback
853 * @param {function()=} opt_callback
854 * @see https://developer.chrome.com/apps/bluetoothSocket#method-listenUsingRfcomm
855 */
856chrome.bluetoothSocket.listenUsingRfcomm =
857    function(socketId, uuid, optionsOrCallback, opt_callback) {};
858
859
860/**
861 * @param {number} socketId
862 * @param {string} uuid
863 * @param {!chrome.bluetoothSocket.ListenOptions|function()} optionsOrCallback
864 * @param {function()=} opt_callback
865 * @see https://developer.chrome.com/apps/bluetoothSocket#method-listenUsingL2cap
866 */
867chrome.bluetoothSocket.listenUsingL2cap =
868    function(socketId, uuid, optionsOrCallback, opt_callback) {};
869
870
871/**
872 * @param {number} socketId
873 * @param {string} address
874 * @param {string} uuid
875 * @param {function()} callback
876 * @see https://developer.chrome.com/apps/bluetoothSocket#method-connect
877 */
878chrome.bluetoothSocket.connect = function(socketId, address, uuid, callback) {};
879
880
881/**
882 * @param {number} socketId
883 * @param {function()=} opt_callback
884 * @see https://developer.chrome.com/apps/bluetoothSocket#method-disconnect
885 */
886chrome.bluetoothSocket.disconnect = function(socketId, opt_callback) {};
887
888
889/**
890 * @param {number} socketId
891 * @param {function()=} opt_callback
892 * @see https://developer.chrome.com/apps/bluetoothSocket#method-close
893 */
894chrome.bluetoothSocket.close = function(socketId, opt_callback) {};
895
896
897/**
898 * @param {number} socketId
899 * @param {!ArrayBuffer} data
900 * @param {function(number)=} opt_callback
901 * @see https://developer.chrome.com/apps/bluetoothSocket#method-send
902 */
903chrome.bluetoothSocket.send = function(socketId, data, opt_callback) {};
904
905
906/**
907 * @param {number} socketId
908 * @param {function(!chrome.bluetoothSocket.SocketInfo)} callback
909 * @see https://developer.chrome.com/apps/bluetoothSocket#method-getInfo
910 */
911chrome.bluetoothSocket.getInfo = function(socketId, callback) {};
912
913
914/**
915 * @param {function(!Array.<!chrome.bluetoothSocket.SocketInfo>)} callback
916 * @see https://developer.chrome.com/apps/bluetoothSocket#method-getSockets
917 */
918chrome.bluetoothSocket.getSockets = function(callback) {};
919
920
921/**
922 * @constructor
923 * @see https://developer.chrome.com/apps/bluetoothSocket#event-onAccept
924 */
925chrome.bluetoothSocket.AcceptEventData = function() {};
926
927
928/** @type {number} */
929chrome.bluetoothSocket.AcceptEventData.prototype.socketId;
930
931
932/** @type {number} */
933chrome.bluetoothSocket.AcceptEventData.prototype.clientSocketId;
934
935
936/**
937 * Event whose listeners take a AcceptEventData parameter.
938 * @constructor
939 */
940chrome.bluetoothSocket.AcceptEvent = function() {};
941
942
943/**
944 * @param {function(!chrome.bluetoothSocket.AcceptEventData): void} callback
945 */
946chrome.bluetoothSocket.AcceptEvent.prototype.addListener =
947    function(callback) {};
948
949
950/**
951 * @param {function(!chrome.bluetoothSocket.AcceptEventData): void} callback
952 */
953chrome.bluetoothSocket.AcceptEvent.prototype.removeListener =
954    function(callback) {};
955
956
957/**
958 * @param {function(!chrome.bluetoothSocket.AcceptEventData): void} callback
959 * @return {boolean}
960 */
961chrome.bluetoothSocket.AcceptEvent.prototype.hasListener =
962    function(callback) {};
963
964
965/** @return {boolean} */
966chrome.bluetoothSocket.AcceptEvent.prototype.hasListeners = function() {};
967
968
969/** @type {!chrome.bluetoothSocket.AcceptEvent} */
970chrome.bluetoothSocket.onAccept;
971
972
973/**
974 * @constructor
975 * @see https://developer.chrome.com/apps/bluetoothSocket#event-onAcceptError
976 */
977chrome.bluetoothSocket.AcceptErrorEventData = function() {};
978
979
980/** @type {number} */
981chrome.bluetoothSocket.AcceptErrorEventData.prototype.socketId;
982
983
984/** @type {string} */
985chrome.bluetoothSocket.AcceptErrorEventData.prototype.errorMessage;
986
987
988/** @type {string} */
989chrome.bluetoothSocket.AcceptErrorEventData.prototype.error;
990
991
992/**
993 * Event whose listeners take a AcceptErrorEventData parameter.
994 * @constructor
995 */
996chrome.bluetoothSocket.AcceptErrorEvent = function() {};
997
998
999/**
1000 * @param {function(
1001 *     !chrome.bluetoothSocket.AcceptErrorEventData): void} callback
1002 */
1003chrome.bluetoothSocket.AcceptErrorEvent.prototype.addListener =
1004    function(callback) {};
1005
1006
1007/**
1008 * @param {function(
1009 *     !chrome.bluetoothSocket.AcceptErrorEventData): void} callback
1010 */
1011chrome.bluetoothSocket.AcceptErrorEvent.prototype.removeListener =
1012    function(callback) {};
1013
1014
1015/**
1016 * @param {function(
1017 *     !chrome.bluetoothSocket.AcceptErrorEventData): void} callback
1018 * @return {boolean}
1019 */
1020chrome.bluetoothSocket.AcceptErrorEvent.prototype.hasListener =
1021    function(callback) {};
1022
1023
1024/** @return {boolean} */
1025chrome.bluetoothSocket.AcceptErrorEvent.prototype.hasListeners =
1026    function() {};
1027
1028
1029/** @type {!chrome.bluetoothSocket.AcceptErrorEvent} */
1030chrome.bluetoothSocket.onAcceptError;
1031
1032
1033/**
1034 * @constructor
1035 * @see https://developer.chrome.com/apps/bluetoothSocket#event-onReceive
1036 */
1037chrome.bluetoothSocket.ReceiveEventData = function() {};
1038
1039
1040/** @type {number} */
1041chrome.bluetoothSocket.ReceiveEventData.prototype.socketId;
1042
1043
1044/** @type {!ArrayBuffer} */
1045chrome.bluetoothSocket.ReceiveEventData.prototype.data;
1046
1047
1048/**
1049 * Event whose listeners take a ReceiveEventData parameter.
1050 * @constructor
1051 */
1052chrome.bluetoothSocket.ReceiveEvent = function() {};
1053
1054
1055/**
1056 * @param {function(!chrome.bluetoothSocket.ReceiveEventData): void} callback
1057 */
1058chrome.bluetoothSocket.ReceiveEvent.prototype.addListener =
1059    function(callback) {};
1060
1061
1062/**
1063 * @param {function(!chrome.bluetoothSocket.ReceiveEventData): void} callback
1064 */
1065chrome.bluetoothSocket.ReceiveEvent.prototype.removeListener =
1066    function(callback) {};
1067
1068
1069/**
1070 * @param {function(!chrome.bluetoothSocket.ReceiveEventData): void} callback
1071 * @return {boolean}
1072 */
1073chrome.bluetoothSocket.ReceiveEvent.prototype.hasListener =
1074    function(callback) {};
1075
1076
1077/** @return {boolean} */
1078chrome.bluetoothSocket.ReceiveEvent.prototype.hasListeners = function() {};
1079
1080
1081/** @type {!chrome.bluetoothSocket.ReceiveEvent} */
1082chrome.bluetoothSocket.onReceive;
1083
1084
1085/**
1086 * @constructor
1087 * @see https://developer.chrome.com/apps/bluetoothSocket#event-onReceiveError
1088 */
1089chrome.bluetoothSocket.ReceiveErrorEventData = function() {};
1090
1091
1092/** @type {number} */
1093chrome.bluetoothSocket.ReceiveErrorEventData.prototype.socketId;
1094
1095
1096/** @type {string} */
1097chrome.bluetoothSocket.ReceiveErrorEventData.prototype.errorMessage;
1098
1099
1100/** @type {string} */
1101chrome.bluetoothSocket.ReceiveErrorEventData.prototype.error;
1102
1103
1104/**
1105 * Event whose listeners take a ReceiveErrorEventData parameter.
1106 * @constructor
1107 */
1108chrome.bluetoothSocket.ReceiveErrorEvent = function() {};
1109
1110
1111/**
1112 * @param {function(
1113 *     !chrome.bluetoothSocket.ReceiveErrorEventData): void} callback
1114 */
1115chrome.bluetoothSocket.ReceiveErrorEvent.prototype.addListener =
1116    function(callback) {};
1117
1118
1119/**
1120 * @param {function(
1121 *     !chrome.bluetoothSocket.ReceiveErrorEventData): void} callback
1122 */
1123chrome.bluetoothSocket.ReceiveErrorEvent.prototype.removeListener =
1124    function(callback) {};
1125
1126
1127/**
1128 * @param {function(
1129 *     !chrome.bluetoothSocket.ReceiveErrorEventData): void} callback
1130 * @return {boolean}
1131 */
1132chrome.bluetoothSocket.ReceiveErrorEvent.prototype.hasListener =
1133    function(callback) {};
1134
1135
1136/** @return {boolean} */
1137chrome.bluetoothSocket.ReceiveErrorEvent.prototype.hasListeners =
1138    function() {};
1139
1140
1141/** @type {!chrome.bluetoothSocket.ReceiveErrorEvent} */
1142chrome.bluetoothSocket.onReceiveError;
1143
1144
1145/**
1146 * @see http://developer.chrome.com/extensions/commands.html
1147 * @const
1148 */
1149chrome.commands = {};
1150
1151
1152/**
1153 * @param {function(Array.<string>): void} callback Callback function.
1154 */
1155chrome.commands.getAll = function(callback) {};
1156
1157
1158/** @type {!ChromeEvent} */
1159chrome.commands.onCommand;
1160
1161
1162/**
1163 * @see https://developer.chrome.com/extensions/extension.html
1164 * @const
1165 */
1166chrome.extension = {};
1167
1168
1169/** @type {!Object|undefined} */
1170chrome.extension.lastError = {};
1171
1172
1173/**
1174 * @type {string|undefined}
1175 */
1176chrome.extension.lastError.message;
1177
1178
1179/** @type {boolean|undefined} */
1180chrome.extension.inIncognitoContext;
1181
1182
1183// TODO: change Object to !Object when it's clear nobody is passing in null
1184// TODO: change Port to !Port since it should never be null
1185/**
1186 * @param {string|Object.<string>=} opt_extensionIdOrConnectInfo Either the
1187 *     extensionId to connect to, in which case connectInfo params can be
1188 *     passed in the next optional argument, or the connectInfo params.
1189 * @param {Object.<string>=} opt_connectInfo The connectInfo object,
1190 *     if arg1 was the extensionId to connect to.
1191 * @return {Port} New port.
1192 */
1193chrome.extension.connect = function(
1194    opt_extensionIdOrConnectInfo, opt_connectInfo) {};
1195
1196
1197/**
1198 * @return {Window} The global JS object for the background page.
1199 */
1200chrome.extension.getBackgroundPage = function() {};
1201
1202
1203/**
1204 * @param {string} path A path to a resource within an extension expressed
1205 *     relative to it's install directory.
1206 * @return {string} The fully-qualified URL to the resource.
1207 */
1208chrome.extension.getURL = function(path) {};
1209
1210
1211/**
1212 * @param {Object=} opt_fetchProperties An object with optional 'type' and
1213 *     optional 'windowId' keys.
1214 * @return {Array.<Window>} The global JS objects for each content view.
1215 */
1216chrome.extension.getViews = function(opt_fetchProperties) {};
1217
1218
1219/**
1220 * @param {function(boolean): void} callback Callback function.
1221 */
1222chrome.extension.isAllowedFileSchemeAccess = function(callback) {};
1223
1224
1225/**
1226 * @param {function(boolean): void} callback Callback function.
1227 */
1228chrome.extension.isAllowedIncognitoAccess = function(callback) {};
1229
1230
1231/**
1232 * @param {string|*} extensionIdOrRequest Either the extensionId to send the
1233 *     request to, in which case the request is passed as the next arg, or the
1234 *     request.
1235 * @param {*=} opt_request The request value, if arg1 was the extensionId.
1236 * @param {function(*): void=} opt_callback The callback function which
1237 *     takes a JSON response object sent by the handler of the request.
1238 */
1239chrome.extension.sendMessage = function(
1240    extensionIdOrRequest, opt_request, opt_callback) {};
1241
1242
1243/**
1244 * @param {number|*=} opt_arg1 Either the extensionId to send the request to,
1245 *     in which case the request is passed as the next arg, or the request.
1246 * @param {*=} opt_request The request value, if arg1 was the extensionId.
1247 * @param {function(*): void=} opt_callback The callback function which
1248 *     takes a JSON response object sent by the handler of the request.
1249 */
1250chrome.extension.sendRequest = function(opt_arg1, opt_request, opt_callback) {};
1251
1252
1253/**
1254 * @param {string} data
1255 */
1256chrome.extension.setUpdateUrlData = function(data) {};
1257
1258
1259/** @type {!ChromeEvent} */
1260chrome.extension.onConnect;
1261
1262
1263/** @type {!ChromeEvent} */
1264chrome.extension.onConnectExternal;
1265
1266
1267/** @type {!ChromeEvent} */
1268chrome.extension.onMessage;
1269
1270
1271/** @type {!ChromeEvent} */
1272chrome.extension.onRequest;
1273
1274
1275/** @type {!ChromeEvent} */
1276chrome.extension.onRequestExternal;
1277
1278
1279/**
1280 * @see https://developer.chrome.com/extensions/runtime.html
1281 * @const
1282 */
1283chrome.runtime = {};
1284
1285
1286/** @type {!Object|undefined} */
1287chrome.runtime.lastError = {};
1288
1289
1290/**
1291 * @type {string|undefined}
1292 */
1293chrome.runtime.lastError.message;
1294
1295
1296/** @type {string} */
1297chrome.runtime.id;
1298
1299
1300/**
1301 * @param {function(!Window=): void} callback Callback function.
1302 */
1303chrome.runtime.getBackgroundPage = function(callback) {};
1304
1305
1306
1307/**
1308 * Manifest information returned from chrome.runtime.getManifest. See
1309 * http://developer.chrome.com/extensions/manifest.html. Note that there are
1310 * several other fields not included here. They should be added to these externs
1311 * as needed.
1312 * @constructor
1313 */
1314chrome.runtime.Manifest = function() {};
1315
1316
1317/** @type {string} */
1318chrome.runtime.Manifest.prototype.name;
1319
1320
1321/** @type {string} */
1322chrome.runtime.Manifest.prototype.version;
1323
1324
1325/** @type {number|undefined} */
1326chrome.runtime.Manifest.prototype.manifest_version;
1327
1328
1329/** @type {string|undefined} */
1330chrome.runtime.Manifest.prototype.description;
1331
1332
1333/** @type {!chrome.runtime.Manifest.Oauth2|undefined} */
1334chrome.runtime.Manifest.prototype.oauth2;
1335
1336
1337/** @type {!Array.<(string|!Object)>} */
1338chrome.runtime.Manifest.prototype.permissions;
1339
1340
1341
1342/**
1343 * Oauth2 info in the manifest.
1344 * See http://developer.chrome.com/apps/app_identity.html#update_manifest.
1345 * @constructor
1346 */
1347chrome.runtime.Manifest.Oauth2 = function() {};
1348
1349
1350/** @type {string} */
1351chrome.runtime.Manifest.Oauth2.prototype.client_id;
1352
1353/**@type {!Array.<string>} */
1354chrome.runtime.Manifest.Oauth2.prototype.scopes;
1355
1356
1357/**
1358 * http://developer.chrome.com/extensions/runtime.html#method-getManifest
1359 * @return {!chrome.runtime.Manifest} The full manifest file of the app or
1360 *     extension.
1361 */
1362chrome.runtime.getManifest = function() {};
1363
1364
1365/**
1366 * @param {string} path A path to a resource within an extension expressed
1367 *     relative to it's install directory.
1368 * @return {string} The fully-qualified URL to the resource.
1369 */
1370chrome.runtime.getURL = function(path) {};
1371
1372/**
1373 * @param {string} url This may be used to clean up server-side data, do
1374 *     analytics, and implement surveys. Maximum 255 characters.
1375 */
1376chrome.runtime.setUninstallUrl = function(url) {};
1377
1378/**
1379 * Reloads the app or extension.
1380 */
1381chrome.runtime.reload = function() {};
1382
1383
1384/**
1385 * @param {function(string, !Object=): void} callback Called with "throttled",
1386 *     "no_update", or "update_available". If an update is available, the object
1387 *     contains more information about the available update.
1388 */
1389chrome.runtime.requestUpdateCheck = function(callback) {};
1390
1391/**
1392 * Restart the ChromeOS device when the app runs in kiosk mode. Otherwise, it's
1393 * no-op.
1394 */
1395chrome.runtime.restart = function() {};
1396
1397
1398/**
1399 * @param {string|!Object.<string>=} opt_extensionIdOrConnectInfo Either the
1400 *     extensionId to connect to, in which case connectInfo params can be
1401 *     passed in the next optional argument, or the connectInfo params.
1402 * @param {!Object.<string>=} opt_connectInfo The connectInfo object,
1403 *     if arg1 was the extensionId to connect to.
1404 * @return {!Port} New port.
1405 */
1406chrome.runtime.connect = function(
1407    opt_extensionIdOrConnectInfo, opt_connectInfo) {};
1408
1409
1410/**
1411 * @see http://developer.chrome.com/extensions/runtime.html#method-connectNative
1412 * @param {string} application Name of the registered native messaging host to
1413 *     connect to, like 'com.google.your_product'.
1414 * @return {!Port} New port.
1415 */
1416chrome.runtime.connectNative = function(application) {};
1417
1418
1419/**
1420 * @param {string|*} extensionIdOrMessage Either the extensionId to send the
1421 *     message to, in which case the message is passed as the next arg, or the
1422 *     message itself.
1423 * @param {(*|Object|function(*): void)=} opt_messageOrOptsOrCallback
1424 *     One of:
1425 *     The message, if arg1 was the extensionId.
1426 *     The options for message sending, if arg1 was the message and this
1427 *     argument is not a function.
1428 *     The callback, if arg1 was the message and this argument is a function.
1429 * @param {(Object|function(*): void)=} opt_optsOrCallback
1430 *     Either the options for message sending, if arg2 was the message,
1431 *     or the callback.
1432 * @param {function(*): void=} opt_callback The callback function which
1433 *     takes a JSON response object sent by the handler of the request.
1434 */
1435chrome.runtime.sendMessage = function(
1436    extensionIdOrMessage, opt_messageOrOptsOrCallback, opt_optsOrCallback,
1437    opt_callback) {};
1438
1439
1440/**
1441 * @see http://developer.chrome.com/extensions/runtime.html#method-sendNativeMessage
1442 * @param {string} application Name of the registered native messaging host to
1443 *     connect to, like 'com.google.your_product'.
1444 * @param {Object} message The message that will be passed to the native
1445 *     messaging host.
1446 * @param {function(*)=} opt_callback Called with the response message sent by
1447 *     the native messaging host. If an error occurs while connecting to the
1448 *     native messaging host, the callback will be called with no arguments and
1449 *     chrome.runtime.lastError will be set to the error message.
1450 */
1451chrome.runtime.sendNativeMessage = function(
1452    application, message, opt_callback) {};
1453
1454/**
1455 *
1456 * @param {function(!Object)} callback
1457 */
1458chrome.runtime.getPlatformInfo = function(callback) {};
1459
1460
1461/**
1462 * @param {function(!DirectoryEntry)} callback
1463 */
1464chrome.runtime.getPackageDirectoryEntry = function(callback) {};
1465
1466
1467/** @type {!chrome.runtime.PortEvent} */
1468chrome.runtime.onConnect;
1469
1470
1471/** @type {!chrome.runtime.PortEvent} */
1472chrome.runtime.onConnectExternal;
1473
1474
1475/** @type {!ChromeObjectEvent} */
1476chrome.runtime.onInstalled;
1477
1478
1479/** @type {!chrome.runtime.MessageSenderEvent} */
1480chrome.runtime.onMessage;
1481
1482
1483/** @type {!chrome.runtime.MessageSenderEvent} */
1484chrome.runtime.onMessageExternal;
1485
1486
1487/** @type {!ChromeEvent} */
1488chrome.runtime.onStartup;
1489
1490
1491/** @type {!ChromeEvent} */
1492chrome.runtime.onSuspend;
1493
1494
1495/** @type {!ChromeEvent} */
1496chrome.runtime.onSuspendCanceled;
1497
1498
1499/** @type {!ChromeObjectEvent} */
1500chrome.runtime.onUpdateAvailable;
1501
1502
1503/** @type {!ChromeStringEvent} */
1504chrome.runtime.onRestartRequired;
1505
1506
1507/**
1508 * Event whose listeners take a Port parameter.
1509 * @constructor
1510 */
1511chrome.runtime.PortEvent = function() {};
1512
1513
1514/**
1515 * @param {function(!Port): void} callback Callback.
1516 */
1517chrome.runtime.PortEvent.prototype.addListener = function(callback) {};
1518
1519
1520/**
1521 * @param {function(!Port): void} callback Callback.
1522 */
1523chrome.runtime.PortEvent.prototype.removeListener = function(callback) {};
1524
1525
1526/**
1527 * @param {function(!Port): void} callback Callback.
1528 * @return {boolean}
1529 */
1530chrome.runtime.PortEvent.prototype.hasListener = function(callback) {};
1531
1532
1533/**
1534 * @return {boolean}
1535 */
1536chrome.runtime.PortEvent.prototype.hasListeners = function() {};
1537
1538
1539
1540/**
1541 * Event whose listeners take a MessageSender and additional parameters.
1542 * @see http://developer.chrome.com/dev/apps/runtime.html#event-onMessage
1543 * @constructor
1544 */
1545chrome.runtime.MessageSenderEvent = function() {};
1546
1547
1548/**
1549 * @param {function(*, !MessageSender, function(*): void): (boolean|undefined)}
1550 *     callback Callback.
1551 */
1552chrome.runtime.MessageSenderEvent.prototype.addListener = function(callback) {};
1553
1554
1555/**
1556 * @param {function(*, !MessageSender, function(*): void): (boolean|undefined)}
1557 *     callback Callback.
1558 */
1559chrome.runtime.MessageSenderEvent.prototype.removeListener = function(callback)
1560    {};
1561
1562
1563/**
1564 * @param {function(*, !MessageSender, function(*): void): (boolean|undefined)}
1565 *     callback Callback.
1566 * @return {boolean}
1567 */
1568chrome.runtime.MessageSenderEvent.prototype.hasListener = function(callback) {};
1569
1570
1571/**
1572 * @return {boolean}
1573 */
1574chrome.runtime.MessageSenderEvent.prototype.hasListeners = function() {};
1575
1576
1577/**
1578 * @const
1579 * @see https://developer.chrome.com/extensions/tabs.html
1580 */
1581chrome.tabs = {};
1582
1583
1584/**
1585 * @typedef {?{
1586 *   code: (string|undefined),
1587 *   file: (string|undefined),
1588 *   allFrames: (boolean|undefined),
1589 *   matchAboutBlank: (boolean|undefined),
1590 *   runAt: (string|undefined)
1591 * }}
1592 */
1593chrome.tabs.InjectDetails;
1594
1595
1596/**
1597 * @see https://developer.chrome.com/extensions/tabs#method-captureVisibleTab
1598 * @param {number|!chrome.types.ImageDetails|function(string):void}
1599 *     windowIdOrOptionsOrCallback One of:
1600 *     The target window.
1601 *     An object defining details about the format and quality of an image, in
1602 *     which case the window defaults to the current window.
1603 *     A callback function which accepts the data URL string of a JPEG encoding
1604 *     of the visible area of the captured tab.
1605 * @param {(!chrome.types.ImageDetails|function(string):void)=}
1606 *     opt_optionsOrCallback Either an object defining details about the
1607 *     format and quality of an image, or a callback function which accepts the
1608 *     data URL string of a JPEG encoding of the visible area of the captured
1609 *     tab.
1610 * @param {function(string):void=} opt_callback A callback function which
1611 *     accepts the data URL string of a JPEG encoding of the visible area of the
1612 *     captured tab.
1613 */
1614chrome.tabs.captureVisibleTab = function(windowIdOrOptionsOrCallback,
1615    opt_optionsOrCallback, opt_callback) {};
1616
1617
1618/**
1619 * @param {number} tabId Tab Id.
1620 * @param {{name: (string|undefined)}=} connectInfo Info Object.
1621 */
1622chrome.tabs.connect = function(tabId, connectInfo) {};
1623
1624
1625/**
1626 * @typedef {?{
1627 *   windowId: (number|undefined),
1628 *   index: (number|undefined),
1629 *   url: (string|undefined),
1630 *   active: (boolean|undefined),
1631 *   pinned: (boolean|undefined),
1632 *   openerTabId: (number|undefined)
1633 * }}
1634 */
1635chrome.tabs.CreateProperties;
1636
1637
1638/**
1639 * @param {!chrome.tabs.CreateProperties} createProperties Info object.
1640 * @param {function(!Tab): void=} opt_callback The callback function.
1641 */
1642chrome.tabs.create = function(createProperties, opt_callback) {};
1643
1644
1645/**
1646 * @see https://developer.chrome.com/extensions/tabs#method-detectLanguage
1647 * @param {number|function(string): void} tabIdOrCallback The tab id, or a
1648 *     callback function that will be invoked with the language of the active
1649 *     tab in the current window.
1650 * @param {function(string): void=} opt_callback An optional callback function
1651 *     that will be invoked with the language of the tab specified as first
1652 *     argument.
1653 */
1654chrome.tabs.detectLanguage = function(tabIdOrCallback, opt_callback) {};
1655
1656
1657/**
1658 * @see https://developer.chrome.com/extensions/tabs#method-executeScript
1659 * @param {number|!chrome.tabs.InjectDetails} tabIdOrDetails
1660 *     Either the id of the tab in which to run the script, or an object
1661 *     containing the details of the script to run, in which case the script
1662 *     will be executed in the active tab of the current window.
1663 * @param {(!chrome.tabs.InjectDetails|function(!Array.<*>):void)=}
1664 *     opt_detailsOrCallback Either an object containing the details of the
1665 *     script to run, if the tab id was speficied as first argument, or a
1666 *     callback that will be invoked with the result of the execution of the
1667 *     script in every injected frame.
1668 * @param {function(!Array.<*>):void=} opt_callback A callback that will be
1669 *     invoked with the result of the execution of the script in every
1670 *     injected frame.
1671 */
1672chrome.tabs.executeScript = function(tabIdOrDetails, opt_detailsOrCallback,
1673    opt_callback) {};
1674
1675
1676/**
1677 * @param {number} tabId Tab id.
1678 * @param {function(!Tab): void} callback Callback.
1679 */
1680chrome.tabs.get = function(tabId, callback) {};
1681
1682
1683/**
1684 * Note (2014-05-21): Because this function is deprecated, the types of it's
1685 * parameters were not upgraded to make the first parameter optional and to mark
1686 * the Array and Tab in the callback as non-null.
1687 *
1688 * @param {number?} windowId Window id.
1689 * @param {function(Array.<Tab>): void} callback Callback.
1690 * @deprecated Please use tabs.query {windowId: windowId}.
1691 */
1692chrome.tabs.getAllInWindow = function(windowId, callback) {};
1693
1694
1695/**
1696 * @param {function(!Tab=): void} callback Callback.
1697 */
1698chrome.tabs.getCurrent = function(callback) {};
1699
1700
1701/**
1702 * Note (2014-05-21): Because this function is deprecated, the types of it's
1703 * parameters were not upgraded to make the first parameter optional and to mark
1704 * the Array and Tab in the callback as non-null.
1705 *
1706 * @param {number?} windowId Window id.
1707 * @param {function(Tab): void} callback Callback.
1708 * @deprecated Please use tabs.query({active: true}).
1709 */
1710chrome.tabs.getSelected = function(windowId, callback) {};
1711
1712
1713/**
1714 * @typedef {?{
1715 *   windowId: (number|undefined),
1716 *   tabs: (number|!Array.<number>)
1717 * }}
1718 */
1719chrome.tabs.HighlightInfo;
1720
1721
1722/**
1723 * @param {!chrome.tabs.HighlightInfo} highlightInfo
1724 * @param {function(!Window): void} callback Callback function invoked
1725 *    with each appropriate Window.
1726 */
1727chrome.tabs.highlight = function(highlightInfo, callback) {};
1728
1729
1730/**
1731 * @link https://developer.chrome.com/extensions/tabs#method-insertCSS
1732 * @param {number|!chrome.tabs.InjectDetails} tabIdOrDetails
1733 *     Either the id of the tab in which to run the script, or an object
1734 *     containing the details of the CSS to insert, in which case the script
1735 *     will be executed in the active tab of the current window.
1736 * @param {(!chrome.tabs.InjectDetails|function():void)=}
1737 *     opt_detailsOrCallback Either an object containing the details of the
1738 *     CSS to insert, if the tab id was speficied as first argument, or a
1739 *     callback that will be invoked after the CSS has been injected.
1740 * @param {function():void=} opt_callback A callback that will be invoked after
1741 *     the CSS has been injected.
1742 */
1743chrome.tabs.insertCSS = function(tabIdOrDetails, opt_detailsOrCallback,
1744    opt_callback) {};
1745
1746
1747/**
1748 * @typedef {?{
1749 *   windowId: (number|undefined),
1750 *   index: number
1751 * }}
1752 */
1753chrome.tabs.MoveProperties;
1754
1755
1756/**
1757 * @param {number|!Array.<number>} tabId Tab id or array of tab ids.
1758 * @param {!chrome.tabs.MoveProperties} moveProperties
1759 * @param {function((!Tab|!Array.<!Tab>)): void=} opt_callback Callback.
1760 */
1761chrome.tabs.move = function(tabId, moveProperties, opt_callback) {};
1762
1763
1764/**
1765 * @typedef {?{
1766 *   active: (boolean|undefined),
1767 *   pinned: (boolean|undefined),
1768 *   highlighted: (boolean|undefined),
1769 *   currentWindow: (boolean|undefined),
1770 *   lastFocusedWindow: (boolean|undefined),
1771 *   status: (string|undefined),
1772 *   title: (string|undefined),
1773 *   url: (string|undefined),
1774 *   windowId: (number|undefined),
1775 *   windowType: (string|undefined),
1776 *   index: (number|undefined)
1777 * }}
1778 */
1779chrome.tabs.QueryInfo;
1780
1781
1782/**
1783 * @param {!chrome.tabs.QueryInfo} queryInfo
1784 * @param {function(!Array.<!Tab>): void} callback Callback.
1785 */
1786chrome.tabs.query = function(queryInfo, callback) {};
1787
1788
1789/**
1790 * @see https://developer.chrome.com/extensions/tabs#method-query
1791 * @param {number} tabId The ID of the tab which is to be duplicated.
1792 * @param {(function(!Tab=):void)=} opt_callback A callback to be invoked with
1793 *     details about the duplicated tab.
1794 */
1795chrome.tabs.duplicate = function(tabId, opt_callback) {};
1796
1797
1798/**
1799 * @typedef {?{
1800 *   bypassCache: (boolean|undefined)
1801 * }}
1802 */
1803chrome.tabs.ReloadProperties;
1804
1805
1806/**
1807 * @see https://developer.chrome.com/extensions/tabs#method-reload
1808 * @param {(number|!chrome.tabs.ReloadProperties|function():void)=}
1809 *     opt_tabIdOrReloadPropertiesOrCallback One of:
1810 *     The ID of the tab to reload; defaults to the selected tab of the current
1811 *     window.
1812 *     An object specifying boolean flags to customize the reload operation.
1813 *     A callback to be invoked when the reload is complete.
1814 * @param {(!chrome.tabs.ReloadProperties|function():void)=}
1815 *     opt_reloadPropertiesOrCallback Either an object specifying boolean flags
1816 *     to customize the reload operation, or a callback to be invoked when the
1817 *     reload is complete, if no object needs to be specified.
1818 * @param {function():void=} opt_callback  A callback to be invoked when the
1819 *     reload is complete.
1820 */
1821chrome.tabs.reload = function(opt_tabIdOrReloadPropertiesOrCallback,
1822    opt_reloadPropertiesOrCallback, opt_callback) {};
1823
1824
1825/**
1826 * @param {number|!Array.<number>} tabIds A tab ID or an array of tab IDs.
1827 * @param {function(): void=} opt_callback Callback.
1828 */
1829chrome.tabs.remove = function(tabIds, opt_callback) {};
1830
1831
1832/**
1833 * @param {number} tabId Tab id.
1834 * @param {*} request The request value of any type.
1835 * @param {function(*): void=} opt_callback The callback function which
1836 *     takes a JSON response object sent by the handler of the request.
1837 */
1838chrome.tabs.sendMessage = function(tabId, request, opt_callback) {};
1839
1840
1841/**
1842 * @param {number} tabId Tab id.
1843 * @param {*} request The request value of any type.
1844 * @param {function(*): void=} opt_callback The callback function which
1845 *     takes a JSON response object sent by the handler of the request.
1846 * @deprecated Please use runtime.sendMessage.
1847 */
1848chrome.tabs.sendRequest = function(tabId, request, opt_callback) {};
1849
1850
1851/**
1852 * @typedef {?{
1853 *   url: (string|undefined),
1854 *   active: (boolean|undefined),
1855 *   highlighted: (boolean|undefined),
1856 *   pinned: (boolean|undefined),
1857 *   openerTabId: (number|undefined)
1858 * }}
1859 */
1860chrome.tabs.UpdateProperties;
1861
1862
1863/**
1864 * @see https://developer.chrome.com/extensions/tabs#method-update
1865 * @param {number|!chrome.tabs.UpdateProperties} tabIdOrUpdateProperties
1866 *     Either the id of the tab to update, or an object with new property
1867 *     values, in which case the selected tab of the current window will be
1868 *     updated.
1869 * @param {(!chrome.tabs.UpdateProperties|function(Tab):void)=}
1870 *     opt_updatePropertiesOrCallback Either an object with new property values,
1871 *     if the tabId was specified as first parameter, or an optional callback
1872 *     that will be invoked with information about the tab being updated.
1873 * @param {function(!Tab=): void=} opt_callback An optional callback that will
1874 *     be invoked with information about the tab being updated.
1875 */
1876chrome.tabs.update = function(tabIdOrUpdateProperties,
1877    opt_updatePropertiesOrCallback, opt_callback) {};
1878
1879
1880/**
1881 * @type {!ChromeEvent}
1882 * @deprecated Please use tabs.onActivated.
1883 */
1884chrome.tabs.onActiveChanged;
1885
1886
1887/** @type {!ChromeEvent} */
1888chrome.tabs.onActivated;
1889
1890
1891/** @type {!ChromeEvent} */
1892chrome.tabs.onAttached;
1893
1894
1895/** @type {!ChromeEvent} */
1896chrome.tabs.onCreated;
1897
1898
1899/** @type {!ChromeEvent} */
1900chrome.tabs.onDetached;
1901
1902
1903/**
1904 * @type {!ChromeEvent}
1905 * @deprecated Please use tabs.onHighlighted.
1906 */
1907chrome.tabs.onHighlightChanged;
1908
1909
1910/**
1911 * @type {!ChromeEvent}
1912 */
1913chrome.tabs.onHighlighted;
1914
1915
1916/** @type {!ChromeEvent} */
1917chrome.tabs.onMoved;
1918
1919
1920/** @type {!ChromeEvent} */
1921chrome.tabs.onRemoved;
1922
1923
1924/** @type {!ChromeEvent} */
1925chrome.tabs.onUpdated;
1926
1927
1928/** @type {!ChromeEvent} */
1929chrome.tabs.onReplaced;
1930
1931// DEPRECATED:
1932// TODO(user): Remove once all usage has been confirmed to have ended.
1933
1934
1935/**
1936 * @type {!ChromeEvent}
1937 * @deprecated Please use tabs.onActivated.
1938 */
1939chrome.tabs.onSelectionChanged;
1940
1941
1942/**
1943 * @const
1944 * @see https://developer.chrome.com/extensions/windows.html
1945 */
1946chrome.windows = {};
1947
1948
1949/**
1950 * @param {Object=} opt_createData May have many keys to specify parameters.
1951 *     Or the callback.
1952 * @param {function(ChromeWindow): void=} opt_callback Callback.
1953 */
1954chrome.windows.create = function(opt_createData, opt_callback) {};
1955
1956
1957/**
1958 * @param {number} id Window id.
1959 * @param {Object=} opt_getInfo May have 'populate' key. Or the callback.
1960 * @param {function(!ChromeWindow): void=} opt_callback Callback when
1961 *     opt_getInfo is an object.
1962 */
1963chrome.windows.get = function(id, opt_getInfo, opt_callback) {};
1964
1965
1966/**
1967 * @param {Object=} opt_getInfo May have 'populate' key. Or the callback.
1968 * @param {function(!Array.<!ChromeWindow>): void=} opt_callback Callback.
1969 */
1970chrome.windows.getAll = function(opt_getInfo, opt_callback) {};
1971
1972
1973/**
1974 * @param {Object=} opt_getInfo May have 'populate' key. Or the callback.
1975 * @param {function(ChromeWindow): void=} opt_callback Callback.
1976 */
1977chrome.windows.getCurrent = function(opt_getInfo, opt_callback) { };
1978
1979
1980/**
1981 * @param {Object=} opt_getInfo May have 'populate' key. Or the callback.
1982 * @param {function(ChromeWindow): void=} opt_callback Callback.
1983 */
1984chrome.windows.getLastFocused = function(opt_getInfo, opt_callback) { };
1985
1986
1987/**
1988 * @param {number} tabId Tab Id.
1989 * @param {function(): void=} opt_callback Callback.
1990 */
1991chrome.windows.remove = function(tabId, opt_callback) {};
1992
1993
1994/**
1995 * @param {number} tabId Tab Id.
1996 * @param {Object} updateProperties An object which may have many keys for
1997 *     various options.
1998 * @param {function(): void=} opt_callback Callback.
1999 */
2000chrome.windows.update = function(tabId, updateProperties, opt_callback) {};
2001
2002
2003/** @type {!ChromeEvent} */
2004chrome.windows.onCreated;
2005
2006
2007/** @type {!ChromeEvent} */
2008chrome.windows.onFocusChanged;
2009
2010
2011/** @type {!ChromeEvent} */
2012chrome.windows.onRemoved;
2013
2014
2015/**
2016 * @see https://developer.chrome.com/extensions/windows.html#property-WINDOW_ID_NONE
2017 * @type {number}
2018 */
2019chrome.windows.WINDOW_ID_NONE;
2020
2021
2022/**
2023 * @see https://developer.chrome.com/extensions/windows.html#property-WINDOW_ID_CURRENT
2024 * @type {number}
2025 */
2026chrome.windows.WINDOW_ID_CURRENT;
2027
2028
2029/**
2030 * @const
2031 * @see https://developer.chrome.com/extensions/i18n.html
2032 */
2033chrome.i18n = {};
2034
2035
2036/**
2037 * @param {function(Array.<string>): void} callback The callback function which
2038 *     accepts an array of the accept languages of the browser, such as
2039 *     'en-US','en','zh-CN'.
2040 */
2041chrome.i18n.getAcceptLanguages = function(callback) {};
2042
2043
2044/**
2045 * @param {string} messageName
2046 * @param {(string|Array.<string>)=} opt_args
2047 * @return {string}
2048 */
2049chrome.i18n.getMessage = function(messageName, opt_args) {};
2050
2051/**
2052 * @return {string}
2053 */
2054chrome.i18n.getUILanguage = function() {};
2055
2056
2057/**
2058 * @const
2059 * @see https://developer.chrome.com/extensions/pageAction.html
2060 */
2061chrome.pageAction = {};
2062
2063
2064/**
2065 * @param {number} tabId Tab Id.
2066 */
2067chrome.pageAction.hide = function(tabId) {};
2068
2069
2070/**
2071 * @param {Object} details An object which has 'tabId' and either
2072 *     'imageData' or 'path'.
2073 */
2074chrome.pageAction.setIcon = function(details) {};
2075
2076
2077/**
2078 * @param {Object} details An object which may have 'popup' or 'tabId' as keys.
2079 */
2080chrome.pageAction.setPopup = function(details) {};
2081
2082
2083/**
2084 * @param {Object} details An object which has 'tabId' and 'title'.
2085 */
2086chrome.pageAction.setTitle = function(details) {};
2087
2088
2089/**
2090 * @param {number} tabId Tab Id.
2091 */
2092chrome.pageAction.show = function(tabId) {};
2093
2094
2095/** @type {!ChromeEvent} */
2096chrome.pageAction.onClicked;
2097
2098/**
2099 * @const
2100 */
2101chrome.browser = {};
2102
2103
2104/**
2105 * @param {{url: string}} details An object with a single 'url' key.
2106 * @param {function(): void} callback The callback function. If an error occurs
2107 * opening the URL, chrome.runtime.lastError will be set to the error message.
2108 */
2109chrome.browser.openTab = function(details, callback) {};
2110
2111
2112/**
2113 * @const
2114 * @see https://developer.chrome.com/extensions/browserAction.html
2115 */
2116chrome.browserAction = {};
2117
2118
2119/**
2120 * @param {Object} details An object whose keys are 'color' and
2121 *     optionally 'tabId'.
2122 */
2123chrome.browserAction.setBadgeBackgroundColor = function(details) {};
2124
2125
2126/**
2127 * @param {Object} details An object whose keys are 'text' and
2128 *     optionally 'tabId'.
2129 */
2130chrome.browserAction.setBadgeText = function(details) {};
2131
2132
2133/**
2134 * @param {Object} details An object which may have 'imageData',
2135 *     'path', or 'tabId' as keys.
2136 */
2137chrome.browserAction.setIcon = function(details) {};
2138
2139
2140/**
2141 * @param {Object} details An object which may have 'popup' or 'tabId' as keys.
2142 */
2143chrome.browserAction.setPopup = function(details) {};
2144
2145
2146/**
2147 * @param {Object} details An object which has 'title' and optionally
2148 *     'tabId'.
2149 */
2150chrome.browserAction.setTitle = function(details) {};
2151
2152
2153/** @type {!ChromeEvent} */
2154chrome.browserAction.onClicked;
2155
2156
2157/**
2158 * @param {number} tabId the ID of the tab on which to disable this action.
2159 */
2160chrome.browserAction.disable = function(tabId) {};
2161
2162
2163/**
2164 * @param {number} tabId the ID of the tab on which to enable this action.
2165 */
2166chrome.browserAction.enable = function(tabId) {};
2167
2168
2169/**
2170 * @const
2171 * @see https://developer.chrome.com/extensions/bookmarks.html
2172 */
2173chrome.bookmarks = {};
2174
2175
2176/**
2177 * @typedef {?{
2178 *   pareintId: (string|undefined),
2179 *   index: (number|undefined),
2180 *   url: (string|undefined),
2181 *   title: (string|undefined)
2182 * }}
2183 * @see https://developer.chrome.com/extensions/bookmarks#method-create
2184 */
2185chrome.bookmarks.CreateDetails;
2186
2187
2188/**
2189 * @param {(string|Array.<string>)} idOrIdList
2190 * @param {function(Array.<BookmarkTreeNode>): void} callback The
2191 *     callback function which accepts an array of BookmarkTreeNode.
2192 * @return {Array.<BookmarkTreeNode>}
2193 */
2194chrome.bookmarks.get = function(idOrIdList, callback) {};
2195
2196
2197/**
2198 * @param {string} id
2199 * @param {function(Array.<BookmarkTreeNode>): void} callback The
2200 *     callback function which accepts an array of BookmarkTreeNode.
2201 * @return {Array.<BookmarkTreeNode>}
2202 */
2203chrome.bookmarks.getChildren = function(id, callback) {};
2204
2205
2206/**
2207 * @param {number} numberOfItems The number of items to return.
2208 * @param {function(Array.<BookmarkTreeNode>): void} callback The
2209 *     callback function which accepts an array of BookmarkTreeNode.
2210 * @return {Array.<BookmarkTreeNode>}
2211 */
2212chrome.bookmarks.getRecent = function(numberOfItems, callback) {};
2213
2214
2215/**
2216 * @param {function(Array.<BookmarkTreeNode>): void} callback The
2217 *     callback function which accepts an array of BookmarkTreeNode.
2218 * @return {Array.<BookmarkTreeNode>}
2219 */
2220chrome.bookmarks.getTree = function(callback) {};
2221
2222
2223/**
2224 * @param {string} id The ID of the root of the subtree to retrieve.
2225 * @param {function(Array.<BookmarkTreeNode>): void} callback The
2226 *     callback function which accepts an array of BookmarkTreeNode.
2227 * @return {Array.<BookmarkTreeNode>}
2228 */
2229chrome.bookmarks.getSubTree = function(id, callback) {};
2230
2231
2232/**
2233 * @param {string} query
2234 * @param {function(Array.<BookmarkTreeNode>): void} callback
2235 * @return {Array.<BookmarkTreeNode>}
2236 */
2237chrome.bookmarks.search = function(query, callback) {};
2238
2239
2240/**
2241 * @param {chrome.bookmarks.CreateDetails} bookmark
2242 * @param {function(BookmarkTreeNode): void=} opt_callback The
2243 *     callback function which accepts a BookmarkTreeNode object.
2244 */
2245chrome.bookmarks.create = function(bookmark, opt_callback) {};
2246
2247
2248/**
2249 * @param {string} id
2250 * @param {Object} destination An object which has optional 'parentId' and
2251 *     optional 'index'.
2252 * @param {function(BookmarkTreeNode): void=} opt_callback
2253 *     The callback function which accepts a BookmarkTreeNode object.
2254 */
2255chrome.bookmarks.move = function(id, destination, opt_callback) {};
2256
2257
2258/**
2259 * @param {string} id
2260 * @param {Object} changes An object which may have 'title' as a key.
2261 * @param {function(BookmarkTreeNode): void=} opt_callback The
2262 *     callback function which accepts a BookmarkTreeNode object.
2263 */
2264chrome.bookmarks.update = function(id, changes, opt_callback) {};
2265
2266
2267/**
2268 * @param {string} id
2269 * @param {function(): void=} opt_callback
2270 */
2271chrome.bookmarks.remove = function(id, opt_callback) {};
2272
2273
2274/**
2275 * @param {string} id
2276 * @param {function(): void=} opt_callback
2277 */
2278chrome.bookmarks.removeTree = function(id, opt_callback) {};
2279
2280
2281/**
2282 * @param {function(): void=} opt_callback
2283 */
2284chrome.bookmarks.import = function(opt_callback) {};
2285
2286
2287/**
2288 * @param {function(): void=} opt_callback
2289 */
2290chrome.bookmarks.export = function(opt_callback) {};
2291
2292
2293/** @type {!ChromeEvent} */
2294chrome.bookmarks.onChanged;
2295
2296
2297/** @type {!ChromeEvent} */
2298chrome.bookmarks.onChildrenReordered;
2299
2300
2301/** @type {!ChromeEvent} */
2302chrome.bookmarks.onCreated;
2303
2304
2305/** @type {!ChromeEvent} */
2306chrome.bookmarks.onImportBegan;
2307
2308
2309/** @type {!ChromeEvent} */
2310chrome.bookmarks.onImportEnded;
2311
2312
2313/** @type {!ChromeEvent} */
2314chrome.bookmarks.onMoved;
2315
2316
2317/** @type {!ChromeEvent} */
2318chrome.bookmarks.onRemoved;
2319
2320
2321/**
2322 * @typedef {?{
2323 *   content: string,
2324 *   description: string
2325 * }}
2326 */
2327var SuggestResult;
2328
2329
2330/**
2331 * @const
2332 * @see https://developer.chrome.com/extensions/omnibox.html
2333 */
2334chrome.omnibox = {};
2335
2336
2337/** @constructor */
2338chrome.omnibox.InputChangedEvent = function() {};
2339
2340
2341/**
2342 * @param {function(string, function(!Array.<!SuggestResult>)): void} callback
2343 */
2344chrome.omnibox.InputChangedEvent.prototype.addListener = function(callback) {};
2345
2346
2347/**
2348 * @param {function(string, function(!Array.<!SuggestResult>)): void} callback
2349 */
2350chrome.omnibox.InputChangedEvent.prototype.removeListener =
2351    function(callback) {};
2352
2353
2354/**
2355 * @param {function(string, function(!Array.<!SuggestResult>)): void} callback
2356 * @return {boolean}
2357 */
2358chrome.omnibox.InputChangedEvent.prototype.hasListener = function(callback) {};
2359
2360
2361/** @return {boolean} */
2362chrome.omnibox.InputChangedEvent.prototype.hasListeners = function() {};
2363
2364
2365/** @constructor */
2366chrome.omnibox.InputEnteredEvent = function() {};
2367
2368
2369/** @param {function(string, string): void} callback */
2370chrome.omnibox.InputEnteredEvent.prototype.addListener = function(callback) {};
2371
2372
2373/** @param {function(string, string): void} callback */
2374chrome.omnibox.InputEnteredEvent.prototype.removeListener =
2375    function(callback) {};
2376
2377
2378/**
2379 * @param {function(string, string): void} callback
2380 * @return {boolean}
2381 */
2382chrome.omnibox.InputEnteredEvent.prototype.hasListener = function(callback) {};
2383
2384
2385/** @return {boolean} */
2386chrome.omnibox.InputEnteredEvent.prototype.hasListeners = function() {};
2387
2388
2389/**
2390 * @param {{description: string}} suggestion A partial SuggestResult object.
2391 */
2392chrome.omnibox.setDefaultSuggestion = function(suggestion) {};
2393
2394
2395/** @type {!ChromeEvent} */
2396chrome.omnibox.onInputCancelled;
2397
2398
2399/** @type {!chrome.omnibox.InputChangedEvent} */
2400chrome.omnibox.onInputChanged;
2401
2402
2403/** @type {!chrome.omnibox.InputEnteredEvent} */
2404chrome.omnibox.onInputEntered;
2405
2406
2407/** @type {!ChromeEvent} */
2408chrome.omnibox.onInputStarted;
2409
2410
2411/**
2412 * @const
2413 * @see https://developer.chrome.com/extensions/dev/contextMenus.html
2414 */
2415chrome.contextMenus = {};
2416
2417
2418/**
2419 * @param {!Object} createProperties
2420 * @param {function()=} opt_callback
2421 * @return {number} The id of the newly created window.
2422 */
2423chrome.contextMenus.create = function(createProperties, opt_callback) {};
2424
2425
2426/**
2427 * @param {number} menuItemId
2428 * @param {function()=} opt_callback
2429 */
2430chrome.contextMenus.remove = function(menuItemId, opt_callback) {};
2431
2432
2433/**
2434 * @param {function()=} opt_callback
2435 */
2436chrome.contextMenus.removeAll = function(opt_callback) {};
2437
2438
2439/**
2440 * @param {number} id
2441 * @param {!Object} updateProperties
2442 * @param {function()=} opt_callback
2443 */
2444chrome.contextMenus.update = function(id, updateProperties, opt_callback) {};
2445
2446
2447/**
2448 * @const
2449 * @see https://developer.chrome.com/extensions/dev/cookies.html
2450 */
2451chrome.cookies = {};
2452
2453
2454/**
2455 * This typedef is used for the parameters to chrome.cookies.get,
2456 * chrome.cookies.remove, and for the parameter to remove's callback. These uses
2457 * all identify a single cookie uniquely without specifying its content, and the
2458 * objects are identical except for the the storeId being optional vs required.
2459 * If greater divergence occurs, then going to two typedefs is recommended.
2460 *
2461 * @typedef {?{
2462 *   url: string,
2463 *   name: string,
2464 *   storeId: (string|undefined)
2465 * }}
2466 */
2467chrome.cookies.CookieIdentifier;
2468
2469
2470/**
2471 * @param {!chrome.cookies.CookieIdentifier} details
2472 * @param {function(Cookie=): void} callback
2473 */
2474chrome.cookies.get = function(details, callback) {};
2475
2476
2477/**
2478 * @param {Object} details
2479 * @param {function(Array.<Cookie>): void} callback
2480 */
2481chrome.cookies.getAll = function(details, callback) {};
2482
2483
2484/**
2485 * @param {function(Array.<CookieStore>): void} callback
2486 */
2487chrome.cookies.getAllCookieStores = function(callback) {};
2488
2489
2490/**
2491 * @param {!chrome.cookies.CookieIdentifier} details
2492 * @param {function(chrome.cookies.CookieIdentifier): void=} opt_callback If
2493 *     removal failed for any reason, the parameter will be "null", and
2494 *     "chrome.runtime.lastError" will be set.
2495 */
2496chrome.cookies.remove = function(details, opt_callback) {};
2497
2498
2499/**
2500 * @typedef {?{
2501 *   url: string,
2502 *   name: (string|undefined),
2503 *   value: (string|undefined),
2504 *   domain: (string|undefined),
2505 *   path: (string|undefined),
2506 *   secure: (boolean|undefined),
2507 *   httpOnly: (boolean|undefined),
2508 *   expirationDate: (number|undefined),
2509 *   storeId: (string|undefined)
2510 * }}
2511 */
2512chrome.cookies.CookieSetDetails;
2513
2514
2515/**
2516 * @param {!chrome.cookies.CookieSetDetails} details
2517 * @param {function(Cookie): void=} opt_callback If setting failed for any
2518 *    reason, the parameter will be "null", and "chrome.runtime.lastError" will
2519 *    be set.
2520 */
2521chrome.cookies.set = function(details, opt_callback) {};
2522
2523
2524/**
2525 * @see https://developer.chrome.com/extensions/cookies.html#event-onChanged
2526 * @type {!ChromeEvent}
2527 */
2528chrome.cookies.onChanged;
2529
2530
2531
2532/** @constructor */
2533function CookieChangeInfo() {}
2534
2535
2536/** @type {boolean} */
2537CookieChangeInfo.prototype.removed;
2538
2539
2540/** @type {Cookie} */
2541CookieChangeInfo.prototype.cookie;
2542
2543
2544/** @type {string} */
2545CookieChangeInfo.prototype.cause;
2546
2547
2548/** @const */
2549chrome.management = {};
2550
2551
2552/**
2553 * @typedef {?{
2554 *   showConfirmDialog: (boolean|undefined)
2555 * }}
2556 */
2557chrome.management.InstallOptions;
2558
2559
2560/**
2561 * @param {string} id
2562 * @param {function(!ExtensionInfo): void=} opt_callback Optional callback
2563 *     function.
2564 */
2565chrome.management.get = function(id, opt_callback) {};
2566
2567
2568/**
2569 * @param {function(!Array.<!ExtensionInfo>): void=} opt_callback Optional
2570 *     callback function.
2571 * @return {!Array.<!ExtensionInfo>}
2572 */
2573chrome.management.getAll = function(opt_callback) {};
2574
2575
2576/**
2577 * @param {string} id The id of an already installed extension.
2578 * @param {function(!Array.<string>)=} opt_callback Optional callback function.
2579 */
2580chrome.management.getPermissionWarningsById = function(id, opt_callback) {};
2581
2582
2583/**
2584 * @param {string} manifestStr Extension's manifest JSON string.
2585 * @param {function(!Array.<string>)=} opt_callback Optional callback function.
2586 */
2587chrome.management.getPermissionWarningsByManifest =
2588    function(manifestStr, opt_callback) {};
2589
2590
2591/**
2592 * @param {string} id The id of an already installed extension.
2593 * @param {function(): void=} opt_callback Optional callback function.
2594 */
2595chrome.management.launchApp = function(id, opt_callback) {};
2596
2597
2598/**
2599 * @param {string} id The id of an already installed extension.
2600 * @param {boolean} enabled Whether this item should be enabled.
2601 * @param {function(): void=} opt_callback Optional callback function.
2602 */
2603chrome.management.setEnabled = function(id, enabled, opt_callback) {};
2604
2605
2606/**
2607 * @param {string} id The id of an already installed extension.
2608 * @param {(!chrome.management.InstallOptions|function(): void)=}
2609 *     opt_optionsOrCallback An optional uninstall options object or an optional
2610 *     callback function.
2611 * @param {function(): void=} opt_callback Optional callback function.
2612 */
2613chrome.management.uninstall =
2614    function(id, opt_optionsOrCallback, opt_callback) {};
2615
2616
2617/**
2618 * @param {(!chrome.management.InstallOptions|function(): void)=}
2619 *     opt_optionsOrCallback An optional uninstall options object or an optional
2620 *     callback function.
2621 * @param {function(): void=} opt_callback An optional callback function.
2622 */
2623chrome.management.uninstallSelf =
2624    function(opt_optionsOrCallback, opt_callback) {};
2625
2626
2627/**
2628 * @param {string} id The id of an already installed extension.
2629 * @param {function(): void=} opt_callback Optional callback function.
2630 */
2631chrome.management.createAppShortcut = function(id, opt_callback) {};
2632
2633
2634/**
2635 * @param {string} id The id of an already installed extension.
2636 * @param {string} launchType The LaunchType enum value to set. Make sure this
2637 *     value is in ExtensionInfo.availableLaunchTypes because the available
2638 *     launch types vary on different platforms and configurations.
2639 * @param {function(): void=} opt_callback Optional callback function.
2640 */
2641chrome.management.setLaunchType = function(id, launchType, opt_callback) {};
2642
2643
2644/**
2645 * @param {string} url The URL of a web page. The scheme of the URL can only be
2646 *     "http" or "https".
2647 * @param {string} title The title of the generated app.
2648 * @param {function(!ExtensionInfo): void=} opt_callback Optional callback
2649 *     function.
2650 */
2651chrome.management.generateAppForLink = function(url, title, opt_callback) {};
2652
2653
2654/** @type {!ChromeExtensionInfoEvent} */
2655chrome.management.onDisabled;
2656
2657
2658/** @type {!ChromeExtensionInfoEvent} */
2659chrome.management.onEnabled;
2660
2661
2662/** @type {!ChromeExtensionInfoEvent} */
2663chrome.management.onInstalled;
2664
2665
2666/** @type {!ChromeStringEvent} */
2667chrome.management.onUninstalled;
2668
2669
2670/**
2671 * @const
2672 * @see https://developer.chrome.com/extensions/idle.html
2673 */
2674chrome.idle = {};
2675
2676
2677/**
2678 * @param {number} thresholdSeconds Threshold in seconds, used to determine
2679 *     when a machine is in the idle state.
2680 * @param {function(string): void} callback Callback to handle the state.
2681 */
2682chrome.idle.queryState = function(thresholdSeconds, callback) {};
2683
2684
2685/**
2686 * @param {number} intervalInSeconds Threshold, in seconds, used to determine
2687 *    when the system is in an idle state.
2688 */
2689chrome.idle.setDetectionInterval = function(intervalInSeconds) {};
2690
2691
2692/** @type {!ChromeEvent} */
2693chrome.idle.onStateChanged;
2694
2695
2696/**
2697 * Chrome Text-to-Speech API.
2698 * @const
2699 * @see https://developer.chrome.com/extensions/tts.html
2700 */
2701chrome.tts = {};
2702
2703
2704
2705/**
2706 * An event from the TTS engine to communicate the status of an utterance.
2707 * @constructor
2708 */
2709function TtsEvent() {}
2710
2711
2712/** @type {string} */
2713TtsEvent.prototype.type;
2714
2715
2716/** @type {number} */
2717TtsEvent.prototype.charIndex;
2718
2719
2720/** @type {string} */
2721TtsEvent.prototype.errorMessage;
2722
2723
2724
2725/**
2726 * A description of a voice available for speech synthesis.
2727 * @constructor
2728 */
2729function TtsVoice() {}
2730
2731
2732/** @type {string} */
2733TtsVoice.prototype.voiceName;
2734
2735
2736/** @type {string} */
2737TtsVoice.prototype.lang;
2738
2739
2740/** @type {string} */
2741TtsVoice.prototype.gender;
2742
2743
2744/** @type {string} */
2745TtsVoice.prototype.extensionId;
2746
2747
2748/** @type {Array.<string>} */
2749TtsVoice.prototype.eventTypes;
2750
2751
2752/**
2753 * Gets an array of all available voices.
2754 * @param {function(Array.<TtsVoice>)=} opt_callback An optional callback
2755 *     function.
2756 */
2757chrome.tts.getVoices = function(opt_callback) {};
2758
2759
2760/**
2761 * Checks if the engine is currently speaking.
2762 * @param {function(boolean)=} opt_callback The callback function.
2763 */
2764chrome.tts.isSpeaking = function(opt_callback) {};
2765
2766
2767/**
2768 * Speaks text using a text-to-speech engine.
2769 * @param {string} utterance The text to speak, either plain text or a complete,
2770 *     well-formed SSML document. Speech engines that do not support SSML will
2771 *     strip away the tags and speak the text. The maximum length of the text is
2772 *     32,768 characters.
2773 * @param {Object=} opt_options The speech options.
2774 * @param {function()=} opt_callback Called right away, before speech finishes.
2775 */
2776chrome.tts.speak = function(utterance, opt_options, opt_callback) {};
2777
2778
2779/**
2780 * Stops any current speech.
2781 */
2782chrome.tts.stop = function() {};
2783
2784
2785/**
2786 * @const
2787 * @see https://developer.chrome.com/extensions/ttsEngine.html
2788 */
2789chrome.ttsEngine = {};
2790
2791
2792/** @type {!ChromeEvent} */
2793chrome.ttsEngine.onSpeak;
2794
2795
2796/** @type {!ChromeEvent} */
2797chrome.ttsEngine.onStop;
2798
2799
2800/**
2801 * @const
2802 * @see https://developer.chrome.com/extensions/contentSettings.html
2803 */
2804chrome.contentSettings = {};
2805
2806
2807/** @type {!ContentSetting} */
2808chrome.contentSettings.cookies;
2809
2810
2811/** @type {!ContentSetting} */
2812chrome.contentSettings.images;
2813
2814
2815/** @type {!ContentSetting} */
2816chrome.contentSettings.javascript;
2817
2818
2819/** @type {!ContentSetting} */
2820chrome.contentSettings.plugins;
2821
2822
2823/** @type {!ContentSetting} */
2824chrome.contentSettings.popups;
2825
2826
2827/** @type {!ContentSetting} */
2828chrome.contentSettings.notifications;
2829
2830
2831/**
2832 * @const
2833 * @see https://developer.chrome.com/extensions/fileBrowserHandle.html
2834 */
2835chrome.fileBrowserHandle = {};
2836
2837
2838/** @type {!ChromeEvent} */
2839chrome.fileBrowserHandle.onExecute;
2840
2841
2842/**
2843 * @const
2844 * @see https://developer.chrome.com/extensions/gcm
2845 */
2846chrome.gcm = {};
2847
2848
2849/**
2850 * @see https://developer.chrome.com/extensions/gcm#property-MAX_MESSAGE_SIZE
2851 * @type {number}
2852 */
2853chrome.gcm.MAX_MESSAGE_SIZE;
2854
2855
2856/**
2857 * Registers the application with GCM. The registration ID will be returned by
2858 * the callback. If register is called again with the same list of senderIds,
2859 * the same registration ID will be returned.
2860 * @see https://developer.chrome.com/extensions/gcm#method-register
2861 * @param {!Array.<string>} senderIds A list of server IDs that are allowed to
2862 *     send messages to the application.
2863 * @param {function(string): void} callback Function called when
2864 *     registration completes with registration ID as argument.
2865 */
2866chrome.gcm.register = function(senderIds, callback) {};
2867
2868
2869/**
2870 * Unregisters the application from GCM.
2871 * @see https://developer.chrome.com/extensions/gcm#method-unregister
2872 * @param {function(): void} callback Called when unregistration is done.
2873 */
2874chrome.gcm.unregister = function(callback) {};
2875
2876
2877/**
2878 * Sends an upstream message using GCM.
2879 * @see https://developer.chrome.com/extensions/gcm#method-send
2880 * @param {!chrome.gcm.Message} message Message to be sent.
2881 * @param {function(string): void} callback Called with message ID.
2882 */
2883chrome.gcm.send = function(message, callback) {};
2884
2885
2886/**
2887 * Outgoing message.
2888 * @typedef {?{
2889 *   destinationId: string,
2890 *   messageId: string,
2891 *   timeToLive: (number|undefined),
2892 *   data: !Object.<string, string>
2893 * }}
2894 */
2895chrome.gcm.Message;
2896
2897
2898/**
2899 * An event, fired when a message is received through GCM.
2900 * @see https://developer.chrome.com/extensions/gcm#event-onMessage
2901 * @type {!chrome.gcm.OnMessageEvent}
2902 */
2903chrome.gcm.onMessage;
2904
2905
2906/**
2907 * An event, fired when GCM server had to delete messages to the application
2908 * from its queue in order to manage its size.
2909 * @see https://developer.chrome.com/extensions/gcm#event-onMessagesDeleted
2910 * @type {!ChromeEvent}
2911 */
2912chrome.gcm.onMessagesDeleted;
2913
2914
2915/**
2916 * An event indicating problems with sending messages.
2917 * @see https://developer.chrome.com/extensions/gcm#event-onSendError
2918 * @type {!chrome.gcm.OnSendErrorEvent}
2919 */
2920chrome.gcm.onSendError;
2921
2922
2923/**
2924 * @constructor
2925 */
2926chrome.gcm.OnMessageEvent = function() {};
2927
2928
2929/**
2930 * @param {function(!Object): void} callback Callback.
2931 */
2932chrome.gcm.OnMessageEvent.prototype.addListener = function(callback) {};
2933
2934
2935/**
2936 * @param {function(!Object): void} callback Callback.
2937 */
2938chrome.gcm.OnMessageEvent.prototype.removeListener = function(callback) {};
2939
2940
2941/**
2942 * @param {function(!Object): void} callback Callback.
2943 * @return {boolean}
2944 */
2945chrome.gcm.OnMessageEvent.prototype.hasListener = function(callback) {};
2946
2947
2948/**
2949 * @return {boolean}
2950 */
2951chrome.gcm.OnMessageEvent.prototype.hasListeners = function() {};
2952
2953
2954/**
2955 * @constructor
2956 */
2957chrome.gcm.OnSendErrorEvent = function() {};
2958
2959
2960/**
2961 * @param {function(!Object): void} callback Callback.
2962 */
2963chrome.gcm.OnSendErrorEvent.prototype.addListener = function(callback) {};
2964
2965
2966/**
2967 * @param {function(!Object): void} callback Callback.
2968 */
2969chrome.gcm.OnSendErrorEvent.prototype.removeListener = function(callback) {};
2970
2971/**
2972 * @param {function(!Object): void} callback Callback.
2973 * @return {boolean}
2974 */
2975chrome.gcm.OnSendErrorEvent.prototype.hasListener = function(callback) {};
2976
2977
2978/**
2979 * @return {boolean}
2980 */
2981chrome.gcm.OnSendErrorEvent.prototype.hasListeners = function() {};
2982
2983
2984/**
2985 * @const
2986 * @see https://developer.chrome.com/extensions/history.html
2987 */
2988chrome.history = {};
2989
2990
2991/**
2992 * @param {Object.<string, string>} details Object with a 'url' key.
2993 */
2994chrome.history.addUrl = function(details) {};
2995
2996
2997/**
2998 * @param {function(): void} callback Callback function.
2999 */
3000chrome.history.deleteAll = function(callback) {};
3001
3002
3003/**
3004 * @param {Object.<string, string>} range Object with 'startTime'
3005 *     and 'endTime' keys.
3006 * @param {function(): void} callback Callback function.
3007 */
3008chrome.history.deleteRange = function(range, callback) {};
3009
3010
3011/**
3012 * @param {Object.<string, string>} details Object with a 'url' key.
3013 */
3014chrome.history.deleteUrl = function(details) {};
3015
3016
3017/**
3018 * @param {Object.<string, string>} details Object with a 'url' key.
3019 * @param {function(!Array.<!VisitItem>): void} callback Callback function.
3020 * @return {!Array.<!VisitItem>}
3021 */
3022chrome.history.getVisits = function(details, callback) {};
3023
3024
3025/**
3026 * @param {Object.<string, string>} query Object with a 'text' (string)
3027 *     key and optional 'startTime' (number), 'endTime' (number) and
3028 *     'maxResults' keys.
3029 * @param {function(!Array.<!HistoryItem>): void} callback Callback function.
3030 * @return {!Array.<!HistoryItem>}
3031 */
3032chrome.history.search = function(query, callback) {};
3033
3034
3035/** @type {!ChromeEvent} */
3036chrome.history.onVisitRemoved;
3037
3038
3039/** @type {!ChromeEvent} */
3040chrome.history.onVisited;
3041
3042
3043/**
3044 * @const
3045 * @see http://developer.chrome.com/apps/identity.html
3046 */
3047chrome.identity = {};
3048
3049
3050/**
3051 * @param {(chrome.identity.TokenDetails|function(string=): void)}
3052 *     detailsOrCallback Token options or a callback function if no options are
3053 *     specified.
3054 * @param {function(string=): void=} opt_callback A callback function if options
3055 *     are specified.
3056 */
3057chrome.identity.getAuthToken = function(detailsOrCallback, opt_callback) {};
3058
3059
3060/** @typedef {{interactive: (boolean|undefined)}} */
3061chrome.identity.TokenDetails;
3062
3063
3064/**
3065 * @param {chrome.identity.InvalidTokenDetails} details
3066 * @param {function(): void} callback
3067 */
3068chrome.identity.removeCachedAuthToken = function(details, callback) {};
3069
3070
3071/** @typedef {{token: string}} */
3072chrome.identity.InvalidTokenDetails;
3073
3074
3075/**
3076 * @param {chrome.identity.WebAuthFlowDetails} details
3077 * @param {function(string=): void} callback
3078 */
3079chrome.identity.launchWebAuthFlow = function(details, callback) {};
3080
3081
3082/** @typedef {{url: string, interactive: (boolean|undefined)}} */
3083chrome.identity.WebAuthFlowDetails;
3084
3085
3086/** @type {!ChromeEvent} */
3087chrome.identity.onSignInChanged;
3088
3089
3090/**
3091 * @const
3092 * @see https://developer.chrome.com/extensions/input.ime.html
3093 */
3094chrome.input = {};
3095
3096
3097/** @const */
3098chrome.input.ime = {};
3099
3100
3101
3102/**
3103 * The OnKeyEvent event takes an extra argument.
3104 * @constructor
3105 */
3106function ChromeInputImeOnKeyEventEvent() {}
3107
3108
3109/**
3110 * @param {function(string, !ChromeKeyboardEvent): (boolean|undefined)} callback
3111 *     callback.
3112 * @param {Array.<string>=} opt_extraInfoSpec Array of extra information.
3113 */
3114ChromeInputImeOnKeyEventEvent.prototype.addListener =
3115    function(callback, opt_extraInfoSpec) {};
3116
3117
3118/**
3119 * @param {function(string, !ChromeKeyboardEvent): (boolean|undefined)} callback
3120 *     callback.
3121 */
3122ChromeInputImeOnKeyEventEvent.prototype.removeListener = function(callback) {};
3123
3124
3125/**
3126 * @param {function(string, !ChromeKeyboardEvent): (boolean|undefined)} callback
3127 *     callback.
3128 */
3129ChromeInputImeOnKeyEventEvent.prototype.hasListener = function(callback) {};
3130
3131
3132/**
3133 * @param {function(string, !ChromeKeyboardEvent): (boolean|undefined)} callback
3134 *     callback.
3135 */
3136ChromeInputImeOnKeyEventEvent.prototype.hasListeners = function(callback) {};
3137
3138
3139/**
3140 * @param {!Object.<string,number>} parameters An object with a
3141 *     'contextID' (number) key.
3142 * @param {function(boolean): void} callback Callback function.
3143 */
3144chrome.input.ime.clearComposition = function(parameters, callback) {};
3145
3146
3147/**
3148 * @param {!Object.<string,(string|number)>} parameters An object with
3149 *     'contextID' (number) and 'text' (string) keys.
3150 * @param {function(boolean): void=} opt_callback Callback function.
3151 */
3152chrome.input.ime.commitText = function(parameters, opt_callback) {};
3153
3154
3155/**
3156 * @param {!Object.<string,(string|number)>} parameters An object with
3157 *     'contextID' (number) and 'text' (string) keys.
3158 * @param {function(boolean): void=} opt_callback Callback function.
3159 */
3160chrome.input.ime.deleteSurroundingText = function(parameters, opt_callback) {};
3161
3162
3163/**
3164 * @param {!Object.<string,(number|Object.<string,(string|number|boolean)>)>}
3165 *     parameters An object with 'engineID' (string) and 'properties'
3166 *     (Object) keys.
3167 * @param {function(boolean): void=} opt_callback Callback function.
3168 */
3169chrome.input.ime.setCandidateWindowProperties =
3170    function(parameters, opt_callback) {};
3171
3172
3173/**
3174 * @param {!Object.<string,(number|Object.<string,(string|number)>)>}
3175 *     parameters An object with 'contextID' (number) and 'candidates'
3176 *     (array of object) keys.
3177 * @param {function(boolean): void=} opt_callback Callback function.
3178 */
3179chrome.input.ime.setCandidates = function(parameters, opt_callback) {};
3180
3181
3182/**
3183 * @param {!Object.<string,(string|number|Object.<string,(string|number)>)>}
3184 *     parameters An object with 'contextID' (number), 'text' (string),
3185 *     'selectionStart (number), 'selectionEnd' (number), 'cursor' (number),
3186 *     and 'segments' (array of object) keys.
3187 * @param {function(boolean): void=} opt_callback Callback function.
3188 */
3189chrome.input.ime.setComposition = function(parameters, opt_callback) {};
3190
3191
3192/**
3193 * @param {!Object.<string,number>} parameters An object with
3194 *     'contextID' (number) and 'candidateID' (number) keys.
3195 * @param {function(boolean): void=} opt_callback Callback function.
3196 */
3197chrome.input.ime.setCursorPosition = function(parameters, opt_callback) {};
3198
3199
3200/**
3201 * @param {!Object.<string,(string|Array.<Object.<string,(string|boolean)>>)>}
3202 *     parameters An object with 'engineID' (string) and 'items'
3203 *     (array of object) keys.
3204 * @param {function(): void=} opt_callback Callback function.
3205 */
3206chrome.input.ime.setMenuItems = function(parameters, opt_callback) {};
3207
3208
3209/**
3210 * @param {!Object.<string,(string|Array.<Object.<string,(string|boolean)>>)>}
3211 *     parameters An object with  'engineID' (string) and 'items'
3212 *     (array of object) keys.
3213 * @param {function(): void=} opt_callback Callback function.
3214 */
3215chrome.input.ime.updateMenuItems = function(parameters, opt_callback) {};
3216
3217
3218/**
3219 * @param {string} requestId Request id of the event that was handled. This
3220 *     should come from keyEvent.requestId.
3221 * @param {boolean} response True if the keystroke was handled, false if not.
3222 */
3223chrome.input.ime.keyEventHandled = function(requestId, response) {};
3224
3225
3226/** @type {!ChromeEvent} */
3227chrome.input.ime.onActivate;
3228
3229
3230/** @type {!ChromeEvent} */
3231chrome.input.ime.onBlur;
3232
3233
3234/** @type {!ChromeEvent} */
3235chrome.input.ime.onCandidateClicked;
3236
3237
3238/** @type {!ChromeEvent} */
3239chrome.input.ime.onDeactivated;
3240
3241
3242/** @type {!ChromeEvent} */
3243chrome.input.ime.onFocus;
3244
3245
3246/** @type {!ChromeEvent} */
3247chrome.input.ime.onInputContextUpdate;
3248
3249
3250/** @type {!ChromeInputImeOnKeyEventEvent} */
3251chrome.input.ime.onKeyEvent;
3252
3253
3254/** @type {!ChromeEvent} */
3255chrome.input.ime.onMenuItemActivated;
3256
3257
3258/** @type {!ChromeEvent} */
3259chrome.input.ime.onReset;
3260
3261
3262/** @type {!ChromeEvent} */
3263chrome.input.ime.onSurroundingTextChanged;
3264
3265
3266/**
3267 * namespace
3268 * @see http://developer.chrome.com/apps/mediaGalleries
3269 * @const
3270 */
3271chrome.mediaGalleries = {};
3272
3273
3274/**
3275 * @param {{interactive: (string|undefined)}|function(!Array.<!FileSystem>)}
3276 *     detailsOrCallback A details object for whether the request should be
3277 *     interactive if permissions haven't been granted yet or the callback.
3278 * @param {function(!Array.<!FileSystem>)=} opt_callback A success callback if
3279 *     no details were supplied as arg1.
3280 */
3281chrome.mediaGalleries.getMediaFileSystems = function(
3282    detailsOrCallback, opt_callback) {};
3283
3284
3285/**
3286 * @param {function(!Array.<!FileSystem>, string)} callback Callback function.
3287 */
3288chrome.mediaGalleries.addUserSelectedFolder = function(callback) {};
3289
3290chrome.mediaGalleries.startMediaScan = function() {};
3291
3292chrome.mediaGalleries.cancelMediaScan = function() {};
3293
3294
3295/**
3296 * @param {function(!Array.<!FileSystem>)} callback Callback function.
3297 */
3298chrome.mediaGalleries.addScanResults = function(callback) {};
3299
3300
3301/**
3302 * @typedef {{
3303 *   name: string,
3304 *   galleryId: string,
3305 *   deviceId: (string|undefined),
3306 *   isRemovable: boolean,
3307 *   isMediaDevice: boolean,
3308 *   isAvailable: boolean
3309 * }}
3310 */
3311chrome.mediaGalleries.MediaFileSystemMetadata;
3312
3313
3314/**
3315 * @param {!FileSystem} mediaFileSystem The file system to get metadata for.
3316 * @return {!chrome.mediaGalleries.MediaFileSystemMetadata}
3317 */
3318chrome.mediaGalleries.getMediaFileSystemMetadata = function(mediaFileSystem) {};
3319
3320
3321/**
3322 * @param {function(!Array.<!chrome.mediaGalleries.MediaFileSystemMetadata>)}
3323 *     callback Callback function.
3324 */
3325chrome.mediaGalleries.getAllMediaFileSystemMetadata = function(callback) {};
3326
3327
3328/**
3329 * @typedef {{
3330 *   mimeType: string,
3331 *   height: (number|undefined),
3332 *   width: (number|undefined),
3333 *   duration: (number|undefined),
3334 *   rotation: (number|undefined),
3335 *   album: (string|undefined),
3336 *   artist: (string|undefined),
3337 *   comment: (string|undefined),
3338 *   copyright: (string|undefined),
3339 *   disc: (number|undefined),
3340 *   genre: (string|undefined),
3341 *   language: (string|undefined),
3342 *   title: (string|undefined),
3343 *   track: (number|undefined)
3344 * }}
3345 */
3346chrome.mediaGalleries.MetaData;
3347
3348
3349/**
3350 * @param {!Blob} mediaFile The media file for which to get metadata.
3351 * @param {{metadataType: (string|undefined)}|
3352 *     function(!chrome.mediaGalleries.MetaData)} optionsOrCallback The options
3353 *     for the metadata to retrieve or the callback to invoke with the metadata.
3354 *     The metadataType should either be 'all' or 'mimeTypeOnly'. Defaults to
3355 *     'all' if the metadataType is omitted.
3356 * @param {function(!chrome.mediaGalleries.MetaData)=} opt_callback If options
3357 *     were passed as arg2, the callback to invoke with the metadata.
3358 */
3359chrome.mediaGalleries.getMetadata = function(
3360    mediaFile, optionsOrCallback, opt_callback) {};
3361
3362
3363/**
3364 * @typedef {{
3365 *   type: string,
3366 *   galleryCount: (number|undefined),
3367 *   audioCount: (number|undefined),
3368 *   imageCount: (number|undefined),
3369 *   videoCount: (number|undefined)
3370 * }}
3371 */
3372chrome.mediaGalleries.OnScanProgressDetails;
3373
3374
3375
3376/**
3377 * Event whose listeners take a chrome.mediaGalleries.OnScanProgressDetails
3378 * parameter.
3379 * @constructor
3380 */
3381chrome.mediaGalleries.ScanProgressEvent = function() {};
3382
3383
3384/** @param {function(!chrome.mediaGalleries.OnScanProgressDetails)} callback */
3385chrome.mediaGalleries.ScanProgressEvent.prototype.addListener =
3386    function(callback) {};
3387
3388
3389/** @param {function(!chrome.mediaGalleries.OnScanProgressDetails)} callback */
3390chrome.mediaGalleries.ScanProgressEvent.prototype.removeListener =
3391    function(callback) {};
3392
3393
3394/**
3395 * @param {function(!chrome.mediaGalleries.OnScanProgressDetails)} callback
3396 * @return {boolean}
3397 */
3398chrome.mediaGalleries.ScanProgressEvent.prototype.hasListener =
3399    function(callback) {};
3400
3401
3402/** @return {boolean} */
3403chrome.mediaGalleries.ScanProgressEvent.prototype.hasListeners = function() {};
3404
3405
3406/** @type {!chrome.mediaGalleries.ScanProgressEvent} */
3407chrome.mediaGalleries.onScanProgress;
3408
3409
3410/**
3411 * @const
3412 * @see https://developer.chrome.com/extensions/pageCapture.html
3413 */
3414chrome.pageCapture = {};
3415
3416
3417/**
3418 * @param {Object.<string, number>} details Object with a 'tabId' (number) key.
3419 * @param {function(Blob=): void} callback Callback function.
3420 */
3421chrome.pageCapture.saveAsMHTML = function(details, callback) {};
3422
3423
3424/**
3425 * @const
3426 * @see https://developer.chrome.com/extensions/permissions.html
3427 */
3428chrome.permissions = {};
3429
3430
3431/**
3432 * @typedef {{
3433 *   permissions: (Array.<string>|undefined),
3434 *   origins: (Array.<string>|undefined)
3435 * }}
3436* @see http://developer.chrome.com/extensions/permissions.html#type-Permissions
3437*/
3438chrome.permissions.Permissions;
3439
3440
3441/**
3442 * @param {!chrome.permissions.Permissions} permissions
3443 * @param {function(boolean): void} callback Callback function.
3444 */
3445chrome.permissions.contains = function(permissions, callback) {};
3446
3447
3448/**
3449 * @param {function(!chrome.permissions.Permissions): void} callback
3450 *     Callback function.
3451 */
3452chrome.permissions.getAll = function(callback) {};
3453
3454
3455/**
3456 * @param {!chrome.permissions.Permissions} permissions
3457 * @param {function(boolean): void=} opt_callback Callback function.
3458 */
3459chrome.permissions.remove = function(permissions, opt_callback) {};
3460
3461
3462/**
3463 * @param {!chrome.permissions.Permissions} permissions
3464 * @param {function(boolean): void=} opt_callback Callback function.
3465 */
3466chrome.permissions.request = function(permissions, opt_callback) {};
3467
3468
3469/** @type {!ChromeEvent} */
3470chrome.permissions.onAdded;
3471
3472
3473/** @type {!ChromeEvent} */
3474chrome.permissions.onRemoved;
3475
3476
3477/**
3478 * @see http://developer.chrome.com/dev/extensions/power.html
3479 */
3480chrome.power = {};
3481
3482
3483/**
3484 * @param {string} level A string describing the degree to which power
3485 *     management should be disabled, should be either "system" or "display".
3486 */
3487chrome.power.requestKeepAwake = function(level) {};
3488
3489
3490/**
3491 * Releases a request previously made via requestKeepAwake().
3492 */
3493chrome.power.releaseKeepAwake = function() {};
3494
3495
3496/**
3497 * @const
3498 * @see https://developer.chrome.com/extensions/privacy.html
3499 */
3500chrome.privacy = {};
3501
3502
3503/** @type {!Object.<string,!ChromeSetting>} */
3504chrome.privacy.network;
3505
3506
3507/** @type {!Object.<string,!ChromeSetting>} */
3508chrome.privacy.services;
3509
3510
3511/** @type {!Object.<string,!ChromeSetting>} */
3512chrome.privacy.websites;
3513
3514
3515/**
3516 * @const
3517 * @see https://developer.chrome.com/extensions/proxy.html
3518 */
3519chrome.proxy = {};
3520
3521
3522/** @type {!Object.<string,!ChromeSetting>} */
3523chrome.proxy.settings;
3524
3525
3526/** @type {!ChromeEvent} */
3527chrome.proxy.onProxyError;
3528
3529
3530/**
3531 * @const
3532 * @see http://developer.chrome.com/apps/socket.html
3533 */
3534chrome.socket = {};
3535
3536
3537
3538/**
3539 * @constructor
3540 */
3541chrome.socket.CreateInfo = function() {};
3542
3543
3544/** @type {number} */
3545chrome.socket.CreateInfo.prototype.socketId;
3546
3547
3548
3549/**
3550 * @constructor
3551 */
3552chrome.socket.ReadInfo = function() {};
3553
3554
3555/** @type {number} */
3556chrome.socket.ReadInfo.prototype.resultCode;
3557
3558
3559/** @type {!ArrayBuffer} */
3560chrome.socket.ReadInfo.prototype.data;
3561
3562
3563
3564/**
3565 * @constructor
3566 */
3567chrome.socket.WriteInfo = function() {};
3568
3569
3570/** @type {number} */
3571chrome.socket.WriteInfo.prototype.bytesWritten;
3572
3573
3574
3575/**
3576 * @constructor
3577 */
3578chrome.socket.RecvFromInfo = function() {};
3579
3580
3581/** @type {number} */
3582chrome.socket.RecvFromInfo.prototype.resultCode;
3583
3584
3585/** @type {!ArrayBuffer} */
3586chrome.socket.RecvFromInfo.prototype.data;
3587
3588
3589/** @type {string} */
3590chrome.socket.RecvFromInfo.prototype.address;
3591
3592
3593/** @type {number} */
3594chrome.socket.RecvFromInfo.prototype.port;
3595
3596
3597
3598/**
3599 * @constructor
3600 */
3601chrome.socket.AcceptInfo = function() {};
3602
3603
3604/** @type {number} */
3605chrome.socket.AcceptInfo.prototype.resultCode;
3606
3607
3608/** @type {(number|undefined)} */
3609chrome.socket.AcceptInfo.prototype.socketId;
3610
3611
3612
3613/**
3614 * @constructor
3615 */
3616chrome.socket.SocketInfo = function() {};
3617
3618
3619/** @type {string} */
3620chrome.socket.SocketInfo.prototype.socketType;
3621
3622
3623/** @type {boolean} */
3624chrome.socket.SocketInfo.prototype.connected;
3625
3626
3627/** @type {(string|undefined)} */
3628chrome.socket.SocketInfo.prototype.peerAddress;
3629
3630
3631/** @type {(number|undefined)} */
3632chrome.socket.SocketInfo.prototype.peerPort;
3633
3634
3635/** @type {(string|undefined)} */
3636chrome.socket.SocketInfo.prototype.localAddress;
3637
3638
3639/** @type {(number|undefined)} */
3640chrome.socket.SocketInfo.prototype.localPort;
3641
3642
3643
3644/**
3645 * @constructor
3646 */
3647chrome.socket.NetworkAdapterInfo = function() {};
3648
3649
3650/** @type {string} */
3651chrome.socket.NetworkAdapterInfo.prototype.name;
3652
3653
3654/** @type {string} */
3655chrome.socket.NetworkAdapterInfo.prototype.address;
3656
3657
3658/**
3659 * @param {string} type The type of socket to create. Must be 'tcp' or 'udp'.
3660 * @param {(Object|function(!chrome.socket.CreateInfo))} optionsOrCallback The
3661 *     socket options or callback.
3662 * @param {function(!chrome.socket.CreateInfo)=} opt_callback Called when the
3663 *     socket has been created.
3664 */
3665chrome.socket.create = function(type, optionsOrCallback, opt_callback) {};
3666
3667
3668/**
3669 * @param {number} socketId The id of the socket to destroy.
3670 */
3671chrome.socket.destroy = function(socketId) {};
3672
3673
3674/**
3675 * @param {number} socketId The id of the socket.
3676 * @param {string} hostname The hostname or IP address of the remote machine.
3677 * @param {number} port The port of the remote machine.
3678 * @param {function(number)} callback Called when the connection attempt is
3679 *     complete.
3680 */
3681chrome.socket.connect = function(socketId, hostname, port, callback) {};
3682
3683
3684/**
3685 * @param {number} socketId The id of the socket.
3686 * @param {string} address The address of the local machine.
3687 * @param {number} port The port of the local machine.
3688 * @param {function(number)} callback Called when the bind attempt is complete.
3689 */
3690chrome.socket.bind = function(socketId, address, port, callback) {};
3691
3692
3693/**
3694 * @param {number} socketId The id of the socket to disconnect.
3695 */
3696chrome.socket.disconnect = function(socketId) {};
3697
3698
3699/**
3700 * @param {number} socketId The id of the socket to read from.
3701 * @param {(number|function(!chrome.socket.ReadInfo))} bufferSizeOrCallback The
3702 *     read buffer size or the callback.
3703 * @param {function(!chrome.socket.ReadInfo)=} opt_callback Called with data
3704 *     that was available to be read without blocking.
3705 */
3706chrome.socket.read = function(socketId, bufferSizeOrCallback, opt_callback) {};
3707
3708
3709/**
3710 * @param {number} socketId The id of the socket to write to.
3711 * @param {!ArrayBuffer} data The data to write.
3712 * @param {function(!chrome.socket.WriteInfo)} callback Called when the write
3713 *     operation completes without blocking or an error occurs.
3714 */
3715chrome.socket.write = function(socketId, data, callback) {};
3716
3717
3718/**
3719 * @param {number} socketId The id of the socket to read from.
3720 * @param {(number|function(!chrome.socket.RecvFromInfo))} bufferSizeOrCallback
3721 *     The read buffer size or the callback.
3722 * @param {function(!chrome.socket.RecvFromInfo)=} opt_callback Called with data
3723 *     that was available to be read without blocking.
3724 */
3725chrome.socket.recvFrom = function(socketId, bufferSizeOrCallback,
3726    opt_callback) {};
3727
3728
3729/**
3730 * @param {number} socketId The id of the socket to write to.
3731 * @param {!ArrayBuffer} data The data to write.
3732 * @param {string} address The address of the remote machine.
3733 * @param {number} port The port of the remote machine.
3734 * @param {function(!chrome.socket.WriteInfo)} callback Called when the write
3735 *     operation completes without blocking or an error occurs.
3736 */
3737chrome.socket.sendTo = function(socketId, data, address, port, callback) {};
3738
3739
3740/**
3741 * @param {number} socketId The id of the socket to listen on.
3742 * @param {string} address The address of the local machine to listen on. Use
3743 *     '0' to listen on all addresses.
3744 * @param {number} port The port of the local machine.
3745 * @param {(number|function(number))} backlogOrCallback The length of the
3746 *     socket's listen queue or the callback.
3747 * @param {function(number)=} opt_callback Called when the listen operation
3748 *     completes.
3749 */
3750chrome.socket.listen =
3751    function(socketId, address, port, backlogOrCallback, opt_callback) {};
3752
3753
3754/**
3755 * @param {number} socketId The id of the socket to accept a connection on.
3756 * @param {function(!chrome.socket.AcceptInfo)} callback Called when a new
3757 *     socket is accepted.
3758 */
3759chrome.socket.accept = function(socketId, callback) {};
3760
3761
3762/**
3763 * @param {number} socketId The id of the socket to listen on.
3764 * @param {boolean} enable If true, enable keep-alive functionality.
3765 * @param {(number|function(boolean))} delayOrCallback The delay in seconds
3766 *     between the last packet received and the first keepalive probe (default
3767 *     is 0) or the callback
3768 * @param {function(boolean)=} opt_callback Called when the setKeepAlive attempt
3769 *     is complete.
3770 */
3771chrome.socket.setKeepAlive = function(socketId, enable, delayOrCallback,
3772    opt_callback) {};
3773
3774
3775/**
3776 * @param {number} socketId The id of the socket to listen on.
3777 * @param {boolean} noDelay If true, disables Nagle's algorithm.
3778 * @param {function(boolean)} callback Called when the setNoDelay attempt is
3779 *     complete.
3780 */
3781chrome.socket.setNoDelay = function(socketId, noDelay, callback) {};
3782
3783
3784/**
3785 * @param {number} socketId The id of the socket.
3786 * @param {function(!chrome.socket.SocketInfo)} callback Called when the state
3787 *     is available.
3788 */
3789chrome.socket.getInfo = function(socketId, callback) {};
3790
3791
3792/**
3793 * @param {function(!Array.<!chrome.socket.NetworkAdapterInfo>)} callback Called
3794 *     when local adapter information is available.
3795 */
3796chrome.socket.getNetworkList = function(callback) {};
3797
3798
3799/**
3800 * @param {number} socketId The id of the socket.
3801 * @param {string} address The group address to join. Domain names are not
3802 *     supported.
3803 * @param {function(number)} callback Called when the join operation is done.
3804 */
3805chrome.socket.joinGroup = function(socketId, address, callback) {};
3806
3807
3808/**
3809 * @param {number} socketId The id of the socket.
3810 * @param {string} address The group address to leave. Domain names are not
3811 *     supported.
3812 * @param {function(number)} callback Called when the leave operation is done.
3813 */
3814chrome.socket.leaveGroup = function(socketId, address, callback) {};
3815
3816
3817/**
3818 * @param {number} socketId The id of the socket.
3819 * @param {number} ttl The time-to-live value.
3820 * @param {function(number)} callback Called when the configuration operation is
3821 *     done.
3822 */
3823chrome.socket.setMulticastTimeToLive = function(socketId, ttl, callback) {};
3824
3825
3826/**
3827 * @param {number} socketId The id of the socket.
3828 * @param {boolean} enabled True to enable loopback mode.
3829 * @param {function(number)} callback Called when the configuration operation is
3830 *     done.
3831 */
3832chrome.socket.setMulticastLoopbackMode = function(socketId, enabled,
3833    callback) {};
3834
3835
3836/**
3837 * @param {number} socketId The id of the socket.
3838 * @param {function(!Array.<string>)} callback Called with an array of string
3839 *     groups.
3840 */
3841chrome.socket.getJoinedGroups = function(socketId, callback) {};
3842
3843
3844/**
3845 * @const
3846 * @see https://developer.chrome.com/extensions/storage.html
3847 */
3848chrome.storage = {};
3849
3850
3851/** @type {!StorageArea} */
3852chrome.storage.sync;
3853
3854
3855/** @type {!StorageArea} */
3856chrome.storage.local;
3857
3858
3859/** @type {!StorageChangeEvent} */
3860chrome.storage.onChanged;
3861
3862
3863/** @const */
3864chrome.system = {};
3865
3866
3867/**
3868 * @const
3869 * @see http://developer.chrome.com/apps/system_display.html
3870 */
3871chrome.system.display = {};
3872
3873
3874/** @type {!ChromeEvent} */
3875chrome.system.display.onDisplayChanged;
3876
3877
3878/**
3879 * @constructor
3880 */
3881chrome.system.display.Bounds = function() {};
3882
3883
3884/** @type {number} */
3885chrome.system.display.Bounds.prototype.left;
3886
3887
3888/** @type {number} */
3889chrome.system.display.Bounds.prototype.top;
3890
3891
3892/** @type {number} */
3893chrome.system.display.Bounds.prototype.width;
3894
3895
3896/** @type {number} */
3897chrome.system.display.Bounds.prototype.height;
3898
3899
3900/**
3901 * @typedef {{
3902 *   left: (number|undefined),
3903 *   top: (number|undefined),
3904 *   right: (number|undefined),
3905 *   bottom: (number|undefined)
3906 * }}
3907 */
3908chrome.system.display.Insets;
3909
3910
3911/**
3912 * @constructor
3913 */
3914chrome.system.display.DisplayInfo = function() {};
3915
3916
3917/** @type {string} */
3918chrome.system.display.DisplayInfo.prototype.id;
3919
3920
3921/** @type {string} */
3922chrome.system.display.DisplayInfo.prototype.name;
3923
3924
3925/** @type {string} */
3926chrome.system.display.DisplayInfo.prototype.mirroringSourceId;
3927
3928
3929/** @type {boolean} */
3930chrome.system.display.DisplayInfo.prototype.isPrimary;
3931
3932
3933/** @type {boolean} */
3934chrome.system.display.DisplayInfo.prototype.isInternal;
3935
3936
3937/** @type {boolean} */
3938chrome.system.display.DisplayInfo.prototype.isEnabled;
3939
3940
3941/** @type {number} */
3942chrome.system.display.DisplayInfo.prototype.dpiX;
3943
3944
3945/** @type {number} */
3946chrome.system.display.DisplayInfo.prototype.dpiY;
3947
3948
3949/** @type {number} */
3950chrome.system.display.DisplayInfo.prototype.rotation;
3951
3952
3953/** @type {!chrome.system.display.Bounds} */
3954chrome.system.display.DisplayInfo.prototype.bounds;
3955
3956
3957/** @type {!chrome.system.display.Insets} */
3958chrome.system.display.DisplayInfo.prototype.overscan;
3959
3960
3961/** @type {!chrome.system.display.Bounds} */
3962chrome.system.display.DisplayInfo.prototype.workArea;
3963
3964
3965/**
3966 * @typedef {{
3967 *   mirroringSourceId: (string|undefined),
3968 *   isPrimary: (boolean|undefined),
3969 *   overscan: (!chrome.system.display.Insets|undefined),
3970 *   rotation: (number|undefined),
3971 *   boundsOriginX: (number|undefined),
3972 *   boundsOriginY: (number|undefined)
3973 * }}
3974 */
3975chrome.system.display.SettableDisplayInfo;
3976
3977
3978chrome.types = {};
3979
3980
3981/**
3982 * @typedef {?{
3983 *   format: (string|undefined),
3984 *   quality: (number|undefined)
3985 * }}
3986 */
3987chrome.types.ImageDetails;
3988
3989
3990/**
3991 * @param {function(!Array.<!chrome.system.display.DisplayInfo>)}
3992 *     callback Called with an array of objects representing display info.
3993 */
3994chrome.system.display.getInfo = function(callback) {};
3995
3996
3997/**
3998 * @param {string} id The display's unique identifier.
3999 * @param {!chrome.system.display.SettableDisplayInfo} info The information
4000 *     about display properties that should be changed.
4001 * @param {function()=} opt_callback The callback to execute when the display
4002 *     info has been changed.
4003 */
4004chrome.system.display.setDisplayProperties =
4005    function(id, info, opt_callback) {};
4006
4007
4008/**
4009 * @const
4010 * @see https://developer.chrome.com/extensions/types.html
4011 */
4012chrome.chromeSetting = {};
4013
4014
4015/** @type {!ChromeEvent} */
4016chrome.chromeSetting.onChange;
4017
4018
4019/**
4020 * @const
4021 * @see https://developer.chrome.com/extensions/webNavigation.html
4022 */
4023chrome.webNavigation = {};
4024
4025
4026/**
4027 * @param {Object} details Object with a 'tabId' (number) key.
4028 * @param {function(!Array.<Object.<string, (boolean|number|string)>>)} callback
4029 *     Callback function.
4030 */
4031chrome.webNavigation.getAllFrames = function(details, callback) {};
4032
4033
4034/**
4035 * @param {Object} details Object with 'tabId' (number) and 'frameId' (number)
4036 *     keys.
4037 * @param {function(Object.<string, (boolean|string)>)} callback
4038 *     Callback function.
4039 */
4040chrome.webNavigation.getFrame = function(details, callback) {};
4041
4042
4043/** @type {!ChromeEvent} */
4044chrome.webNavigation.onBeforeNavigate;
4045
4046
4047/** @type {!ChromeEvent} */
4048chrome.webNavigation.onCommitted;
4049
4050
4051/** @type {!ChromeEvent} */
4052chrome.webNavigation.onDOMContentLoaded;
4053
4054
4055/** @type {!ChromeEvent} */
4056chrome.webNavigation.onCompleted;
4057
4058
4059/** @type {!ChromeEvent} */
4060chrome.webNavigation.onErrorOccurred;
4061
4062
4063/** @type {!ChromeEvent} */
4064chrome.webNavigation.onCreatedNavigationTarget;
4065
4066
4067/** @type {!ChromeEvent} */
4068chrome.webNavigation.onReferenceFragmentUpdated;
4069
4070
4071/** @type {!ChromeEvent} */
4072chrome.webNavigation.onTabReplaced;
4073
4074
4075/** @type {!ChromeEvent} */
4076chrome.webNavigation.onHistoryStateUpdated;
4077
4078
4079
4080/**
4081 * Most event listeners for WebRequest take extra arguments.
4082 * @see https://developer.chrome.com/extensions/webRequest.html.
4083 * @constructor
4084 */
4085function WebRequestEvent() {}
4086
4087
4088/**
4089 * @param {function(!Object): (void|!BlockingResponse)} listener Listener
4090 *     function.
4091 * @param {!RequestFilter} filter A set of filters that restrict
4092 *     the events that will be sent to this listener.
4093 * @param {Array.<string>=} opt_extraInfoSpec Array of extra information
4094 *     that should be passed to the listener function.
4095 */
4096WebRequestEvent.prototype.addListener =
4097    function(listener, filter, opt_extraInfoSpec) {};
4098
4099
4100/**
4101 * @param {function(!Object): (void|!BlockingResponse)} listener Listener
4102 *     function.
4103 */
4104WebRequestEvent.prototype.removeListener = function(listener) {};
4105
4106
4107/**
4108 * @param {function(!Object): (void|!BlockingResponse)} listener Listener
4109 *     function.
4110 */
4111WebRequestEvent.prototype.hasListener = function(listener) {};
4112
4113
4114/**
4115 * @param {function(!Object): (void|!BlockingResponse)} listener Listener
4116 *     function.
4117 */
4118WebRequestEvent.prototype.hasListeners = function(listener) {};
4119
4120
4121
4122/**
4123 * The onErrorOccurred event takes one less parameter than the others.
4124 * @see https://developer.chrome.com/extensions/webRequest.html.
4125 * @constructor
4126 */
4127function WebRequestOnErrorOccurredEvent() {}
4128
4129
4130/**
4131 * @param {function(!Object): void} listener Listener function.
4132 * @param {!RequestFilter} filter A set of filters that restrict
4133 *     the events that will be sent to this listener.
4134 */
4135WebRequestOnErrorOccurredEvent.prototype.addListener =
4136    function(listener, filter) {};
4137
4138
4139/**
4140 * @param {function(!Object): void} listener Listener function.
4141 */
4142WebRequestOnErrorOccurredEvent.prototype.removeListener = function(listener) {};
4143
4144
4145/**
4146 * @param {function(!Object): void} listener Listener function.
4147 */
4148WebRequestOnErrorOccurredEvent.prototype.hasListener = function(listener) {};
4149
4150
4151/**
4152 * @param {function(!Object): void} listener Listener function.
4153 */
4154WebRequestOnErrorOccurredEvent.prototype.hasListeners = function(listener) {};
4155
4156
4157/**
4158 * @const
4159 * @see https://developer.chrome.com/extensions/webRequest.html
4160 */
4161chrome.webRequest = {};
4162
4163
4164/**
4165 * @param {function(): void=} opt_callback Callback function.
4166 */
4167chrome.webRequest.handlerBehaviorChanged = function(opt_callback) {};
4168
4169
4170/** @type {!WebRequestEvent} */
4171chrome.webRequest.onAuthRequired;
4172
4173
4174/** @type {!WebRequestEvent} */
4175chrome.webRequest.onBeforeRedirect;
4176
4177
4178/** @type {!WebRequestEvent} */
4179chrome.webRequest.onBeforeRequest;
4180
4181
4182/** @type {!WebRequestEvent} */
4183chrome.webRequest.onBeforeSendHeaders;
4184
4185
4186/** @type {!WebRequestEvent} */
4187chrome.webRequest.onCompleted;
4188
4189
4190/** @type {!WebRequestOnErrorOccurredEvent} */
4191chrome.webRequest.onErrorOccurred;
4192
4193
4194/** @type {!WebRequestEvent} */
4195chrome.webRequest.onHeadersReceived;
4196
4197
4198/** @type {!WebRequestEvent} */
4199chrome.webRequest.onResponseStarted;
4200
4201
4202/** @type {!WebRequestEvent} */
4203chrome.webRequest.onSendHeaders;
4204
4205
4206// Classes
4207
4208
4209
4210/**onKeyEvent
4211 * @see https://developer.chrome.com/extensions/management.html
4212 * @constructor
4213 */
4214function ExtensionInfo() {}
4215
4216
4217/** @type {string} */
4218ExtensionInfo.prototype.id;
4219
4220
4221/** @type {string} */
4222ExtensionInfo.prototype.name;
4223
4224
4225/** @type {string} */
4226ExtensionInfo.prototype.description;
4227
4228
4229/** @type {string} */
4230ExtensionInfo.prototype.version;
4231
4232
4233/** @type {boolean} */
4234ExtensionInfo.prototype.mayDisable;
4235
4236
4237/** @type {boolean} */
4238ExtensionInfo.prototype.enabled;
4239
4240
4241/** @type {string|undefined} */
4242ExtensionInfo.prototype.disabledReason;
4243
4244
4245/** @type {boolean} */
4246ExtensionInfo.prototype.isApp;
4247
4248
4249/** @type {string|undefined} */
4250ExtensionInfo.prototype.appLaunchUrl;
4251
4252
4253/** @type {string|undefined} */
4254ExtensionInfo.prototype.homepageUrl;
4255
4256
4257/** @type {string|undefined} */
4258ExtensionInfo.prototype.updateUrl;
4259
4260
4261/** @type {boolean} */
4262ExtensionInfo.prototype.offlineEnabled;
4263
4264
4265/** @type {string} */
4266ExtensionInfo.prototype.optionsUrl;
4267
4268
4269/** @type {!Array.<!IconInfo>|undefined} */
4270ExtensionInfo.prototype.icons;
4271
4272
4273/** @type {!Array.<string>} */
4274ExtensionInfo.prototype.permissions;
4275
4276
4277/** @type {!Array.<string>} */
4278ExtensionInfo.prototype.hostPermissions;
4279
4280
4281/** @type {string} */
4282ExtensionInfo.prototype.installType;
4283
4284
4285/** @type {string|undefined} */
4286ExtensionInfo.prototype.launchType;
4287
4288
4289/** @type {!Array.<string>|undefined} */
4290ExtensionInfo.prototype.availableLaunchTypes;
4291
4292
4293
4294/**
4295 * @see https://developer.chrome.com/extensions/management.html
4296 * @constructor
4297 */
4298function IconInfo() {}
4299
4300
4301/** @type {number} */
4302IconInfo.prototype.size;
4303
4304
4305/** @type {string} */
4306IconInfo.prototype.url;
4307
4308
4309
4310/**
4311 * @see https://developer.chrome.com/extensions/tabs
4312 * @constructor
4313 */
4314function Tab() {}
4315
4316// TODO: Make this field optional once dependent projects have been updated.
4317/**
4318 * @type {number}
4319 */
4320Tab.prototype.id;
4321
4322
4323/** @type {number} */
4324Tab.prototype.index;
4325
4326
4327/** @type {number} */
4328Tab.prototype.windowId;
4329
4330
4331// TODO: Make this field optional once dependent projects have been updated.
4332/**
4333 * @type {number}
4334 */
4335Tab.prototype.openerTabId;
4336
4337
4338/** @type {boolean} */
4339Tab.prototype.highlighted;
4340
4341
4342/** @type {boolean} */
4343Tab.prototype.active;
4344
4345
4346/** @type {boolean} */
4347Tab.prototype.pinned;
4348
4349
4350// TODO: Make this field optional once dependent projects have been updated.
4351/**
4352 * @type {string}
4353 */
4354Tab.prototype.url;
4355
4356
4357// TODO: Make this field optional once dependent projects have been updated.
4358/**
4359 * @type {string}
4360 */
4361Tab.prototype.title;
4362
4363
4364// TODO: Make this field optional once dependent projects have been updated.
4365/**
4366 * @type {string}
4367 */
4368Tab.prototype.favIconUrl;
4369
4370
4371// TODO: Make this field optional once dependent projects have been updated.
4372/**
4373 * @type {string}
4374 */
4375Tab.prototype.status;
4376
4377
4378/** @type {boolean} */
4379Tab.prototype.incognito;
4380
4381
4382/** @type {number|undefined} */
4383Tab.prototype.width;
4384
4385
4386/** @type {number|undefined} */
4387Tab.prototype.height;
4388
4389
4390/** @type {number|undefined} */
4391Tab.prototype.sessionId;
4392
4393
4394/**
4395 * @see https://developer.chrome.com/extensions/windows.html
4396 * @constructor
4397 */
4398function ChromeWindow() {}
4399
4400
4401/** @type {number} */
4402ChromeWindow.prototype.id;
4403
4404
4405/** @type {boolean} */
4406ChromeWindow.prototype.focused;
4407
4408
4409/** @type {number} */
4410ChromeWindow.prototype.top;
4411
4412
4413/** @type {number} */
4414ChromeWindow.prototype.left;
4415
4416
4417/** @type {number} */
4418ChromeWindow.prototype.width;
4419
4420
4421/** @type {number} */
4422ChromeWindow.prototype.height;
4423
4424
4425/** @type {Array.<Tab>} */
4426ChromeWindow.prototype.tabs;
4427
4428
4429/** @type {boolean} */
4430ChromeWindow.prototype.incognito;
4431
4432
4433/** @type {string} */
4434ChromeWindow.prototype.type;
4435
4436
4437/** @type {string} */
4438ChromeWindow.prototype.state;
4439
4440
4441/** @type {boolean} */
4442ChromeWindow.prototype.alwaysOnTop;
4443
4444
4445
4446/**
4447 * @see https://developer.chrome.com/extensions/events.html
4448 * @constructor
4449 */
4450function ChromeEvent() {}
4451
4452
4453/** @param {!Function} callback */
4454ChromeEvent.prototype.addListener = function(callback) {};
4455
4456
4457/** @param {!Function} callback */
4458ChromeEvent.prototype.removeListener = function(callback) {};
4459
4460
4461/**
4462 * @param {!Function} callback
4463 * @return {boolean}
4464 */
4465ChromeEvent.prototype.hasListener = function(callback) {};
4466
4467
4468/** @return {boolean} */
4469ChromeEvent.prototype.hasListeners = function() {};
4470
4471
4472/**
4473 * Event whose listeners take a string parameter.
4474 * @constructor
4475 */
4476function ChromeStringEvent() {}
4477
4478
4479/** @param {function(string): void} callback */
4480ChromeStringEvent.prototype.addListener = function(callback) {};
4481
4482
4483/** @param {function(string): void} callback */
4484ChromeStringEvent.prototype.removeListener = function(callback) {};
4485
4486
4487/**
4488 * @param {function(string): void} callback
4489 * @return {boolean}
4490 */
4491ChromeStringEvent.prototype.hasListener = function(callback) {};
4492
4493
4494/** @return {boolean} */
4495ChromeStringEvent.prototype.hasListeners = function() {};
4496
4497
4498
4499/**
4500 * Event whose listeners take a boolean parameter.
4501 * @constructor
4502 */
4503
4504function ChromeBooleanEvent() {}
4505
4506
4507/**
4508 * @param {function(boolean): void} callback
4509 */
4510ChromeBooleanEvent.prototype.addListener = function(callback) {};
4511
4512
4513/**
4514 * @param {function(boolean): void} callback
4515 */
4516ChromeBooleanEvent.prototype.removeListener = function(callback) {};
4517
4518
4519/**
4520 * @param {function(boolean): void} callback
4521 * @return {boolean}
4522 */
4523ChromeBooleanEvent.prototype.hasListener = function(callback) {};
4524
4525
4526/**
4527 * @return {boolean}
4528 */
4529ChromeBooleanEvent.prototype.hasListeners = function() {};
4530
4531
4532
4533/**
4534 * Event whose listeners take a number parameter.
4535 * @constructor
4536 */
4537
4538function ChromeNumberEvent() {}
4539
4540
4541/**
4542 * @param {function(number): void} callback
4543 */
4544ChromeNumberEvent.prototype.addListener = function(callback) {};
4545
4546
4547/**
4548 * @param {function(number): void} callback
4549 */
4550ChromeNumberEvent.prototype.removeListener = function(callback) {};
4551
4552
4553/**
4554 * @param {function(number): void} callback
4555 * @return {boolean}
4556 */
4557ChromeNumberEvent.prototype.hasListener = function(callback) {};
4558
4559
4560/**
4561 * @return {boolean}
4562 */
4563ChromeNumberEvent.prototype.hasListeners = function() {};
4564
4565
4566
4567/**
4568 * Event whose listeners take an Object parameter.
4569 * @constructor
4570 */
4571function ChromeObjectEvent() {}
4572
4573
4574/**
4575 * @param {function(!Object): void} callback Callback.
4576 */
4577ChromeObjectEvent.prototype.addListener = function(callback) {};
4578
4579
4580/**
4581 * @param {function(!Object): void} callback Callback.
4582 */
4583ChromeObjectEvent.prototype.removeListener = function(callback) {};
4584
4585
4586/**
4587 * @param {function(!Object): void} callback Callback.
4588 * @return {boolean}
4589 */
4590ChromeObjectEvent.prototype.hasListener = function(callback) {};
4591
4592
4593/**
4594 * @return {boolean}
4595 */
4596ChromeObjectEvent.prototype.hasListeners = function() {};
4597
4598
4599
4600/**
4601 * Event whose listeners take an ExtensionInfo parameter.
4602 * @constructor
4603 */
4604function ChromeExtensionInfoEvent() {}
4605
4606
4607/** @param {function(!ExtensionInfo): void} callback */
4608ChromeExtensionInfoEvent.prototype.addListener = function(callback) {};
4609
4610
4611/** @param {function(!ExtensionInfo): void} callback */
4612ChromeExtensionInfoEvent.prototype.removeListener = function(callback) {};
4613
4614
4615/**
4616 * @param {function(!ExtensionInfo): void} callback
4617 * @return {boolean}
4618 */
4619ChromeExtensionInfoEvent.prototype.hasListener = function(callback) {};
4620
4621
4622/** @return {boolean} */
4623ChromeExtensionInfoEvent.prototype.hasListeners = function() {};
4624
4625
4626/**
4627 * Event whose listeners take a string array parameter.
4628 * @constructor
4629 */
4630function ChromeStringArrayEvent() {}
4631
4632
4633/** @param {function(!Array.<string>): void} callback */
4634ChromeStringArrayEvent.prototype.addListener = function(callback) {};
4635
4636
4637/** @param {function(!Array.<string>): void} callback */
4638ChromeStringArrayEvent.prototype.removeListener = function(callback) {};
4639
4640
4641/**
4642 * @param {function(!Array.<string>): void} callback
4643 * @return {boolean}
4644 */
4645ChromeStringArrayEvent.prototype.hasListener = function(callback) {};
4646
4647
4648/** @return {boolean} */
4649ChromeStringArrayEvent.prototype.hasListeners = function() {};
4650
4651
4652
4653/**
4654 * Event whose listeners take two strings as parameters.
4655 * @constructor
4656 */
4657function ChromeStringStringEvent() {}
4658
4659
4660/** @param {function(string, string): void} callback */
4661ChromeStringStringEvent.prototype.addListener = function(callback) {};
4662
4663
4664/** @param {function(string, string): void} callback */
4665ChromeStringStringEvent.prototype.removeListener = function(callback) {};
4666
4667
4668/**
4669 * @param {function(string, string): void} callback
4670 * @return {boolean}
4671 */
4672ChromeStringStringEvent.prototype.hasListener = function(callback) {};
4673
4674
4675/** @return {boolean} */
4676ChromeStringStringEvent.prototype.hasListeners = function() {};
4677
4678
4679/**
4680 * @see http://developer.chrome.com/extensions/pushMessaging.html
4681 * @const
4682 */
4683chrome.pushMessaging = {};
4684
4685
4686/**
4687 * @type {!chrome.pushMessaging.PushMessageEvent}
4688 */
4689chrome.pushMessaging.onMessage;
4690
4691
4692/**
4693 * @param {boolean|function(!chrome.pushMessaging.ChannelIdResult)}
4694 *     interactiveOrCallback Either a flag(optional), if set to true, user will
4695 *     be asked to log in if they are not already logged in, or, when he flag is
4696 *     not given, the callback.
4697 * @param {function(!chrome.pushMessaging.ChannelIdResult)=} opt_callback
4698 *     Callback.
4699 */
4700chrome.pushMessaging.getChannelId =
4701    function(interactiveOrCallback, opt_callback) {};
4702
4703
4704
4705/**
4706 * Event whose listeners take a chrome.pushMessaging.Message parameter.
4707 * @constructor
4708 */
4709chrome.pushMessaging.PushMessageEvent = function() {};
4710
4711
4712/**
4713 * @param {function(!chrome.pushMessaging.Message): void} callback
4714 */
4715chrome.pushMessaging.PushMessageEvent.prototype.addListener =
4716    function(callback) {};
4717
4718
4719/**
4720 * @param {function(!chrome.pushMessaging.Message): void} callback
4721 */
4722chrome.pushMessaging.PushMessageEvent.prototype.removeListener =
4723    function(callback) {};
4724
4725
4726/**
4727 * @param {function(!chrome.pushMessaging.Message): void} callback
4728 * @return {boolean}
4729 */
4730chrome.pushMessaging.PushMessageEvent.prototype.hasListener =
4731    function(callback) {};
4732
4733
4734/**
4735 * @return {boolean}
4736 */
4737chrome.pushMessaging.PushMessageEvent.prototype.hasListeners = function() {};
4738
4739
4740
4741/**
4742 * @see http://developer.chrome.com/apps/runtime.html#type-Port
4743 * @constructor
4744 */
4745function Port() {}
4746
4747
4748/** @type {string} */
4749Port.prototype.name;
4750
4751
4752/** @type {!ChromeEvent} */
4753Port.prototype.onDisconnect;
4754
4755
4756/** @type {!ChromeEvent} */
4757Port.prototype.onMessage;
4758
4759
4760/** @type {MessageSender} */
4761Port.prototype.sender;
4762
4763
4764/**
4765 * @param {Object.<string>} obj Message object.
4766 */
4767Port.prototype.postMessage = function(obj) {};
4768
4769
4770/**
4771 * Note: as of 2012-04-12, this function is no longer documented on
4772 * the public web pages, but there are still existing usages.
4773 */
4774Port.prototype.disconnect = function() {};
4775
4776
4777
4778/**
4779 * @see http://developer.chrome.com/extensions/runtime.html#type-MessageSender
4780 * @constructor
4781 */
4782function MessageSender() {}
4783
4784
4785/** @type {!Tab|undefined} */
4786MessageSender.prototype.tab;
4787
4788
4789/** @type {string|undefined} */
4790MessageSender.prototype.id;
4791
4792
4793/** @type {string|undefined} */
4794MessageSender.prototype.url;
4795
4796
4797/** @type {string|undefined} */
4798MessageSender.prototype.tlsChannelId;
4799
4800
4801
4802/**
4803 * @see https://developer.chrome.com/extensions/bookmarks.html#type-BookmarkTreeNode
4804 * @constructor
4805 */
4806function BookmarkTreeNode() {}
4807
4808
4809/** @type {string} */
4810BookmarkTreeNode.prototype.id;
4811
4812
4813/** @type {string|undefined} */
4814BookmarkTreeNode.prototype.parentId;
4815
4816
4817/** @type {number|undefined} */
4818BookmarkTreeNode.prototype.index;
4819
4820
4821/** @type {string|undefined} */
4822BookmarkTreeNode.prototype.url;
4823
4824
4825/** @type {string} */
4826BookmarkTreeNode.prototype.title;
4827
4828
4829/** @type {number|undefined} */
4830BookmarkTreeNode.prototype.dateAdded;
4831
4832
4833/** @type {number|undefined} */
4834BookmarkTreeNode.prototype.dateGroupModified;
4835
4836
4837/** @type {string|undefined} */
4838BookmarkTreeNode.prototype.unmodifiable;
4839
4840
4841/** @type {!Array.<!BookmarkTreeNode>|undefined} */
4842BookmarkTreeNode.prototype.children;
4843
4844
4845
4846/**
4847 * @see https://developer.chrome.com/extensions/dev/cookies.html#type-Cookie
4848 * @constructor
4849 */
4850function Cookie() {}
4851
4852
4853/** @type {string} */
4854Cookie.prototype.name;
4855
4856
4857/** @type {string} */
4858Cookie.prototype.value;
4859
4860
4861/** @type {string} */
4862Cookie.prototype.domain;
4863
4864
4865/** @type {boolean} */
4866Cookie.prototype.hostOnly;
4867
4868
4869/** @type {string} */
4870Cookie.prototype.path;
4871
4872
4873/** @type {boolean} */
4874Cookie.prototype.secure;
4875
4876
4877/** @type {boolean} */
4878Cookie.prototype.httpOnly;
4879
4880
4881/** @type {boolean} */
4882Cookie.prototype.session;
4883
4884
4885/** @type {number} */
4886Cookie.prototype.expirationDate;
4887
4888
4889/** @type {string} */
4890Cookie.prototype.storeId;
4891
4892
4893
4894/**
4895 * @see https://developer.chrome.com/extensions/dev/cookies.html#type-CookieStore
4896 * @constructor
4897 */
4898function CookieStore() {}
4899
4900
4901/** @type {string} */
4902CookieStore.prototype.id;
4903
4904
4905/** @type {Array.<number>} */
4906CookieStore.prototype.tabIds;
4907
4908
4909
4910/**
4911 * @see https://developer.chrome.com/extensions/dev/contextMenus.html#type-OnClickData
4912 * @constructor
4913 */
4914function OnClickData() {}
4915
4916
4917/** @type {number} */
4918OnClickData.prototype.menuItemId;
4919
4920
4921/** @type {number} */
4922OnClickData.prototype.parentMenuItemId;
4923
4924
4925/** @type {string} */
4926OnClickData.prototype.mediaType;
4927
4928
4929/** @type {string} */
4930OnClickData.prototype.linkUrl;
4931
4932
4933/** @type {string} */
4934OnClickData.prototype.srcUrl;
4935
4936
4937/** @type {string} */
4938OnClickData.prototype.pageUrl;
4939
4940
4941/** @type {string} */
4942OnClickData.prototype.frameUrl;
4943
4944
4945/** @type {string} */
4946OnClickData.prototype.selectionText;
4947
4948
4949/** @type {string} */
4950OnClickData.prototype.editable;
4951
4952
4953
4954/**
4955 * @see https://developer.chrome.com/extensions/debugger.html#type-Debuggee
4956 * @constructor
4957 */
4958function Debuggee() {}
4959
4960
4961/** @type {number} */
4962Debuggee.prototype.tabId;
4963
4964
4965
4966/**
4967 * @see https://developer.chrome.com/extensions/contentSettings.html#type-ResourceIdentifier
4968 * @constructor
4969 */
4970function ResourceIdentifier() {}
4971
4972
4973/** @type {string} */
4974ResourceIdentifier.prototype.id;
4975
4976
4977/** @type {string} */
4978ResourceIdentifier.prototype.description;
4979
4980
4981
4982/**
4983 * @see https://developer.chrome.com/extensions/contentSettings.html#type-ContentSetting
4984 * @constructor
4985 */
4986function ContentSetting() {}
4987
4988
4989/**
4990 * @param {!Object.<string,string>} details Settings details.
4991 * @param {function(): void=} opt_callback Callback function.
4992 */
4993ContentSetting.prototype.clear = function(details, opt_callback) {};
4994
4995
4996/**
4997 * @param {!Object.<string,(string|boolean|ResourceIdentifier)>} details
4998 *     Settings details.
4999 * @param {function(): void} callback Callback function.
5000 */
5001ContentSetting.prototype.get = function(details, callback) {};
5002
5003
5004/**
5005 * @param {function(): void} callback Callback function.
5006 */
5007ContentSetting.prototype.getResourceIdentifiers = function(callback) {};
5008
5009
5010/**
5011 * @param {!Object.<string,(string|ResourceIdentifier)>} details
5012 *     Settings details.
5013 * @param {function(): void=} opt_callback Callback function.
5014 */
5015ContentSetting.prototype.set = function(details, opt_callback) {};
5016
5017
5018
5019/**
5020 * @see https://developer.chrome.com/extensions/history.html#type-HistoryItem
5021 * @constructor
5022 */
5023function HistoryItem() {}
5024
5025
5026/** @type {string} */
5027HistoryItem.prototype.id;
5028
5029
5030/** @type {string} */
5031HistoryItem.prototype.url;
5032
5033
5034/** @type {string} */
5035HistoryItem.prototype.title;
5036
5037
5038/** @type {number} */
5039HistoryItem.prototype.lastVisitTime;
5040
5041
5042/** @type {number} */
5043HistoryItem.prototype.visitCount;
5044
5045
5046/** @type {number} */
5047HistoryItem.prototype.typedCount;
5048
5049
5050
5051/**
5052 * @see https://developer.chrome.com/extensions/history.html#type-VisitItem
5053 * @constructor
5054 */
5055function VisitItem() {}
5056
5057
5058/** @type {string} */
5059VisitItem.prototype.id;
5060
5061
5062/** @type {string} */
5063VisitItem.prototype.visitId;
5064
5065
5066/** @type {number} */
5067VisitItem.prototype.visitTime;
5068
5069
5070/** @type {string} */
5071VisitItem.prototype.referringVisitId;
5072
5073
5074/** @type {string} */
5075VisitItem.prototype.transition;
5076
5077
5078
5079/**
5080 * @see https://developer.chrome.com/extensions/fileBrowserHandler.html#type-FileHandlerExecuteEventDetails
5081 * @constructor
5082 */
5083function FileHandlerExecuteEventDetails() {}
5084
5085
5086/** @type {!Array.<!FileEntry>} */
5087FileHandlerExecuteEventDetails.prototype.entries;
5088
5089
5090/** @type {number} */
5091FileHandlerExecuteEventDetails.prototype.tab_id;
5092
5093
5094
5095/**
5096 * @see https://developer.chrome.com/extensions/input.ime.html#type-KeyboardEvent
5097 * @constructor
5098 */
5099function ChromeKeyboardEvent() {}
5100
5101
5102/** @type {string} */
5103ChromeKeyboardEvent.prototype.type;
5104
5105
5106/** @type {string} */
5107ChromeKeyboardEvent.prototype.requestId;
5108
5109
5110/** @type {string} */
5111ChromeKeyboardEvent.prototype.key;
5112
5113
5114/** @type {boolean} */
5115ChromeKeyboardEvent.prototype.altKey;
5116
5117
5118/** @type {boolean} */
5119ChromeKeyboardEvent.prototype.ctrlKey;
5120
5121
5122/** @type {boolean} */
5123ChromeKeyboardEvent.prototype.shiftKey;
5124
5125
5126
5127/**
5128 * @see https://developer.chrome.com/extensions/input.ime.html#type-InputContext
5129 * @constructor
5130 */
5131function InputContext() {}
5132
5133
5134/** @type {number} */
5135InputContext.prototype.contextID;
5136
5137
5138/** @type {string} */
5139InputContext.prototype.type;
5140
5141
5142
5143/**
5144 * @see https://developer.chrome.com/extensions/proxy.html#type-ProxyServer
5145 * @constructor
5146 */
5147function ProxyServer() {}
5148
5149
5150/** @type {string} */
5151ProxyServer.prototype.scheme;
5152
5153
5154/** @type {string} */
5155ProxyServer.prototype.host;
5156
5157
5158/** @type {number} */
5159ProxyServer.prototype.port;
5160
5161
5162
5163/**
5164 * @see https://developer.chrome.com/extensions/proxy.html#type-ProxyRules
5165 * @constructor
5166 */
5167function ProxyRules() {}
5168
5169
5170/** @type {ProxyServer} */
5171ProxyRules.prototype.singleProxy;
5172
5173
5174/** @type {ProxyServer} */
5175ProxyRules.prototype.proxyForHttp;
5176
5177
5178/** @type {ProxyServer} */
5179ProxyRules.prototype.proxyForHttps;
5180
5181
5182/** @type {ProxyServer} */
5183ProxyRules.prototype.proxyForFtp;
5184
5185
5186/** @type {ProxyServer} */
5187ProxyRules.prototype.fallbackProxy;
5188
5189
5190/** @type {!Array.<string>} */
5191ProxyRules.prototype.bypassList;
5192
5193
5194
5195/**
5196 * @see https://developer.chrome.com/extensions/proxy.html#type-PacScript
5197 * @constructor
5198 */
5199function PacScript() {}
5200
5201
5202/** @type {string} */
5203PacScript.prototype.url;
5204
5205
5206/** @type {string} */
5207PacScript.prototype.data;
5208
5209
5210/** @type {boolean} */
5211PacScript.prototype.mandatory;
5212
5213
5214
5215/**
5216 * @see https://developer.chrome.com/extensions/proxy.html#type-ProxyConfig
5217 * @constructor
5218 */
5219function ProxyConfig() {}
5220
5221
5222/** @type {ProxyRules} */
5223ProxyConfig.prototype.rules;
5224
5225
5226/** @type {PacScript} */
5227ProxyConfig.prototype.pacScript;
5228
5229
5230/** @type {string} */
5231ProxyConfig.prototype.mode;
5232
5233
5234
5235/**
5236 * The event listener for Storage receives an Object mapping each
5237 * key that changed to its corresponding StorageChange for that item.
5238 *
5239 * @see https://developer.chrome.com/extensions/storage.html
5240 * @constructor
5241 */
5242function StorageChangeEvent() {}
5243
5244
5245/**
5246 * @param {function(!Object.<string, !StorageChange>, string)} callback
5247 *    Listener will receive an object that maps each key to its StorageChange,
5248 *    and the namespace ("sync" or "local") of the storage area the changes
5249 *    are for.
5250 */
5251StorageChangeEvent.prototype.addListener = function(callback) {};
5252
5253
5254/** @param {function(!Object.<string, !StorageChange>, string)} callback */
5255StorageChangeEvent.prototype.removeListener = function(callback) {};
5256
5257
5258/** @param {function(!Object.<string, !StorageChange>, string)} callback */
5259StorageChangeEvent.prototype.hasListener = function(callback) {};
5260
5261
5262/** @param {function(!Object.<string, !StorageChange>, string)} callback */
5263StorageChangeEvent.prototype.hasListeners = function(callback) {};
5264
5265
5266
5267/**
5268 * @see https://developer.chrome.com/extensions/storage.html#type-StorageChange
5269 * @constructor
5270 */
5271function StorageChange() {}
5272
5273
5274/** @type {?} */
5275StorageChange.prototype.oldValue;
5276
5277
5278/** @type {?} */
5279StorageChange.prototype.newValue;
5280
5281
5282
5283/**
5284 * @see https://developer.chrome.com/extensions/storage.html#type-StorageArea
5285 * @constructor
5286 */
5287function StorageArea() {}
5288
5289
5290/**
5291 * Removes all items from storage.
5292 * @param {function(): void=} opt_callback Callback function.
5293 */
5294StorageArea.prototype.clear = function(opt_callback) {};
5295
5296
5297/**
5298 * @param {(string|!Array.<string>|!Object|null)=} opt_keys
5299 *    A single key to get, list of keys to get, or a dictionary
5300 *    specifying default values (see description of the
5301 *    object). An empty list or object will return an empty
5302 *    result object. Pass in null to get the entire contents of storage.
5303 * @param {function(Object)=} opt_callback Callback with storage items, or null
5304 *    on failure.
5305 */
5306StorageArea.prototype.get = function(opt_keys, opt_callback) {};
5307
5308
5309/**
5310 * @param {(string|!Array.<string>)} keys
5311 *    A single key or a list of keys for items to remove.
5312 * @param {function()=} opt_callback Callback.
5313 */
5314StorageArea.prototype.remove = function(keys, opt_callback) {};
5315
5316
5317/**
5318 * @param {!Object.<string>} keys
5319 *    Object specifying items to augment storage
5320 *    with. Values that cannot be serialized (functions, etc) will be ignored.
5321 * @param {function()=} opt_callback Callback.
5322 */
5323StorageArea.prototype.set = function(keys, opt_callback) { };
5324
5325
5326/**
5327 * @param {(string|!Array.<string>|null)=} opt_keys
5328 *    A single key or list of keys to get the total usage for. An empty list
5329 *    will return 0. Pass in null to get the total usage of all of storage.
5330 * @param {function(number)=} opt_callback
5331 *    Callback with the amount of space being used by storage.
5332 */
5333StorageArea.prototype.getBytesInUse = function(opt_keys, opt_callback) { };
5334
5335
5336
5337/**
5338 * @see https://developer.chrome.com/extensions/types.html#type-ChromeSetting
5339 * @constructor
5340 */
5341function ChromeSetting() {}
5342
5343
5344/**
5345 * @param {Object} details Object with a 'scope' (string) key.
5346 * @param {function(): void=} opt_callback Callback function.
5347 */
5348ChromeSetting.prototype.clear = function(details, opt_callback) {};
5349
5350
5351/**
5352 * @param {Object} details Object with an 'incognito' (boolean) key.
5353 * @param {function(Object.<string, *>): void} callback Callback function.
5354 */
5355ChromeSetting.prototype.get = function(details, callback) {};
5356
5357
5358/**
5359 * @param {Object} details Object with a 'value' (*) key and an optional
5360 *     'scope' (string) key.
5361 * @param {function(): void=} opt_callback Callback function.
5362 */
5363ChromeSetting.prototype.set = function(details, opt_callback) {};
5364
5365
5366
5367/**
5368 * @see https://developer.chrome.com/extensions/webRequest.html#type-RequestFilter
5369 * @constructor
5370 */
5371function RequestFilter() {}
5372
5373
5374/** @type {!Array.<string>} */
5375RequestFilter.prototype.urls;
5376
5377
5378/** @type {!Array.<string>} */
5379RequestFilter.prototype.types;
5380
5381
5382/** @type {number} */
5383RequestFilter.prototype.tabId;
5384
5385
5386/** @type {number} */
5387RequestFilter.prototype.windowId;
5388
5389
5390
5391/**
5392 * @see https://developer.chrome.com/extensions/webRequest.html#type-HttpHeaders
5393 * @constructor
5394 */
5395function HttpHeader() {}
5396
5397
5398/** @type {string} */
5399HttpHeader.prototype.name;
5400
5401
5402/** @type {string} */
5403HttpHeader.prototype.value;
5404
5405
5406/** @type {!Array.<number>} */
5407HttpHeader.prototype.binaryValue;
5408
5409
5410/**
5411 * @see https://developer.chrome.com/extensions/webRequest.html#type-HttpHeaders
5412 * @typedef {Array.<!HttpHeader>}
5413 * @private
5414 */
5415var HttpHeaders_;
5416
5417
5418
5419/**
5420 * @see https://developer.chrome.com/extensions/webRequest.html#type-BlockingResponse
5421 * @constructor
5422 */
5423function BlockingResponse() {}
5424
5425
5426/** @type {boolean} */
5427BlockingResponse.prototype.cancel;
5428
5429
5430/** @type {string} */
5431BlockingResponse.prototype.redirectUrl;
5432
5433
5434/** @type {!HttpHeaders_} */
5435BlockingResponse.prototype.requestHeaders;
5436
5437
5438/** @type {!HttpHeaders_} */
5439BlockingResponse.prototype.responseHeaders;
5440
5441
5442/** @type {Object.<string,string>} */
5443BlockingResponse.prototype.authCredentials;
5444
5445
5446
5447/**
5448 * @see http://developer.chrome.com/extensions/pushMessaging.html#type-Message
5449 * @constructor
5450 */
5451chrome.pushMessaging.Message = function() {};
5452
5453
5454/**
5455 * @type {number}
5456 */
5457chrome.pushMessaging.Message.prototype.subchannelId;
5458
5459
5460/**
5461 * @type {string}
5462 */
5463chrome.pushMessaging.Message.prototype.payload;
5464
5465
5466
5467/**
5468 * @see http://developer.chrome.com/extensions/pushMessaging.html#type-ChannelIdResult
5469 * @constructor
5470 */
5471chrome.pushMessaging.ChannelIdResult = function() {};
5472
5473
5474/**
5475 * @type {string}
5476 */
5477chrome.pushMessaging.ChannelIdResult.prototype.channelId;
5478
5479
5480/**
5481 * The {@code chrome.fileSystem} API makes use of the Entry and FileEntry types
5482 * defined in {@code javascript/externs/fileapi.js}.
5483 * @const
5484 * @see http://developer.chrome.com/apps/fileSystem.html
5485 */
5486chrome.fileSystem = {};
5487
5488
5489/**
5490 * @param {!Entry} entry The entry to get the display path for. The entry can
5491 *     originally be obtained through
5492 *     {@code chrome.fileSystem.chooseEntry} or
5493 *     {@code chrome.fileSystem.restoreEntry}.
5494 * @param {function(string)} callback A success callback.
5495 * @see http://developer.chrome.com/apps/fileSystem.html#method-getDisplayPath
5496 */
5497chrome.fileSystem.getDisplayPath = function(entry, callback) {};
5498
5499
5500/**
5501 * @param {!Entry} entry The entry to get a writable entry for.
5502 * @param {function(!Entry)} callback A success callback.
5503 * @see http://developer.chrome.com/apps/fileSystem.html#method-getWritableEntry
5504 */
5505chrome.fileSystem.getWritableEntry = function(entry, callback) {};
5506
5507
5508/**
5509 * @param {!Entry} entry The entry to query writability.
5510 * @param {function(boolean)} callback A success callback.
5511 * @see http://developer.chrome.com/apps/fileSystem.html#method-isWritableEntry
5512 */
5513chrome.fileSystem.isWritableEntry = function(entry, callback) {};
5514
5515
5516/**
5517 * @typedef {{
5518 *   description: (string|undefined),
5519 *   mimeTypes: (!Array.<string>|undefined),
5520 *   extensions: (!Array.<string>|undefined)
5521 * }}
5522 * @see http://developer.chrome.com/apps/fileSystem.html#method-chooseEntry
5523 */
5524chrome.fileSystem.AcceptsOption;
5525
5526
5527/**
5528 * @typedef {{
5529 *   type: (string|undefined),
5530 *   suggestedName: (string|undefined),
5531 *   accepts: (!Array.<!chrome.fileSystem.AcceptsOption>|undefined),
5532 *   acceptsAllTypes: (boolean|undefined),
5533 *   acceptsMultiple: (boolean|undefined)
5534 * }}
5535 * @see http://developer.chrome.com/apps/fileSystem.html#method-chooseEntry
5536 */
5537chrome.fileSystem.ChooseEntryOptions;
5538
5539
5540/**
5541 * @param {!chrome.fileSystem.ChooseEntryOptions|
5542 *     function(Entry=, !Array.<!FileEntry>=)} optionsOrCallback The
5543 *     options for the file prompt or the callback.
5544 * @param {function(Entry=, !Array.<!FileEntry>=)=} opt_callback A success
5545 *     callback, if arg1 is options.
5546 * @see http://developer.chrome.com/apps/fileSystem.html#method-chooseEntry
5547 */
5548chrome.fileSystem.chooseEntry = function(optionsOrCallback, opt_callback) {};
5549
5550
5551/**
5552 * @param {string} id The ID of the file entry to restore.
5553 * @param {function(!Entry)} callback A success callback.
5554 * @see http://developer.chrome.com/apps/fileSystem.html#method-restoreEntry
5555 */
5556chrome.fileSystem.restoreEntry = function(id, callback) {};
5557
5558
5559/**
5560 * @param {string} id The ID of the file entry to query restorability.
5561 * @param {function(boolean)} callback A success callback.
5562 * @see http://developer.chrome.com/apps/fileSystem.html#method-isRestorable
5563 */
5564chrome.fileSystem.isRestorable = function(id, callback) {};
5565
5566
5567/**
5568 * @param {!Entry} entry The entry to regain access to.
5569 * @return {string} The ID that can be passed to restoreEntry to regain access
5570 *     to the given file entry.
5571 * @see http://developer.chrome.com/apps/fileSystem.html#method-retainEntry
5572 */
5573chrome.fileSystem.retainEntry = function(entry) {};
5574
5575
5576/**
5577 * @const
5578 * @see http://developer.chrome.com/extensions/alarms.html
5579 */
5580chrome.alarms = {};
5581
5582
5583/**
5584 * Creates an alarm. Near the time(s) specified by alarmInfo, the onAlarm event
5585 * is fired. If there is another alarm with the same name (or no name if none is
5586 * specified), it will be cancelled and replaced by this alarm.
5587 * @param {string|!chrome.alarms.AlarmCreateInfo} nameOrAlarmCreateInfo Either
5588 *     the name to identify this alarm or the info used to create the alarm. If
5589 *     no name is passed, the empty string is used to identify the alarm.
5590 * @param {!chrome.alarms.AlarmCreateInfo=} opt_alarmInfo If a name was passed
5591 *     as arg1, the info used to create the alarm.
5592 * @see http://developer.chrome.com/extensions/alarms.html#method-create
5593 */
5594chrome.alarms.create = function(nameOrAlarmCreateInfo, opt_alarmInfo) {};
5595
5596
5597/**
5598 * Retrieves details about the specified alarm.
5599 * @param {string|function(!chrome.alarms.Alarm)} nameOrCallback The name
5600 *     of the alarm to get or the callback to invoke with the alarm. If no name
5601 *     is passed, the empty string is used to get the alarm.
5602 * @param {function(!chrome.alarms.Alarm)=} opt_callback If a name was passed
5603 *     as arg1, the callback to invoke with the alarm.
5604 * @see http://developer.chrome.com/extensions/alarms.html#method-get
5605 */
5606chrome.alarms.get = function(nameOrCallback, opt_callback) {};
5607
5608
5609/**
5610 * Gets an array of all the alarms.
5611 * @param {function(!Array.<!chrome.alarms.Alarm>)} callback
5612 * @see http://developer.chrome.com/extensions/alarms.html#method-getAll
5613 */
5614chrome.alarms.getAll = function(callback) {};
5615
5616
5617/**
5618 * Clears the alarm with the given name.
5619 * @param {string=} opt_name
5620 * @see http://developer.chrome.com/extensions/alarms.html#method-clear
5621 */
5622chrome.alarms.clear = function(opt_name) {};
5623
5624
5625/**
5626 * Clears all alarms.
5627 * @see http://developer.chrome.com/extensions/alarms.html#method-clearAll
5628 */
5629chrome.alarms.clearAll = function() {};
5630
5631
5632/**
5633 * Fired when an alarm has elapsed. Useful for event pages.
5634 * @type {!chrome.alarms.AlarmEvent}
5635 * @see http://developer.chrome.com/extensions/alarms.html#event-onAlarm
5636 */
5637chrome.alarms.onAlarm;
5638
5639
5640
5641/**
5642 * @constructor
5643 */
5644chrome.alarms.AlarmEvent = function() {};
5645
5646
5647/**
5648 * @param {function(!chrome.alarms.Alarm): void} callback
5649 */
5650chrome.alarms.AlarmEvent.prototype.addListener = function(callback) {};
5651
5652
5653/**
5654 * @param {function(!chrome.alarms.Alarm): void} callback
5655 */
5656chrome.alarms.AlarmEvent.prototype.removeListener = function(callback) {};
5657
5658
5659/**
5660 * @param {function(!chrome.alarms.Alarm): void} callback
5661 * @return {boolean}
5662 */
5663chrome.alarms.AlarmEvent.prototype.hasListener = function(callback) {};
5664
5665
5666/**
5667 * @return {boolean}
5668 */
5669chrome.alarms.AlarmEvent.prototype.hasListeners = function() {};
5670
5671
5672
5673/**
5674 * @interface
5675 * @see http://developer.chrome.com/extensions/alarms.html#type-Alarm
5676 */
5677chrome.alarms.Alarm = function() {};
5678
5679
5680/**
5681 * Name of this alarm.
5682 * @type {string}
5683 */
5684chrome.alarms.Alarm.prototype.name;
5685
5686
5687/**
5688 * Time at which this alarm was scheduled to fire, in milliseconds past the
5689 * epoch (e.g. Date.now() + n). For performance reasons, the alarm may have been
5690 * delayed an arbitrary amount beyond this.
5691 * @type {number}
5692 */
5693chrome.alarms.Alarm.prototype.scheduledTime;
5694
5695
5696/**
5697 * If not null, the alarm is a repeating alarm and will fire again in
5698 * periodInMinutes minutes.
5699 * @type {?number}
5700 */
5701chrome.alarms.Alarm.prototype.periodInMinutes;
5702
5703
5704/**
5705 * @typedef {{
5706 *   when: (number|undefined),
5707 *   delayInMinutes: (number|undefined),
5708 *   periodInMinutes: (number|undefined)
5709 * }}
5710 * @see http://developer.chrome.com/extensions/alarms.html#method-create
5711 */
5712chrome.alarms.AlarmCreateInfo;
5713
5714
5715/**
5716 * @see https://developer.chrome.com/apps/hid
5717 * @const
5718 */
5719chrome.hid = {};
5720
5721
5722/**
5723 * @typedef {?{
5724 *   vendorId: number,
5725 *   productId: number
5726 * }}
5727 * @see https://developer.chrome.com/apps/hid#method-getDevices
5728 */
5729chrome.hid.HidGetDevicesOptions;
5730
5731/**
5732 * @typedef {?{
5733 *   usagePage: number,
5734 *   usage: number,
5735 *   reportIds: !Array.<number>
5736 * }}
5737* @see https://developer.chrome.com/apps/hid#method-getDevices
5738*/
5739chrome.hid.HidDeviceUsage;
5740
5741/**
5742 * @typedef {?{
5743 *   deviceId: number,
5744 *   vendorId: number,
5745 *   productId: number,
5746 *   collections: !Array.<!chrome.hid.HidDeviceUsage>,
5747 *   maxInputReportSize: number,
5748 *   maxOutputReportSize: number,
5749 *   maxFeatureReportSize: number
5750 * }}
5751* @see https://developer.chrome.com/apps/hid#method-getDevices
5752*/
5753chrome.hid.HidDeviceInfo;
5754
5755
5756/**
5757 * @typedef {?{
5758 *   connectionId: number
5759 * }}
5760 * @see https://developer.chrome.com/apps/hid#method-connect
5761 */
5762chrome.hid.HidConnectInfo;
5763
5764
5765/**
5766 * @see https://developer.chrome.com/apps/hid#method-getDevices
5767 * Enumerates all the connected HID devices specified by the
5768 * vendorId/productId/interfaceId tuple.
5769 * @param {!chrome.hid.HidGetDevicesOptions} options The properties to search
5770 *     for on target devices.
5771 * @param {function(!Array.<!Object>)} callback Invoked with a list of
5772 *     |HidDeviceInfo|s on complete.
5773 */
5774chrome.hid.getDevices = function(options, callback) {};
5775
5776
5777/**
5778 * @see https://developer.chrome.com/apps/hid#method-connect
5779 * Opens a connection to a HID device for communication.
5780 * @param {number} deviceId The ID of the device to open.
5781 * @param {function(!Object=)} callback Invoked with an |HidConnectInfo| if the
5782 *     connection succeeds, or undefined if it fails.
5783 */
5784chrome.hid.connect = function(deviceId, callback) {};
5785
5786
5787/**
5788 * @see https://developer.chrome.com/apps/hid#method-disconnect
5789 * Disconnects from a device.
5790 * @param {number} connectionId The connection to close.
5791 * @param {function()=} opt_callback The callback to invoke once the connection
5792 *     is closed.
5793 */
5794chrome.hid.disconnect = function(connectionId, opt_callback) {};
5795
5796
5797/**
5798 * @see https://developer.chrome.com/apps/hid#method-receive
5799 * Receives an input report from an HID device.
5800 * @param {number} connectionId The connection from which to receive the report.
5801 * @param {function(number, !ArrayBuffer)} callback The callback to invoke with
5802 *     the received report.
5803 */
5804chrome.hid.receive = function(connectionId, callback) {};
5805
5806
5807/**
5808 * @see https://developer.chrome.com/apps/hid#method-send
5809 * Sends an output report to an HID device.
5810 * @param {number} connectionId The connection to which to send the report.
5811 * @param {number} reportId The report ID to use, or 0 if none.
5812 * @param {!ArrayBuffer} data The report data.
5813 * @param {function()} callback The callback to invoke once the write is
5814 *     finished.
5815 */
5816chrome.hid.send = function(connectionId, reportId, data, callback) {};
5817
5818
5819/**
5820 * @see https://developer.chrome.com/apps/hid#method-receiveFeatureReport
5821 * Receives a feature report from the device.
5822 * @param {number} connectionId The connection from which to read the feature
5823 *     report.
5824 * @param {number} reportId The report ID to use, or 0 if none.
5825 * @param {number} size The size of the feature report to receive.
5826 * @param {function(!ArrayBuffer)} callback The callback to invoke with the
5827 *     received report.
5828 */
5829chrome.hid.receiveFeatureReport =
5830    function(connectionId, reportId, size, callback) {};
5831
5832
5833/**
5834 * @see https://developer.chrome.com/apps/hid#method-sendFeatureReport
5835 * Sends a feature report to the device.
5836 * @param {number} connectionId The connection to which to send the feature
5837 *     report.
5838 * @param {number} reportId The report ID to use, or 0 if none.
5839 * @param {!ArrayBuffer} data The report data.
5840 * @param {function()} callback The callback to invoke once the write is
5841 *     finished.
5842 */
5843chrome.hid.sendFeatureReport =
5844    function(connectionId, reportId, data, callback) {};
5845
5846
5847/**
5848 * @see http://developer.chrome.com/extensions/notifications.html
5849 * @const
5850 */
5851chrome.notifications = {};
5852
5853
5854/**
5855 * @typedef {{
5856 *   title: string,
5857 *   iconUrl: (string|undefined)
5858 * }}
5859 * @see http://developer.chrome.com/extensions/notifications.html#type-NotificationOptions
5860 */
5861chrome.notifications.NotificationButton;
5862
5863
5864/**
5865 * @typedef {{
5866 *   title: string,
5867 *   message: string
5868 * }}
5869 * @see http://developer.chrome.com/extensions/notifications.html#type-NotificationOptions
5870 */
5871chrome.notifications.NotificationItem;
5872
5873
5874/**
5875 * @typedef {{
5876 *   type: (string|undefined),
5877 *   iconUrl: (string|undefined),
5878 *   title: (string|undefined),
5879 *   message: (string|undefined),
5880 *   contextMessage: (string|undefined),
5881 *   priority: (number|undefined),
5882 *   eventTime: (number|undefined),
5883 *   buttons: (!Array.<!chrome.notifications.NotificationButton>|undefined),
5884 *   imageUrl: (string|undefined),
5885 *   items: (!Array.<!chrome.notifications.NotificationItem>|undefined),
5886 *   progress: (number|undefined),
5887 *   isClickable: (boolean|undefined)
5888 * }}
5889 * @see http://developer.chrome.com/extensions/notifications.html#type-NotificationOptions
5890 */
5891chrome.notifications.NotificationOptions;
5892
5893
5894/**
5895 * @typedef {function(string): void}
5896 * @see http://developer.chrome.com/extensions/notifications.html#method-create
5897 * @see http://developer.chrome.com/extensions/notifications.html#event-onClicked
5898 */
5899chrome.notifications.StringCallback;
5900
5901
5902/**
5903 * @typedef {function(boolean): void}
5904 * @see http://developer.chrome.com/extensions/notifications.html#method-update
5905 * @see http://developer.chrome.com/extensions/notifications.html#method-clear
5906 */
5907chrome.notifications.BooleanCallback;
5908
5909
5910/**
5911 * @typedef {function(!Object): void}
5912 * @see http://developer.chrome.com/extensions/notifications.html#method-getAll
5913 */
5914chrome.notifications.ObjectCallback;
5915
5916
5917/**
5918 * @typedef {function(string, boolean): void}
5919 * @see http://developer.chrome.com/extensions/notifications.html#event-onClosed
5920 */
5921chrome.notifications.ClosedCallback;
5922
5923
5924/**
5925 * @typedef {function(string, number): void}
5926 * @see http://developer.chrome.com/extensions/notifications.html#event-onButtonClicked
5927 */
5928chrome.notifications.ButtonCallback;
5929
5930
5931/**
5932 * @param {string} notificationId
5933 * @param {!chrome.notifications.NotificationOptions} options
5934 * @param {!chrome.notifications.StringCallback} callback
5935 * @see http://developer.chrome.com/extensions/notifications.html#method-create
5936 */
5937chrome.notifications.create = function(notificationId, options, callback) {};
5938
5939
5940/**
5941 * @param {string} notificationId
5942 * @param {!chrome.notifications.NotificationOptions} options
5943 * @param {!chrome.notifications.BooleanCallback} callback
5944 * @see http://developer.chrome.com/extensions/notifications.html#method-update
5945 */
5946chrome.notifications.update = function(notificationId, options, callback) {};
5947
5948
5949/**
5950 * @param {string} notificationId
5951 * @param {!chrome.notifications.BooleanCallback} callback
5952 * @see http://developer.chrome.com/extensions/notifications.html#method-clear
5953 */
5954chrome.notifications.clear = function(notificationId, callback) {};
5955
5956
5957/**
5958 * @see http://developer.chrome.com/extensions/notifications.html#method-getAll
5959 * @param {!chrome.notifications.ObjectCallback} callback
5960 */
5961chrome.notifications.getAll = function(callback) {};
5962
5963
5964/**
5965 * @see http://developer.chrome.com/extensions/notifications.html#method-getPermissionLevel
5966 * @param {function(string)} callback takes 'granted' or 'denied'
5967 */
5968chrome.notifications.getPermissionLevel = function(callback) {};
5969
5970
5971/**
5972 * @type {!chrome.notifications.ClosedEvent}
5973 * @see http://developer.chrome.com/extensions/notifications.html#event-onClosed
5974 */
5975chrome.notifications.onClosed;
5976
5977
5978/**
5979 * @type {!chrome.notifications.ClickedEvent}
5980 * @see http://developer.chrome.com/extensions/notifications.html#event-onClicked
5981 */
5982chrome.notifications.onClicked;
5983
5984
5985/**
5986 * @type {!chrome.notifications.ButtonClickedEvent}
5987 * @see http://developer.chrome.com/extensions/notifications.html#event-onButtonClicked
5988 */
5989chrome.notifications.onButtonClicked;
5990
5991
5992
5993/**
5994 * @interface
5995 * @see http://developer.chrome.com/extensions/notifications.html#event-onClosed
5996 */
5997chrome.notifications.ClosedEvent = function() {};
5998
5999
6000/**
6001 * @param {!chrome.notifications.ClosedCallback} callback
6002 */
6003chrome.notifications.ClosedEvent.prototype.addListener = function(callback) {};
6004
6005
6006/**
6007 * @param {!chrome.notifications.ClosedCallback} callback
6008 */
6009chrome.notifications.ClosedEvent.prototype.removeListener =
6010    function(callback) {};
6011
6012
6013/**
6014 * @param {!chrome.notifications.ClosedCallback} callback
6015 * @return {boolean}
6016 */
6017chrome.notifications.ClosedEvent.prototype.hasListener = function(callback) {};
6018
6019
6020/**
6021 * @return {boolean}
6022 */
6023chrome.notifications.ClosedEvent.prototype.hasListeners = function() {};
6024
6025
6026
6027/**
6028 * @interface
6029 * @see http://developer.chrome.com/extensions/notifications.html#event-onClicked
6030 */
6031chrome.notifications.ClickedEvent = function() {};
6032
6033
6034/**
6035 * @param {!chrome.notifications.StringCallback} callback
6036 */
6037chrome.notifications.ClickedEvent.prototype.addListener = function(callback) {};
6038
6039
6040/**
6041 * @param {!chrome.notifications.StringCallback} callback
6042 */
6043chrome.notifications.ClickedEvent.prototype.removeListener =
6044    function(callback) {};
6045
6046
6047/**
6048 * @param {!chrome.notifications.StringCallback} callback
6049 * @return {boolean}
6050 */
6051chrome.notifications.ClickedEvent.prototype.hasListener = function(callback) {};
6052
6053
6054/**
6055 * @return {boolean}
6056 */
6057chrome.notifications.ClickedEvent.prototype.hasListeners = function() {};
6058
6059
6060
6061/**
6062 * @interface
6063 * @see http://developer.chrome.com/extensions/notifications.html#event-onButtonClicked
6064 */
6065chrome.notifications.ButtonClickedEvent = function() {};
6066
6067
6068/**
6069 * @param {!chrome.notifications.ButtonCallback} callback
6070 */
6071chrome.notifications.ButtonClickedEvent.prototype.addListener =
6072    function(callback) {};
6073
6074
6075/**
6076 * @param {!chrome.notifications.ButtonCallback} callback
6077 */
6078chrome.notifications.ButtonClickedEvent.prototype.removeListener =
6079    function(callback) {};
6080
6081
6082/**
6083 * @param {!chrome.notifications.ButtonCallback} callback
6084 * @return {boolean}
6085 */
6086chrome.notifications.ButtonClickedEvent.prototype.hasListener =
6087    function(callback) {};
6088
6089
6090/**
6091 * @return {boolean}
6092 */
6093chrome.notifications.ButtonClickedEvent.prototype.hasListeners = function() {};
6094
6095
6096
6097/**
6098 * @const
6099 * @see http://developer.chrome.com/apps/system_storage.html
6100 */
6101chrome.system.storage = {};
6102
6103
6104
6105/** @constructor */
6106chrome.system.storage.StorageUnitInfo = function() {};
6107
6108
6109/** @type {string} */
6110chrome.system.storage.StorageUnitInfo.id;
6111
6112
6113/** @type {string} */
6114chrome.system.storage.StorageUnitInfo.name;
6115
6116
6117/** @type {string} Any of 'fixed', 'removable', or 'unknown' */
6118chrome.system.storage.StorageUnitInfo.type;
6119
6120
6121/** @type {number} */
6122chrome.system.storage.StorageUnitInfo.capacity;
6123
6124
6125
6126/**
6127 * Event whose listeners take a StorageUnitInfoEvent parameter.
6128 * @constructor
6129 */
6130chrome.system.storage.StorageUnitInfoEvent = function() {};
6131
6132
6133/** @param {function(!chrome.system.storage.StorageUnitInfo): void} callback */
6134chrome.system.storage.StorageUnitInfoEvent.prototype.addListener =
6135    function(callback) {};
6136
6137
6138/** @param {function(!chrome.system.storage.StorageUnitInfo): void} callback */
6139chrome.system.storage.StorageUnitInfoEvent.prototype.removeListener =
6140    function(callback) {};
6141
6142
6143/**
6144 * @param {function(!chrome.system.storage.StorageUnitInfo): void} callback
6145 * @return {boolean}
6146 */
6147chrome.system.storage.StorageUnitInfoEvent.prototype.hasListener =
6148    function(callback) {};
6149
6150
6151/** @return {boolean} */
6152chrome.system.storage.StorageUnitInfoEvent.prototype.hasListeners =
6153    function() {};
6154
6155
6156/** @type {chrome.system.storage.StorageUnitInfoEvent} */
6157chrome.system.storage.onAttached;
6158
6159
6160/** @type {!ChromeStringEvent} */
6161chrome.system.storage.onDetached;
6162
6163
6164/**
6165 * Gets the storage information from the system.
6166 * @param {function(!Array.<!chrome.system.storage.StorageUnitInfo>)} callback
6167 */
6168chrome.system.storage.getInfo = function(callback) {};
6169
6170
6171/**
6172 * Ejects a removable storage device.
6173 * @param {string} id The transient device ID from StorageUnitInfo.
6174 * @param {function(string)} callback Callback function where the value
6175 *     is any of: "success", "in_use", "no_such_device", "failure"
6176 */
6177chrome.system.storage.ejectDevice = function(id, callback) {};
6178
6179
6180/**
6181 * Gets the available capacity of a specified storage device.
6182 * @param {string} id The transient device ID from StorageUnitInfo.
6183 * @param {function(Object.<string, number>)} callback A callback function that
6184 *     accepts an object with {@code id} and {@code availableCapacity} fields.
6185 */
6186chrome.system.storage.getAvailableCapacity = function(id, callback) {};
6187
6188
6189/**
6190 * @see http://developer.chrome.com/apps/usb.html
6191 * @const
6192 */
6193chrome.usb = {};
6194
6195
6196
6197/** @constructor */
6198chrome.usb.Device = function Device() {};
6199
6200
6201/** @type {number} */
6202chrome.usb.Device.prototype.device;
6203
6204
6205/** @type {number} */
6206chrome.usb.Device.prototype.vendorId;
6207
6208
6209/** @type {number} */
6210chrome.usb.Device.prototype.productId;
6211
6212
6213
6214/** @constructor */
6215chrome.usb.ConnectionHandle = function ConnectionHandle() {};
6216
6217
6218/** @type {number} */
6219chrome.usb.ConnectionHandle.prototype.handle;
6220
6221
6222/** @type {number} */
6223chrome.usb.ConnectionHandle.prototype.vendorId;
6224
6225
6226/** @type {number} */
6227chrome.usb.ConnectionHandle.prototype.productId;
6228
6229
6230
6231/**
6232 * @typedef {?{
6233 *   direction: string,
6234 *   endpoint: number,
6235 *   length: (number|undefined),
6236 *   data: (!ArrayBuffer|undefined)
6237 * }}
6238 */
6239chrome.usb.GenericTransferInfo;
6240
6241
6242/**
6243 * @typedef {?{
6244 *   direction: string,
6245 *   recipient: string,
6246 *   requestType: string,
6247 *   request: number,
6248 *   value: number,
6249 *   index: number,
6250 *   length: (number|undefined),
6251 *   data: (!ArrayBuffer|undefined)
6252 * }}
6253 */
6254chrome.usb.ControlTransferInfo;
6255
6256
6257
6258/** @constructor */
6259chrome.usb.TransferResultInfo = function() {};
6260
6261
6262/** @type {number|undefined} */
6263chrome.usb.TransferResultInfo.prototype.resultCode;
6264
6265
6266/** @type {!ArrayBuffer|undefined} */
6267chrome.usb.TransferResultInfo.prototype.data;
6268
6269
6270/**
6271 * @typedef {?{
6272 *   deviceId: number,
6273 *   productId: number,
6274 *   interfaceId: (number|undefined)
6275 * }}
6276 */
6277chrome.usb.FindDevicesOptions;
6278
6279
6280/**
6281 * @see http://developer.chrome.com/apps/usb.html#method-getDevices
6282 * @param {!Object} options The properties to search for on target devices.
6283 * @param {function(!Array.<!chrome.usb.Device>)} callback Invoked with a list
6284 *     of |Device|s on complete.
6285 */
6286chrome.usb.getDevices = function(options, callback) {};
6287
6288
6289/**
6290 * @see http://developer.chrome.com/apps/usb.html#method-requestAccess
6291 * @param {!chrome.usb.Device} device The device to request access to.
6292 * @param {number} interfaceId
6293 * @param {function(boolean)} callback
6294 */
6295chrome.usb.requestAccess = function(device, interfaceId, callback) {};
6296
6297
6298/**
6299 * @see http://developer.chrome.com/apps/usb.html#method-openDevice
6300 * @param {!chrome.usb.Device} device The device to open.
6301 * @param {function(!chrome.usb.ConnectionHandle=)} callback Invoked with the
6302 *     created ConnectionHandle on complete.
6303 */
6304chrome.usb.openDevice = function(device, callback) {};
6305
6306
6307/**
6308 * @see http://developer.chrome.com/apps/usb.html#method-findDevices
6309 * @param {!chrome.usb.FindDevicesOptions} options The properties to search for
6310 *     on target devices.
6311 * @param {function(!Array.<!chrome.usb.ConnectionHandle>)} callback Invoked
6312 *     with the opened ConnectionHandle on complete.
6313 */
6314chrome.usb.findDevices = function(options, callback) {};
6315
6316
6317/**
6318 * @see http://developer.chrome.com/apps/usb.html#method-closeDevice
6319 * @param {!chrome.usb.ConnectionHandle} handle The connection handle to close.
6320 * @param {function()=} opt_callback The callback to invoke once the device is
6321 *     closed.
6322 */
6323chrome.usb.closeDevice = function(handle, opt_callback) {};
6324
6325
6326/**
6327 * @see http://developer.chrome.com/apps/usb.html#method-listInterfaces
6328 * @param {!chrome.usb.ConnectionHandle} handle The device from which the
6329 *     interfaces should be listed.
6330 * @param {function(!Array.<!Object>)} callback
6331 *     The callback to invoke when the interfaces are enumerated.
6332 */
6333chrome.usb.listInterfaces = function(handle, callback) {};
6334
6335
6336/**
6337 * @see http://developer.chrome.com/apps/usb.html#method-claimInterface
6338 * @param {!chrome.usb.ConnectionHandle} handle The device on which the
6339 *     interface is to be claimed.
6340 * @param {number} interfaceNumber
6341 * @param {function()} callback The callback to invoke once the interface is
6342 *     claimed.
6343 */
6344chrome.usb.claimInterface = function(handle, interfaceNumber, callback) {};
6345
6346
6347/**
6348 * @see http://developer.chrome.com/apps/usb.html#method-releaseInterface
6349 * @param {!chrome.usb.ConnectionHandle} handle The device on which the
6350 *     interface is to be released.
6351 * @param {number} interfaceNumber
6352 * @param {function()} callback The callback to invoke once the interface is
6353 *     released.
6354 */
6355chrome.usb.releaseInterface = function(handle, interfaceNumber, callback) {};
6356
6357
6358/**
6359 * @see http://developer.chrome.com/apps/usb.html#method-setInterfaceAlternateSetting
6360 * @param {!chrome.usb.ConnectionHandle} handle The device on which the
6361 *     interface settings are to be set.
6362 * @param {number} interfaceNumber
6363 * @param {number} alternateSetting The alternate setting to set.
6364 * @param {function()} callback The callback to invoke once the interface
6365 *     setting is set.
6366 */
6367chrome.usb.setInterfaceAlternateSetting = function(
6368    handle, interfaceNumber, alternateSetting, callback) {};
6369
6370
6371/**
6372 * @see http://developer.chrome.com/apps/usb.html#method-controlTransfer
6373 * @param {!chrome.usb.ConnectionHandle} handle A connection handle to make the
6374 *     transfer on.
6375 * @param {!chrome.usb.ControlTransferInfo} transferInfo The parameters to the
6376 *     transfer.
6377 * @param {function(!chrome.usb.TransferResultInfo)} callback Invoked once the
6378 *     transfer has completed.
6379 */
6380chrome.usb.controlTransfer = function(handle, transferInfo, callback) {};
6381
6382
6383/**
6384 * @see http://developer.chrome.com/apps/usb.html#method-bulkTransfer
6385 * @param {!chrome.usb.ConnectionHandle} handle A connection handle to make
6386 *     the transfer on.
6387 * @param {!chrome.usb.GenericTransferInfo} transferInfo The parameters to the
6388 *     transfer. See GenericTransferInfo.
6389 * @param {function(!chrome.usb.TransferResultInfo)} callback Invoked once the
6390 *     transfer has completed.
6391 */
6392chrome.usb.bulkTransfer = function(handle, transferInfo, callback) {};
6393
6394
6395/**
6396 * @see http://developer.chrome.com/apps/usb.html#method-interruptTransfer
6397 * @param {!chrome.usb.ConnectionHandle} handle A connection handle to make the
6398 *     transfer on.
6399 * @param {!chrome.usb.GenericTransferInfo} transferInfo The parameters to the
6400 *     transfer. See GenericTransferInfo.
6401 * @param {function(!chrome.usb.TransferResultInfo)} callback Invoked once the
6402 *     transfer has completed.
6403 */
6404chrome.usb.interruptTransfer = function(handle, transferInfo, callback) {};
6405
6406
6407/**
6408 * @see http://developer.chrome.com/apps/usb.html#method-isochronousTransfer
6409 * @param {!chrome.usb.ConnectionHandle} handle A connection handle to make the
6410 *     transfer on.
6411 * @param {!Object} transferInfo The parameters to the transfer. See
6412 *     IsochronousTransferInfo.
6413 * @param {function(!chrome.usb.TransferResultInfo)} callback Invoked once the
6414 *     transfer has been completed.
6415 */
6416chrome.usb.isochronousTransfer = function(handle, transferInfo, callback) {};
6417
6418
6419/**
6420 * @see http://developer.chrome.com/apps/usb.html#method-resetDevice
6421 * @param {!chrome.usb.ConnectionHandle} handle A connection handle to reset.
6422 * @param {function(boolean)} callback Invoked once the device is reset with a
6423 *     boolean indicating whether the reset completed successfully.
6424 */
6425chrome.usb.resetDevice = function(handle, callback) {};
6426
6427
6428/**
6429 * @const
6430 * @see https://developer.chrome.com/apps/webstore
6431 */
6432chrome.webstore = {};
6433
6434
6435/**
6436 * @param {string|function()|function(string)=}
6437 *     opt_urlOrSuccessCallbackOrFailureCallback Either the URL to install or
6438 *     the succcess callback taking no arg or the failure callback taking an
6439 *     error string arg.
6440 * @param {function()|function(string)=} opt_successCallbackOrFailureCallback
6441 *     Either the succcess callback taking no arg or the failure callback
6442 *     taking an error string arg.
6443 * @param {function(string)=} opt_failureCallback The failure callback.
6444 */
6445chrome.webstore.install = function(
6446    opt_urlOrSuccessCallbackOrFailureCallback,
6447    opt_successCallbackOrFailureCallback,
6448    opt_failureCallback) {};
6449
6450
6451/** @type {!ChromeStringEvent} */
6452chrome.webstore.onInstallStageChanged;
6453
6454
6455/** @type {!ChromeNumberEvent} */
6456chrome.webstore.onDownloadProgress;
6457
6458
6459////////////////////////////////////////////////////////////////////////////////
6460/////////////////////////// Chrome Private APIs ////////////////////////////////
6461////////////////////////////////////////////////////////////////////////////////
6462
6463
6464/** @const */
6465chrome.screenlockPrivate = {};
6466
6467
6468/**
6469 * @param {string} message Displayed on the unlock screen.
6470 */
6471chrome.screenlockPrivate.showMessage = function(message) {};
6472
6473
6474/**
6475 * @param {function(boolean)} callback
6476 */
6477chrome.screenlockPrivate.getLocked = function(callback) {};
6478
6479
6480/**
6481 * @param {boolean} locked If true and the screen is unlocked, locks the screen.
6482 *     If false and the screen is locked, unlocks the screen.
6483 */
6484chrome.screenlockPrivate.setLocked = function(locked) {};
6485
6486
6487/** @type {!ChromeBooleanEvent} */
6488chrome.screenlockPrivate.onChanged;
6489
6490
6491/**
6492 * @const
6493 */
6494chrome.musicManagerPrivate = {};
6495
6496
6497/**
6498 * @param {function(string): void} callback
6499 */
6500chrome.musicManagerPrivate.getDeviceId = function(callback) {};
6501
6502
6503/**
6504 * @const
6505 */
6506chrome.mediaGalleriesPrivate = {};
6507
6508
6509/**
6510 * @typedef {function({deviceId: string, deviceName: string}): void}
6511 */
6512chrome.mediaGalleriesPrivate.DeviceCallback;
6513
6514
6515/**
6516 * @typedef {function({galleryId: string}): void}
6517 */
6518chrome.mediaGalleriesPrivate.GalleryChangeCallback;
6519
6520
6521/**
6522 * @typedef {function({galleryId: string, success: boolean}): void}
6523 */
6524chrome.mediaGalleriesPrivate.AddGalleryWatchCallback;
6525
6526
6527/**
6528 * @param {string} galleryId
6529 * @param {!chrome.mediaGalleriesPrivate.AddGalleryWatchCallback} callback
6530 */
6531chrome.mediaGalleriesPrivate.addGalleryWatch = function(galleryId, callback) {};
6532
6533
6534/**
6535 * @type {!chrome.mediaGalleriesPrivate.DeviceEvent}
6536 * @deprecated Use {chrome.system.storage.onAttach}.
6537 */
6538chrome.mediaGalleriesPrivate.onDeviceAttached;
6539
6540
6541/**
6542 * @type {!chrome.mediaGalleriesPrivate.DeviceEvent}
6543 * @deprecated Use {chrome.system.storage.onDetach}.
6544 */
6545chrome.mediaGalleriesPrivate.onDeviceDetached;
6546
6547
6548/**
6549 * @type {!chrome.mediaGalleriesPrivate.GalleryChangeEvent}
6550 */
6551chrome.mediaGalleriesPrivate.onGalleryChanged;
6552
6553
6554
6555/**
6556 * @interface
6557 * @deprecated Use {chrome.system.storage.DeviceEvent}.
6558 */
6559chrome.mediaGalleriesPrivate.DeviceEvent = function() {};
6560
6561
6562/**
6563 * @param {!chrome.mediaGalleriesPrivate.DeviceCallback} callback
6564 * @deprecated Use {chrome.system.storage.DeviceEvent.addListener}.
6565 */
6566chrome.mediaGalleriesPrivate.DeviceEvent.prototype.addListener =
6567    function(callback) {};
6568
6569
6570/**
6571 * @param {!chrome.mediaGalleriesPrivate.DeviceCallback} callback
6572 * @deprecated Use {chrome.system.storage.DeviceEvent.removeListener}.
6573 */
6574chrome.mediaGalleriesPrivate.DeviceEvent.prototype.removeListener =
6575    function(callback) {};
6576
6577
6578/**
6579 * @param {!chrome.mediaGalleriesPrivate.DeviceCallback} callback
6580 * @deprecated Use {chrome.system.storage.DeviceEvent.hasListener}.
6581 */
6582chrome.mediaGalleriesPrivate.DeviceEvent.prototype.hasListener =
6583    function(callback) {};
6584
6585
6586/**
6587 * @return {boolean}
6588 * @deprecated Use {chrome.system.storage.DeviceEvent.hasListener}
6589 */
6590chrome.mediaGalleriesPrivate.DeviceEvent.prototype.hasListeners =
6591    function(callback) {};
6592
6593
6594
6595/**
6596 * @interface
6597 */
6598chrome.mediaGalleriesPrivate.GalleryChangeEvent = function() {};
6599
6600
6601/**
6602 * @param {!chrome.mediaGalleriesPrivate.GalleryChangeCallback} callback
6603 */
6604chrome.mediaGalleriesPrivate.GalleryChangeEvent.prototype.addListener =
6605    function(callback) {};
6606
6607
6608/**
6609 * @param {!chrome.mediaGalleriesPrivate.GalleryChangeCallback} callback
6610 */
6611chrome.mediaGalleriesPrivate.GalleryChangeEvent.prototype.removeListener =
6612    function(callback) {};
6613
6614
6615/**
6616 * @param {!chrome.mediaGalleriesPrivate.GalleryChangeCallback} callback
6617 */
6618chrome.mediaGalleriesPrivate.GalleryChangeEvent.prototype.hasListener =
6619    function(callback) {};
6620
6621
6622/**
6623 * @return {boolean}
6624 */
6625chrome.mediaGalleriesPrivate.GalleryChangeEvent.prototype.hasListeners =
6626    function() {};
6627
6628
6629/**
6630 * WARNING(2014/08/04): This API is still under active initial development and
6631 * unstable and has a number of issues:
6632 *
6633 * 1. The types NetworkProperties and ManagedNetworkProperties are not defined
6634 *    in the docs; that is, there is no list of fields and their types.
6635 *    Therefore, these types are treated as bags-of-objects, rather than types.
6636 * 2. According to Steven Bennetts, NetworkProperties *should* be a
6637 *    bag-of-properties as it's a map containing ONC properties and the ONC
6638 *    properties do not follow the JS field naming conventions; specifically,
6639 *    the properties start with an uppercase letter, and at least one property
6640 *    is in all uppercase.
6641 * 3. The deviceSsid and deviceBssid fields of VerticationProperties are listed
6642 *    as being required while their description mentions "Only set if" which
6643 *    sound optional. The dev team was unclear whether they are required or
6644 *    optional.
6645 * 4. Some parameters to some functions are marked as being in the Beta channel
6646 *    only (for example, the networkGuid parameter to getCaptivePortalStatus).
6647 *
6648 * Because of the above issues, this API should not be used as an example for
6649 * other APIs added to this file. Please contact mednik@ for questions on and
6650 * maintenance for this API.
6651 * @const
6652 * @see https://developer.chrome.com/extensions/networkingPrivate
6653 */
6654chrome.networkingPrivate = {};
6655
6656
6657/**
6658 * @typedef {?{
6659 *   certificate: string,
6660 *   publicKey: string,
6661 *   nonce: string,
6662 *   signedData: string,
6663 *   deviceSerial: string,
6664 *   deviceSsid: string,
6665 *   deviceBssid: string
6666 * }}
6667 */
6668chrome.networkingPrivate.VerificationProperties;
6669
6670
6671/**
6672 * @typedef {?{
6673 *   networkType: string,
6674 *   visible: (boolean|undefined),
6675 *   configured: (boolean|undefined),
6676 *   limit: (number|undefined)
6677 * }}
6678 */
6679chrome.networkingPrivate.NetworkFilter;
6680
6681
6682/**
6683 * @param {string} guid
6684 * @param {function(!Object)} callback
6685 */
6686chrome.networkingPrivate.getProperties = function(guid, callback) {};
6687
6688
6689/**
6690 * @param {string} guid
6691 * @param {function(!Object)} callback
6692 */
6693chrome.networkingPrivate.getManagedProperties = function(guid, callback) {};
6694
6695
6696/**
6697 * @param {string} guid
6698 * @param {function(!Object)} callback
6699 */
6700chrome.networkingPrivate.getState = function(guid, callback) {};
6701
6702
6703/**
6704 * @param {string} guid
6705 * @param {!Object} properties
6706 * @param {function()} callback
6707 */
6708chrome.networkingPrivate.setProperties = function(guid, properties, callback) {
6709};
6710
6711
6712/**
6713 * @param {boolean} shared
6714 * @param {!Object} properties
6715 * @param {function(string)} callback Returns guid of the configured
6716 *     configuration.
6717 */
6718chrome.networkingPrivate.createNetwork =
6719    function(shared, properties, callback) {};
6720
6721
6722/**
6723 * @param {!chrome.networkingPrivate.NetworkFilter} filter
6724 * @param {function(!Array.<!Object>)=} opt_callback
6725 */
6726chrome.networkingPrivate.getNetworks = function(filter, opt_callback) {};
6727
6728
6729/**
6730 * @param {string} type
6731 * @param {function(!Array.<!Object>)=} opt_callback
6732 */
6733chrome.networkingPrivate.getVisibleNetworks = function(type, opt_callback) {};
6734
6735
6736/** @param {function(!Array.<string>)=} opt_callback */
6737chrome.networkingPrivate.getEnabledNetworkTypes = function(opt_callback) {};
6738
6739
6740/** @param {string} networkType */
6741chrome.networkingPrivate.enableNetworkType = function(networkType) {};
6742
6743
6744/** @param {string} networkType */
6745chrome.networkingPrivate.disableNetworkType = function(networkType) {};
6746
6747
6748/**
6749 * Requests that the networking subsystem scan for new networks and update the
6750 * list returned by getVisibleNetworks.
6751 */
6752chrome.networkingPrivate.requestNetworkScan = function() {};
6753
6754
6755/**
6756 * @param {string} guid
6757 * @param {function()=} opt_callback
6758 */
6759chrome.networkingPrivate.startConnect = function(guid, opt_callback) {};
6760
6761
6762/**
6763 * @param {string} guid
6764 * @param {function()=} opt_callback
6765 */
6766chrome.networkingPrivate.startDisconnect = function(guid, opt_callback) {};
6767
6768
6769/**
6770 * @param {!chrome.networkingPrivate.VerificationProperties} verificationInfo
6771 * @param {function(boolean)} callback
6772 */
6773chrome.networkingPrivate.verifyDestination =
6774    function(verificationInfo, callback) {};
6775
6776
6777/**
6778 * @param {!chrome.networkingPrivate.VerificationProperties} verificationInfo
6779 * @param {string} guid
6780 * @param {function(string)} callback
6781 */
6782chrome.networkingPrivate.verifyAndEncryptCredentials =
6783    function(verificationInfo, guid, callback) {};
6784
6785
6786/**
6787 * @param {!chrome.networkingPrivate.VerificationProperties} verificationInfo
6788 * @param {string} data
6789 * @param {function(string)} callback
6790 */
6791chrome.networkingPrivate.verifyAndEncryptData =
6792    function(verificationInfo, data, callback) {};
6793
6794
6795/**
6796 * @param {string} ipOrMacAddress
6797 * @param {boolean} enabled
6798 * @param {function(string)} callback
6799 */
6800chrome.networkingPrivate.setWifiTDLSEnabledState =
6801    function(ipOrMacAddress, enabled, callback) {};
6802
6803
6804/**
6805 * @param {string} ipOrMacAddress
6806 * @param {function(string)} callback
6807 */
6808chrome.networkingPrivate.getWifiTDLSStatus =
6809    function(ipOrMacAddress, callback) {};
6810
6811
6812/**
6813 * @param {string} guid
6814 * @param {function(string)} callback
6815 */
6816chrome.networkingPrivate.getCaptivePortalStatus = function(guid, callback) {};
6817
6818
6819/** @type {!ChromeStringArrayEvent} */
6820chrome.networkingPrivate.onNetworksChanged;
6821
6822
6823/** @type {!ChromeStringArrayEvent} */
6824chrome.networkingPrivate.onNetworkListChanged;
6825
6826
6827/** @type {!ChromeStringStringEvent} */
6828chrome.networkingPrivate.onPortalDetectionCompleted;
6829
6830
6831/**
6832 * WARNING(2014/08/14): This API is still under active initial development and
6833 * unstable. The types are not well defined or documented, and this API
6834 * definition here should not be used as an example for other APIs added to this
6835 * file. Please contact mednik@ for questions on and maintenance for this API.
6836 * @const
6837 * @see http://goo.gl/afV8wB
6838 */
6839chrome.mdns = {};
6840
6841
6842/**
6843 * Data type sent to the event handler of chrome.mdns.onServiceList.
6844 * TODO: This one event handler data type is being made a typedef
6845 * as an experiment. This allows us to create these objects in tests to pass
6846 * to the handlers which isn't possible by using the object form.
6847 * @typedef {{
6848 *     serviceName: string,
6849 *     serviceHostPort: string,
6850 *     ipAddress: string,
6851 *     serviceData: !Array.<string>}}
6852 */
6853chrome.mdns.MdnsService;
6854
6855
6856/**
6857 * Event whose listeners take an array of MdnsService parameter.
6858 * @constructor
6859 */
6860chrome.mdns.ServiceListEvent = function() {};
6861
6862
6863/**
6864 * @param {function(!Array.<!chrome.mdns.MdnsService>): void} callback
6865 * @param {!Object=} opt_filter
6866 */
6867chrome.mdns.ServiceListEvent.prototype.addListener =
6868    function(callback, opt_filter) {};
6869
6870
6871/** @param {function(!Array.<!chrome.mdns.MdnsService>): void} callback */
6872chrome.mdns.ServiceListEvent.prototype.removeListener = function(callback) {};
6873
6874
6875/**
6876 * @param {function(!Array.<!chrome.mdns.MdnsService>): void} callback
6877 * @return {boolean}
6878 */
6879chrome.mdns.ServiceListEvent.prototype.hasListener = function(callback) {};
6880
6881
6882/** @return {boolean} */
6883chrome.mdns.ServiceListEvent.prototype.hasListeners = function() {};
6884
6885
6886/** @type {!chrome.mdns.ServiceListEvent} */
6887chrome.mdns.onServiceList;
6888
6889
6890/**
6891 * @const
6892 * @see http://goo.gl/79p5h5
6893 */
6894chrome.gcdPrivate = {};
6895
6896
6897/**
6898 * Represents a GCD device discovered locally or registered to a given user.
6899 * deviceId: Opaque device identifier to be passed to API.
6900 * setupType: How this device was discovered.
6901 * cloudId: Cloud identifier string.
6902 * deviceName: Device human readable name.
6903 * deviceType: Device type (camera, printer, etc).
6904 * deviceDescription: Device human readable description.
6905 * @typedef {?{
6906 *   deviceId: string,
6907 *   setupType: string,
6908 *   cloudId: (string|undefined),
6909 *   deviceType: string,
6910 *   deviceName: string,
6911 *   deviceDescription: string
6912 * }}
6913 */
6914chrome.gcdPrivate.Device;
6915
6916
6917/** @constructor */
6918chrome.gcdPrivate.ConfirmationInfo = function() {};
6919
6920
6921/** @type {string} */
6922chrome.gcdPrivate.ConfirmationInfo.prototype.type;
6923
6924
6925/** @type {string|undefined} */
6926chrome.gcdPrivate.ConfirmationInfo.prototype.code;
6927
6928
6929/**
6930 * Returns the list of cloud devices visible locally or available in the
6931 * cloud for user account.
6932 * @param {function(!Array.<!chrome.gcdPrivate.Device>): void} callback
6933 */
6934chrome.gcdPrivate.getCloudDeviceList = function(callback) {};
6935
6936
6937/**
6938 * Queries network for local devices. Triggers onDeviceStateChanged and
6939 * onDeviceRemoved events. Call this function *only* after registering for
6940 * onDeviceStateChanged and onDeviceRemoved events, or it will do nothing.
6941 */
6942chrome.gcdPrivate.queryForNewLocalDevices = function() {};
6943
6944
6945/**
6946 * Cache the WiFi password in the browser process for use during
6947 * provisioning. This is done to allow the gathering of the wifi password to
6948 * not be done while connected to the device's network. Callback is called
6949 * with true if wifi password was cached and false if it was unavailable.
6950 * @param {string} ssid
6951 * @param {function(boolean): void} callback
6952 */
6953chrome.gcdPrivate.prefetchWifiPassword = function(ssid, callback) {};
6954
6955
6956/**
6957 * Establish the session.
6958 * @param {string} ipAddress
6959 * @param {number} port
6960 * @param {function(number, string, !chrome.gcdPrivate.ConfirmationInfo): void}
6961 *     callback Called when the session is established or on error. 1st param,
6962 *     |sessionId|, is the session ID (identifies the session for future calls).
6963 *     2nd param, |status|, is the status (success or type of error). 3rd param,
6964 *     |confirmationInfo|, is the info about how the device handles
6965 *     confirmation.
6966 */
6967chrome.gcdPrivate.establishSession = function(ipAddress, port, callback) {};
6968
6969
6970/**
6971 * Confirm that the code is correct. Device will still need to confirm. |code|
6972 * must be present and must match the code from the device, even when the code
6973 * is supplied in the |ConfirmationInfo| object.
6974 * @param {number} sessionId
6975 * @param {string} code
6976 * @param {function(string): void} callback
6977 */
6978chrome.gcdPrivate.confirmCode = function(sessionId, code, callback) {};
6979
6980
6981/**
6982 * Send an encrypted message to the device. If the message is a setup message
6983 * with a wifi ssid specified but no password, the password cached from
6984 * prefetchWifiPassword() will be used and the call will fail if it's not
6985 * available. For open networks use an empty string as the password.
6986 * @param {number} sessionId
6987 * @param {string} api The API path.
6988 * @param {!Object} input The input message to be sent over the encrypted
6989 *     channel.
6990 * @param {function(string, ?Object): void} callback
6991 */
6992chrome.gcdPrivate.sendMessage = function(sessionId, api, input, callback) {};
6993
6994
6995/**
6996 * Terminate the session with the device.
6997 * @param {number} sessionId
6998 */
6999chrome.gcdPrivate.terminateSession = function(sessionId) {};
7000
7001
7002/**
7003 * Returns command definitions.
7004 * @param {string} deviceId The device to get command definitions for.
7005 * @param {function(!Object): void} callback The result callback.
7006 */
7007chrome.gcdPrivate.getCommandDefinitions = function(deviceId, callback) {};
7008
7009
7010/**
7011 * Creates and sends a new command.
7012 * @param {string} deviceId The device to send the command to.
7013 * @param {number} expireInMs The number of milliseconds since now before the
7014 *     command expires. An expired command should not be executed by the device.
7015 *     Acceptable values are 10 sec (10000 ms) to 30 days (2592000000 ms),
7016 *     inclusive. All values outside that range will be replaced by 30 days.
7017 * @param {!Object} command Described at
7018 *     https://developers.google.com/cloud-devices/v1/reference/commands.
7019 * @param {function(!Object): void} callback  The result callback.
7020 */
7021chrome.gcdPrivate.insertCommand = function(
7022    deviceId, expireInMs, command, callback) {};
7023
7024
7025/**
7026 * Returns a particular command.
7027 * @param {string} commandId Unique command ID.
7028 * @param {function(!Object): void} callback  The result callback.
7029 */
7030chrome.gcdPrivate.getCommand = function(commandId, callback) {};
7031
7032
7033/**
7034 * Cancels a command.
7035 * @param {string} commandId Unique command ID.
7036 * @param {function(!Object): void} callback  The result callback.
7037 */
7038chrome.gcdPrivate.cancelCommand = function(commandId, callback) {};
7039
7040
7041/**
7042 * Lists all commands in order of creation.
7043 * @param {string} deviceId The device to send the command to.
7044 * @param {string} byUser List all the commands issued by the user. Special
7045 *     value 'me' can be used to list by the current user.
7046 * @param {string} state Command state.
7047 * @param {function(!Array.<!Object>): void} callback  The result callback.
7048 */
7049chrome.gcdPrivate.getCommandsList = function(
7050    deviceId, byUser, state, callback) {};
7051
7052
7053/**
7054 * Event whose listeners take a chrome.gcdPrivate.Device.
7055 * @constructor
7056 */
7057chrome.gcdPrivate.DeviceEvent = function() {};
7058
7059
7060/** @param {function(!chrome.gcdPrivate.Device): void} callback */
7061chrome.gcdPrivate.DeviceEvent.prototype.addListener = function(callback) {};
7062
7063
7064/** @param {function(!chrome.gcdPrivate.Device): void} callback */
7065chrome.gcdPrivate.DeviceEvent.prototype.removeListener = function(callback) {};
7066
7067
7068/**
7069 * @param {function(!chrome.gcdPrivate.Device): void} callback
7070 * @return {boolean}
7071 */
7072chrome.gcdPrivate.DeviceEvent.prototype.hasListener = function(callback) {};
7073
7074
7075/** @return {boolean} */
7076chrome.gcdPrivate.DeviceEvent.prototype.hasListeners = function() {};
7077
7078
7079/**
7080 * Fires when a device's state changes. When a listener is first added, this
7081 * event fires for all known devices on the network. Afterwards, it will fire
7082 * with device status updates.
7083 * @type {!chrome.gcdPrivate.DeviceEvent}
7084 */
7085chrome.gcdPrivate.onDeviceStateChanged;
7086
7087
7088/**
7089 * Fires when a given device disappears.
7090 * |deviceId| The device that has disappeared.
7091 * @type {!ChromeStringEvent}
7092 */
7093chrome.gcdPrivate.onDeviceRemoved;
7094
7095
7096/**
7097 * @const
7098 * @see http://goo.gl/bKHibo
7099 */
7100chrome.bluetoothPrivate = {};
7101
7102
7103/** @constructor */
7104chrome.bluetoothPrivate.PairingEvent = function() {};
7105
7106
7107/** @type {string} */
7108chrome.bluetoothPrivate.PairingEvent.prototype.pairing;
7109
7110
7111/** @type {!chrome.bluetooth.Device} */
7112chrome.bluetoothPrivate.PairingEvent.prototype.device;
7113
7114
7115/** @type {string|undefined} */
7116chrome.bluetoothPrivate.PairingEvent.prototype.pincode;
7117
7118
7119/** @type {number|undefined} */
7120chrome.bluetoothPrivate.PairingEvent.prototype.passkey;
7121
7122
7123/** @type {number|undefined} */
7124chrome.bluetoothPrivate.PairingEvent.prototype.enteredKey;
7125
7126
7127/**
7128 * @typedef {{
7129 *   name: (string|undefined),
7130 *   powered: (boolean|undefined),
7131 *   discoverable: (boolean|undefined)
7132 * }}
7133 */
7134chrome.bluetoothPrivate.NewAdapterState;
7135
7136
7137/**
7138 * @typedef {{
7139 *   device: !chrome.bluetooth.Device,
7140 *   response: (string|undefined),
7141 *   pincode: (string|undefined),
7142 *   passkey: (number|undefined),
7143 *   enteredKey: (number|undefined)
7144 * }}
7145 */
7146chrome.bluetoothPrivate.SetPairingResponseOptions;
7147
7148
7149/**
7150 * @param {!chrome.bluetoothPrivate.NewAdapterState} adapterState
7151 * @param {function()} callback
7152 */
7153chrome.bluetoothPrivate.setAdapterState = function(adapterState, callback) {};
7154
7155
7156/**
7157 * @param {!chrome.bluetoothPrivate.SetPairingResponseOptions} options
7158 * @param {function()} callback
7159 */
7160chrome.bluetoothPrivate.setPairingResponse = function(options, callback) {};
7161
7162
7163/**
7164 * Event whose listeners take a PairingEvent parameter.
7165 * @constructor
7166 */
7167chrome.bluetoothPrivate.PairingEventEvent = function() {};
7168
7169
7170/** @param {function(!chrome.bluetoothPrivate.PairingEvent): void} callback */
7171chrome.bluetoothPrivate.PairingEventEvent.prototype.addListener =
7172    function(callback) {};
7173
7174
7175/** @param {function(!chrome.bluetoothPrivate.PairingEvent): void} callback */
7176chrome.bluetoothPrivate.PairingEventEvent.prototype.removeListener =
7177    function(callback) {};
7178
7179
7180/**
7181 * @param {function(!chrome.bluetoothPrivate.PairingEvent): void} callback
7182 * @return {boolean}
7183 */
7184chrome.bluetoothPrivate.PairingEventEvent.prototype.hasListener =
7185    function(callback) {};
7186
7187
7188/** @return {boolean} */
7189chrome.bluetoothPrivate.PairingEventEvent.prototype.hasListeners =
7190    function() {};
7191
7192
7193/** @type {!chrome.bluetoothPrivate.PairingEventEvent} */
7194chrome.bluetoothPrivate.onPairing;
7195