├── README.md ├── chap-links-library.js ├── ace.js ├── sencha-touch.js ├── codemirror.js └── google-visualization.js /README.md: -------------------------------------------------------------------------------- 1 | About 2 | ===== 3 | 4 | This is a collection of externs for closure-compiler. 5 | 6 | They are probably not full and contain only that part that was used in other projects. 7 | 8 | Feel free to fork and pull back changes. -------------------------------------------------------------------------------- /chap-links-library.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @namespace 3 | */ 4 | var links; 5 | 6 | /** 7 | * @constructor 8 | * @param container 9 | */ 10 | links.Timeline = function(container){}; 11 | links.Timeline.prototype.draw = function(data, options){}; 12 | /** 13 | * @param {Date} time 14 | */ 15 | links.Timeline.prototype.setCustomTime = function(time){}; 16 | -------------------------------------------------------------------------------- /ace.js: -------------------------------------------------------------------------------- 1 | /* 2 | * Extern for Ace (Ajax.org Cloud9 Editor) 3 | * https://github.com/ajaxorg/ace 4 | */ 5 | 6 | /** 7 | * @param {string} path 8 | * @return {RequiredObject} 9 | */ 10 | function require(path) {} 11 | 12 | /** 13 | * @class 14 | * @constructor 15 | */ 16 | var RequiredObject; 17 | 18 | /** 19 | * @type {function (new:Object)} 20 | */ 21 | RequiredObject.prototype.Mode; 22 | 23 | /** 24 | * @namespace 25 | */ 26 | var ace; 27 | 28 | /** 29 | * @param {string} id 30 | * @return {!ace.AceEditor} 31 | */ 32 | ace.edit = function(id) {}; 33 | 34 | /** 35 | * @class 36 | * @constructor 37 | */ 38 | ace.AceEditor = function(){}; 39 | 40 | /** 41 | * @param {string} theme 42 | */ 43 | ace.AceEditor.prototype.setTheme = function(theme) {}; 44 | 45 | /** 46 | * @param {boolean} readOnly 47 | */ 48 | ace.AceEditor.prototype.setReadOnly = function(readOnly) {}; 49 | 50 | /** 51 | * @return {ace.AceSession} 52 | */ 53 | ace.AceEditor.prototype.getSession = function() {}; 54 | 55 | ace.AceEditor.prototype.resize = function() {}; 56 | 57 | /** 58 | * @class 59 | * @constructor 60 | */ 61 | ace.AceSession = function(){}; 62 | 63 | /** 64 | * @param {Object} mode 65 | */ 66 | ace.AceSession.prototype.setMode = function(mode) {}; 67 | 68 | /** 69 | * @param {string} value 70 | */ 71 | ace.AceSession.prototype.setValue = function(value) {}; 72 | 73 | /** 74 | * @return {string} 75 | */ 76 | ace.AceSession.prototype.getValue = function() {}; -------------------------------------------------------------------------------- /sencha-touch.js: -------------------------------------------------------------------------------- 1 | /* 2 | * Extern for Sencha Touch Mobile JavaScript Framework 3 | * http://www.sencha.com/products/touch/ 4 | */ 5 | 6 | /** 7 | * @namespace 8 | */ 9 | var Ext = {}; 10 | 11 | /** 12 | * @class 13 | * @constructor 14 | * @param {...} var_args 15 | */ 16 | Ext.ExtConstructor = function(var_args) { 17 | }; 18 | /** 19 | * @type Ext.lib.Component 20 | */ 21 | Ext.ExtConstructor.prototype.superclass = null; 22 | 23 | 24 | /** 25 | * @param {Object} opt 26 | */ 27 | Ext.setup = function(opt) { 28 | }; 29 | /** 30 | * @param {...} var_arg 31 | * @return {Ext.Element} 32 | */ 33 | Ext.get = function(var_arg) { 34 | }; 35 | /** 36 | * @param {...} var_arg 37 | * @return {Ext.Element} 38 | */ 39 | Ext.getBody= function(var_arg) { 40 | }; 41 | /** 42 | * @param {...} var_arg 43 | * @return {Object} 44 | */ 45 | Ext.is = function(var_arg) { 46 | }; 47 | /** 48 | * @param {...} var_arg 49 | */ 50 | Ext.regModel = function(var_arg) { 51 | }; 52 | /** 53 | * @param {function()} base 54 | * @param {Object} child 55 | * @return {function(...)} 56 | */ 57 | Ext.extend = function (base, child) { 58 | }; 59 | 60 | 61 | /** 62 | * @class 63 | * @constructor 64 | * @param {Object} opt 65 | */ 66 | Ext.Application = function(opt) { 67 | }; 68 | 69 | Ext.lib = {}; 70 | 71 | /** 72 | * @class 73 | * @constructor 74 | * @param {...} var_args 75 | */ 76 | Ext.lib.Component = function(var_args) { 77 | }; 78 | Ext.lib.Component.prototype.initComponent = function() { 79 | }; 80 | /** 81 | * @return {boolean} 82 | */ 83 | Ext.lib.Component.prototype.isHidden = function() { 84 | }; 85 | /** 86 | * @return {number} 87 | */ 88 | Ext.lib.Component.prototype.getWidth = function() { 89 | }; 90 | /** 91 | * @return {number} 92 | */ 93 | Ext.lib.Component.prototype.getHeight = function() { 94 | }; 95 | /** 96 | * @param {...} var_arg 97 | * @return {Ext.Component} 98 | */ 99 | Ext.lib.Component.prototype.setWidth = function(var_arg) { 100 | }; 101 | /** 102 | * @param {...} var_arg 103 | * @return {Ext.Component} 104 | */ 105 | Ext.lib.Component.prototype.setHeight = function(var_arg) { 106 | }; 107 | 108 | /** 109 | * @param {...} var_arg 110 | * @return {Ext.Component} 111 | */ 112 | Ext.lib.Component.prototype.setSize = function(var_arg) { 113 | }; 114 | /** 115 | * @return {Object} 116 | */ 117 | Ext.lib.Component.prototype.getEl = function() { 118 | }; 119 | 120 | Ext.lib.Component.prototype.disable = function() { 121 | }; 122 | /** 123 | * @param {...} var_arg 124 | */ 125 | Ext.lib.Component.prototype.on = function(var_arg) { 126 | }; 127 | /** 128 | * @param {...} var_arg 129 | * @return Ext.Container 130 | */ 131 | Ext.lib.Component.prototype.up = function(var_arg) { 132 | }; 133 | /** 134 | * @return Ext.Container 135 | */ 136 | Ext.lib.Component.prototype.doComponentLayout = function() { 137 | }; 138 | 139 | /** 140 | * @class 141 | * @constructor 142 | * @param {Object} opt 143 | */ 144 | Ext.Element = function(opt) { 145 | }; 146 | /** 147 | * @param {...} var_arg 148 | * @return {Ext.CompositeElement|Ext.Element} 149 | */ 150 | Ext.Element.prototype.select = function (var_arg) { 151 | }; 152 | /** 153 | * @param {...} var_arg 154 | * @return {Object} 155 | */ 156 | Ext.Element.prototype.getBox = function (var_arg) { 157 | }; 158 | /** 159 | * @param {...} var_arg 160 | * @return {Object} 161 | */ 162 | Ext.Element.prototype.child = function (var_arg) { 163 | }; 164 | 165 | /** 166 | * @type Element 167 | */ 168 | Ext.Element.prototype.dom; 169 | 170 | /** 171 | * @class 172 | * @constructor 173 | * @param {Object} opt 174 | */ 175 | Ext.CompositeElement = function (opt) { 176 | }; 177 | 178 | /** 179 | * @class 180 | * @constructor 181 | * @extends Ext.lib.Component 182 | * @param {Object} opt 183 | */ 184 | Ext.Component = function(opt) { 185 | }; 186 | /** 187 | * @param {...} var_arg 188 | */ 189 | Ext.Component.prototype.showBy = function(var_arg) { 190 | }; 191 | /** 192 | * @param {...} var_arg 193 | */ 194 | Ext.Component.prototype.show = function(var_arg) { 195 | }; 196 | /** 197 | * @param {...} var_arg 198 | */ 199 | Ext.Component.prototype.hide = function(var_arg) { 200 | }; 201 | 202 | /** 203 | * @class 204 | * @constructor 205 | * @param {Object} opt 206 | * @extends Ext.Component 207 | */ 208 | Ext.Container = function(opt) { 209 | }; 210 | /** 211 | * @param {...} var_arg 212 | */ 213 | Ext.Container.prototype.add = function(var_arg) { 214 | }; 215 | /** 216 | * @param {...} var_arg 217 | */ 218 | Ext.Container.prototype.doLayout = function(var_arg) { 219 | }; 220 | /** 221 | * @param {string} selector 222 | * @return {Ext.Component} 223 | */ 224 | Ext.Container.prototype.down = function(selector) { 225 | }; 226 | /** 227 | * @type Ext.util.MixedCollection 228 | */ 229 | Ext.Container.prototype.items = null; 230 | /** 231 | * @param {?boolean} autoDestroy 232 | */ 233 | Ext.Container.prototype.removeAll = function(autoDestroy) { 234 | }; 235 | /** 236 | */ 237 | Ext.Container.prototype.destroy = function() { 238 | }; 239 | /** 240 | * @class 241 | * @constructor 242 | */ 243 | Ext.Scroller = function(){}; 244 | Ext.Scroller.prototype.onStart = function(){}; 245 | Ext.Scroller.prototype.onDrag = function(){}; 246 | Ext.Scroller.prototype.onDragEnd = function(){}; 247 | /** 248 | * @param {string} event 249 | * @param {function()} handler 250 | */ 251 | Ext.Scroller.prototype.on = function(event, handler){}; 252 | /** 253 | * @class 254 | * @constructor 255 | * @param {Object} opt 256 | * @extends Ext.Container 257 | */ 258 | Ext.Panel = function(opt) { 259 | }; 260 | /** 261 | * @type Ext.Scroller 262 | */ 263 | Ext.Panel.prototype.scroller; 264 | /** 265 | * @param {...} var_arg 266 | */ 267 | Ext.Panel.prototype.addDocked = function(var_arg) { 268 | }; 269 | /** 270 | * @param {...} var_arg 271 | */ 272 | Ext.Panel.prototype.setActiveItem = function(var_arg) { 273 | }; 274 | /** 275 | * @return {Ext.Element} 276 | */ 277 | Ext.Panel.prototype.getEl = function() {}; 278 | /** 279 | * @return {Ext.layout.ContainerLayout} 280 | */ 281 | Ext.Panel.prototype.getLayout = function() {}; 282 | /** 283 | * @class 284 | * @constructor 285 | * @param {Object} opt 286 | * @extends Ext.Panel 287 | */ 288 | Ext.TabBar = function(opt) { 289 | }; 290 | 291 | /** 292 | * @class 293 | * @constructor 294 | * @param {Object} opt 295 | * @extends Ext.Panel 296 | */ 297 | Ext.TabPanel = function(opt) { 298 | }; 299 | /** 300 | * @return {Ext.TabBar} 301 | */ 302 | Ext.Panel.prototype.getTabBar = function() { 303 | }; 304 | 305 | /** 306 | * @class 307 | * @constructor 308 | * @param {Object} opt 309 | * @extends Ext.Panel 310 | */ 311 | Ext.form.FormPanel = function(opt) { 312 | }; 313 | /** 314 | * @type Ext.Panel 315 | */ 316 | Ext.form.FormPanel.superclass = null; 317 | /** 318 | * @return {Object} 319 | */ 320 | Ext.Panel.prototype.getValues = function() { 321 | }; 322 | 323 | 324 | /** 325 | * @class 326 | * @constructor 327 | * @param {Object} opt 328 | * @extends Ext.Container 329 | */ 330 | Ext.Toolbar = function(opt) { 331 | }; 332 | 333 | /** 334 | * @class 335 | * @constructor 336 | * @extends Ext.Component 337 | * @param {Object} opt 338 | */ 339 | Ext.Button = function(opt) { 340 | }; 341 | /** 342 | * @class 343 | * @constructor 344 | * @param {Object} el 345 | * @param {Object} opt 346 | */ 347 | Ext.LoadMask = function (el,opt){ 348 | }; 349 | /** 350 | * @return {boolean} 351 | */ 352 | Ext.LoadMask.prototype.isHidden = function (){ 353 | }; 354 | Ext.LoadMask.prototype.hide = function (){ 355 | }; 356 | Ext.LoadMask.prototype.show = function (){ 357 | }; 358 | /** 359 | * @class 360 | * @constructor 361 | * @param {Object} opt 362 | */ 363 | Ext.Anim = function(opt) { 364 | }; 365 | /** 366 | * @param {...} var_arg 367 | */ 368 | Ext.Anim.prototype.run = function(var_arg) { 369 | }; 370 | /** 371 | * @param {...} var_arg 372 | */ 373 | Ext.Anim.run = function(var_arg) { 374 | }; 375 | 376 | /** 377 | * @class 378 | * @constructor 379 | * @param {Object} opt 380 | * @extends Ext.Component 381 | */ 382 | Ext.DataView = function(opt) { 383 | }; 384 | 385 | /** 386 | * @class 387 | * @constructor 388 | * @param {Object} opt 389 | * @extends Ext.DataView 390 | */ 391 | Ext.List = function(opt) { 392 | }; 393 | Ext.List.prototype.refresh = function () { 394 | }; 395 | /** 396 | * @param {Ext.data.Store} store 397 | */ 398 | Ext.List.prototype.bindStore = function (store) { 399 | }; 400 | 401 | 402 | Ext.util = {}; 403 | /** 404 | * @class 405 | * @constructor 406 | * @param {Object} opt 407 | */ 408 | Ext.util.MixedCollection = function(opt) { 409 | }; 410 | Ext.util.MixedCollection.prototype.clear = function (){ 411 | }; 412 | /** 413 | * @param {...} var_args 414 | */ 415 | Ext.util.MixedCollection.prototype.addAll = function (var_args){ 416 | }; 417 | 418 | /** 419 | * @class 420 | * @constructor 421 | * @param {Object} opt 422 | */ 423 | Ext.data.AbstractStore = function(opt) { 424 | }; 425 | /** 426 | * @class 427 | * @constructor 428 | * @param {Object} opt 429 | * @extends Ext.data.AbstractStore 430 | */ 431 | Ext.data.Store = function(opt) { 432 | }; 433 | /** 434 | * @type Ext.util.MixedCollection 435 | */ 436 | Ext.data.Store.prototype.data = null; 437 | /** 438 | * @type Ext.util.MixedCollection 439 | */ 440 | Ext.data.Store.data = null; 441 | /** 442 | * @class 443 | * @param {Object} opt 444 | * @constructor 445 | */ 446 | Ext.data.Proxy = function(opt) { 447 | }; 448 | /** 449 | * @class 450 | * @constructor 451 | * @param {Object} opt 452 | * @extends Ext.data.Proxy 453 | */ 454 | Ext.data.ClientProxy = function(opt) { 455 | }; 456 | /** 457 | * @class 458 | * @constructor 459 | * @param {Object} opt 460 | * @extends Ext.data.ClientProxy 461 | */ 462 | Ext.data.MemoryProxy = function(opt) { 463 | }; 464 | 465 | Ext.layout = {}; 466 | /** 467 | * @class 468 | * @constructor 469 | */ 470 | Ext.layout.ContainerLayout = function() {}; 471 | 472 | /** 473 | * @return {Ext.Element} 474 | */ 475 | Ext.layout.ContainerLayout.prototype.getTarget = function(){}; 476 | -------------------------------------------------------------------------------- /codemirror.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @constructor 3 | */ 4 | var CodeMirrorObj = function() { 5 | 6 | }; 7 | 8 | /** 9 | * Get the current editor content. 10 | * @return {string} 11 | */ 12 | CodeMirrorObj.prototype.getValue = function(){}; 13 | /** 14 | * Set the editor content. 15 | * @param {string} value 16 | */ 17 | CodeMirrorObj.prototype.setValue = function(value){}; 18 | /** 19 | * Get the currently selected code. 20 | * @return {string} 21 | */ 22 | CodeMirrorObj.prototype.getSelection = function(){}; 23 | /** 24 | * Replace the selection with the given string. 25 | * @param {string} str 26 | */ 27 | CodeMirrorObj.prototype.replaceString = function(str){}; 28 | /** 29 | * Give the editor focus. 30 | */ 31 | CodeMirrorObj.prototype.focus = function(){}; 32 | /** 33 | * Change the configuration of the editor. option should the name of an option, and value 34 | * should be a valid value for that option. 35 | * @param {string} option 36 | * @param {*} value 37 | */ 38 | CodeMirrorObj.prototype.setOption = function(option, value){}; 39 | /** 40 | * Retrieves the current value of the given option for this editor instance. 41 | * @param {string} option 42 | */ 43 | CodeMirrorObj.prototype.getOption = function(option){}; 44 | /** 45 | * Returns an {x, y, yBot} object containing the coordinates of the cursor relative to the top-left corner 46 | * of the page. yBot is the coordinate of the bottom of the cursor. start is a boolean 47 | * indicating whether you want the start or the end of the selection. 48 | * @param {boolean} start 49 | * @return {{x:number, y:number, yBot:number}} 50 | */ 51 | CodeMirrorObj.prototype.cursorCoords = function(start){}; 52 | /** 53 | * Like cursorCoords, but returns the position of an arbitrary characters. pos should be a 54 | * {line, ch} object. 55 | * @param {{line:number, ch:number}} pos 56 | * @return {{x:number, y:number, yBot:number}} 57 | */ 58 | CodeMirrorObj.prototype.charCoords = function(pos){}; 59 | /** 60 | * Given an {x, y} object (in page coordinates), returns the {line, ch} position that 61 | * corresponds to it. 62 | * @param {{x:number, y:number}} obj 63 | * @return {{line:number, ch:number}} 64 | */ 65 | CodeMirrorObj.prototype.coordsChar = function(obj){}; 66 | /** 67 | * Undo one edit (if any undo events are stored). 68 | */ 69 | CodeMirrorObj.prototype.undo = function(){}; 70 | /** 71 | * Redo one undone edit. 72 | */ 73 | CodeMirrorObj.prototype.redo = function(){}; 74 | /** 75 | * Returns an object with {undo, redo} properties, both of which hold integers, indicating the amount of 76 | * stored undo and redo operations. 77 | * @return {{undo:number, redo:number}} 78 | */ 79 | CodeMirrorObj.prototype.historySize = function(){}; 80 | /** 81 | * Reset the given line's indentation to the indentation prescribed by the mode. If the second argument is given, 82 | * indentation will be increased (if dir is true) or decreased (if false) by an indent unit instead. 83 | * @param {number} line 84 | * @param {boolean} dir 85 | */ 86 | CodeMirrorObj.prototype.indentLine = function(line, dir){}; 87 | /** 88 | * Used to implement search/replace functionality. query can be a regular expression or a string (only 89 | * strings will match across lines—if they contain newlines). start provides the starting position of the 90 | * search. It can be a {line, ch} object, or can be left off to default to the start of the document. 91 | * caseFold is only relevant when matching a string. It will cause the search to be case-insensitive. 92 | * @param {(RegExp|string)} query 93 | * @param {number} start 94 | * @param {boolean} caseFold 95 | * @return {CodeMirrorCursor} 96 | */ 97 | CodeMirrorObj.prototype.getSearchCursor = function(query, start, caseFold){}; 98 | /** 99 | * Retrieves information about the token the current mode found at the given position (a {line, ch} 100 | * object). The returned object has the following properties: 101 | * start - The character (on the given line) at which the token starts. 102 | * end - The character at which the token ends. 103 | * string - The token's string. 104 | * className - The class the mode assigned to the token. (Can be null when no class was assigned.) 105 | * state - The mode's state at the end of this token. 106 | * @param {{line:number, ch:number}} pos 107 | * @return {{start:number, end:number, string:string, className:?string, state:string}} 108 | */ 109 | CodeMirrorObj.prototype.getTokenAt = function(pos){}; 110 | /** 111 | * Can be used to mark a range of text with a specific CSS class name. from and to should be 112 | * {line, ch} objects. The method will return a function that can be called to remove the marking. 113 | * @param {{line:number, ch:number}} from 114 | * @param {{line:number, ch:number}} to 115 | * @param {string} className 116 | * @return {function()} 117 | */ 118 | CodeMirrorObj.prototype.markText = function(from, to, className){}; 119 | /** 120 | * Add a gutter marker for the given line. Gutter markers are shown in the line-number area (instead of the number for 121 | * this line). Both text and className are optional. Setting text to a Unicode 122 | * character like ● tends to give a nice effect. To put a picture in the gutter, set text to a space and 123 | * className to something that sets a background image. If you specify text, the given text 124 | * (which may contain HTML) will, by default, replace the line number for that line. If this is not what you want, you 125 | * can include the string %N% in the text, which will be replaced by the line number. 126 | * @param {(number|CodeMirrorLineHandle)} line 127 | * @param {string=} opt_text 128 | * @param {string=} opt_className 129 | * @return {CodeMirrorLineHandle} 130 | */ 131 | CodeMirrorObj.prototype.setMarker = function(line, opt_text, opt_className){}; 132 | /** 133 | * Clears a marker created with setMarker. line can be either a number or a handle returned 134 | * by setMarker (since a number may now refer to a different line if something was added or deleted). 135 | * @param {(number|CodeMirrorLineHandle)} line 136 | */ 137 | CodeMirrorObj.prototype.clearMarker = function(line){}; 138 | /** 139 | * Set a CSS class name for the given line. line can be a number or a line handle (as returned by 140 | * setMarker or this function). Pass null to clear the class for a line. 141 | * @param {(null|number|CodeMirrorLineHandle)} line 142 | * @param {string} className 143 | * @return {CodeMirrorLineHandle} 144 | */ 145 | CodeMirrorObj.prototype.setLineClass = function(line, className){}; 146 | /** 147 | * Returns the line number, text content, and marker status of the given line, which can be either a number or a handle 148 | * returned by setMarker. The returned object has the structure 149 | * {line, text, markerText, markerClass}. 150 | * @param {(number|CodeMirrorLineHandle)} line 151 | * @return {{line:number, text:string, markerText:string, markerClass:string}} 152 | */ 153 | CodeMirrorObj.prototype.lineInfo = function(line){}; 154 | /** 155 | * Puts node, which should be an absolutely positioned DOM node, into the editor, positioned right below 156 | * the given {line, ch} position. When scrollIntoView is true, the editor will ensure that 157 | * the entire node is visible (if possible). To remove the widget again, simply use DOM methods (move it somewhere else, 158 | * or call removeChild on its parent). 159 | * @param {{line:number, ch:number}} pos 160 | * @param {Element} node 161 | * @param {boolean} scrollIntoView 162 | */ 163 | CodeMirrorObj.prototype.addWidget = function(pos, node, scrollIntoView){}; 164 | /** 165 | * Force matching-bracket-highlighting to happen. 166 | */ 167 | CodeMirrorObj.prototype.matchBrackets = function(){}; 168 | /** 169 | * Get the number of lines in the editor. 170 | * @return {number} 171 | */ 172 | CodeMirrorObj.prototype.lineCount = function(){}; 173 | /** 174 | * start is a boolean indicating whether the start or the end of the selection must be retrieved. If it is 175 | * not given, the current cursor pos, i.e. the side of the selection that would move if you pressed an arrow key, is 176 | * chosen. A {line, ch} object will be returned. 177 | * @param {boolean} start 178 | * @return {{line:number, ch:number}} 179 | */ 180 | CodeMirrorObj.prototype.getCursor = function(start){}; 181 | /** 182 | * Return true if any text is selected. 183 | * @return {boolean} 184 | */ 185 | CodeMirrorObj.prototype.somethingSelected = function(){}; 186 | /** 187 | * Set the cursor position. You can either pass a single {line, ch} object, or the line and the character 188 | * as two separate parameters. 189 | * @param {({line:number, ch:number}|number)} pos 190 | * @param {number} opt_ch 191 | */ 192 | CodeMirrorObj.prototype.setCursor = function(pos, opt_ch){}; 193 | /** 194 | * Set the selection range. start and end should be {line, ch} objects. 195 | * @param {{line:number, ch:number}} start 196 | * @param {{line:number, ch:number}} end 197 | */ 198 | CodeMirrorObj.prototype.setSelection = function(start, end){}; 199 | /** 200 | * Get the content of line n. 201 | * @param {number} n 202 | */ 203 | CodeMirrorObj.prototype.getLine = function(n){}; 204 | /** 205 | * Set the content of line n. 206 | * @param {number} n 207 | * @param {string} text 208 | */ 209 | CodeMirrorObj.prototype.setLine = function(n, text){}; 210 | /** 211 | * Remove the given line from the document. 212 | * @param {number} n 213 | */ 214 | CodeMirrorObj.prototype.removeLine = function(n){}; 215 | /** 216 | * Get the text between the given points in the editor, which should be {line, ch} objects. 217 | * @param {{line:number, ch:number}} from 218 | * @param {{line:number, ch:number}} to 219 | */ 220 | CodeMirrorObj.prototype.getRange = function(from, to){}; 221 | /** 222 | * Replace the part of the document between from and to with the given string. 223 | * from and to must be {line, ch} objects. to can be left off to simply 224 | * insert the string at position from. 225 | * @param {string} str 226 | * @param {{line:number, ch:number}} from 227 | * @param {{line:number, ch:number}} to 228 | */ 229 | CodeMirrorObj.prototype.replaceRange = function(str, from, to){}; 230 | /** 231 | * Calculates and returns a {line, ch} object for a zero-based index who's value is relative 232 | * to the start of the editor's text. If the index is out of range of the text then the returned object is 233 | * clipped to start or end of the text respectively. 234 | * @param {number} index 235 | * @return {{line:number, ch:number}} 236 | */ 237 | CodeMirrorObj.prototype.coordsFromIndex = function(index){}; 238 | /** 239 | * CodeMirror internally buffers changes and only updates its DOM structure after it has finished performing some 240 | * operation. If you need to perform a lot of operations on a CodeMirror instance, you can call this method with a 241 | * function argument. It will call the function, buffering up all changes, and only doing the expensive update after 242 | * the function returns. This can be a lot faster. The return value from this method will be the return value of your 243 | * function. 244 | * @param {function()} func 245 | * @return {*} 246 | */ 247 | CodeMirrorObj.prototype.operation = function(func){}; 248 | /** 249 | * If your code does something to change the size of the editor element (window resizes are already listened for), or 250 | * unhides it, you should probably follow up by calling this method to ensure CodeMirror is still looking as intended. 251 | */ 252 | CodeMirrorObj.prototype.refresh = function(){}; 253 | /** 254 | * Returns the hiden textarea used to read input. 255 | * @return {HTMLTextAreaElement} 256 | */ 257 | CodeMirrorObj.prototype.getInputField = function(){}; 258 | /** 259 | * Returns the DOM node that represents the editor. Remove this from your tree to delete an editor instance. 260 | * @return {Element} 261 | */ 262 | CodeMirrorObj.prototype.getWrapperElement = function(){}; 263 | /** 264 | * Returns the DOM node that is responsible for the sizing and the scrolling of the editor. You can change the 265 | * height and width styles of this element to resize an editor. 266 | * (You might have to call the refresh method afterwards.) 267 | * @return {Element} 268 | */ 269 | CodeMirrorObj.prototype.getScrollerElement = function(){}; 270 | /** 271 | * Fetches the DOM node that represents the editor gutter. 272 | * @return {Element} 273 | */ 274 | CodeMirrorObj.prototype.getGutterElement = function(){}; 275 | /** 276 | * Returns the mode's parser state, if any, at the end of the given line number. If no line number is given, the state 277 | * at the end of the document is returned. This can be useful for storing parsing errors in the state, or getting other 278 | * kinds of contextual information for a line. 279 | * @param {number=} opt_line 280 | * @return {string} 281 | */ 282 | CodeMirrorObj.prototype.getStateAfter = function(opt_line){}; 283 | 284 | /** 285 | * @constructor 286 | * @extends CodeMirrorObj 287 | */ 288 | var CodeMirrorFromTextAreaObj = function(){}; 289 | /** 290 | * Copy the content of the editor into the textarea. 291 | */ 292 | CodeMirrorFromTextAreaObj.prototype.save = function(){}; 293 | /** 294 | * Remove the editor, and restore the original textarea (with the editor's current content). 295 | */ 296 | CodeMirrorFromTextAreaObj.prototype.toTextArea = function(){}; 297 | 298 | /** 299 | * @constructor 300 | */ 301 | var CodeMirrorLineHandle = function(){}; 302 | 303 | /** 304 | * @constructor 305 | */ 306 | var CodeMirrorCursor = function(){}; 307 | /** 308 | * Search forward from the current position. The return value indicates whether a match was found. If matching a regular 309 | * expression, the return value will be the array returned by the match method, in case you want to extract 310 | * matched groups. 311 | * @return {boolean} 312 | */ 313 | CodeMirrorCursor.prototype.findNext = function(){}; 314 | /** 315 | * Search backward from the current position. The return value indicates whether a match was found. If matching a regular 316 | * expression, the return value will be the array returned by the match method, in case you want to extract 317 | * matched groups. 318 | * @return {boolean} 319 | */ 320 | CodeMirrorCursor.prototype.findPrevious = function(){}; 321 | /** 322 | * Is only valid when the last call to findNext or findPrevious did not return false. It will 323 | * return {line, ch} object pointing at the start of the match. 324 | * @return {{line:number, ch:number}} 325 | */ 326 | CodeMirrorCursor.prototype.from = function(){}; 327 | /** 328 | * Is only valid when the last call to findNext or findPrevious did not return false. It will 329 | * return {line, ch} object pointing at the end of the match. 330 | * @return {{line:number, ch:number}} 331 | */ 332 | CodeMirrorCursor.prototype.to = function(){}; 333 | /** 334 | * Replaces the currently found match with the given text and adjusts the cursor position to reflect the replacement. 335 | * @param {string} text 336 | */ 337 | CodeMirrorCursor.prototype.replace = function(text){}; 338 | 339 | 340 | 341 | /** 342 | * @param {(Element|function(Element))} element 343 | * @param {Object} opt_options 344 | * @return {CodeMirrorObj} 345 | */ 346 | var CodeMirror = function(element, opt_options) {}; 347 | 348 | /** 349 | * @param {HTMLTextAreaElement} textAreaElement 350 | * @return {CodeMirrorFromTextAreaObj} 351 | */ 352 | CodeMirror.fromTextArea = function(textAreaElement) {}; 353 | /** 354 | * @param {string} name 355 | * @param {*} value 356 | */ 357 | CodeMirror.defineExtension = function(name, value){}; -------------------------------------------------------------------------------- /google-visualization.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @namespace 3 | */ 4 | var google; 5 | 6 | /** 7 | * 8 | * @param {string} name 9 | * @param {string} version 10 | * @param {Object=} opt_params 11 | */ 12 | google.load = function(name, version, opt_params) {}; 13 | 14 | /** 15 | * 16 | * @param {Function} callback 17 | */ 18 | google.setOnLoadCallback = function(callback){}; 19 | 20 | /** 21 | * @namespace 22 | */ 23 | google.visualization; 24 | 25 | /** 26 | * @enum string 27 | */ 28 | google.visualization.DataTableColumnType = { 29 | STRING: 'string', 30 | NUMBER: 'number', 31 | BOOLEAN: 'boolean', 32 | DATE: 'date', 33 | DATETIME: 'datetime', 34 | TIMEOFDAY: 'timeofday' 35 | }; 36 | 37 | /** 38 | * @constructor 39 | * @param {Object=} opt_data 40 | * @param {string=} opt_version 41 | */ 42 | google.visualization.DataTable = function(opt_data, opt_version) {}; 43 | 44 | /** 45 | * 46 | * @param {google.visualization.DataTableColumnType|string} type 47 | * @param {string=} opt_label 48 | * @param {string=} opt_id 49 | * @return {number} 50 | */ 51 | google.visualization.DataTable.prototype.addColumn = function(type, opt_label, opt_id){}; 52 | 53 | /** 54 | * 55 | * @param {Array} opt_cellArray 56 | * @return {number} 57 | */ 58 | google.visualization.DataTable.prototype.addRow = function(opt_cellArray){}; 59 | 60 | /** 61 | * 62 | * @param {number|Array} numOrArray 63 | * @return {number} 64 | */ 65 | google.visualization.DataTable.prototype.addRows = function(numOrArray){}; 66 | 67 | /** 68 | * @return {google.visualization.DataTable} 69 | */ 70 | google.visualization.DataTable.prototype.clone = function(){}; 71 | 72 | /** 73 | * 74 | * @param {number} columnIndex 75 | * @return {string} 76 | */ 77 | google.visualization.DataTable.prototype.getColumnId = function(columnIndex){}; 78 | 79 | /** 80 | * 81 | * @param {number} columnIndex 82 | * @return {string} 83 | */ 84 | google.visualization.DataTable.prototype.getColumnLabel = function(columnIndex){}; 85 | 86 | /** 87 | * 88 | * @param {number} columnIndex 89 | * @return {string} 90 | */ 91 | google.visualization.DataTable.prototype.getColumnPattern = function(columnIndex){}; 92 | 93 | /** 94 | * 95 | * @param {number} columnIndex 96 | * @return {Object} 97 | */ 98 | google.visualization.DataTable.prototype.getColumnProperties = function(columnIndex){}; 99 | 100 | /** 101 | * 102 | * @param {number} columnIndex 103 | * @param {string} name 104 | * @return {*} 105 | */ 106 | google.visualization.DataTable.prototype.getColumnProperty = function(columnIndex, name){}; 107 | 108 | /** 109 | * 110 | * @param {number} columnIndex 111 | * @return {{min:?*, max:?*}} 112 | */ 113 | google.visualization.DataTable.prototype.getColumnRange = function(columnIndex){}; 114 | 115 | /** 116 | * 117 | * @param {number} columnIndex 118 | * @return {google.visualization.DataTableColumnType} 119 | */ 120 | google.visualization.DataTable.prototype.getColumnType = function(columnIndex){}; 121 | 122 | /** 123 | * 124 | * @param {number} columnIndex 125 | * @return {Array.<*>} 126 | */ 127 | google.visualization.DataTable.prototype.getDistinctValues = function(columnIndex){}; 128 | 129 | /** 130 | * 131 | * @param {Array} filters 132 | * @return {Array.} 133 | */ 134 | google.visualization.DataTable.prototype.getFilteredRows = function(filters){}; 135 | 136 | /** 137 | * 138 | * @param {number} rowIndex 139 | * @param {number} columnIndex 140 | * @return {string} 141 | */ 142 | google.visualization.DataTable.prototype.getFormattedValue = function(rowIndex, columnIndex){}; 143 | 144 | /** 145 | * @return {number} 146 | */ 147 | google.visualization.DataTable.prototype.getNumberOfColumns = function(){}; 148 | 149 | /** 150 | * @return {number} 151 | */ 152 | google.visualization.DataTable.prototype.getNumberOfRows = function(){}; 153 | 154 | /** 155 | * 156 | * @param {number} rowIndex 157 | * @param {number} columnIndex 158 | * @return {Object} 159 | */ 160 | google.visualization.DataTable.prototype.getProperties = function(rowIndex, columnIndex){}; 161 | 162 | /** 163 | * 164 | * @param {number} rowIndex 165 | * @param {number} columnIndex 166 | * @param {string} name 167 | * @return {*} 168 | */ 169 | google.visualization.DataTable.prototype.getProperty = function(rowIndex, columnIndex, name){}; 170 | 171 | /** 172 | * 173 | * @param {number} rowIndex 174 | * @return {Object} 175 | */ 176 | google.visualization.DataTable.prototype.getRowProperties = function(rowIndex){}; 177 | 178 | /** 179 | * 180 | * @param {number} rowIndex 181 | * @param {string} name 182 | * @return {*} 183 | */ 184 | google.visualization.DataTable.prototype.getRowProperty = function(rowIndex, name){}; 185 | 186 | /** 187 | * 188 | * @param {*} sortColumns 189 | * @return {Array.} 190 | */ 191 | google.visualization.DataTable.prototype.getSortedRows = function(sortColumns){}; 192 | 193 | /** 194 | * @return {Object} 195 | */ 196 | google.visualization.DataTable.prototype.getTableProperties = function(){}; 197 | 198 | /** 199 | * 200 | * @param {string} name 201 | * @return {*} 202 | */ 203 | google.visualization.DataTable.prototype.getTableProperty = function(name){}; 204 | 205 | /** 206 | * 207 | * @param {number} rowIndex 208 | * @param {number} columnIndex 209 | * @return {string|number|boolean|Date|Array|null} 210 | */ 211 | google.visualization.DataTable.prototype.getValue = function(rowIndex, columnIndex){}; 212 | 213 | /** 214 | * 215 | * @param {number} columnIndex 216 | * @param {string} type 217 | * @param {string=} opt_label 218 | * @param {string=} opt_id 219 | */ 220 | google.visualization.DataTable.prototype.insertColumn = function(columnIndex, type, opt_label, opt_id){}; 221 | 222 | google.visualization.DataTable.prototype.insertRows = function(rowIndex, numberOrArray){}; 223 | 224 | google.visualization.DataTable.prototype.removeColumn = function(columnIndex){}; 225 | 226 | google.visualization.DataTable.prototype.removeColumns = function(columnIndex, numberOfColumns){}; 227 | 228 | google.visualization.DataTable.prototype.removeRow = function(rowIndex){}; 229 | 230 | google.visualization.DataTable.prototype.removeRows = function(rowIndex, numberOfRows){}; 231 | 232 | google.visualization.DataTable.prototype.setCell = function(rowIndex, columnIndex, opt_value, opt_formattedValue, opt_properties){}; 233 | 234 | google.visualization.DataTable.prototype.setColumnLabel = function(columnIndex, label){}; 235 | 236 | google.visualization.DataTable.prototype.setColumnProperty = function(columnIndex, name, value){}; 237 | 238 | google.visualization.DataTable.prototype.setColumnProperties = function(columnIndex, properties){}; 239 | 240 | google.visualization.DataTable.prototype.setFormattedValue = function(rowIndex, columnIndex, formattedValue){}; 241 | 242 | google.visualization.DataTable.prototype.setProperty = function(rowIndex, columnIndex, name, value){}; 243 | 244 | google.visualization.DataTable.prototype.setProperties = function(rowIndex, columnIndex, properties){}; 245 | 246 | google.visualization.DataTable.prototype.setRowProperty = function(rowIndex, name, value){}; 247 | 248 | google.visualization.DataTable.prototype.setRowProperties = function(rowIndex, properties){}; 249 | 250 | google.visualization.DataTable.prototype.setTableProperty = function(name, value){}; 251 | 252 | google.visualization.DataTable.prototype.setTableProperties = function(properties){}; 253 | 254 | google.visualization.DataTable.prototype.setValue = function(rowIndex, columnIndex, value){}; 255 | 256 | google.visualization.DataTable.prototype.sort = function(sortColumns){}; 257 | 258 | google.visualization.DataTable.prototype.toJSON = function(){}; 259 | 260 | /** 261 | * @constructor 262 | * @param responseObj 263 | */ 264 | google.visualization.QueryResponse = function(responseObj){}; 265 | google.visualization.QueryResponse.getVersionFromResponse = function(responseObj){}; 266 | google.visualization.QueryResponse.prototype.getVersion = function(){}; 267 | google.visualization.QueryResponse.prototype.getExecutionStatus = function(){}; 268 | google.visualization.QueryResponse.prototype.isError = function(){}; 269 | google.visualization.QueryResponse.prototype.hasWarning = function(){}; 270 | google.visualization.QueryResponse.prototype.containsReason = function(reason){}; 271 | google.visualization.QueryResponse.prototype.getDataSignature = function(){}; 272 | google.visualization.QueryResponse.prototype.getDataTable = function(){}; 273 | google.visualization.QueryResponse.prototype.getReasons = function(){}; 274 | google.visualization.QueryResponse.prototype.getMessage = function(){}; 275 | google.visualization.QueryResponse.prototype.getDetailedMessage = function(){}; 276 | 277 | /** 278 | * @constructor 279 | * @param dataSourceUrl 280 | */ 281 | google.visualization.Query = function(dataSourceUrl){}; 282 | google.visualization.Query.refreshAllQueries = function(){}; 283 | google.visualization.Query.setResponse = function(response){}; 284 | google.visualization.Query.prototype.setRefreshInterval = function(intervalSeconds){}; 285 | google.visualization.Query.prototype.send = function(responseHandler){}; 286 | google.visualization.Query.prototype.makeRequest = function(responseHandler, opt_params){}; 287 | google.visualization.Query.prototype.abort = function(){}; 288 | google.visualization.Query.prototype.setTimeout = function(timeoutSeconds){}; 289 | google.visualization.Query.prototype.setRefreshable = function(refreshable){}; 290 | google.visualization.Query.prototype.setQuery = function(queryString){}; 291 | 292 | google.visualization.errors = {}; 293 | google.visualization.errors.addError = function(container, message, opt_detailedMessage, opt_options){}; 294 | google.visualization.errors.removeAll = function(container){}; 295 | google.visualization.errors.addErrorFromQueryResponse = function(container, response){}; 296 | google.visualization.errors.removeError = function(id){}; 297 | google.visualization.errors.getContainer = function(errorId){}; 298 | 299 | google.visualization.events = {}; 300 | google.visualization.events.addListener = function(eventSource, eventName, eventHandler){}; 301 | google.visualization.events.trigger = function(eventSource, eventName, eventDetails){}; 302 | google.visualization.events.removeListener = function(listener){}; 303 | 304 | /** 305 | * @constructor 306 | * @param dataTable 307 | */ 308 | google.visualization.DataView = function(dataTable){}; 309 | google.visualization.DataView.prototype.setColumns = function(colIndices){}; 310 | google.visualization.DataView.prototype.setRows = function(arg0, opt_arg1){}; 311 | google.visualization.DataView.prototype.getViewColumns = function(){}; 312 | google.visualization.DataView.prototype.getViewRows = function(){}; 313 | google.visualization.DataView.prototype.hideColumns = function(colIndices){}; 314 | google.visualization.DataView.prototype.hideRows = function(arg0, opt_arg1){}; 315 | google.visualization.DataView.prototype.getViewColumnIndex = function(tableColumnIndex){}; 316 | google.visualization.DataView.prototype.getViewRowIndex = function(tableRowIndex){}; 317 | google.visualization.DataView.prototype.getTableColumnIndex = function(viewColumnIndex){}; 318 | google.visualization.DataView.prototype.getTableRowIndex = function(viewRowIndex){}; 319 | google.visualization.DataView.prototype.getNumberOfRows = function(){}; 320 | google.visualization.DataView.prototype.getNumberOfColumns = function(){}; 321 | google.visualization.DataView.prototype.getColumnId = function(columnIndex){}; 322 | google.visualization.DataView.prototype.getColumnIndex = function(columnId){}; 323 | google.visualization.DataView.prototype.getColumnLabel = function(columnIndex){}; 324 | google.visualization.DataView.prototype.getColumnPattern = function(columnIndex){}; 325 | google.visualization.DataView.prototype.getColumnType = function(columnIndex){}; 326 | google.visualization.DataView.prototype.getValue = function(rowIndex, columnIndex){}; 327 | google.visualization.DataView.prototype.getFormattedValue = function(rowIndex, columnIndex){}; 328 | google.visualization.DataView.prototype.getProperty = function(rowIndex, columnIndex, property){}; 329 | google.visualization.DataView.prototype.getColumnProperty = function(columnIndex, property){}; 330 | google.visualization.DataView.prototype.getColumnProperties = function(columnIndex){}; 331 | google.visualization.DataView.prototype.getTableProperty = function(property){}; 332 | google.visualization.DataView.prototype.getTableProperties = function(){}; 333 | google.visualization.DataView.prototype.getRowProperty = function(rowIndex, property){}; 334 | google.visualization.DataView.prototype.getRowProperties = function(rowIndex){}; 335 | google.visualization.DataView.prototype.getColumnRange = function(columnIndex){}; 336 | google.visualization.DataView.prototype.getDistinctValues = function(columnIndex){}; 337 | google.visualization.DataView.prototype.getSortedRows = function(sortColumns){}; 338 | google.visualization.DataView.prototype.getFilteredRows = function(columnFilters){}; 339 | 340 | google.visualization.formatters = {}; 341 | google.visualization.formatters.ArrowFormat = function(opt_options){}; 342 | google.visualization.formatters.ArrowFormat.prototype.format = function(dataTable, columnIndex){}; 343 | google.visualization.formatters.BarFormat = function(opt_options){}; 344 | google.visualization.formatters.BarFormat.prototype.format = function(dataTable, columnIndex){}; 345 | google.visualization.formatters.ColorFormat = function(){}; 346 | google.visualization.formatters.ColorFormat.prototype.addRange = function(from, to, color, bgcolor){}; 347 | google.visualization.formatters.ColorFormat.prototype.addGradientRange = function(from, to, color, fromBgColor, toBgColor){}; 348 | google.visualization.formatters.ColorFormat.prototype.format = function(dataTable, columnIndex){}; 349 | google.visualization.formatters.DateFormat = function(opt_options){}; 350 | google.visualization.formatters.DateFormat.prototype.format = function(dataTable, columnIndex){}; 351 | google.visualization.formatters.NumberFormat = function(opt_options){}; 352 | google.visualization.formatters.NumberFormat.prototype.format = function(dataTable, columnIndex){}; 353 | google.visualization.formatters.PatternFormat = function(pattern){}; 354 | google.visualization.formatters.PatternFormat.prototype.format = function(dataTable, srcColumnIndices, opt_dstColumnIndex){}; 355 | 356 | /** 357 | * @constructor 358 | */ 359 | google.visualization.GadgetHelper = function(){}; 360 | google.visualization.GadgetHelper.prototype.createQueryFromPrefs = function(prefs){}; 361 | google.visualization.GadgetHelper.prototype.validateResponse = function(response) {}; 362 | 363 | /** 364 | * @constructor 365 | * @param container 366 | */ 367 | google.visualization.AnnotatedTimeLine = function(container){}; 368 | google.visualization.AnnotatedTimeLine.prototype.draw = function(data, options){}; 369 | google.visualization.AnnotatedTimeLine.prototype.getSelection = function(){}; 370 | google.visualization.AnnotatedTimeLine.prototype.getVisibleChartRange = function(){}; 371 | google.visualization.AnnotatedTimeLine.prototype.setVisibleChartRange = function(firstDate, lastDate, opt_animate){}; 372 | google.visualization.AnnotatedTimeLine.prototype.showDataColumns = function(columnIndexes){}; 373 | google.visualization.AnnotatedTimeLine.prototype.hideDataColumns = function(columnIndexes){}; 374 | 375 | /** 376 | * @constructor 377 | * @param container 378 | */ 379 | google.visualization.AreaChart = function(container){}; 380 | google.visualization.AreaChart.prototype.draw = function(data, options){}; 381 | 382 | /** 383 | * @constructor 384 | * @param container 385 | */ 386 | google.visualization.BarChart = function(container){}; 387 | google.visualization.BarChart.prototype.draw = function(data, options){}; 388 | 389 | /** 390 | * @constructor 391 | * @param container 392 | */ 393 | google.visualization.ColumnChart = function(container){}; 394 | google.visualization.ColumnChart.prototype.draw = function(data, options){}; 395 | 396 | /** 397 | * @constructor 398 | * @param container 399 | */ 400 | google.visualization.Gauge = function(container){}; 401 | google.visualization.Gauge.prototype.draw = function(dataTable, opt_options){}; 402 | 403 | /** 404 | * @constructor 405 | * @param container 406 | */ 407 | google.visualization.GeoMap = function(container){}; 408 | google.visualization.GeoMap.clickOnRegion = function(id, zoomLevel, segmentBy, instanceIndex){}; 409 | google.visualization.GeoMap.prototype.setSelection = function(selection){}; 410 | google.visualization.GeoMap.prototype.getSelection = function(){}; 411 | google.visualization.GeoMap.prototype.draw = function(dataTable, options){}; 412 | 413 | /** 414 | * @constructor 415 | * @param container 416 | */ 417 | google.visualization.Map = function(container){}; 418 | google.visualization.Map.prototype.draw = function(dataTable, options){}; 419 | google.visualization.Map.prototype.setSelection = function(selection){}; 420 | google.visualization.Map.prototype.getSelection = function(){}; 421 | 422 | /** 423 | * @constructor 424 | * @param container 425 | */ 426 | google.visualization.ImageAreaChart = function(container){}; 427 | google.visualization.ImageAreaChart.prototype.draw = function(data, options){}; 428 | 429 | /** 430 | * @constructor 431 | * @param container 432 | */ 433 | google.visualization.ImageBarChart = function(container){}; 434 | google.visualization.ImageBarChart.prototype.draw = function(data, options){}; 435 | 436 | /** 437 | * @constructor 438 | * @param container 439 | */ 440 | google.visualization.ImageChart = function(container){}; 441 | google.visualization.ImageChart.prototype.draw = function(data, options){}; 442 | 443 | /** 444 | * @constructor 445 | * @param container 446 | */ 447 | google.visualization.ImageLineChart = function(container){}; 448 | google.visualization.ImageLineChart.prototype.draw = function(data, options){}; 449 | 450 | /** 451 | * @constructor 452 | * @param container 453 | */ 454 | google.visualization.ImagePieChart = function(container){}; 455 | google.visualization.ImagePieChart.prototype.draw = function(data, options){}; 456 | 457 | /** 458 | * @constructor 459 | * @param container 460 | * @param opt_domHelper 461 | */ 462 | google.visualization.ImageSparkLine = function(container, opt_domHelper){}; 463 | google.visualization.ImageSparkLine.prototype.getSelection = function(){}; 464 | google.visualization.ImageSparkLine.prototype.setSelection = function(selection){}; 465 | google.visualization.ImageSparkLine.prototype.draw = function(dataTable, options){}; 466 | 467 | /** 468 | * @constructor 469 | * @param container 470 | */ 471 | google.visualization.IntensityMap = function(container){}; 472 | google.visualization.IntensityMap.prototype.getSelection = function(){}; 473 | google.visualization.IntensityMap.prototype.setSelection = function(selection){}; 474 | google.visualization.IntensityMap.prototype.draw = function(dataTable, options){}; 475 | 476 | /** 477 | * @constructor 478 | * @param container 479 | */ 480 | google.visualization.LineChart = function(container){}; 481 | google.visualization.LineChart.prototype.draw = function(data, options){}; 482 | 483 | /** 484 | * @constructor 485 | * @param container 486 | */ 487 | google.visualization.MotionChart = function(container){}; 488 | google.visualization.MotionChart.prototype.draw = function(dataTable, options){}; 489 | google.visualization.MotionChart.prototype.getState = function(){}; 490 | 491 | /** 492 | * @constructor 493 | * @param container 494 | */ 495 | google.visualization.PieChart = function(container){}; 496 | google.visualization.PieChart.prototype.draw = function(data, options){}; 497 | 498 | /** 499 | * @constructor 500 | * @param container 501 | */ 502 | google.visualization.ScatterChart = function(container){}; 503 | google.visualization.ScatterChart.prototype.draw = function(data, options){}; 504 | 505 | /** 506 | * @constructor 507 | * @param container 508 | */ 509 | google.visualization.OrgChart = function(container){}; 510 | google.visualization.OrgChart.prototype.draw = function(dataTable, options){}; 511 | google.visualization.OrgChart.prototype.getSelection = function(){}; 512 | google.visualization.OrgChart.prototype.setSelection = function(selection){}; 513 | google.visualization.OrgChart.prototype.getCollapsedNodes = function(){}; 514 | google.visualization.OrgChart.prototype.getChildrenIndexes = function(rowInd){}; 515 | google.visualization.OrgChart.prototype.collapse = function(rowInd, collapse){}; 516 | 517 | /** 518 | * @constructor 519 | * @param container 520 | */ 521 | google.visualization.Table = function(container){}; 522 | google.visualization.Table.prototype.draw = function(dataTable, options){}; 523 | google.visualization.Table.prototype.getSortInfo = function(){}; 524 | google.visualization.Table.prototype.getSelection = function(){}; 525 | google.visualization.Table.prototype.setSelection = function(selection){}; 526 | 527 | google.visualization.drawToolbar = function(container, components){}; 528 | 529 | /** 530 | * @constructor 531 | * @param container 532 | */ 533 | google.visualization.Player = function(container){}; 534 | google.visualization.Player.prototype.draw = function(options){}; 535 | --------------------------------------------------------------------------------