diff options
Diffstat (limited to '')
| -rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/temp_externs/html5.js | 3231 |
1 files changed, 3231 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/temp_externs/html5.js b/dom/canvas/test/webgl-conf/checkout/deqp/temp_externs/html5.js new file mode 100644 index 0000000000..4e8fbd0ec7 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/temp_externs/html5.js @@ -0,0 +1,3231 @@ +/* + * Copyright 2008 The Closure Compiler Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/** + * @fileoverview Definitions for all the extensions over the + * W3C's DOM3 specification in HTML5. This file depends on + * w3c_dom3.js. The whole file has been fully type annotated. + * + * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/index.html + * @see http://dev.w3.org/html5/spec/Overview.html + * + * This also includes Typed Array definitions from + * http://www.khronos.org/registry/typedarray/specs/latest/ + * + * This relies on w3c_event.js being included first. + * + * @externs + */ + + +/** + * Note: In IE, the contains() method only exists on Elements, not Nodes. + * Therefore, it is recommended that you use the Conformance framework to + * prevent calling this on Nodes which are not Elements. + * @see https://connect.microsoft.com/IE/feedback/details/780874/node-contains-is-incorrect + * + * @param {Node} n The node to check + * @return {boolean} If 'n' is this Node, or is contained within this Node. + * @see https://developer.mozilla.org/en-US/docs/Web/API/Node.contains + * @nosideeffects + */ +Node.prototype.contains = function(n) {}; + + +/** + * @constructor + * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#the-canvas-element + * @extends {HTMLElement} + */ +function HTMLCanvasElement() {} + +/** @type {number} */ +HTMLCanvasElement.prototype.width; + +/** @type {number} */ +HTMLCanvasElement.prototype.height; + +/** + * @param {string=} opt_type + * @param {...*} var_args + * @return {string} + * @throws {Error} + * @nosideeffects + */ +HTMLCanvasElement.prototype.toDataURL = function(opt_type, var_args) {}; + +/** + * @param {string} contextId + * @param {Object=} opt_args + * @return {Object} + */ +HTMLCanvasElement.prototype.getContext = function(contextId, opt_args) {}; + +/** + * @constructor + * @see http://www.w3.org/TR/2dcontext/#canvasrenderingcontext2d + */ +function CanvasRenderingContext2D() {} + +/** @type {HTMLCanvasElement} */ +CanvasRenderingContext2D.prototype.canvas; + +/** + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.save = function() {}; + +/** + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.restore = function() {}; + +/** + * @param {number} x + * @param {number} y + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.scale = function(x, y) {}; + +/** + * @param {number} angle + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.rotate = function(angle) {}; + +/** + * @param {number} x + * @param {number} y + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.translate = function(x, y) {}; + +/** + * @param {number} m11 + * @param {number} m12 + * @param {number} m21 + * @param {number} m22 + * @param {number} dx + * @param {number} dy + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.transform = function( + m11, m12, m21, m22, dx, dy) {}; + +/** + * @param {number} m11 + * @param {number} m12 + * @param {number} m21 + * @param {number} m22 + * @param {number} dx + * @param {number} dy + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.setTransform = function( + m11, m12, m21, m22, dx, dy) {}; + +/** + * @param {number} x0 + * @param {number} y0 + * @param {number} x1 + * @param {number} y1 + * @return {CanvasGradient} + * @throws {Error} + * @nosideeffects + */ +CanvasRenderingContext2D.prototype.createLinearGradient = function( + x0, y0, x1, y1) {}; + +/** + * @param {number} x0 + * @param {number} y0 + * @param {number} r0 + * @param {number} x1 + * @param {number} y1 + * @param {number} r1 + * @return {CanvasGradient} + * @throws {Error} + * @nosideeffects + */ +CanvasRenderingContext2D.prototype.createRadialGradient = function( + x0, y0, r0, x1, y1, r1) {}; + +/** + * @param {HTMLImageElement|HTMLCanvasElement} image + * @param {string} repetition + * @return {CanvasPattern} + * @throws {Error} + * @nosideeffects + */ +CanvasRenderingContext2D.prototype.createPattern = function( + image, repetition) {}; + +/** + * @param {number} x + * @param {number} y + * @param {number} w + * @param {number} h + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.clearRect = function(x, y, w, h) {}; + +/** + * @param {number} x + * @param {number} y + * @param {number} w + * @param {number} h + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.fillRect = function(x, y, w, h) {}; + +/** + * @param {number} x + * @param {number} y + * @param {number} w + * @param {number} h + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.strokeRect = function(x, y, w, h) {}; + +/** + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.beginPath = function() {}; + +/** + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.closePath = function() {}; + +/** + * @param {number} x + * @param {number} y + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.moveTo = function(x, y) {}; + +/** + * @param {number} x + * @param {number} y + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.lineTo = function(x, y) {}; + +/** + * @param {number} cpx + * @param {number} cpy + * @param {number} x + * @param {number} y + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.quadraticCurveTo = function( + cpx, cpy, x, y) {}; + +/** + * @param {number} cp1x + * @param {number} cp1y + * @param {number} cp2x + * @param {number} cp2y + * @param {number} x + * @param {number} y + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.bezierCurveTo = function( + cp1x, cp1y, cp2x, cp2y, x, y) {}; + +/** + * @param {number} x1 + * @param {number} y1 + * @param {number} x2 + * @param {number} y2 + * @param {number} radius + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.arcTo = function(x1, y1, x2, y2, radius) {}; + +/** + * @param {number} x + * @param {number} y + * @param {number} w + * @param {number} h + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.rect = function(x, y, w, h) {}; + +/** + * @param {number} x + * @param {number} y + * @param {number} radius + * @param {number} startAngle + * @param {number} endAngle + * @param {boolean=} opt_anticlockwise + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.arc = function( + x, y, radius, startAngle, endAngle, opt_anticlockwise) {}; + +/** + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.fill = function() {}; + +/** + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.stroke = function() {}; + +/** + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.clip = function() {}; + +/** + * @param {number} x + * @param {number} y + * @return {boolean} + * @nosideeffects + */ +CanvasRenderingContext2D.prototype.isPointInPath = function(x, y) {}; + +/** + * @param {string} text + * @param {number} x + * @param {number} y + * @param {number=} opt_maxWidth + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.fillText = function( + text, x, y, opt_maxWidth) {}; + +/** + * @param {string} text + * @param {number} x + * @param {number} y + * @param {number=} opt_maxWidth + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.strokeText = function( + text, x, y, opt_maxWidth) {}; + +/** + * @param {string} text + * @return {TextMetrics} + * @nosideeffects + */ +CanvasRenderingContext2D.prototype.measureText = function(text) {}; + +/** + * @param {HTMLImageElement|HTMLCanvasElement|Image|HTMLVideoElement} image + * @param {number} dx Destination x coordinate. + * @param {number} dy Destination y coordinate. + * @param {number=} opt_dw Destination box width. Defaults to the image width. + * @param {number=} opt_dh Destination box height. + * Defaults to the image height. + * @param {number=} opt_sx Source box x coordinate. Used to select a portion of + * the source image to draw. Defaults to 0. + * @param {number=} opt_sy Source box y coordinate. Used to select a portion of + * the source image to draw. Defaults to 0. + * @param {number=} opt_sw Source box width. Used to select a portion of + * the source image to draw. Defaults to the full image width. + * @param {number=} opt_sh Source box height. Used to select a portion of + * the source image to draw. Defaults to the full image height. + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.drawImage = function( + image, dx, dy, opt_dw, opt_dh, opt_sx, opt_sy, opt_sw, opt_sh) {}; + +/** + * @param {number} sw + * @param {number} sh + * @return {ImageData} + * @nosideeffects + */ +CanvasRenderingContext2D.prototype.createImageData = function(sw, sh) {}; + +/** + * @param {number} sx + * @param {number} sy + * @param {number} sw + * @param {number} sh + * @return {ImageData} + * @throws {Error} + * @nosideeffects + */ +CanvasRenderingContext2D.prototype.getImageData = function(sx, sy, sw, sh) {}; + +/** + * @param {ImageData} imagedata + * @param {number} dx + * @param {number} dy + * @param {number=} opt_dirtyX + * @param {number=} opt_dirtyY + * @param {number=} opt_dirtyWidth + * @param {number=} opt_dirtyHeight + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.putImageData = function(imagedata, dx, dy, + opt_dirtyX, opt_dirtyY, opt_dirtyWidth, opt_dirtyHeight) {}; + +/** + * Note: WebKit only + * @param {number|string=} opt_a + * @param {number=} opt_b + * @param {number=} opt_c + * @param {number=} opt_d + * @param {number=} opt_e + * @see http://developer.apple.com/library/safari/#documentation/appleapplications/reference/WebKitDOMRef/CanvasRenderingContext2D_idl/Classes/CanvasRenderingContext2D/index.html + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.setFillColor; + +/** + * Note: WebKit only + * @param {number|string=} opt_a + * @param {number=} opt_b + * @param {number=} opt_c + * @param {number=} opt_d + * @param {number=} opt_e + * @see http://developer.apple.com/library/safari/#documentation/appleapplications/reference/WebKitDOMRef/CanvasRenderingContext2D_idl/Classes/CanvasRenderingContext2D/index.html + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.setStrokeColor; + +/** + * @return {Array.<number>} + */ +CanvasRenderingContext2D.prototype.getLineDash; + +/** + * @param {Array.<number>} segments + * @return {undefined} + */ +CanvasRenderingContext2D.prototype.setLineDash; + +/** @type {string} */ +CanvasRenderingContext2D.prototype.fillColor; + +/** + * @type {string} + * @implicitCast + */ +CanvasRenderingContext2D.prototype.fillStyle; + +/** @type {string} */ +CanvasRenderingContext2D.prototype.font; + +/** @type {number} */ +CanvasRenderingContext2D.prototype.globalAlpha; + +/** @type {string} */ +CanvasRenderingContext2D.prototype.globalCompositeOperation; + +/** @type {number} */ +CanvasRenderingContext2D.prototype.lineWidth; + +/** @type {string} */ +CanvasRenderingContext2D.prototype.lineCap; + +/** @type {string} */ +CanvasRenderingContext2D.prototype.lineJoin; + +/** @type {number} */ +CanvasRenderingContext2D.prototype.miterLimit; + +/** @type {number} */ +CanvasRenderingContext2D.prototype.shadowBlur; + +/** @type {string} */ +CanvasRenderingContext2D.prototype.shadowColor; + +/** @type {number} */ +CanvasRenderingContext2D.prototype.shadowOffsetX; + +/** @type {number} */ +CanvasRenderingContext2D.prototype.shadowOffsetY; + +/** + * @type {string} + * @implicitCast + */ +CanvasRenderingContext2D.prototype.strokeStyle; + +/** @type {string} */ +CanvasRenderingContext2D.prototype.strokeColor; + +/** @type {string} */ +CanvasRenderingContext2D.prototype.textAlign; + +/** @type {string} */ +CanvasRenderingContext2D.prototype.textBaseline; + +/** + * @constructor + */ +function CanvasGradient() {} + +/** + * @param {number} offset + * @param {string} color + * @return {undefined} + */ +CanvasGradient.prototype.addColorStop = function(offset, color) {}; + +/** + * @constructor + */ +function CanvasPattern() {} + +/** + * @constructor + */ +function TextMetrics() {} + +/** @type {number} */ +TextMetrics.prototype.width; + +/** + * @constructor + */ +function ImageData() {} + +/** @type {Uint8ClampedArray} */ +ImageData.prototype.data; + +/** @type {number} */ +ImageData.prototype.width; + +/** @type {number} */ +ImageData.prototype.height; + +/** + * @constructor + */ +function ClientInformation() {} + +/** @type {boolean} */ +ClientInformation.prototype.onLine; + +/** + * @param {string} protocol + * @param {string} uri + * @param {string} title + * @return {undefined} + */ +ClientInformation.prototype.registerProtocolHandler = function( + protocol, uri, title) {}; + +/** + * @param {string} mimeType + * @param {string} uri + * @param {string} title + * @return {undefined} + */ +ClientInformation.prototype.registerContentHandler = function( + mimeType, uri, title) {}; + +// HTML5 Database objects +/** + * @constructor + */ +function Database() {} + +/** + * @type {string} + */ +Database.prototype.version; + +/** + * @param {function(!SQLTransaction) : void} callback + * @param {(function(!SQLError) : void)=} opt_errorCallback + * @param {Function=} opt_Callback + */ +Database.prototype.transaction = function( + callback, opt_errorCallback, opt_Callback) {}; + +/** + * @param {function(!SQLTransaction) : void} callback + * @param {(function(!SQLError) : void)=} opt_errorCallback + * @param {Function=} opt_Callback + */ +Database.prototype.readTransaction = function( + callback, opt_errorCallback, opt_Callback) {}; + +/** + * @param {string} oldVersion + * @param {string} newVersion + * @param {function(!SQLTransaction) : void} callback + * @param {function(!SQLError) : void} errorCallback + * @param {Function} successCallback + */ +Database.prototype.changeVersion = function( + oldVersion, newVersion, callback, errorCallback, successCallback) {}; + +/** + * @interface + */ +function DatabaseCallback() {} + +/** + * @param {!Database} db + * @return {undefined} + */ +DatabaseCallback.prototype.handleEvent = function(db) {}; + +/** + * @constructor + */ +function SQLError() {} + +/** + * @type {number} + */ +SQLError.prototype.code; + +/** + * @type {string} + */ +SQLError.prototype.message; + +/** + * @constructor + */ +function SQLTransaction() {} + +/** + * @param {string} sqlStatement + * @param {Array.<*>=} opt_queryArgs + * @param {SQLStatementCallback=} opt_callback + * @param {(function(!SQLTransaction, !SQLError) : (boolean|void))=} + * opt_errorCallback + */ +SQLTransaction.prototype.executeSql = function( + sqlStatement, opt_queryArgs, opt_callback, opt_errorCallback) {}; + +/** + * @typedef {(function(!SQLTransaction, !SQLResultSet) : void)} + */ +var SQLStatementCallback; + +/** + * @constructor + */ +function SQLResultSet() {} + +/** + * @type {number} + */ +SQLResultSet.prototype.insertId; + +/** + * @type {number} + */ +SQLResultSet.prototype.rowsAffected; + +/** + * @type {SQLResultSetRowList} + */ +SQLResultSet.prototype.rows; + +/** + * @constructor + */ +function SQLResultSetRowList() {} + +/** + * @type {number} + */ +SQLResultSetRowList.prototype.length; + +/** + * @param {number} index + * @return {Object} + * @nosideeffects + */ +SQLResultSetRowList.prototype.item = function(index) {}; + +/** + * @param {string} name + * @param {string} version + * @param {string} description + * @param {number} size + * @param {(DatabaseCallback|function(Database))=} opt_callback + * @return {Database} + */ +function openDatabase(name, version, description, size, opt_callback) {} + +/** + * @param {string} name + * @param {string} version + * @param {string} description + * @param {number} size + * @param {(DatabaseCallback|function(Database))=} opt_callback + * @return {Database} + */ +Window.prototype.openDatabase = + function(name, version, description, size, opt_callback) {}; + +/** + * @type {boolean} + */ +HTMLImageElement.prototype.complete; + +/** + * @type {string} + * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/embedded-content-1.html#attr-img-crossorigin + */ +HTMLImageElement.prototype.crossOrigin; + +/** + * This is a superposition of the Window and Worker postMessage methods. + * @param {*} message + * @param {(string|!Array.<!Transferable>)=} opt_targetOriginOrTransfer + * @param {(string|!Array.<!MessagePort>|!Array.<!Transferable>)=} + * opt_targetOriginOrPortsOrTransfer + * @return {void} + */ +function postMessage(message, opt_targetOriginOrTransfer, + opt_targetOriginOrPortsOrTransfer) {} + +/** + * The postMessage method (as implemented in Opera). + * @param {string} message + */ +Document.prototype.postMessage = function(message) {}; + +/** + * Document head accessor. + * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/dom.html#the-head-element-0 + * @type {HTMLHeadElement} + */ +Document.prototype.head; + +/** + * @see https://developer.apple.com/webapps/docs/documentation/AppleApplications/Reference/SafariJSRef/DOMApplicationCache/DOMApplicationCache.html + * @constructor + * @implements {EventTarget} + */ +function DOMApplicationCache() {} + +/** + * @param {boolean=} opt_useCapture + * @override + */ +DOMApplicationCache.prototype.addEventListener = function( + type, listener, opt_useCapture) {}; + +/** + * @param {boolean=} opt_useCapture + * @override + */ +DOMApplicationCache.prototype.removeEventListener = function( + type, listener, opt_useCapture) {}; + +/** @override */ +DOMApplicationCache.prototype.dispatchEvent = function(evt) {}; + +/** + * The object isn't associated with an application cache. This can occur if the + * update process fails and there is no previous cache to revert to, or if there + * is no manifest file. + * @type {number} + */ +DOMApplicationCache.prototype.UNCACHED = 0; + +/** + * The cache is idle. + * @type {number} + */ +DOMApplicationCache.prototype.IDLE = 1; + +/** + * The update has started but the resources are not downloaded yet - for + * example, this can happen when the manifest file is fetched. + * @type {number} + */ +DOMApplicationCache.prototype.CHECKING = 2; + +/** + * The resources are being downloaded into the cache. + * @type {number} + */ +DOMApplicationCache.prototype.DOWNLOADING = 3; + +/** + * Resources have finished downloading and the new cache is ready to be used. + * @type {number} + */ +DOMApplicationCache.prototype.UPDATEREADY = 4; + +/** + * The cache is obsolete. + * @type {number} + */ +DOMApplicationCache.prototype.OBSOLETE = 5; + +/** + * The current status of the application cache. + * @type {number} + */ +DOMApplicationCache.prototype.status; + +/** + * Sent when the update process finishes for the first time; that is, the first + * time an application cache is saved. + * @type {?function(!Event)} + */ +DOMApplicationCache.prototype.oncached; + +/** + * Sent when the cache update process begins. + * @type {?function(!Event)} + */ +DOMApplicationCache.prototype.onchecking; + +/** + * Sent when the update process begins downloading resources in the manifest + * file. + * @type {?function(!Event)} + */ +DOMApplicationCache.prototype.ondownloading; + +/** + * Sent when an error occurs. + * @type {?function(!Event)} + */ +DOMApplicationCache.prototype.onerror; + +/** + * Sent when the update process finishes but the manifest file does not change. + * @type {?function(!Event)} + */ +DOMApplicationCache.prototype.onnoupdate; + +/** + * Sent when each resource in the manifest file begins to download. + * @type {?function(!Event)} + */ +DOMApplicationCache.prototype.onprogress; + +/** + * Sent when there is an existing application cache, the update process + * finishes, and there is a new application cache ready for use. + * @type {?function(!Event)} + */ +DOMApplicationCache.prototype.onupdateready; + +/** + * Replaces the active cache with the latest version. + * @throws {DOMException} + */ +DOMApplicationCache.prototype.swapCache = function() {}; + +/** + * Manually triggers the update process. + * @throws {DOMException} + */ +DOMApplicationCache.prototype.update = function() {}; + +/** @type {DOMApplicationCache} */ +var applicationCache; + +/** @type {DOMApplicationCache} */ +Window.prototype.applicationCache; + +/** + * @see https://developer.mozilla.org/En/DOM/Worker/Functions_available_to_workers + * @param {...string} var_args + */ +Window.prototype.importScripts = function(var_args) {}; + +/** + * @see https://developer.mozilla.org/En/DOM/Worker/Functions_available_to_workers + * @param {...string} var_args + */ +var importScripts = function(var_args) {}; + +/** + * @see http://dev.w3.org/html5/workers/ + * @constructor + * @implements {EventTarget} + */ +function WebWorker() {} + +/** + * @param {boolean=} opt_useCapture + * @override + */ +WebWorker.prototype.addEventListener = function( + type, listener, opt_useCapture) {}; + +/** + * @param {boolean=} opt_useCapture + * @override + */ +WebWorker.prototype.removeEventListener = function( + type, listener, opt_useCapture) {}; + +/** @override */ +WebWorker.prototype.dispatchEvent = function(evt) {}; + +/** + * Stops the worker process + */ +WebWorker.prototype.terminate = function() {}; + +/** + * Posts a message to the worker thread. + * @param {string} message + */ +WebWorker.prototype.postMessage = function(message) {}; + +/** + * Sent when the worker thread posts a message to its creator. + * @type {?function(!MessageEvent.<*>)} + */ +WebWorker.prototype.onmessage; + +/** + * Sent when the worker thread encounters an error. + * TODO(tbreisacher): Should this change to function(!ErrorEvent)? + * @type {?function(!Event)} + */ +WebWorker.prototype.onerror; + +/** + * @see http://dev.w3.org/html5/workers/ + * @constructor + * @implements {EventTarget} + */ +function Worker(opt_arg0) {} + +/** + * @param {boolean=} opt_useCapture + * @override + */ +Worker.prototype.addEventListener = function( + type, listener, opt_useCapture) {}; + +/** + * @param {boolean=} opt_useCapture + * @override + */ +Worker.prototype.removeEventListener = function( + type, listener, opt_useCapture) {}; + +/** @override */ +Worker.prototype.dispatchEvent = function(evt) {}; + +/** + * Stops the worker process + */ +Worker.prototype.terminate = function() {}; + +/** + * Posts a message to the worker thread. + * @param {*} message + * @param {Array.<!Transferable>=} opt_transfer + */ +Worker.prototype.postMessage = function(message, opt_transfer) {}; + +/** + * Posts a message to the worker thread. + * @param {*} message + * @param {Array.<!Transferable>=} opt_transfer + */ +Worker.prototype.webkitPostMessage = function(message, opt_transfer) {}; + +/** + * Sent when the worker thread posts a message to its creator. + * @type {?function(!MessageEvent.<*>)} + */ +Worker.prototype.onmessage; + +/** + * Sent when the worker thread encounters an error. + * TODO(tbreisacher): Should this change to function(!ErrorEvent)? + * @type {?function(!Event)} + */ +Worker.prototype.onerror; + +/** + * @see http://dev.w3.org/html5/workers/ + * @param {string} scriptURL The URL of the script to run in the SharedWorker. + * @param {string=} opt_name A name that can later be used to obtain a + * reference to the same SharedWorker. + * @constructor + * @implements {EventTarget} + */ +function SharedWorker(scriptURL, opt_name) {} + +/** + * @param {boolean=} opt_useCapture + * @override + */ +SharedWorker.prototype.addEventListener = function( + type, listener, opt_useCapture) {}; + +/** + * @param {boolean=} opt_useCapture + * @override + */ +SharedWorker.prototype.removeEventListener = function( + type, listener, opt_useCapture) {}; + +/** @override */ +SharedWorker.prototype.dispatchEvent = function(evt) {}; + +/** + * @type {!MessagePort} + */ +SharedWorker.prototype.port; + +/** + * Called on network errors for loading the initial script. + * TODO(tbreisacher): Should this change to function(!ErrorEvent)? + * @type {?function(!Event)} + */ +SharedWorker.prototype.onerror; + +/** + * @see http://dev.w3.org/html5/workers/ + * @interface + */ +function WorkerLocation() {} + +/** @type {string} */ +WorkerLocation.prototype.protocol; + +/** @type {string} */ +WorkerLocation.prototype.host; + +/** @type {string} */ +WorkerLocation.prototype.hostname; + +/** @type {string} */ +WorkerLocation.prototype.port; + +/** @type {string} */ +WorkerLocation.prototype.pathname; + +/** @type {string} */ +WorkerLocation.prototype.search; + +/** @type {string} */ +WorkerLocation.prototype.hash; + +/** + * @see http://dev.w3.org/html5/workers/ + * @interface + * @extends {EventTarget} + */ +function WorkerGlobalScope() {} + +/** @type {WorkerGlobalScope} */ +WorkerGlobalScope.prototype.self; + +/** @type {WorkerLocation} */ +WorkerGlobalScope.prototype.location; + +/** + * Closes the worker represented by this WorkerGlobalScope. + */ +WorkerGlobalScope.prototype.close = function() {}; + +/** + * Sent when the worker encounters an error. + * @type {?function(!Event)} + */ +WorkerGlobalScope.prototype.onerror; + +/** + * Sent when the worker goes offline. + * @type {?function(!Event)} + */ +WorkerGlobalScope.prototype.onoffline; + +/** + * Sent when the worker goes online. + * @type {?function(!Event)} + */ +WorkerGlobalScope.prototype.ononline; + +/** + * @see http://dev.w3.org/html5/workers/ + * @interface + * @extends {WorkerGlobalScope} + */ +function DedicatedWorkerGlobalScope() {} + +/** + * Posts a message to creator of this worker. + * @param {*} message + * @param {Array.<!Transferable>=} opt_transfer + */ +DedicatedWorkerGlobalScope.prototype.postMessage = + function(message, opt_transfer) {}; + +/** + * Posts a message to creator of this worker. + * @param {*} message + * @param {Array.<!Transferable>=} opt_transfer + */ +DedicatedWorkerGlobalScope.prototype.webkitPostMessage = + function(message, opt_transfer) {}; + +/** + * Sent when the creator posts a message to this worker. + * @type {?function(!MessageEvent.<*>)} + */ +DedicatedWorkerGlobalScope.prototype.onmessage; + +/** + * @see http://dev.w3.org/html5/workers/ + * @interface + * @extends {WorkerGlobalScope} + */ +function SharedWorkerGlobalScope() {} + +/** @type {string} */ +SharedWorkerGlobalScope.prototype.name; + +/** + * Sent when a connection to this worker is opened. + * @type {?function(!Event)} + */ +SharedWorkerGlobalScope.prototype.onconnect; + +/** @type {Element} */ +HTMLElement.prototype.contextMenu; + +/** @type {boolean} */ +HTMLElement.prototype.draggable; + +/** + * This is actually a DOMSettableTokenList property. However since that + * interface isn't currently defined and no known browsers implement this + * feature, just define the property for now. + * + * @const + * @type {Object} + */ +HTMLElement.prototype.dropzone; + +/** + * @see http://www.w3.org/TR/html5/dom.html#dom-getelementsbyclassname + * @param {string} classNames + * @return {!NodeList} + * @nosideeffects + */ +HTMLElement.prototype.getElementsByClassName = function(classNames) {}; +// NOTE: Document.prototype.getElementsByClassName is in gecko_dom.js + +/** @type {boolean} */ +HTMLElement.prototype.hidden; + +/** @type {boolean} */ +HTMLElement.prototype.spellcheck; + +/** + * @see http://www.w3.org/TR/components-intro/ + * @return {!ShadowRoot} + */ +HTMLElement.prototype.createShadowRoot; + +/** + * @see http://www.w3.org/TR/components-intro/ + * @return {!ShadowRoot} + */ +HTMLElement.prototype.webkitCreateShadowRoot; + +/** + * @see http://www.w3.org/TR/shadow-dom/ + * @type {ShadowRoot} + */ +HTMLElement.prototype.shadowRoot; + +/** + * @see http://www.w3.org/TR/shadow-dom/ + * @return {!NodeList} + */ +HTMLElement.prototype.getDestinationInsertionPoints = function() {}; + +/** + * @see http://www.w3.org/TR/components-intro/ + * @type {function()} + */ +HTMLElement.prototype.createdCallback; + +/** + * @see http://w3c.github.io/webcomponents/explainer/#lifecycle-callbacks + * @type {function()} + */ +HTMLElement.prototype.attachedCallback; + +/** + * @see http://w3c.github.io/webcomponents/explainer/#lifecycle-callbacks + * @type {function()} + */ +HTMLElement.prototype.detachedCallback; + +/** @type {string} */ +HTMLAnchorElement.prototype.hash; + +/** @type {string} */ +HTMLAnchorElement.prototype.host; + +/** @type {string} */ +HTMLAnchorElement.prototype.hostname; + +/** @type {string} */ +HTMLAnchorElement.prototype.pathname; + +/** + * The 'ping' attribute is known to be supported in recent versions (as of + * mid-2014) of Chrome, Safari, and Firefox, and is not supported in any + * current version of Internet Explorer. + * + * @type {string} + * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/semantics.html#hyperlink-auditing + */ +HTMLAnchorElement.prototype.ping; + +/** @type {string} */ +HTMLAnchorElement.prototype.port; + +/** @type {string} */ +HTMLAnchorElement.prototype.protocol; + +/** @type {string} */ +HTMLAnchorElement.prototype.search; + +/** + * @type {string} + * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/semantics.html#hyperlink-auditing + */ +HTMLAreaElement.prototype.ping; + +/** + * @type {string} + * @see http://www.w3.org/TR/html-markup/iframe.html#iframe.attrs.srcdoc + */ +HTMLIFrameElement.prototype.srcdoc; + +/** @type {string} */ +HTMLInputElement.prototype.autocomplete; + +/** @type {string} */ +HTMLInputElement.prototype.dirname; + +/** @type {FileList} */ +HTMLInputElement.prototype.files; + +/** @type {string} */ +HTMLInputElement.prototype.list; + +/** @type {string} */ +HTMLInputElement.prototype.max; + +/** @type {string} */ +HTMLInputElement.prototype.min; + +/** @type {string} */ +HTMLInputElement.prototype.pattern; + +/** @type {boolean} */ +HTMLInputElement.prototype.multiple; + +/** @type {string} */ +HTMLInputElement.prototype.placeholder; + +/** @type {boolean} */ +HTMLInputElement.prototype.required; + +/** @type {string} */ +HTMLInputElement.prototype.step; + +/** @type {Date} */ +HTMLInputElement.prototype.valueAsDate; + +/** @type {number} */ +HTMLInputElement.prototype.valueAsNumber; + +/** + * Changes the form control's value by the value given in the step attribute + * multiplied by opt_n. + * @param {number=} opt_n step multiplier. Defaults to 1. + */ +HTMLInputElement.prototype.stepDown = function(opt_n) {}; + +/** + * Changes the form control's value by the value given in the step attribute + * multiplied by opt_n. + * @param {number=} opt_n step multiplier. Defaults to 1. + */ +HTMLInputElement.prototype.stepUp = function(opt_n) {}; + + + +/** + * @constructor + * @extends {HTMLElement} + * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement + */ +function HTMLMediaElement() {} + +/** + * @type {number} + * @const + */ +HTMLMediaElement.HAVE_NOTHING; // = 0 + +/** + * @type {number} + * @const + */ +HTMLMediaElement.HAVE_METADATA; // = 1 + +/** + * @type {number} + * @const + */ +HTMLMediaElement.HAVE_CURRENT_DATA; // = 2 + +/** + * @type {number} + * @const + */ +HTMLMediaElement.HAVE_FUTURE_DATA; // = 3 + +/** + * @type {number} + * @const + */ +HTMLMediaElement.HAVE_ENOUGH_DATA; // = 4 + +/** @type {MediaError} */ +HTMLMediaElement.prototype.error; + +/** @type {string} */ +HTMLMediaElement.prototype.src; + +/** @type {string} */ +HTMLMediaElement.prototype.currentSrc; + +/** @type {number} */ +HTMLMediaElement.prototype.networkState; + +/** @type {boolean} */ +HTMLMediaElement.prototype.autobuffer; + +/** @type {TimeRanges} */ +HTMLMediaElement.prototype.buffered; + +/** + * Loads the media element. + */ +HTMLMediaElement.prototype.load = function() {}; + +/** + * @param {string} type Type of the element in question in question. + * @return {string} Whether it can play the type. + * @nosideeffects + */ +HTMLMediaElement.prototype.canPlayType = function(type) {}; + +/** + * Callback when the media is buffered and ready to play through. + * @type {function(!Event)} + */ +HTMLMediaElement.prototype.oncanplaythrough; + +/** @type {number} */ +HTMLMediaElement.prototype.readyState; + +/** @type {boolean} */ +HTMLMediaElement.prototype.seeking; + +/** + * The current time, in seconds. + * @type {number} + */ +HTMLMediaElement.prototype.currentTime; + +/** + * The absolute timeline offset. + * @return {!Date} + */ +HTMLMediaElement.prototype.getStartDate = function() {}; + +/** + * The length of the media in seconds. + * @type {number} + */ +HTMLMediaElement.prototype.duration; + +/** @type {boolean} */ +HTMLMediaElement.prototype.paused; + +/** @type {number} */ +HTMLMediaElement.prototype.defaultPlaybackRate; + +/** @type {number} */ +HTMLMediaElement.prototype.playbackRate; + +/** @type {TimeRanges} */ +HTMLMediaElement.prototype.played; + +/** @type {TimeRanges} */ +HTMLMediaElement.prototype.seekable; + +/** @type {boolean} */ +HTMLMediaElement.prototype.ended; + +/** @type {boolean} */ +HTMLMediaElement.prototype.autoplay; + +/** @type {boolean} */ +HTMLMediaElement.prototype.loop; + +/** + * Starts playing the media. + */ +HTMLMediaElement.prototype.play = function() {}; + +/** + * Pauses the media. + */ +HTMLMediaElement.prototype.pause = function() {}; + +/** @type {boolean} */ +HTMLMediaElement.prototype.controls; + +/** + * The audio volume, from 0.0 (silent) to 1.0 (loudest). + * @type {number} + */ +HTMLMediaElement.prototype.volume; + +/** @type {boolean} */ +HTMLMediaElement.prototype.muted; + +/** + * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#dom-media-addtexttrack + * @param {string} kind Kind of the text track. + * @param {string=} opt_label Label of the text track. + * @param {string=} opt_language Language of the text track. + * @return {TextTrack} TextTrack object added to the media element. + */ +HTMLMediaElement.prototype.addTextTrack = + function(kind, opt_label, opt_language) {}; + +/** @type {TextTrackList} */ +HTMLMediaElement.prototype.textTracks; + + +/** + * @see http://www.w3.org/TR/shadow-dom/ + * @return {!NodeList} + */ +Text.prototype.getDestinationInsertionPoints = function() {}; + + +/** + * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#texttracklist + * @constructor + */ +function TextTrackList() {} + +/** @type {number} */ +TextTrackList.prototype.length; + +/** + * @param {string} id + * @return {TextTrack} + */ +TextTrackList.prototype.getTrackById = function(id) {}; + + +/** + * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#texttrack + * @constructor + * @implements {EventTarget} + */ +function TextTrack() {} + +/** + * @param {TextTrackCue} cue + */ +TextTrack.prototype.addCue = function(cue) {}; + +/** + * @param {TextTrackCue} cue + */ +TextTrack.prototype.removeCue = function(cue) {}; + +/** + * @const {TextTrackCueList} + */ +TextTrack.prototype.activeCues; + +/** + * @const {TextTrackCueList} + */ +TextTrack.prototype.cues; + +/** @override */ +TextTrack.prototype.addEventListener = function(type, listener, useCapture) {}; + +/** @override */ +TextTrack.prototype.dispatchEvent = function(evt) {}; + +/** @override */ +TextTrack.prototype.removeEventListener = function(type, listener, useCapture) + {}; + + + +/** + * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#texttrackcuelist + * @constructor + */ +function TextTrackCueList() {} + +/** @const {number} */ +TextTrackCueList.prototype.length; + +/** + * @param {string} id + * @return {TextTrackCue} + */ +TextTrackCueList.prototype.getCueById = function(id) {}; + + + +/** + * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#texttrackcue + * @constructor + * @param {number} startTime + * @param {number} endTime + * @param {string} text + */ +function TextTrackCue(startTime, endTime, text) {} + +/** @type {string} */ +TextTrackCue.prototype.id; + +/** @type {number} */ +TextTrackCue.prototype.startTime; + +/** @type {number} */ +TextTrackCue.prototype.endTime; + +/** @type {string} */ +TextTrackCue.prototype.text; + + +/** + * @see http://dev.w3.org/html5/webvtt/#the-vttcue-interface + * @constructor + * @extends {TextTrackCue} + */ +function VTTCue(startTime, endTime, text) {} + + +/** + * @constructor + * @extends {HTMLMediaElement} + */ +function HTMLAudioElement() {} + +/** + * @constructor + * @extends {HTMLMediaElement} + * The webkit-prefixed attributes are defined in + * https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit/Source/core/html/HTMLVideoElement.idl + */ +function HTMLVideoElement() {} + +/** + * Starts displaying the video in full screen mode. + */ +HTMLVideoElement.prototype.webkitEnterFullscreen = function() {}; + +/** + * Starts displaying the video in full screen mode. + */ +HTMLVideoElement.prototype.webkitEnterFullScreen = function() {}; + +/** + * Stops displaying the video in full screen mode. + */ +HTMLVideoElement.prototype.webkitExitFullscreen = function() {}; + +/** + * Stops displaying the video in full screen mode. + */ +HTMLVideoElement.prototype.webkitExitFullScreen = function() {}; + +/** @type {string} */ +HTMLVideoElement.prototype.width; + +/** @type {string} */ +HTMLVideoElement.prototype.height; + +/** @type {number} */ +HTMLVideoElement.prototype.videoWidth; + +/** @type {number} */ +HTMLVideoElement.prototype.videoHeight; + +/** @type {string} */ +HTMLVideoElement.prototype.poster; + +/** @type {boolean} */ +HTMLVideoElement.prototype.webkitSupportsFullscreen; + +/** @type {boolean} */ +HTMLVideoElement.prototype.webkitDisplayingFullscreen; + +/** @type {number} */ +HTMLVideoElement.prototype.webkitDecodedFrameCount; + +/** @type {number} */ +HTMLVideoElement.prototype.webkitDroppedFrameCount; + +/** + * @constructor + */ +function MediaError() {} + +/** @type {number} */ +MediaError.prototype.code; + +// HTML5 MessageChannel +/** + * @see http://dev.w3.org/html5/spec/comms.html#messagechannel + * @constructor + */ +function MessageChannel() {} + +/** + * Returns the first port. + * @type {!MessagePort} + */ +MessageChannel.prototype.port1; + +/** + * Returns the second port. + * @type {!MessagePort} + */ +MessageChannel.prototype.port2; + +// HTML5 MessagePort +/** + * @see http://dev.w3.org/html5/spec/comms.html#messageport + * @constructor + * @implements {EventTarget} + * @implements {Transferable} + */ +function MessagePort() {} + +/** + * @param {boolean=} opt_useCapture + * @override + */ +MessagePort.prototype.addEventListener = function( + type, listener, opt_useCapture) {}; + +/** + * @param {boolean=} opt_useCapture + * @override + */ +MessagePort.prototype.removeEventListener = function( + type, listener, opt_useCapture) {}; + +/** @override */ +MessagePort.prototype.dispatchEvent = function(evt) {}; + + +/** + * Posts a message through the channel, optionally with the given + * Array of Transferables. + * @param {*} message + * @param {Array.<!Transferable>=} opt_transfer + */ +MessagePort.prototype.postMessage = function(message, opt_transfer) { +}; + +/** + * Begins dispatching messages received on the port. + */ +MessagePort.prototype.start = function() {}; + +/** + * Disconnects the port, so that it is no longer active. + */ +MessagePort.prototype.close = function() {}; + +/** + * TODO(blickly): Change this to MessageEvent.<*> and add casts as needed + * @type {?function(!MessageEvent.<?>)} + */ +MessagePort.prototype.onmessage; + +// HTML5 MessageEvent class +/** + * @see http://dev.w3.org/html5/spec/comms.html#messageevent + * @constructor + * @extends {Event} + * @template T + */ +function MessageEvent() {} + +/** + * The data payload of the message. + * @type {T} + */ +MessageEvent.prototype.data; + +/** + * The origin of the message, for server-sent events and cross-document + * messaging. + * @type {string} + */ +MessageEvent.prototype.origin; + +/** + * The last event ID, for server-sent events. + * @type {string} + */ +MessageEvent.prototype.lastEventId; + +/** + * The window that dispatched the event. + * @type {Window} + */ +MessageEvent.prototype.source; + +/** + * The Array of MessagePorts sent with the message, for cross-document + * messaging and channel messaging. + * @type {Array.<MessagePort>} + */ +MessageEvent.prototype.ports; + +/** + * Initializes the event in a manner analogous to the similarly-named methods in + * the DOM Events interfaces. + * @param {string} typeArg + * @param {boolean} canBubbleArg + * @param {boolean} cancelableArg + * @param {T} dataArg + * @param {string} originArg + * @param {string} lastEventIdArg + * @param {Window} sourceArg + * @param {Array.<MessagePort>} portsArg + */ +MessageEvent.prototype.initMessageEvent = function(typeArg, canBubbleArg, + cancelableArg, dataArg, originArg, lastEventIdArg, sourceArg, portsArg) {}; + +/** + * Initializes the event in a manner analogous to the similarly-named methods in + * the DOM Events interfaces. + * @param {string} namespaceURI + * @param {string} typeArg + * @param {boolean} canBubbleArg + * @param {boolean} cancelableArg + * @param {T} dataArg + * @param {string} originArg + * @param {string} lastEventIdArg + * @param {Window} sourceArg + * @param {Array.<MessagePort>} portsArg + */ +MessageEvent.prototype.initMessageEventNS = function(namespaceURI, typeArg, + canBubbleArg, cancelableArg, dataArg, originArg, lastEventIdArg, sourceArg, + portsArg) {}; + +/** + * HTML5 DataTransfer class. + * + * We say that this extends ClipboardData, because Event.prototype.clipboardData + * is a DataTransfer on WebKit but a ClipboardData on IE. The interfaces are so + * similar that it's easier to merge them. + * + * @see http://www.w3.org/TR/2011/WD-html5-20110113/dnd.html + * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html + * @see http://developers.whatwg.org/dnd.html#datatransferitem + * @constructor + * @extends {ClipboardData} + */ +function DataTransfer() {} + +/** @type {string} */ +DataTransfer.prototype.dropEffect; + +/** @type {string} */ +DataTransfer.prototype.effectAllowed; + +/** @type {Array.<string>} */ +DataTransfer.prototype.types; + +/** @type {FileList} */ +DataTransfer.prototype.files; + +/** + * @param {string=} opt_format Format for which to remove data. + * @override + */ +DataTransfer.prototype.clearData = function(opt_format) {}; + +/** + * @param {string} format Format for which to set data. + * @param {string} data Data to add. + * @override + */ +DataTransfer.prototype.setData = function(format, data) {}; + +/** + * @param {string} format Format for which to set data. + * @return {string} Data for the given format. + * @override + */ +DataTransfer.prototype.getData = function(format) { return ''; }; + +/** + * @param {HTMLElement} img The image to use when dragging. + * @param {number} x Horizontal position of the cursor. + * @param {number} y Vertical position of the cursor. + */ +DataTransfer.prototype.setDragImage = function(img, x, y) {}; + +/** + * @param {HTMLElement} elem Element to receive drag result events. + */ +DataTransfer.prototype.addElement = function(elem) {}; + +/** + * Addition for accessing clipboard file data that are part of the proposed + * HTML5 spec. + * @type {DataTransfer} + */ +MouseEvent.prototype.dataTransfer; + +/** + * @typedef {{ + * bubbles: (boolean|undefined), + * cancelable: (boolean|undefined), + * view: (Window|undefined), + * detail: (number|undefined), + * screenX: (number|undefined), + * screenY: (number|undefined), + * clientX: (number|undefined), + * clientY: (number|undefined), + * ctrlKey: (boolean|undefined), + * shiftKey: (boolean|undefined), + * altKey: (boolean|undefined), + * metaKey: (boolean|undefined), + * button: (number|undefined), + * buttons: (number|undefined), + * relatedTarget: (EventTarget|undefined), + * deltaX: (number|undefined), + * deltaY: (number|undefined), + * deltaZ: (number|undefined), + * deltaMode: (number|undefined) + * }} + */ +var WheelEventInit; + +/** + * @param {string} type + * @param {WheelEventInit=} opt_eventInitDict + * @see http://www.w3.org/TR/DOM-Level-3-Events/#interface-WheelEvent + * @constructor + * @extends {MouseEvent} + */ +var WheelEvent = function(type, opt_eventInitDict) {}; + +/** @const {number} */ +WheelEvent.prototype.deltaX; + +/** @const {number} */ +WheelEvent.prototype.deltaY; + +/** @const {number} */ +WheelEvent.prototype.deltaZ; + +/** @const {number} */ +WheelEvent.prototype.deltaMode; + +/** + * HTML5 DataTransferItem class. + * + * @see http://www.w3.org/TR/2011/WD-html5-20110113/dnd.html + * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html + * @see http://developers.whatwg.org/dnd.html#datatransferitem + * @constructor + */ +var DataTransferItem = function() {}; + +/** @type {string} */ +DataTransferItem.prototype.kind; + +/** @type {string} */ +DataTransferItem.prototype.type; + +/** + * @param {function(string)} callback + * @nosideeffects + */ +DataTransferItem.prototype.getAsString = function(callback) {}; + +/** + * @return {?File} The file corresponding to this item, or null. + * @nosideeffects + */ +DataTransferItem.prototype.getAsFile = function() { return null; }; + +/** + * @return {?Entry} The Entry corresponding to this item, or null. Note that + * despite its name,this method only works in Chrome, and will eventually + * be renamed to {@code getAsEntry}. + * @nosideeffects + */ +DataTransferItem.prototype.webkitGetAsEntry = function() { return null; }; + +/** + * HTML5 DataTransferItemList class. There are some discrepancies in the docs + * on the whatwg.org site. When in doubt, these prototypes match what is + * implemented as of Chrome 30. + * + * @see http://www.w3.org/TR/2011/WD-html5-20110113/dnd.html + * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html + * @see http://developers.whatwg.org/dnd.html#datatransferitem + * @constructor + */ +var DataTransferItemList = function() {}; + +/** @type {number} */ +DataTransferItemList.prototype.length; + +/** + * @param {number} i File to return from the list. + * @return {DataTransferItem} The ith DataTransferItem in the list, or null. + * @nosideeffects + */ +DataTransferItemList.prototype.item = function(i) { return null; }; + +/** + * Adds an item to the list. + * @param {string|!File} data Data for the item being added. + * @param {string=} opt_type Mime type of the item being added. MUST be present + * if the {@code data} parameter is a string. + */ +DataTransferItemList.prototype.add = function(data, opt_type) {}; + +/** + * Removes an item from the list. + * @param {number} i File to remove from the list. + */ +DataTransferItemList.prototype.remove = function(i) {}; + +/** + * Removes all items from the list. + */ +DataTransferItemList.prototype.clear = function() {}; + +/** @type {!DataTransferItemList} */ +DataTransfer.prototype.items; + + +/** + * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html#the-dragevent-interface + * @constructor + * @extends {MouseEvent} + */ +function DragEvent() {} + +/** @type {DataTransfer} */ +DragEvent.prototype.dataTransfer; + + +/** + * @typedef {{ + * lengthComputable: (boolean|undefined), + * loaded: (number|undefined), + * total: (number|undefined) + * }} + */ +var ProgressEventInit; + +/** + * @constructor + * @param {string} type + * @param {ProgressEventInit=} opt_progressEventInitDict + * @extends {Event} + * @see https://developer.mozilla.org/en-US/docs/Web/API/ProgressEvent + */ +function ProgressEvent(type, opt_progressEventInitDict) {} + +/** @type {number} */ +ProgressEvent.prototype.total; + +/** @type {number} */ +ProgressEvent.prototype.loaded; + +/** @type {boolean} */ +ProgressEvent.prototype.lengthComputable; + + +/** + * @constructor + */ +function TimeRanges() {} + +/** @type {number} */ +TimeRanges.prototype.length; + +/** + * @param {number} index The index. + * @return {number} The start time of the range at index. + * @throws {DOMException} + */ +TimeRanges.prototype.start = function(index) { return 0; }; + +/** + * @param {number} index The index. + * @return {number} The end time of the range at index. + * @throws {DOMException} + */ +TimeRanges.prototype.end = function(index) { return 0; }; + + +// HTML5 Web Socket class +/** + * @see http://dev.w3.org/html5/websockets/ + * @constructor + * @param {string} url + * @param {string=} opt_protocol + * @implements {EventTarget} + */ +function WebSocket(url, opt_protocol) {} + +/** + * @param {boolean=} opt_useCapture + * @override + */ +WebSocket.prototype.addEventListener = function( + type, listener, opt_useCapture) {}; + +/** + * @param {boolean=} opt_useCapture + * @override + */ +WebSocket.prototype.removeEventListener = function( + type, listener, opt_useCapture) {}; + +/** @override */ +WebSocket.prototype.dispatchEvent = function(evt) {}; + +/** + * Returns the URL value that was passed to the constructor. + * @type {string} + */ +WebSocket.prototype.URL; + +/** + * The connection has not yet been established. + * @type {number} + */ +WebSocket.prototype.CONNECTING = 0; + +/** + * The Web Socket connection is established and communication is possible. + * @type {number} + */ +WebSocket.prototype.OPEN = 1; + +/** + * The connection has been closed or could not be opened. + * @type {number} + */ +WebSocket.prototype.CLOSED = 2; + +/** + * Represents the state of the connection. + * @type {number} + */ +WebSocket.prototype.readyState; + +/** + * Returns the number of bytes that have been queued but not yet sent. + * @type {number} + */ +WebSocket.prototype.bufferedAmount; + +/** + * An event handler called on open event. + * @type {?function(!Event)} + */ +WebSocket.prototype.onopen; + +/** + * An event handler called on message event. + * TODO(blickly): Change this to MessageEvent.<*> and add casts as needed + * @type {?function(!MessageEvent.<?>)} + */ +WebSocket.prototype.onmessage; + +/** + * An event handler called on close event. + * @type {?function(!Event)} + */ +WebSocket.prototype.onclose; + +/** + * Transmits data using the connection. + * @param {string|ArrayBuffer|ArrayBufferView} data + * @return {boolean} + */ +WebSocket.prototype.send = function(data) {}; + +/** + * Closes the Web Socket connection or connection attempt, if any. + */ +WebSocket.prototype.close = function() {}; + +/** + * @type {string} Sets the type of data (blob or arraybuffer) for binary data. + */ +WebSocket.prototype.binaryType; + +// HTML5 History +/** + * Pushes a new state into the session history. + * @see http://www.w3.org/TR/html5/history.html#the-history-interface + * @param {*} data New state. + * @param {string} title The title for a new session history entry. + * @param {string=} opt_url The URL for a new session history entry. + */ +History.prototype.pushState = function(data, title, opt_url) {}; + +/** + * Replaces the current state in the session history. + * @see http://www.w3.org/TR/html5/history.html#the-history-interface + * @param {*} data New state. + * @param {string} title The title for a session history entry. + * @param {string=} opt_url The URL for a new session history entry. + */ +History.prototype.replaceState = function(data, title, opt_url) {}; + +/** + * Pending state object. + * @see https://developer.mozilla.org/en-US/docs/Web/Guide/API/DOM/Manipulating_the_browser_history#Reading_the_current_state + * @type {*} + */ +History.prototype.state; + +/** + * @see http://www.whatwg.org/specs/web-apps/current-work/#popstateevent + * @constructor + * @extends {Event} + * + * @param {string} type + * @param {{state: *}=} opt_eventInitDict + */ +function PopStateEvent(type, opt_eventInitDict) {} + +/** + * @type {*} + */ +PopStateEvent.prototype.state; + +/** + * Initializes the event after it has been created with document.createEvent + * @param {string} typeArg + * @param {boolean} canBubbleArg + * @param {boolean} cancelableArg + * @param {*} stateArg + */ +PopStateEvent.prototype.initPopStateEvent = function(typeArg, canBubbleArg, + cancelableArg, stateArg) {}; + +/** + * @see http://www.whatwg.org/specs/web-apps/current-work/#hashchangeevent + * @constructor + * @extends {Event} + * + * @param {string} type + * @param {{oldURL: string, newURL: string}=} opt_eventInitDict + */ +function HashChangeEvent(type, opt_eventInitDict) {} + +/** @type {string} */ +HashChangeEvent.prototype.oldURL; + +/** @type {string} */ +HashChangeEvent.prototype.newURL; + +/** + * Initializes the event after it has been created with document.createEvent + * @param {string} typeArg + * @param {boolean} canBubbleArg + * @param {boolean} cancelableArg + * @param {string} oldURLArg + * @param {string} newURLArg + */ +HashChangeEvent.prototype.initHashChangeEvent = function(typeArg, canBubbleArg, + cancelableArg, oldURLArg, newURLArg) {}; + +/** + * @see http://www.whatwg.org/specs/web-apps/current-work/#pagetransitionevent + * @constructor + * @extends {Event} + * + * @param {string} type + * @param {{persisted: boolean}=} opt_eventInitDict + */ +function PageTransitionEvent(type, opt_eventInitDict) {} + +/** @type {boolean} */ +PageTransitionEvent.prototype.persisted; + +/** + * Initializes the event after it has been created with document.createEvent + * @param {string} typeArg + * @param {boolean} canBubbleArg + * @param {boolean} cancelableArg + * @param {*} persistedArg + */ +PageTransitionEvent.prototype.initPageTransitionEvent = function(typeArg, + canBubbleArg, cancelableArg, persistedArg) {}; + +/** + * @constructor + */ +function FileList() {} + +/** @type {number} */ +FileList.prototype.length; + +/** + * @param {number} i File to return from the list. + * @return {File} The ith file in the list. + * @nosideeffects + */ +FileList.prototype.item = function(i) { return null; }; + +/** + * @type {boolean} + * @see http://dev.w3.org/2006/webapi/XMLHttpRequest-2/#withcredentials + */ +XMLHttpRequest.prototype.withCredentials; + +/** + * @type {XMLHttpRequestUpload} + * @see http://dev.w3.org/2006/webapi/XMLHttpRequest-2/#the-upload-attribute + */ +XMLHttpRequest.prototype.upload; + +/** + * @param {string} mimeType The mime type to override with. + */ +XMLHttpRequest.prototype.overrideMimeType = function(mimeType) {}; + +/** + * @type {string} + * @see http://dev.w3.org/2006/webapi/XMLHttpRequest-2/#the-responsetype-attribute + */ +XMLHttpRequest.prototype.responseType; + +/** + * @type {*} + * @see http://dev.w3.org/2006/webapi/XMLHttpRequest-2/#the-responsetype-attribute + */ +XMLHttpRequest.prototype.response; + + +/** + * @type {ArrayBuffer} + * Implemented as a draft spec in Firefox 4 as the way to get a requested array + * buffer from an XMLHttpRequest. + * @see https://developer.mozilla.org/En/Using_XMLHttpRequest#Receiving_binary_data_using_JavaScript_typed_arrays + */ +XMLHttpRequest.prototype.mozResponseArrayBuffer; + +/** + * XMLHttpRequestEventTarget defines events for checking the status of a data + * transfer between a client and a server. This should be a common base class + * for XMLHttpRequest and XMLHttpRequestUpload. + * + * @constructor + * @implements {EventTarget} + */ +function XMLHttpRequestEventTarget() {} + +/** + * @param {boolean=} opt_useCapture + * @override + */ +XMLHttpRequestEventTarget.prototype.addEventListener = function( + type, listener, opt_useCapture) {}; + +/** + * @param {boolean=} opt_useCapture + * @override + */ +XMLHttpRequestEventTarget.prototype.removeEventListener = function( + type, listener, opt_useCapture) {}; + +/** @override */ +XMLHttpRequestEventTarget.prototype.dispatchEvent = function(evt) {}; + +/** + * An event target to track the status of an upload. + * + * @constructor + * @extends {XMLHttpRequestEventTarget} + */ +function XMLHttpRequestUpload() {} + +/** + * @param {number=} opt_width + * @param {number=} opt_height + * @constructor + * @extends {HTMLImageElement} + */ +function Image(opt_width, opt_height) {} + + +/** + * Dataset collection. + * This is really a DOMStringMap but it behaves close enough to an object to + * pass as an object. + * @type {Object} + * @const + */ +HTMLElement.prototype.dataset; + + +/** + * @constructor + * @see https://dom.spec.whatwg.org/#interface-domtokenlist + */ +function DOMTokenList() {} + +/** + * Returns the number of CSS classes applied to this Element. + * @type {number} + */ +DOMTokenList.prototype.length; + +/** + * @param {number} index The index of the item to return. + * @return {string} The CSS class at the specified index. + * @nosideeffects + */ +DOMTokenList.prototype.item = function(index) {}; + +/** + * @param {string} token The CSS class to check for. + * @return {boolean} Whether the CSS class has been applied to the Element. + * @nosideeffects + */ +DOMTokenList.prototype.contains = function(token) {}; + +/** + * @param {...string} var_args The CSS class(es) to add to this element. + */ +DOMTokenList.prototype.add = function(var_args) {}; + +/** + * @param {...string} var_args The CSS class(es) to remove from this element. + */ +DOMTokenList.prototype.remove = function(var_args) {}; + +/** + * @param {string} token The CSS class to toggle from this element. + * @param {boolean=} opt_force True to add the class whether it exists + * or not. False to remove the class whether it exists or not. + * This argument is not supported on IE 10 and below, according to + * the MDN page linked below. + * @return {boolean} False if the token was removed; True otherwise. + * @see https://developer.mozilla.org/en-US/docs/Web/API/Element.classList + */ +DOMTokenList.prototype.toggle = function(token, opt_force) {}; + +/** + * @return {string} A stringified representation of CSS classes. + * @nosideeffects + * @override + */ +DOMTokenList.prototype.toString = function() {}; + +/** + * A better interface to CSS classes than className. + * @type {DOMTokenList} + * @see http://www.w3.org/TR/html5/elements.html#dom-classlist + * @const + */ +HTMLElement.prototype.classList; + +/** + * Web Cryptography API + * @see http://www.w3.org/TR/WebCryptoAPI/ + */ + +/** @see https://developer.mozilla.org/en/DOM/window.crypto */ +Window.prototype.crypto; + +/** + * @see https://developer.mozilla.org/en/DOM/window.crypto.getRandomValues + * @param {!ArrayBufferView} typedArray + * @return {!ArrayBufferView} + * @throws {Error} + */ +Window.prototype.crypto.getRandomValues = function(typedArray) {}; + +/** + * Constraint Validation API properties and methods + * @see http://www.w3.org/TR/2009/WD-html5-20090423/forms.html#the-constraint-validation-api + */ + +/** @return {boolean} */ +HTMLFormElement.prototype.checkValidity = function() {}; + +/** @type {boolean} */ +HTMLFormElement.prototype.noValidate; + +/** @constructor */ +function ValidityState() {} + +/** @type {boolean} */ +ValidityState.prototype.customError; + +/** @type {boolean} */ +ValidityState.prototype.patternMismatch; + +/** @type {boolean} */ +ValidityState.prototype.rangeOverflow; + +/** @type {boolean} */ +ValidityState.prototype.rangeUnderflow; + +/** @type {boolean} */ +ValidityState.prototype.stepMismatch; + +/** @type {boolean} */ +ValidityState.prototype.typeMismatch; + +/** @type {boolean} */ +ValidityState.prototype.tooLong; + +/** @type {boolean} */ +ValidityState.prototype.valid; + +/** @type {boolean} */ +ValidityState.prototype.valueMissing; + + +/** @type {boolean} */ +HTMLButtonElement.prototype.autofocus; + +/** + * @const + * @type {NodeList} + */ +HTMLButtonElement.prototype.labels; + +/** @type {string} */ +HTMLButtonElement.prototype.validationMessage; + +/** + * @const + * @type {ValidityState} + */ +HTMLButtonElement.prototype.validity; + +/** @type {boolean} */ +HTMLButtonElement.prototype.willValidate; + +/** @return {boolean} */ +HTMLButtonElement.prototype.checkValidity = function() {}; + +/** @param {string} message */ +HTMLButtonElement.prototype.setCustomValidity = function(message) {}; + +/** + * @type {string} + * @see http://www.w3.org/TR/html5/forms.html#attr-fs-formaction + */ +HTMLButtonElement.prototype.formAction; + +/** + * @type {string} + * @see http://www.w3.org/TR/html5/forms.html#attr-fs-formenctype + */ +HTMLButtonElement.prototype.formEnctype; + +/** + * @type {string} + * @see http://www.w3.org/TR/html5/forms.html#attr-fs-formmethod + */ +HTMLButtonElement.prototype.formMethod; + +/** + * @type {string} + * @see http://www.w3.org/TR/html5/forms.html#attr-fs-formtarget + */ +HTMLButtonElement.prototype.formTarget; + +/** @type {boolean} */ +HTMLInputElement.prototype.autofocus; + +/** @type {boolean} */ +HTMLInputElement.prototype.formNoValidate; + +/** + * @type {string} + * @see http://www.w3.org/TR/html5/forms.html#attr-fs-formaction + */ +HTMLInputElement.prototype.formAction; + +/** + * @type {string} + * @see http://www.w3.org/TR/html5/forms.html#attr-fs-formenctype + */ +HTMLInputElement.prototype.formEnctype; + +/** + * @type {string} + * @see http://www.w3.org/TR/html5/forms.html#attr-fs-formmethod + */ +HTMLInputElement.prototype.formMethod; + +/** + * @type {string} + * @see http://www.w3.org/TR/html5/forms.html#attr-fs-formtarget + */ +HTMLInputElement.prototype.formTarget; + +/** + * @const + * @type {NodeList} + */ +HTMLInputElement.prototype.labels; + +/** @type {string} */ +HTMLInputElement.prototype.validationMessage; + +/** + * @const + * @type {ValidityState} + */ +HTMLInputElement.prototype.validity; + +/** @type {boolean} */ +HTMLInputElement.prototype.willValidate; + +/** @return {boolean} */ +HTMLInputElement.prototype.checkValidity = function() {}; + +/** @param {string} message */ +HTMLInputElement.prototype.setCustomValidity = function(message) {}; + +/** @type {Element} */ +HTMLLabelElement.prototype.control; + +/** @type {boolean} */ +HTMLSelectElement.prototype.autofocus; + +/** + * @const + * @type {NodeList} + */ +HTMLSelectElement.prototype.labels; + +/** @type {HTMLCollection} */ +HTMLSelectElement.prototype.selectedOptions; + +/** @type {string} */ +HTMLSelectElement.prototype.validationMessage; + +/** + * @const + * @type {ValidityState} + */ +HTMLSelectElement.prototype.validity; + +/** @type {boolean} */ +HTMLSelectElement.prototype.willValidate; + +/** @return {boolean} */ +HTMLSelectElement.prototype.checkValidity = function() {}; + +/** @param {string} message */ +HTMLSelectElement.prototype.setCustomValidity = function(message) {}; + +/** @type {boolean} */ +HTMLTextAreaElement.prototype.autofocus; + +/** + * @const + * @type {NodeList} + */ +HTMLTextAreaElement.prototype.labels; + +/** @type {string} */ +HTMLTextAreaElement.prototype.validationMessage; + +/** + * @const + * @type {ValidityState} + */ +HTMLTextAreaElement.prototype.validity; + +/** @type {boolean} */ +HTMLTextAreaElement.prototype.willValidate; + +/** @return {boolean} */ +HTMLTextAreaElement.prototype.checkValidity = function() {}; + +/** @param {string} message */ +HTMLTextAreaElement.prototype.setCustomValidity = function(message) {}; + +/** + * @constructor + * @extends {HTMLElement} + * @see http://www.w3.org/TR/html5/the-embed-element.html#htmlembedelement + */ +function HTMLEmbedElement() {} + +/** + * @type {string} + * @see http://www.w3.org/TR/html5/dimension-attributes.html#dom-dim-width + */ +HTMLEmbedElement.prototype.width; + +/** + * @type {string} + * @see http://www.w3.org/TR/html5/dimension-attributes.html#dom-dim-height + */ +HTMLEmbedElement.prototype.height; + +/** + * @type {string} + * @see http://www.w3.org/TR/html5/the-embed-element.html#dom-embed-src + */ +HTMLEmbedElement.prototype.src; + +/** + * @type {string} + * @see http://www.w3.org/TR/html5/the-embed-element.html#dom-embed-type + */ +HTMLEmbedElement.prototype.type; + +// Fullscreen APIs. + +/** + * @see http://www.w3.org/TR/2012/WD-fullscreen-20120703/#dom-element-requestfullscreen + */ +Element.prototype.requestFullscreen = function() {}; + +/** + * @type {boolean} + * @see http://www.w3.org/TR/2012/WD-fullscreen-20120703/#dom-document-fullscreenenabled + */ +Document.prototype.fullscreenEnabled; + +/** + * @type {Element} + * @see http://www.w3.org/TR/2012/WD-fullscreen-20120703/#dom-document-fullscreenelement + */ +Document.prototype.fullscreenElement; + +/** + * @see http://www.w3.org/TR/2012/WD-fullscreen-20120703/#dom-document-exitfullscreen + */ +Document.prototype.exitFullscreen = function() {}; + +// Externs definitions of browser current implementations. +// Firefox 10 implementation. +Element.prototype.mozRequestFullScreen = function() {}; + +Element.prototype.mozRequestFullScreenWithKeys = function() {}; + +/** @type {boolean} */ +Document.prototype.mozFullScreen; + +Document.prototype.mozCancelFullScreen = function() {}; + +/** @type {Element} */ +Document.prototype.mozFullScreenElement; + +/** @type {boolean} */ +Document.prototype.mozFullScreenEnabled; + +// Chrome 21 implementation. +/** + * The current fullscreen element for the document is set to this element. + * Valid only for Webkit browsers. + * @param {number=} opt_allowKeyboardInput Whether keyboard input is desired. + * Should use ALLOW_KEYBOARD_INPUT constant. + */ +Element.prototype.webkitRequestFullScreen = function(opt_allowKeyboardInput) {}; + +/** + * The current fullscreen element for the document is set to this element. + * Valid only for Webkit browsers. + * @param {number=} opt_allowKeyboardInput Whether keyboard input is desired. + * Should use ALLOW_KEYBOARD_INPUT constant. + */ +Element.prototype.webkitRequestFullscreen = function(opt_allowKeyboardInput) {}; + +/** @type {boolean} */ +Document.prototype.webkitIsFullScreen; + +Document.prototype.webkitCancelFullScreen = function() {}; + +/** @type {Element} */ +Document.prototype.webkitCurrentFullScreenElement; + +/** @type {Element} */ +Document.prototype.webkitFullscreenElement; + +/** @type {boolean} */ +Document.prototype.webkitFullScreenKeyboardInputAllowed; + +// IE 11 implementation. +// http://msdn.microsoft.com/en-us/library/ie/dn265028(v=vs.85).aspx +/** @return {void} */ +Element.prototype.msRequestFullscreen = function() {}; + +/** @return {void} */ +Element.prototype.msExitFullscreen = function() {}; + +/** @type {boolean} */ +Document.prototype.msFullscreenEnabled; + +/** @type {Element} */ +Document.prototype.msFullscreenElement; + +/** @type {number} */ +Element.ALLOW_KEYBOARD_INPUT = 1; + +/** @type {number} */ +Element.prototype.ALLOW_KEYBOARD_INPUT = 1; + + +/** @constructor */ +function MutationObserverInit() {} + +/** @type {boolean} */ +MutationObserverInit.prototype.childList; + +/** @type {boolean} */ +MutationObserverInit.prototype.attributes; + +/** @type {boolean} */ +MutationObserverInit.prototype.characterData; + +/** @type {boolean} */ +MutationObserverInit.prototype.subtree; + +/** @type {boolean} */ +MutationObserverInit.prototype.attributeOldValue; + +/** @type {boolean} */ +MutationObserverInit.prototype.characterDataOldValue; + +/** @type {Array.<string>} */ +MutationObserverInit.prototype.attributeFilter; + + +/** @constructor */ +function MutationRecord() {} + +/** @type {string} */ +MutationRecord.prototype.type; + +/** @type {Node} */ +MutationRecord.prototype.target; + +/** @type {NodeList} */ +MutationRecord.prototype.addedNodes; + +/** @type {NodeList} */ +MutationRecord.prototype.removedNodes; + +/** @type {Node} */ +MutationRecord.prototype.previouSibling; + +/** @type {Node} */ +MutationRecord.prototype.nextSibling; + +/** @type {?string} */ +MutationRecord.prototype.attributeName; + +/** @type {?string} */ +MutationRecord.prototype.attributeNamespace; + +/** @type {?string} */ +MutationRecord.prototype.oldValue; + + +/** + * @see http://www.w3.org/TR/domcore/#mutation-observers + * @param {function(Array.<MutationRecord>, MutationObserver)} callback + * @constructor + */ +function MutationObserver(callback) {} + +/** + * @param {Node} target + * @param {MutationObserverInit=} options + */ +MutationObserver.prototype.observe = function(target, options) {}; + +MutationObserver.prototype.disconnect = function() {}; + +/** + * @type {function(new:MutationObserver, function(Array.<MutationRecord>))} + */ +Window.prototype.WebKitMutationObserver; + +/** + * @type {function(new:MutationObserver, function(Array.<MutationRecord>))} + */ +Window.prototype.MozMutationObserver; + + +/** + * @see http://www.w3.org/TR/page-visibility/ + * @type {VisibilityState} + */ +Document.prototype.visibilityState; + +/** + * @type {string} + */ +Document.prototype.webkitVisibilityState; + +/** + * @type {string} + */ +Document.prototype.msVisibilityState; + +/** + * @see http://www.w3.org/TR/page-visibility/ + * @type {boolean} + */ +Document.prototype.hidden; + +/** + * @type {boolean} + */ +Document.prototype.webkitHidden; + +/** + * @type {boolean} + */ +Document.prototype.msHidden; + +/** + * @see http://www.w3.org/TR/components-intro/ + * @see http://w3c.github.io/webcomponents/spec/custom/#extensions-to-document-interface-to-register + * @param {string} type + * @param {{extends: (string|undefined), prototype: (Object|undefined)}} options + */ +Document.prototype.registerElement; + +/** + * This method is deprecated and should be removed by the end of 2014. + * @see http://www.w3.org/TR/components-intro/ + * @see http://w3c.github.io/webcomponents/spec/custom/#extensions-to-document-interface-to-register + * @param {string} type + * @param {{extends: (string|undefined), prototype: (Object|undefined)}} options + */ +Document.prototype.register; + +/** + * @type {!FontFaceSet} + * @see http://dev.w3.org/csswg/css-font-loading/#dom-fontfacesource-fonts + */ +Document.prototype.fonts; + + +/** + * Definition of ShadowRoot interface, + * @see http://www.w3.org/TR/shadow-dom/#api-shadow-root + * @constructor + * @extends {DocumentFragment} + */ +function ShadowRoot() {} + +/** + * The host element that a ShadowRoot is attached to. + * Note: this is not yet W3C standard but is undergoing development. + * W3C feature tracking bug: + * https://www.w3.org/Bugs/Public/show_bug.cgi?id=22399 + * Draft specification: + * https://dvcs.w3.org/hg/webcomponents/raw-file/6743f1ace623/spec/shadow/index.html#shadow-root-object + * @type {!Element} + */ +ShadowRoot.prototype.host; + +/** + * @param {string} id id. + * @return {HTMLElement} + * @nosideeffects + */ +ShadowRoot.prototype.getElementById = function(id) {}; + + +/** + * @param {string} className + * @return {!NodeList} + * @nosideeffects + */ +ShadowRoot.prototype.getElementsByClassName = function(className) {}; + + +/** + * @param {string} tagName + * @return {!NodeList} + * @nosideeffects + */ +ShadowRoot.prototype.getElementsByTagName = function(tagName) {}; + + +/** + * @param {string} namespace + * @param {string} localName + * @return {!NodeList} + * @nosideeffects + */ +ShadowRoot.prototype.getElementsByTagNameNS = function(namespace, localName) {}; + + +/** + * @return {Selection} + * @nosideeffects + */ +ShadowRoot.prototype.getSelection = function() {}; + + +/** + * @param {number} x + * @param {number} y + * @return {Element} + * @nosideeffects + */ +ShadowRoot.prototype.elementFromPoint = function(x, y) {}; + + +/** + * @type {boolean} + */ +ShadowRoot.prototype.applyAuthorStyles; + + +/** + * @type {boolean} + */ +ShadowRoot.prototype.resetStyleInheritance; + + +/** + * @type {Element} + */ +ShadowRoot.prototype.activeElement; + + +/** + * @type {?ShadowRoot} + */ +ShadowRoot.prototype.olderShadowRoot; + + +/** + * @type {string} + */ +ShadowRoot.prototype.innerHTML; + + +/** + * @type {!StyleSheetList} + */ +ShadowRoot.prototype.styleSheets; + + + +/** + * @see http://www.w3.org/TR/shadow-dom/#the-content-element + * @constructor + * @extends {HTMLElement} + */ +function HTMLContentElement() {} + +/** + * @type {!string} + */ +HTMLContentElement.prototype.select; + +/** + * @return {!NodeList} + */ +HTMLContentElement.prototype.getDistributedNodes = function() {}; + + +/** + * @see http://www.w3.org/TR/shadow-dom/#the-shadow-element + * @constructor + * @extends {HTMLElement} + */ +function HTMLShadowElement() {} + +/** + * @return {!NodeList} + */ +HTMLShadowElement.prototype.getDistributedNodes = function() {}; + + +/** + * @see http://www.w3.org/TR/html5/webappapis.html#the-errorevent-interface + * + * @constructor + * @extends {Event} + * + * @param {string} type + * @param {ErrorEventInit=} opt_eventInitDict + */ +function ErrorEvent(type, opt_eventInitDict) {} + +/** @const {string} */ +ErrorEvent.prototype.message; + +/** @const {string} */ +ErrorEvent.prototype.filename; + +/** @const {number} */ +ErrorEvent.prototype.lineno; + +/** @const {number} */ +ErrorEvent.prototype.colno; + +/** @const {*} */ +ErrorEvent.prototype.error; + + +/** + * @see http://www.w3.org/TR/html5/webappapis.html#the-errorevent-interface + * + * @typedef {{ + * bubbles: (boolean|undefined), + * cancelable: (boolean|undefined), + * message: string, + * filename: string, + * lineno: number, + * colno: number, + * error: * + * }} + */ + var ErrorEventInit; + + +/** + * @see http://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument + * @param {string=} opt_title A title to give the new HTML document + * @return {!HTMLDocument} + */ +DOMImplementation.prototype.createHTMLDocument = function(opt_title) {}; + + + +/** + * @constructor + * @see https://html.spec.whatwg.org/multipage/embedded-content.html#the-picture-element + * @extends {HTMLElement} + */ +function HTMLPictureElement() {} + +/** + * @constructor + * @see https://html.spec.whatwg.org/multipage/embedded-content.html#the-picture-element + * @extends {HTMLElement} + */ +function HTMLSourceElement() {} + +/** @type {string} */ +HTMLSourceElement.prototype.media; + +/** @type {string} */ +HTMLSourceElement.prototype.sizes; + +/** @type {string} */ +HTMLSourceElement.prototype.src; + +/** @type {string} */ +HTMLSourceElement.prototype.srcset; + +/** @type {string} */ +HTMLSourceElement.prototype.type; + +/** @type {string} */ +HTMLImageElement.prototype.sizes; + +/** @type {string} */ +HTMLImageElement.prototype.srcset; + + +/** + * 4.11 Interactive elements + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html + */ + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#the-details-element + * @constructor + * @extends {HTMLElement} + */ +function HTMLDetailsElement() {} + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#dom-details-open + * @type {boolean} + */ +HTMLDetailsElement.prototype.open; + + +// As of 2/20/2015, <summary> has no special web IDL interface nor global +// constructor (i.e. HTMLSummaryElement). + + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#dom-menu-type + * @type {string} + */ +HTMLMenuElement.prototype.type; + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#dom-menu-label + * @type {string} + */ +HTMLMenuElement.prototype.label; + + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#the-menuitem-element + * @constructor + * @extends {HTMLElement} + */ +function HTMLMenuItemElement() {} + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#dom-menuitem-type + * @type {string} + */ +HTMLMenuItemElement.prototype.type; + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#dom-menuitem-label + * @type {string} + */ +HTMLMenuItemElement.prototype.label; + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#dom-menuitem-icon + * @type {string} + */ +HTMLMenuItemElement.prototype.icon; + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#dom-menuitem-disabled + * @type {boolean} + */ +HTMLMenuItemElement.prototype.disabled; + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#dom-menuitem-checked + * @type {boolean} + */ +HTMLMenuItemElement.prototype.checked; + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#dom-menuitem-radiogroup + * @type {string} + */ +HTMLMenuItemElement.prototype.radiogroup; + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#dom-menuitem-default + * @type {boolean} + */ +HTMLMenuItemElement.prototype.default; + +// TODO(dbeam): add HTMLMenuItemElement.prototype.command if it's implemented. + + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#relatedevent + * @param {string} type + * @param {{relatedTarget: (EventTarget|undefined)}=} opt_eventInitDict + * @constructor + * @extends {Event} + */ +function RelatedEvent(type, opt_eventInitDict) {} + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#dom-relatedevent-relatedtarget + * @type {EventTarget|undefined} + */ +RelatedEvent.prototype.relatedTarget; + + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#the-dialog-element + * @constructor + * @extends {HTMLElement} + */ +function HTMLDialogElement() {} + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#dom-dialog-open + * @type {boolean} + */ +HTMLDialogElement.prototype.open; + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#dom-dialog-returnvalue + * @type {string} + */ +HTMLDialogElement.prototype.returnValue; + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#dom-dialog-show + * @param {(MouseEvent|Element)=} opt_anchor + */ +HTMLDialogElement.prototype.show = function(opt_anchor) {}; + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#dom-dialog-showmodal + * @param {(MouseEvent|Element)=} opt_anchor + */ +HTMLDialogElement.prototype.showModal = function(opt_anchor) {}; + +/** + * @see http://www.w3.org/html/wg/drafts/html/master/interactive-elements.html#dom-dialog-close + * @param {string=} opt_returnValue + */ +HTMLDialogElement.prototype.close = function(opt_returnValue) {}; |