mirror of
https://github.com/react/react-native-devtools-frontend.git
synced 2026-10-05 03:21:16 +08:00
Tim van der Lippe
bfcaca046e
- Update yargs to 16.1.1 - Update @rollup/plugin-commonjs to 17.0.0 - Update @types/codemirror to 0.0.100 - Update Puppeteer to 5.5.0 - Update Rollup to 2.34.0 DISABLE_THIRD_PARTY_CHECK=NPM update R=jacktfranklin@chromium.org Change-Id: Ie3ed95b7c83ec615122643769ff5c53ac4111c09 Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/2567910 Commit-Queue: Tim van der Lippe <tvanderlippe@chromium.org> Reviewed-by: Jack Franklin <jacktfranklin@chromium.org>
9735 lines
396 KiB
JavaScript
9735 lines
396 KiB
JavaScript
Protocol.Accessibility = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.AccessibilityAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.AccessibilityAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.AccessibilityAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.AccessibilityAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.AccessibilityAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.AccessibilityAgent.DisableResponse>} */
|
|
Protocol.AccessibilityAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.AccessibilityAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.AccessibilityAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.AccessibilityAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.AccessibilityAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.AccessibilityAgent.EnableResponse>} */
|
|
Protocol.AccessibilityAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId=} opt_nodeId
|
|
* @param {Protocol.DOM.BackendNodeId=} opt_backendNodeId
|
|
* @param {Protocol.Runtime.RemoteObjectId=} opt_objectId
|
|
* @param {boolean=} opt_fetchRelatives
|
|
* @return {!Promise<?Array<Protocol.Accessibility.AXNode>>}
|
|
*/
|
|
Protocol.AccessibilityAgent.prototype.getPartialAXTree = function(opt_nodeId, opt_backendNodeId, opt_objectId, opt_fetchRelatives) {};
|
|
/** @typedef {!{objectId: (Protocol.Runtime.RemoteObjectId|undefined), nodeId: (Protocol.DOM.NodeId|undefined), backendNodeId: (Protocol.DOM.BackendNodeId|undefined), fetchRelatives: (boolean|undefined)}} */
|
|
Protocol.AccessibilityAgent.GetPartialAXTreeRequest;
|
|
/** @typedef {!{nodes: !Array<Protocol.Accessibility.AXNode>}} */
|
|
Protocol.AccessibilityAgent.GetPartialAXTreeResponse;
|
|
/**
|
|
* @param {!Protocol.AccessibilityAgent.GetPartialAXTreeRequest} obj
|
|
* @return {!Promise<!Protocol.AccessibilityAgent.GetPartialAXTreeResponse>} */
|
|
Protocol.AccessibilityAgent.prototype.invoke_getPartialAXTree = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<Protocol.Accessibility.AXNode>>}
|
|
*/
|
|
Protocol.AccessibilityAgent.prototype.getFullAXTree = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.AccessibilityAgent.GetFullAXTreeRequest;
|
|
/** @typedef {!{nodes: !Array<Protocol.Accessibility.AXNode>}} */
|
|
Protocol.AccessibilityAgent.GetFullAXTreeResponse;
|
|
/**
|
|
* @param {!Protocol.AccessibilityAgent.GetFullAXTreeRequest} obj
|
|
* @return {!Promise<!Protocol.AccessibilityAgent.GetFullAXTreeResponse>} */
|
|
Protocol.AccessibilityAgent.prototype.invoke_getFullAXTree = function(obj) {};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Accessibility.AXNodeId;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Accessibility.AXValueType = {
|
|
Boolean: "boolean",
|
|
Tristate: "tristate",
|
|
BooleanOrUndefined: "booleanOrUndefined",
|
|
Idref: "idref",
|
|
IdrefList: "idrefList",
|
|
Integer: "integer",
|
|
Node: "node",
|
|
NodeList: "nodeList",
|
|
Number: "number",
|
|
String: "string",
|
|
ComputedString: "computedString",
|
|
Token: "token",
|
|
TokenList: "tokenList",
|
|
DomRelation: "domRelation",
|
|
Role: "role",
|
|
InternalRole: "internalRole",
|
|
ValueUndefined: "valueUndefined"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Accessibility.AXValueSourceType = {
|
|
Attribute: "attribute",
|
|
Implicit: "implicit",
|
|
Style: "style",
|
|
Contents: "contents",
|
|
Placeholder: "placeholder",
|
|
RelatedElement: "relatedElement"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Accessibility.AXValueNativeSourceType = {
|
|
Figcaption: "figcaption",
|
|
Label: "label",
|
|
Labelfor: "labelfor",
|
|
Labelwrapped: "labelwrapped",
|
|
Legend: "legend",
|
|
Tablecaption: "tablecaption",
|
|
Title: "title",
|
|
Other: "other"
|
|
};
|
|
|
|
/** @typedef {!{type:(Protocol.Accessibility.AXValueSourceType), value:(Protocol.Accessibility.AXValue|undefined), attribute:(string|undefined), attributeValue:(Protocol.Accessibility.AXValue|undefined), superseded:(boolean|undefined), nativeSource:(Protocol.Accessibility.AXValueNativeSourceType|undefined), nativeSourceValue:(Protocol.Accessibility.AXValue|undefined), invalid:(boolean|undefined), invalidReason:(string|undefined)}} */
|
|
Protocol.Accessibility.AXValueSource;
|
|
|
|
/** @typedef {!{backendDOMNodeId:(Protocol.DOM.BackendNodeId), idref:(string|undefined), text:(string|undefined)}} */
|
|
Protocol.Accessibility.AXRelatedNode;
|
|
|
|
/** @typedef {!{name:(Protocol.Accessibility.AXPropertyName), value:(Protocol.Accessibility.AXValue)}} */
|
|
Protocol.Accessibility.AXProperty;
|
|
|
|
/** @typedef {!{type:(Protocol.Accessibility.AXValueType), value:(*|undefined), relatedNodes:(!Array<Protocol.Accessibility.AXRelatedNode>|undefined), sources:(!Array<Protocol.Accessibility.AXValueSource>|undefined)}} */
|
|
Protocol.Accessibility.AXValue;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Accessibility.AXPropertyName = {
|
|
Busy: "busy",
|
|
Disabled: "disabled",
|
|
Editable: "editable",
|
|
Focusable: "focusable",
|
|
Focused: "focused",
|
|
Hidden: "hidden",
|
|
HiddenRoot: "hiddenRoot",
|
|
Invalid: "invalid",
|
|
Keyshortcuts: "keyshortcuts",
|
|
Settable: "settable",
|
|
Roledescription: "roledescription",
|
|
Live: "live",
|
|
Atomic: "atomic",
|
|
Relevant: "relevant",
|
|
Root: "root",
|
|
Autocomplete: "autocomplete",
|
|
HasPopup: "hasPopup",
|
|
Level: "level",
|
|
Multiselectable: "multiselectable",
|
|
Orientation: "orientation",
|
|
Multiline: "multiline",
|
|
Readonly: "readonly",
|
|
Required: "required",
|
|
Valuemin: "valuemin",
|
|
Valuemax: "valuemax",
|
|
Valuetext: "valuetext",
|
|
Checked: "checked",
|
|
Expanded: "expanded",
|
|
Modal: "modal",
|
|
Pressed: "pressed",
|
|
Selected: "selected",
|
|
Activedescendant: "activedescendant",
|
|
Controls: "controls",
|
|
Describedby: "describedby",
|
|
Details: "details",
|
|
Errormessage: "errormessage",
|
|
Flowto: "flowto",
|
|
Labelledby: "labelledby",
|
|
Owns: "owns"
|
|
};
|
|
|
|
/** @typedef {!{nodeId:(Protocol.Accessibility.AXNodeId), ignored:(boolean), ignoredReasons:(!Array<Protocol.Accessibility.AXProperty>|undefined), role:(Protocol.Accessibility.AXValue|undefined), name:(Protocol.Accessibility.AXValue|undefined), description:(Protocol.Accessibility.AXValue|undefined), value:(Protocol.Accessibility.AXValue|undefined), properties:(!Array<Protocol.Accessibility.AXProperty>|undefined), childIds:(!Array<Protocol.Accessibility.AXNodeId>|undefined), backendDOMNodeId:(Protocol.DOM.BackendNodeId|undefined)}} */
|
|
Protocol.Accessibility.AXNode;
|
|
/** @interface */
|
|
Protocol.AccessibilityDispatcher = function() {};
|
|
Protocol.Animation = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.AnimationAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.AnimationAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.AnimationAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.AnimationAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.AnimationAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.AnimationAgent.DisableResponse>} */
|
|
Protocol.AnimationAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.AnimationAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.AnimationAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.AnimationAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.AnimationAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.AnimationAgent.EnableResponse>} */
|
|
Protocol.AnimationAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} id
|
|
* @return {!Promise<?number>}
|
|
*/
|
|
Protocol.AnimationAgent.prototype.getCurrentTime = function(id) {};
|
|
/** @typedef {!{id: string}} */
|
|
Protocol.AnimationAgent.GetCurrentTimeRequest;
|
|
/** @typedef {!{currentTime: number}} */
|
|
Protocol.AnimationAgent.GetCurrentTimeResponse;
|
|
/**
|
|
* @param {!Protocol.AnimationAgent.GetCurrentTimeRequest} obj
|
|
* @return {!Promise<!Protocol.AnimationAgent.GetCurrentTimeResponse>} */
|
|
Protocol.AnimationAgent.prototype.invoke_getCurrentTime = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?number>}
|
|
*/
|
|
Protocol.AnimationAgent.prototype.getPlaybackRate = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.AnimationAgent.GetPlaybackRateRequest;
|
|
/** @typedef {!{playbackRate: number}} */
|
|
Protocol.AnimationAgent.GetPlaybackRateResponse;
|
|
/**
|
|
* @param {!Protocol.AnimationAgent.GetPlaybackRateRequest} obj
|
|
* @return {!Promise<!Protocol.AnimationAgent.GetPlaybackRateResponse>} */
|
|
Protocol.AnimationAgent.prototype.invoke_getPlaybackRate = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<string>} animations
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.AnimationAgent.prototype.releaseAnimations = function(animations) {};
|
|
/** @typedef {!{animations: !Array<string>}} */
|
|
Protocol.AnimationAgent.ReleaseAnimationsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.AnimationAgent.ReleaseAnimationsResponse;
|
|
/**
|
|
* @param {!Protocol.AnimationAgent.ReleaseAnimationsRequest} obj
|
|
* @return {!Promise<!Protocol.AnimationAgent.ReleaseAnimationsResponse>} */
|
|
Protocol.AnimationAgent.prototype.invoke_releaseAnimations = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} animationId
|
|
* @return {!Promise<?Protocol.Runtime.RemoteObject>}
|
|
*/
|
|
Protocol.AnimationAgent.prototype.resolveAnimation = function(animationId) {};
|
|
/** @typedef {!{animationId: string}} */
|
|
Protocol.AnimationAgent.ResolveAnimationRequest;
|
|
/** @typedef {!{remoteObject: Protocol.Runtime.RemoteObject}} */
|
|
Protocol.AnimationAgent.ResolveAnimationResponse;
|
|
/**
|
|
* @param {!Protocol.AnimationAgent.ResolveAnimationRequest} obj
|
|
* @return {!Promise<!Protocol.AnimationAgent.ResolveAnimationResponse>} */
|
|
Protocol.AnimationAgent.prototype.invoke_resolveAnimation = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<string>} animations
|
|
* @param {number} currentTime
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.AnimationAgent.prototype.seekAnimations = function(animations, currentTime) {};
|
|
/** @typedef {!{currentTime: number, animations: !Array<string>}} */
|
|
Protocol.AnimationAgent.SeekAnimationsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.AnimationAgent.SeekAnimationsResponse;
|
|
/**
|
|
* @param {!Protocol.AnimationAgent.SeekAnimationsRequest} obj
|
|
* @return {!Promise<!Protocol.AnimationAgent.SeekAnimationsResponse>} */
|
|
Protocol.AnimationAgent.prototype.invoke_seekAnimations = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<string>} animations
|
|
* @param {boolean} paused
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.AnimationAgent.prototype.setPaused = function(animations, paused) {};
|
|
/** @typedef {!{paused: boolean, animations: !Array<string>}} */
|
|
Protocol.AnimationAgent.SetPausedRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.AnimationAgent.SetPausedResponse;
|
|
/**
|
|
* @param {!Protocol.AnimationAgent.SetPausedRequest} obj
|
|
* @return {!Promise<!Protocol.AnimationAgent.SetPausedResponse>} */
|
|
Protocol.AnimationAgent.prototype.invoke_setPaused = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} playbackRate
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.AnimationAgent.prototype.setPlaybackRate = function(playbackRate) {};
|
|
/** @typedef {!{playbackRate: number}} */
|
|
Protocol.AnimationAgent.SetPlaybackRateRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.AnimationAgent.SetPlaybackRateResponse;
|
|
/**
|
|
* @param {!Protocol.AnimationAgent.SetPlaybackRateRequest} obj
|
|
* @return {!Promise<!Protocol.AnimationAgent.SetPlaybackRateResponse>} */
|
|
Protocol.AnimationAgent.prototype.invoke_setPlaybackRate = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} animationId
|
|
* @param {number} duration
|
|
* @param {number} delay
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.AnimationAgent.prototype.setTiming = function(animationId, duration, delay) {};
|
|
/** @typedef {!{duration: number, delay: number, animationId: string}} */
|
|
Protocol.AnimationAgent.SetTimingRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.AnimationAgent.SetTimingResponse;
|
|
/**
|
|
* @param {!Protocol.AnimationAgent.SetTimingRequest} obj
|
|
* @return {!Promise<!Protocol.AnimationAgent.SetTimingResponse>} */
|
|
Protocol.AnimationAgent.prototype.invoke_setTiming = function(obj) {};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Animation.AnimationType = {
|
|
CSSTransition: "CSSTransition",
|
|
CSSAnimation: "CSSAnimation",
|
|
WebAnimation: "WebAnimation"
|
|
};
|
|
|
|
/** @typedef {!{id:(string), name:(string), pausedState:(boolean), playState:(string), playbackRate:(number), startTime:(number), currentTime:(number), type:(Protocol.Animation.AnimationType), source:(Protocol.Animation.AnimationEffect|undefined), cssId:(string|undefined)}} */
|
|
Protocol.Animation.Animation;
|
|
|
|
/** @typedef {!{delay:(number), endDelay:(number), iterationStart:(number), iterations:(number), duration:(number), direction:(string), fill:(string), backendNodeId:(Protocol.DOM.BackendNodeId|undefined), keyframesRule:(Protocol.Animation.KeyframesRule|undefined), easing:(string)}} */
|
|
Protocol.Animation.AnimationEffect;
|
|
|
|
/** @typedef {!{name:(string|undefined), keyframes:(!Array<Protocol.Animation.KeyframeStyle>)}} */
|
|
Protocol.Animation.KeyframesRule;
|
|
|
|
/** @typedef {!{offset:(string), easing:(string)}} */
|
|
Protocol.Animation.KeyframeStyle;
|
|
/** @interface */
|
|
Protocol.AnimationDispatcher = function() {};
|
|
/**
|
|
* @param {string} id
|
|
*/
|
|
Protocol.AnimationDispatcher.prototype.animationCanceled = function(id) {};
|
|
/**
|
|
* @param {string} id
|
|
*/
|
|
Protocol.AnimationDispatcher.prototype.animationCreated = function(id) {};
|
|
/**
|
|
* @param {Protocol.Animation.Animation} animation
|
|
*/
|
|
Protocol.AnimationDispatcher.prototype.animationStarted = function(animation) {};
|
|
Protocol.ApplicationCache = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.ApplicationCacheAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ApplicationCacheAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ApplicationCacheAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ApplicationCacheAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.ApplicationCacheAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.ApplicationCacheAgent.EnableResponse>} */
|
|
Protocol.ApplicationCacheAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @return {!Promise<?Protocol.ApplicationCache.ApplicationCache>}
|
|
*/
|
|
Protocol.ApplicationCacheAgent.prototype.getApplicationCacheForFrame = function(frameId) {};
|
|
/** @typedef {!{frameId: Protocol.Page.FrameId}} */
|
|
Protocol.ApplicationCacheAgent.GetApplicationCacheForFrameRequest;
|
|
/** @typedef {!{applicationCache: Protocol.ApplicationCache.ApplicationCache}} */
|
|
Protocol.ApplicationCacheAgent.GetApplicationCacheForFrameResponse;
|
|
/**
|
|
* @param {!Protocol.ApplicationCacheAgent.GetApplicationCacheForFrameRequest} obj
|
|
* @return {!Promise<!Protocol.ApplicationCacheAgent.GetApplicationCacheForFrameResponse>} */
|
|
Protocol.ApplicationCacheAgent.prototype.invoke_getApplicationCacheForFrame = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<Protocol.ApplicationCache.FrameWithManifest>>}
|
|
*/
|
|
Protocol.ApplicationCacheAgent.prototype.getFramesWithManifests = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ApplicationCacheAgent.GetFramesWithManifestsRequest;
|
|
/** @typedef {!{frameIds: !Array<Protocol.ApplicationCache.FrameWithManifest>}} */
|
|
Protocol.ApplicationCacheAgent.GetFramesWithManifestsResponse;
|
|
/**
|
|
* @param {!Protocol.ApplicationCacheAgent.GetFramesWithManifestsRequest} obj
|
|
* @return {!Promise<!Protocol.ApplicationCacheAgent.GetFramesWithManifestsResponse>} */
|
|
Protocol.ApplicationCacheAgent.prototype.invoke_getFramesWithManifests = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.ApplicationCacheAgent.prototype.getManifestForFrame = function(frameId) {};
|
|
/** @typedef {!{frameId: Protocol.Page.FrameId}} */
|
|
Protocol.ApplicationCacheAgent.GetManifestForFrameRequest;
|
|
/** @typedef {!{manifestURL: string}} */
|
|
Protocol.ApplicationCacheAgent.GetManifestForFrameResponse;
|
|
/**
|
|
* @param {!Protocol.ApplicationCacheAgent.GetManifestForFrameRequest} obj
|
|
* @return {!Promise<!Protocol.ApplicationCacheAgent.GetManifestForFrameResponse>} */
|
|
Protocol.ApplicationCacheAgent.prototype.invoke_getManifestForFrame = function(obj) {};
|
|
|
|
/** @typedef {!{url:(string), size:(number), type:(string)}} */
|
|
Protocol.ApplicationCache.ApplicationCacheResource;
|
|
|
|
/** @typedef {!{manifestURL:(string), size:(number), creationTime:(number), updateTime:(number), resources:(!Array<Protocol.ApplicationCache.ApplicationCacheResource>)}} */
|
|
Protocol.ApplicationCache.ApplicationCache;
|
|
|
|
/** @typedef {!{frameId:(Protocol.Page.FrameId), manifestURL:(string), status:(number)}} */
|
|
Protocol.ApplicationCache.FrameWithManifest;
|
|
/** @interface */
|
|
Protocol.ApplicationCacheDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @param {string} manifestURL
|
|
* @param {number} status
|
|
*/
|
|
Protocol.ApplicationCacheDispatcher.prototype.applicationCacheStatusUpdated = function(frameId, manifestURL, status) {};
|
|
/**
|
|
* @param {boolean} isNowOnline
|
|
*/
|
|
Protocol.ApplicationCacheDispatcher.prototype.networkStateUpdated = function(isNowOnline) {};
|
|
Protocol.Audits = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.AuditsAgent = function(){};
|
|
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {string} encoding
|
|
* @param {number=} opt_quality
|
|
* @param {boolean=} opt_sizeOnly
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.AuditsAgent.prototype.getEncodedResponse = function(requestId, encoding, opt_quality, opt_sizeOnly) {};
|
|
/** @typedef {!{sizeOnly: (boolean|undefined), quality: (number|undefined), requestId: Protocol.Network.RequestId, encoding: string}} */
|
|
Protocol.AuditsAgent.GetEncodedResponseRequest;
|
|
/** @typedef {!{body: string, encodedSize: number, originalSize: number}} */
|
|
Protocol.AuditsAgent.GetEncodedResponseResponse;
|
|
/**
|
|
* @param {!Protocol.AuditsAgent.GetEncodedResponseRequest} obj
|
|
* @return {!Promise<!Protocol.AuditsAgent.GetEncodedResponseResponse>} */
|
|
Protocol.AuditsAgent.prototype.invoke_getEncodedResponse = function(obj) {};
|
|
/** @interface */
|
|
Protocol.AuditsDispatcher = function() {};
|
|
Protocol.BackgroundService = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.BackgroundServiceAgent = function(){};
|
|
|
|
/**
|
|
* @param {Protocol.BackgroundService.ServiceName} service
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.BackgroundServiceAgent.prototype.startObserving = function(service) {};
|
|
/** @typedef {!{service: Protocol.BackgroundService.ServiceName}} */
|
|
Protocol.BackgroundServiceAgent.StartObservingRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BackgroundServiceAgent.StartObservingResponse;
|
|
/**
|
|
* @param {!Protocol.BackgroundServiceAgent.StartObservingRequest} obj
|
|
* @return {!Promise<!Protocol.BackgroundServiceAgent.StartObservingResponse>} */
|
|
Protocol.BackgroundServiceAgent.prototype.invoke_startObserving = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.BackgroundService.ServiceName} service
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.BackgroundServiceAgent.prototype.stopObserving = function(service) {};
|
|
/** @typedef {!{service: Protocol.BackgroundService.ServiceName}} */
|
|
Protocol.BackgroundServiceAgent.StopObservingRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BackgroundServiceAgent.StopObservingResponse;
|
|
/**
|
|
* @param {!Protocol.BackgroundServiceAgent.StopObservingRequest} obj
|
|
* @return {!Promise<!Protocol.BackgroundServiceAgent.StopObservingResponse>} */
|
|
Protocol.BackgroundServiceAgent.prototype.invoke_stopObserving = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} shouldRecord
|
|
* @param {Protocol.BackgroundService.ServiceName} service
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.BackgroundServiceAgent.prototype.setRecording = function(shouldRecord, service) {};
|
|
/** @typedef {!{shouldRecord: boolean, service: Protocol.BackgroundService.ServiceName}} */
|
|
Protocol.BackgroundServiceAgent.SetRecordingRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BackgroundServiceAgent.SetRecordingResponse;
|
|
/**
|
|
* @param {!Protocol.BackgroundServiceAgent.SetRecordingRequest} obj
|
|
* @return {!Promise<!Protocol.BackgroundServiceAgent.SetRecordingResponse>} */
|
|
Protocol.BackgroundServiceAgent.prototype.invoke_setRecording = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.BackgroundService.ServiceName} service
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.BackgroundServiceAgent.prototype.clearEvents = function(service) {};
|
|
/** @typedef {!{service: Protocol.BackgroundService.ServiceName}} */
|
|
Protocol.BackgroundServiceAgent.ClearEventsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BackgroundServiceAgent.ClearEventsResponse;
|
|
/**
|
|
* @param {!Protocol.BackgroundServiceAgent.ClearEventsRequest} obj
|
|
* @return {!Promise<!Protocol.BackgroundServiceAgent.ClearEventsResponse>} */
|
|
Protocol.BackgroundServiceAgent.prototype.invoke_clearEvents = function(obj) {};
|
|
|
|
/** @enum {string} */
|
|
Protocol.BackgroundService.ServiceName = {
|
|
BackgroundFetch: "backgroundFetch",
|
|
BackgroundSync: "backgroundSync",
|
|
PushMessaging: "pushMessaging",
|
|
Notifications: "notifications",
|
|
PaymentHandler: "paymentHandler",
|
|
PeriodicBackgroundSync: "periodicBackgroundSync"
|
|
};
|
|
|
|
/** @typedef {!{key:(string), value:(string)}} */
|
|
Protocol.BackgroundService.EventMetadata;
|
|
|
|
/** @typedef {!{timestamp:(Protocol.Network.TimeSinceEpoch), origin:(string), serviceWorkerRegistrationId:(Protocol.ServiceWorker.RegistrationID), service:(Protocol.BackgroundService.ServiceName), eventName:(string), instanceId:(string), eventMetadata:(!Array<Protocol.BackgroundService.EventMetadata>)}} */
|
|
Protocol.BackgroundService.BackgroundServiceEvent;
|
|
/** @interface */
|
|
Protocol.BackgroundServiceDispatcher = function() {};
|
|
/**
|
|
* @param {boolean} isRecording
|
|
* @param {Protocol.BackgroundService.ServiceName} service
|
|
*/
|
|
Protocol.BackgroundServiceDispatcher.prototype.recordingStateChanged = function(isRecording, service) {};
|
|
/**
|
|
* @param {Protocol.BackgroundService.BackgroundServiceEvent} backgroundServiceEvent
|
|
*/
|
|
Protocol.BackgroundServiceDispatcher.prototype.backgroundServiceEventReceived = function(backgroundServiceEvent) {};
|
|
Protocol.Browser = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.BrowserAgent = function(){};
|
|
|
|
/**
|
|
* @param {string} origin
|
|
* @param {Protocol.Browser.PermissionDescriptor} permission
|
|
* @param {Protocol.Browser.PermissionSetting} setting
|
|
* @param {Protocol.Target.TargetID=} opt_browserContextId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.BrowserAgent.prototype.setPermission = function(origin, permission, setting, opt_browserContextId) {};
|
|
/** @typedef {!{origin: string, browserContextId: (Protocol.Target.TargetID|undefined), setting: Protocol.Browser.PermissionSetting, permission: Protocol.Browser.PermissionDescriptor}} */
|
|
Protocol.BrowserAgent.SetPermissionRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BrowserAgent.SetPermissionResponse;
|
|
/**
|
|
* @param {!Protocol.BrowserAgent.SetPermissionRequest} obj
|
|
* @return {!Promise<!Protocol.BrowserAgent.SetPermissionResponse>} */
|
|
Protocol.BrowserAgent.prototype.invoke_setPermission = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} origin
|
|
* @param {!Array<Protocol.Browser.PermissionType>} permissions
|
|
* @param {Protocol.Target.BrowserContextID=} opt_browserContextId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.BrowserAgent.prototype.grantPermissions = function(origin, permissions, opt_browserContextId) {};
|
|
/** @typedef {!{origin: string, browserContextId: (Protocol.Target.BrowserContextID|undefined), permissions: !Array<Protocol.Browser.PermissionType>}} */
|
|
Protocol.BrowserAgent.GrantPermissionsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BrowserAgent.GrantPermissionsResponse;
|
|
/**
|
|
* @param {!Protocol.BrowserAgent.GrantPermissionsRequest} obj
|
|
* @return {!Promise<!Protocol.BrowserAgent.GrantPermissionsResponse>} */
|
|
Protocol.BrowserAgent.prototype.invoke_grantPermissions = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Target.BrowserContextID=} opt_browserContextId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.BrowserAgent.prototype.resetPermissions = function(opt_browserContextId) {};
|
|
/** @typedef {!{browserContextId: (Protocol.Target.BrowserContextID|undefined)}} */
|
|
Protocol.BrowserAgent.ResetPermissionsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BrowserAgent.ResetPermissionsResponse;
|
|
/**
|
|
* @param {!Protocol.BrowserAgent.ResetPermissionsRequest} obj
|
|
* @return {!Promise<!Protocol.BrowserAgent.ResetPermissionsResponse>} */
|
|
Protocol.BrowserAgent.prototype.invoke_resetPermissions = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.BrowserAgent.prototype.close = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BrowserAgent.CloseRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BrowserAgent.CloseResponse;
|
|
/**
|
|
* @param {!Protocol.BrowserAgent.CloseRequest} obj
|
|
* @return {!Promise<!Protocol.BrowserAgent.CloseResponse>} */
|
|
Protocol.BrowserAgent.prototype.invoke_close = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.BrowserAgent.prototype.crash = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BrowserAgent.CrashRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BrowserAgent.CrashResponse;
|
|
/**
|
|
* @param {!Protocol.BrowserAgent.CrashRequest} obj
|
|
* @return {!Promise<!Protocol.BrowserAgent.CrashResponse>} */
|
|
Protocol.BrowserAgent.prototype.invoke_crash = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.BrowserAgent.prototype.crashGpuProcess = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BrowserAgent.CrashGpuProcessRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BrowserAgent.CrashGpuProcessResponse;
|
|
/**
|
|
* @param {!Protocol.BrowserAgent.CrashGpuProcessRequest} obj
|
|
* @return {!Promise<!Protocol.BrowserAgent.CrashGpuProcessResponse>} */
|
|
Protocol.BrowserAgent.prototype.invoke_crashGpuProcess = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.BrowserAgent.prototype.getVersion = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BrowserAgent.GetVersionRequest;
|
|
/** @typedef {!{userAgent: string, product: string, revision: string, jsVersion: string, protocolVersion: string}} */
|
|
Protocol.BrowserAgent.GetVersionResponse;
|
|
/**
|
|
* @param {!Protocol.BrowserAgent.GetVersionRequest} obj
|
|
* @return {!Promise<!Protocol.BrowserAgent.GetVersionResponse>} */
|
|
Protocol.BrowserAgent.prototype.invoke_getVersion = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<string>>}
|
|
*/
|
|
Protocol.BrowserAgent.prototype.getBrowserCommandLine = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BrowserAgent.GetBrowserCommandLineRequest;
|
|
/** @typedef {!{arguments: !Array<string>}} */
|
|
Protocol.BrowserAgent.GetBrowserCommandLineResponse;
|
|
/**
|
|
* @param {!Protocol.BrowserAgent.GetBrowserCommandLineRequest} obj
|
|
* @return {!Promise<!Protocol.BrowserAgent.GetBrowserCommandLineResponse>} */
|
|
Protocol.BrowserAgent.prototype.invoke_getBrowserCommandLine = function(obj) {};
|
|
|
|
/**
|
|
* @param {string=} opt_query
|
|
* @param {boolean=} opt_delta
|
|
* @return {!Promise<?Array<Protocol.Browser.Histogram>>}
|
|
*/
|
|
Protocol.BrowserAgent.prototype.getHistograms = function(opt_query, opt_delta) {};
|
|
/** @typedef {!{query: (string|undefined), delta: (boolean|undefined)}} */
|
|
Protocol.BrowserAgent.GetHistogramsRequest;
|
|
/** @typedef {!{histograms: !Array<Protocol.Browser.Histogram>}} */
|
|
Protocol.BrowserAgent.GetHistogramsResponse;
|
|
/**
|
|
* @param {!Protocol.BrowserAgent.GetHistogramsRequest} obj
|
|
* @return {!Promise<!Protocol.BrowserAgent.GetHistogramsResponse>} */
|
|
Protocol.BrowserAgent.prototype.invoke_getHistograms = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} name
|
|
* @param {boolean=} opt_delta
|
|
* @return {!Promise<?Protocol.Browser.Histogram>}
|
|
*/
|
|
Protocol.BrowserAgent.prototype.getHistogram = function(name, opt_delta) {};
|
|
/** @typedef {!{name: string, delta: (boolean|undefined)}} */
|
|
Protocol.BrowserAgent.GetHistogramRequest;
|
|
/** @typedef {!{histogram: Protocol.Browser.Histogram}} */
|
|
Protocol.BrowserAgent.GetHistogramResponse;
|
|
/**
|
|
* @param {!Protocol.BrowserAgent.GetHistogramRequest} obj
|
|
* @return {!Promise<!Protocol.BrowserAgent.GetHistogramResponse>} */
|
|
Protocol.BrowserAgent.prototype.invoke_getHistogram = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Browser.WindowID} windowId
|
|
* @return {!Promise<?Protocol.Browser.Bounds>}
|
|
*/
|
|
Protocol.BrowserAgent.prototype.getWindowBounds = function(windowId) {};
|
|
/** @typedef {!{windowId: Protocol.Browser.WindowID}} */
|
|
Protocol.BrowserAgent.GetWindowBoundsRequest;
|
|
/** @typedef {!{bounds: Protocol.Browser.Bounds}} */
|
|
Protocol.BrowserAgent.GetWindowBoundsResponse;
|
|
/**
|
|
* @param {!Protocol.BrowserAgent.GetWindowBoundsRequest} obj
|
|
* @return {!Promise<!Protocol.BrowserAgent.GetWindowBoundsResponse>} */
|
|
Protocol.BrowserAgent.prototype.invoke_getWindowBounds = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Target.TargetID=} opt_targetId
|
|
* @return {!Promise<?Protocol.Browser.WindowID>}
|
|
*/
|
|
Protocol.BrowserAgent.prototype.getWindowForTarget = function(opt_targetId) {};
|
|
/** @typedef {!{targetId: (Protocol.Target.TargetID|undefined)}} */
|
|
Protocol.BrowserAgent.GetWindowForTargetRequest;
|
|
/** @typedef {!{windowId: Protocol.Browser.WindowID, bounds: Protocol.Browser.Bounds}} */
|
|
Protocol.BrowserAgent.GetWindowForTargetResponse;
|
|
/**
|
|
* @param {!Protocol.BrowserAgent.GetWindowForTargetRequest} obj
|
|
* @return {!Promise<!Protocol.BrowserAgent.GetWindowForTargetResponse>} */
|
|
Protocol.BrowserAgent.prototype.invoke_getWindowForTarget = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Browser.WindowID} windowId
|
|
* @param {Protocol.Browser.Bounds} bounds
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.BrowserAgent.prototype.setWindowBounds = function(windowId, bounds) {};
|
|
/** @typedef {!{windowId: Protocol.Browser.WindowID, bounds: Protocol.Browser.Bounds}} */
|
|
Protocol.BrowserAgent.SetWindowBoundsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BrowserAgent.SetWindowBoundsResponse;
|
|
/**
|
|
* @param {!Protocol.BrowserAgent.SetWindowBoundsRequest} obj
|
|
* @return {!Promise<!Protocol.BrowserAgent.SetWindowBoundsResponse>} */
|
|
Protocol.BrowserAgent.prototype.invoke_setWindowBounds = function(obj) {};
|
|
|
|
/**
|
|
* @param {string=} opt_badgeLabel
|
|
* @param {string=} opt_image
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.BrowserAgent.prototype.setDockTile = function(opt_badgeLabel, opt_image) {};
|
|
/** @typedef {!{image: (string|undefined), badgeLabel: (string|undefined)}} */
|
|
Protocol.BrowserAgent.SetDockTileRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.BrowserAgent.SetDockTileResponse;
|
|
/**
|
|
* @param {!Protocol.BrowserAgent.SetDockTileRequest} obj
|
|
* @return {!Promise<!Protocol.BrowserAgent.SetDockTileResponse>} */
|
|
Protocol.BrowserAgent.prototype.invoke_setDockTile = function(obj) {};
|
|
|
|
/** @typedef {number} */
|
|
Protocol.Browser.WindowID;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Browser.WindowState = {
|
|
Normal: "normal",
|
|
Minimized: "minimized",
|
|
Maximized: "maximized",
|
|
Fullscreen: "fullscreen"
|
|
};
|
|
|
|
/** @typedef {!{left:(number|undefined), top:(number|undefined), width:(number|undefined), height:(number|undefined), windowState:(Protocol.Browser.WindowState|undefined)}} */
|
|
Protocol.Browser.Bounds;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Browser.PermissionType = {
|
|
AccessibilityEvents: "accessibilityEvents",
|
|
AudioCapture: "audioCapture",
|
|
BackgroundSync: "backgroundSync",
|
|
BackgroundFetch: "backgroundFetch",
|
|
ClipboardRead: "clipboardRead",
|
|
ClipboardWrite: "clipboardWrite",
|
|
DurableStorage: "durableStorage",
|
|
Flash: "flash",
|
|
Geolocation: "geolocation",
|
|
Midi: "midi",
|
|
MidiSysex: "midiSysex",
|
|
Notifications: "notifications",
|
|
PaymentHandler: "paymentHandler",
|
|
PeriodicBackgroundSync: "periodicBackgroundSync",
|
|
ProtectedMediaIdentifier: "protectedMediaIdentifier",
|
|
Sensors: "sensors",
|
|
VideoCapture: "videoCapture",
|
|
IdleDetection: "idleDetection",
|
|
WakeLockScreen: "wakeLockScreen",
|
|
WakeLockSystem: "wakeLockSystem"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Browser.PermissionSetting = {
|
|
Granted: "granted",
|
|
Denied: "denied",
|
|
Prompt: "prompt"
|
|
};
|
|
|
|
/** @typedef {!{name:(string), sysex:(boolean|undefined), userVisibleOnly:(boolean|undefined), type:(string|undefined)}} */
|
|
Protocol.Browser.PermissionDescriptor;
|
|
|
|
/** @typedef {!{low:(number), high:(number), count:(number)}} */
|
|
Protocol.Browser.Bucket;
|
|
|
|
/** @typedef {!{name:(string), sum:(number), count:(number), buckets:(!Array<Protocol.Browser.Bucket>)}} */
|
|
Protocol.Browser.Histogram;
|
|
/** @interface */
|
|
Protocol.BrowserDispatcher = function() {};
|
|
Protocol.CSS = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.CSSAgent = function(){};
|
|
|
|
/**
|
|
* @param {Protocol.CSS.StyleSheetId} styleSheetId
|
|
* @param {string} ruleText
|
|
* @param {Protocol.CSS.SourceRange} location
|
|
* @return {!Promise<?Protocol.CSS.CSSRule>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.addRule = function(styleSheetId, ruleText, location) {};
|
|
/** @typedef {!{styleSheetId: Protocol.CSS.StyleSheetId, location: Protocol.CSS.SourceRange, ruleText: string}} */
|
|
Protocol.CSSAgent.AddRuleRequest;
|
|
/** @typedef {!{rule: Protocol.CSS.CSSRule}} */
|
|
Protocol.CSSAgent.AddRuleResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.AddRuleRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.AddRuleResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_addRule = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.CSS.StyleSheetId} styleSheetId
|
|
* @return {!Promise<?Array<string>>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.collectClassNames = function(styleSheetId) {};
|
|
/** @typedef {!{styleSheetId: Protocol.CSS.StyleSheetId}} */
|
|
Protocol.CSSAgent.CollectClassNamesRequest;
|
|
/** @typedef {!{classNames: !Array<string>}} */
|
|
Protocol.CSSAgent.CollectClassNamesResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.CollectClassNamesRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.CollectClassNamesResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_collectClassNames = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @return {!Promise<?Protocol.CSS.StyleSheetId>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.createStyleSheet = function(frameId) {};
|
|
/** @typedef {!{frameId: Protocol.Page.FrameId}} */
|
|
Protocol.CSSAgent.CreateStyleSheetRequest;
|
|
/** @typedef {!{styleSheetId: Protocol.CSS.StyleSheetId}} */
|
|
Protocol.CSSAgent.CreateStyleSheetResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.CreateStyleSheetRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.CreateStyleSheetResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_createStyleSheet = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CSSAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CSSAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.DisableResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CSSAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CSSAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.EnableResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {!Array<string>} forcedPseudoClasses
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.forcePseudoState = function(nodeId, forcedPseudoClasses) {};
|
|
/** @typedef {!{forcedPseudoClasses: !Array<string>, nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.CSSAgent.ForcePseudoStateRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CSSAgent.ForcePseudoStateResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.ForcePseudoStateRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.ForcePseudoStateResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_forcePseudoState = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @return {!Promise<?Array<string>>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.getBackgroundColors = function(nodeId) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.CSSAgent.GetBackgroundColorsRequest;
|
|
/** @typedef {!{backgroundColors: !Array<string>, computedFontWeight: string, computedFontSize: string}} */
|
|
Protocol.CSSAgent.GetBackgroundColorsResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.GetBackgroundColorsRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.GetBackgroundColorsResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_getBackgroundColors = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @return {!Promise<?Array<Protocol.CSS.CSSComputedStyleProperty>>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.getComputedStyleForNode = function(nodeId) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.CSSAgent.GetComputedStyleForNodeRequest;
|
|
/** @typedef {!{computedStyle: !Array<Protocol.CSS.CSSComputedStyleProperty>}} */
|
|
Protocol.CSSAgent.GetComputedStyleForNodeResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.GetComputedStyleForNodeRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.GetComputedStyleForNodeResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_getComputedStyleForNode = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @return {!Promise<?Protocol.CSS.CSSStyle>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.getInlineStylesForNode = function(nodeId) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.CSSAgent.GetInlineStylesForNodeRequest;
|
|
/** @typedef {!{inlineStyle: Protocol.CSS.CSSStyle, attributesStyle: Protocol.CSS.CSSStyle}} */
|
|
Protocol.CSSAgent.GetInlineStylesForNodeResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.GetInlineStylesForNodeRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.GetInlineStylesForNodeResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_getInlineStylesForNode = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @return {!Promise<?Protocol.CSS.CSSStyle>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.getMatchedStylesForNode = function(nodeId) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.CSSAgent.GetMatchedStylesForNodeRequest;
|
|
/** @typedef {!{inlineStyle: Protocol.CSS.CSSStyle, attributesStyle: Protocol.CSS.CSSStyle, cssKeyframesRules: !Array<Protocol.CSS.CSSKeyframesRule>, matchedCSSRules: !Array<Protocol.CSS.RuleMatch>, inherited: !Array<Protocol.CSS.InheritedStyleEntry>, pseudoElements: !Array<Protocol.CSS.PseudoElementMatches>}} */
|
|
Protocol.CSSAgent.GetMatchedStylesForNodeResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.GetMatchedStylesForNodeRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.GetMatchedStylesForNodeResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_getMatchedStylesForNode = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<Protocol.CSS.CSSMedia>>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.getMediaQueries = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CSSAgent.GetMediaQueriesRequest;
|
|
/** @typedef {!{medias: !Array<Protocol.CSS.CSSMedia>}} */
|
|
Protocol.CSSAgent.GetMediaQueriesResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.GetMediaQueriesRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.GetMediaQueriesResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_getMediaQueries = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @return {!Promise<?Array<Protocol.CSS.PlatformFontUsage>>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.getPlatformFontsForNode = function(nodeId) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.CSSAgent.GetPlatformFontsForNodeRequest;
|
|
/** @typedef {!{fonts: !Array<Protocol.CSS.PlatformFontUsage>}} */
|
|
Protocol.CSSAgent.GetPlatformFontsForNodeResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.GetPlatformFontsForNodeRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.GetPlatformFontsForNodeResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_getPlatformFontsForNode = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.CSS.StyleSheetId} styleSheetId
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.getStyleSheetText = function(styleSheetId) {};
|
|
/** @typedef {!{styleSheetId: Protocol.CSS.StyleSheetId}} */
|
|
Protocol.CSSAgent.GetStyleSheetTextRequest;
|
|
/** @typedef {!{text: string}} */
|
|
Protocol.CSSAgent.GetStyleSheetTextResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.GetStyleSheetTextRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.GetStyleSheetTextResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_getStyleSheetText = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {string} propertyName
|
|
* @param {string} value
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.setEffectivePropertyValueForNode = function(nodeId, propertyName, value) {};
|
|
/** @typedef {!{propertyName: string, nodeId: Protocol.DOM.NodeId, value: string}} */
|
|
Protocol.CSSAgent.SetEffectivePropertyValueForNodeRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CSSAgent.SetEffectivePropertyValueForNodeResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.SetEffectivePropertyValueForNodeRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.SetEffectivePropertyValueForNodeResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_setEffectivePropertyValueForNode = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.CSS.StyleSheetId} styleSheetId
|
|
* @param {Protocol.CSS.SourceRange} range
|
|
* @param {string} keyText
|
|
* @return {!Promise<?Protocol.CSS.Value>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.setKeyframeKey = function(styleSheetId, range, keyText) {};
|
|
/** @typedef {!{range: Protocol.CSS.SourceRange, styleSheetId: Protocol.CSS.StyleSheetId, keyText: string}} */
|
|
Protocol.CSSAgent.SetKeyframeKeyRequest;
|
|
/** @typedef {!{keyText: Protocol.CSS.Value}} */
|
|
Protocol.CSSAgent.SetKeyframeKeyResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.SetKeyframeKeyRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.SetKeyframeKeyResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_setKeyframeKey = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.CSS.StyleSheetId} styleSheetId
|
|
* @param {Protocol.CSS.SourceRange} range
|
|
* @param {string} text
|
|
* @return {!Promise<?Protocol.CSS.CSSMedia>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.setMediaText = function(styleSheetId, range, text) {};
|
|
/** @typedef {!{text: string, range: Protocol.CSS.SourceRange, styleSheetId: Protocol.CSS.StyleSheetId}} */
|
|
Protocol.CSSAgent.SetMediaTextRequest;
|
|
/** @typedef {!{media: Protocol.CSS.CSSMedia}} */
|
|
Protocol.CSSAgent.SetMediaTextResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.SetMediaTextRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.SetMediaTextResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_setMediaText = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.CSS.StyleSheetId} styleSheetId
|
|
* @param {Protocol.CSS.SourceRange} range
|
|
* @param {string} selector
|
|
* @return {!Promise<?Protocol.CSS.SelectorList>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.setRuleSelector = function(styleSheetId, range, selector) {};
|
|
/** @typedef {!{range: Protocol.CSS.SourceRange, styleSheetId: Protocol.CSS.StyleSheetId, selector: string}} */
|
|
Protocol.CSSAgent.SetRuleSelectorRequest;
|
|
/** @typedef {!{selectorList: Protocol.CSS.SelectorList}} */
|
|
Protocol.CSSAgent.SetRuleSelectorResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.SetRuleSelectorRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.SetRuleSelectorResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_setRuleSelector = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.CSS.StyleSheetId} styleSheetId
|
|
* @param {string} text
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.setStyleSheetText = function(styleSheetId, text) {};
|
|
/** @typedef {!{text: string, styleSheetId: Protocol.CSS.StyleSheetId}} */
|
|
Protocol.CSSAgent.SetStyleSheetTextRequest;
|
|
/** @typedef {!{sourceMapURL: string}} */
|
|
Protocol.CSSAgent.SetStyleSheetTextResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.SetStyleSheetTextRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.SetStyleSheetTextResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_setStyleSheetText = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<Protocol.CSS.StyleDeclarationEdit>} edits
|
|
* @return {!Promise<?Array<Protocol.CSS.CSSStyle>>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.setStyleTexts = function(edits) {};
|
|
/** @typedef {!{edits: !Array<Protocol.CSS.StyleDeclarationEdit>}} */
|
|
Protocol.CSSAgent.SetStyleTextsRequest;
|
|
/** @typedef {!{styles: !Array<Protocol.CSS.CSSStyle>}} */
|
|
Protocol.CSSAgent.SetStyleTextsResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.SetStyleTextsRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.SetStyleTextsResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_setStyleTexts = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.startRuleUsageTracking = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CSSAgent.StartRuleUsageTrackingRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CSSAgent.StartRuleUsageTrackingResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.StartRuleUsageTrackingRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.StartRuleUsageTrackingResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_startRuleUsageTracking = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<Protocol.CSS.RuleUsage>>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.stopRuleUsageTracking = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CSSAgent.StopRuleUsageTrackingRequest;
|
|
/** @typedef {!{ruleUsage: !Array<Protocol.CSS.RuleUsage>}} */
|
|
Protocol.CSSAgent.StopRuleUsageTrackingResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.StopRuleUsageTrackingRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.StopRuleUsageTrackingResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_stopRuleUsageTracking = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<Protocol.CSS.RuleUsage>>}
|
|
*/
|
|
Protocol.CSSAgent.prototype.takeCoverageDelta = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CSSAgent.TakeCoverageDeltaRequest;
|
|
/** @typedef {!{coverage: !Array<Protocol.CSS.RuleUsage>}} */
|
|
Protocol.CSSAgent.TakeCoverageDeltaResponse;
|
|
/**
|
|
* @param {!Protocol.CSSAgent.TakeCoverageDeltaRequest} obj
|
|
* @return {!Promise<!Protocol.CSSAgent.TakeCoverageDeltaResponse>} */
|
|
Protocol.CSSAgent.prototype.invoke_takeCoverageDelta = function(obj) {};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.CSS.StyleSheetId;
|
|
|
|
/** @enum {string} */
|
|
Protocol.CSS.StyleSheetOrigin = {
|
|
Injected: "injected",
|
|
UserAgent: "user-agent",
|
|
Inspector: "inspector",
|
|
Regular: "regular"
|
|
};
|
|
|
|
/** @typedef {!{pseudoType:(Protocol.DOM.PseudoType), matches:(!Array<Protocol.CSS.RuleMatch>)}} */
|
|
Protocol.CSS.PseudoElementMatches;
|
|
|
|
/** @typedef {!{inlineStyle:(Protocol.CSS.CSSStyle|undefined), matchedCSSRules:(!Array<Protocol.CSS.RuleMatch>)}} */
|
|
Protocol.CSS.InheritedStyleEntry;
|
|
|
|
/** @typedef {!{rule:(Protocol.CSS.CSSRule), matchingSelectors:(!Array<number>)}} */
|
|
Protocol.CSS.RuleMatch;
|
|
|
|
/** @typedef {!{text:(string), range:(Protocol.CSS.SourceRange|undefined)}} */
|
|
Protocol.CSS.Value;
|
|
|
|
/** @typedef {!{selectors:(!Array<Protocol.CSS.Value>), text:(string)}} */
|
|
Protocol.CSS.SelectorList;
|
|
|
|
/** @typedef {!{styleSheetId:(Protocol.CSS.StyleSheetId), frameId:(Protocol.Page.FrameId), sourceURL:(string), sourceMapURL:(string|undefined), origin:(Protocol.CSS.StyleSheetOrigin), title:(string), ownerNode:(Protocol.DOM.BackendNodeId|undefined), disabled:(boolean), hasSourceURL:(boolean|undefined), isInline:(boolean), startLine:(number), startColumn:(number), length:(number), endLine:(number), endColumn:(number)}} */
|
|
Protocol.CSS.CSSStyleSheetHeader;
|
|
|
|
/** @typedef {!{styleSheetId:(Protocol.CSS.StyleSheetId|undefined), selectorList:(Protocol.CSS.SelectorList), origin:(Protocol.CSS.StyleSheetOrigin), style:(Protocol.CSS.CSSStyle), media:(!Array<Protocol.CSS.CSSMedia>|undefined)}} */
|
|
Protocol.CSS.CSSRule;
|
|
|
|
/** @typedef {!{styleSheetId:(Protocol.CSS.StyleSheetId), startOffset:(number), endOffset:(number), used:(boolean)}} */
|
|
Protocol.CSS.RuleUsage;
|
|
|
|
/** @typedef {!{startLine:(number), startColumn:(number), endLine:(number), endColumn:(number)}} */
|
|
Protocol.CSS.SourceRange;
|
|
|
|
/** @typedef {!{name:(string), value:(string), important:(boolean|undefined)}} */
|
|
Protocol.CSS.ShorthandEntry;
|
|
|
|
/** @typedef {!{name:(string), value:(string)}} */
|
|
Protocol.CSS.CSSComputedStyleProperty;
|
|
|
|
/** @typedef {!{styleSheetId:(Protocol.CSS.StyleSheetId|undefined), cssProperties:(!Array<Protocol.CSS.CSSProperty>), shorthandEntries:(!Array<Protocol.CSS.ShorthandEntry>), cssText:(string|undefined), range:(Protocol.CSS.SourceRange|undefined)}} */
|
|
Protocol.CSS.CSSStyle;
|
|
|
|
/** @typedef {!{name:(string), value:(string), important:(boolean|undefined), implicit:(boolean|undefined), text:(string|undefined), parsedOk:(boolean|undefined), disabled:(boolean|undefined), range:(Protocol.CSS.SourceRange|undefined)}} */
|
|
Protocol.CSS.CSSProperty;
|
|
|
|
/** @enum {string} */
|
|
Protocol.CSS.CSSMediaSource = {
|
|
MediaRule: "mediaRule",
|
|
ImportRule: "importRule",
|
|
LinkedSheet: "linkedSheet",
|
|
InlineSheet: "inlineSheet"
|
|
};
|
|
|
|
/** @typedef {!{text:(string), source:(Protocol.CSS.CSSMediaSource), sourceURL:(string|undefined), range:(Protocol.CSS.SourceRange|undefined), styleSheetId:(Protocol.CSS.StyleSheetId|undefined), mediaList:(!Array<Protocol.CSS.MediaQuery>|undefined)}} */
|
|
Protocol.CSS.CSSMedia;
|
|
|
|
/** @typedef {!{expressions:(!Array<Protocol.CSS.MediaQueryExpression>), active:(boolean)}} */
|
|
Protocol.CSS.MediaQuery;
|
|
|
|
/** @typedef {!{value:(number), unit:(string), feature:(string), valueRange:(Protocol.CSS.SourceRange|undefined), computedLength:(number|undefined)}} */
|
|
Protocol.CSS.MediaQueryExpression;
|
|
|
|
/** @typedef {!{familyName:(string), isCustomFont:(boolean), glyphCount:(number)}} */
|
|
Protocol.CSS.PlatformFontUsage;
|
|
|
|
/** @typedef {!{fontFamily:(string), fontStyle:(string), fontVariant:(string), fontWeight:(string), fontStretch:(string), unicodeRange:(string), src:(string), platformFontFamily:(string)}} */
|
|
Protocol.CSS.FontFace;
|
|
|
|
/** @typedef {!{animationName:(Protocol.CSS.Value), keyframes:(!Array<Protocol.CSS.CSSKeyframeRule>)}} */
|
|
Protocol.CSS.CSSKeyframesRule;
|
|
|
|
/** @typedef {!{styleSheetId:(Protocol.CSS.StyleSheetId|undefined), origin:(Protocol.CSS.StyleSheetOrigin), keyText:(Protocol.CSS.Value), style:(Protocol.CSS.CSSStyle)}} */
|
|
Protocol.CSS.CSSKeyframeRule;
|
|
|
|
/** @typedef {!{styleSheetId:(Protocol.CSS.StyleSheetId), range:(Protocol.CSS.SourceRange), text:(string)}} */
|
|
Protocol.CSS.StyleDeclarationEdit;
|
|
/** @interface */
|
|
Protocol.CSSDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.CSS.FontFace=} opt_font
|
|
*/
|
|
Protocol.CSSDispatcher.prototype.fontsUpdated = function(opt_font) {};
|
|
Protocol.CSSDispatcher.prototype.mediaQueryResultChanged = function() {};
|
|
/**
|
|
* @param {Protocol.CSS.CSSStyleSheetHeader} header
|
|
*/
|
|
Protocol.CSSDispatcher.prototype.styleSheetAdded = function(header) {};
|
|
/**
|
|
* @param {Protocol.CSS.StyleSheetId} styleSheetId
|
|
*/
|
|
Protocol.CSSDispatcher.prototype.styleSheetChanged = function(styleSheetId) {};
|
|
/**
|
|
* @param {Protocol.CSS.StyleSheetId} styleSheetId
|
|
*/
|
|
Protocol.CSSDispatcher.prototype.styleSheetRemoved = function(styleSheetId) {};
|
|
Protocol.CacheStorage = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.CacheStorageAgent = function(){};
|
|
|
|
/**
|
|
* @param {Protocol.CacheStorage.CacheId} cacheId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.CacheStorageAgent.prototype.deleteCache = function(cacheId) {};
|
|
/** @typedef {!{cacheId: Protocol.CacheStorage.CacheId}} */
|
|
Protocol.CacheStorageAgent.DeleteCacheRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CacheStorageAgent.DeleteCacheResponse;
|
|
/**
|
|
* @param {!Protocol.CacheStorageAgent.DeleteCacheRequest} obj
|
|
* @return {!Promise<!Protocol.CacheStorageAgent.DeleteCacheResponse>} */
|
|
Protocol.CacheStorageAgent.prototype.invoke_deleteCache = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.CacheStorage.CacheId} cacheId
|
|
* @param {string} request
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.CacheStorageAgent.prototype.deleteEntry = function(cacheId, request) {};
|
|
/** @typedef {!{cacheId: Protocol.CacheStorage.CacheId, request: string}} */
|
|
Protocol.CacheStorageAgent.DeleteEntryRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CacheStorageAgent.DeleteEntryResponse;
|
|
/**
|
|
* @param {!Protocol.CacheStorageAgent.DeleteEntryRequest} obj
|
|
* @return {!Promise<!Protocol.CacheStorageAgent.DeleteEntryResponse>} */
|
|
Protocol.CacheStorageAgent.prototype.invoke_deleteEntry = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} securityOrigin
|
|
* @return {!Promise<?Array<Protocol.CacheStorage.Cache>>}
|
|
*/
|
|
Protocol.CacheStorageAgent.prototype.requestCacheNames = function(securityOrigin) {};
|
|
/** @typedef {!{securityOrigin: string}} */
|
|
Protocol.CacheStorageAgent.RequestCacheNamesRequest;
|
|
/** @typedef {!{caches: !Array<Protocol.CacheStorage.Cache>}} */
|
|
Protocol.CacheStorageAgent.RequestCacheNamesResponse;
|
|
/**
|
|
* @param {!Protocol.CacheStorageAgent.RequestCacheNamesRequest} obj
|
|
* @return {!Promise<!Protocol.CacheStorageAgent.RequestCacheNamesResponse>} */
|
|
Protocol.CacheStorageAgent.prototype.invoke_requestCacheNames = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.CacheStorage.CacheId} cacheId
|
|
* @param {string} requestURL
|
|
* @param {!Array<Protocol.CacheStorage.Header>} requestHeaders
|
|
* @return {!Promise<?Protocol.CacheStorage.CachedResponse>}
|
|
*/
|
|
Protocol.CacheStorageAgent.prototype.requestCachedResponse = function(cacheId, requestURL, requestHeaders) {};
|
|
/** @typedef {!{requestHeaders: !Array<Protocol.CacheStorage.Header>, cacheId: Protocol.CacheStorage.CacheId, requestURL: string}} */
|
|
Protocol.CacheStorageAgent.RequestCachedResponseRequest;
|
|
/** @typedef {!{response: Protocol.CacheStorage.CachedResponse}} */
|
|
Protocol.CacheStorageAgent.RequestCachedResponseResponse;
|
|
/**
|
|
* @param {!Protocol.CacheStorageAgent.RequestCachedResponseRequest} obj
|
|
* @return {!Promise<!Protocol.CacheStorageAgent.RequestCachedResponseResponse>} */
|
|
Protocol.CacheStorageAgent.prototype.invoke_requestCachedResponse = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.CacheStorage.CacheId} cacheId
|
|
* @param {number=} opt_skipCount
|
|
* @param {number=} opt_pageSize
|
|
* @param {string=} opt_pathFilter
|
|
* @return {!Promise<?Array<Protocol.CacheStorage.DataEntry>>}
|
|
*/
|
|
Protocol.CacheStorageAgent.prototype.requestEntries = function(cacheId, opt_skipCount, opt_pageSize, opt_pathFilter) {};
|
|
/** @typedef {!{pathFilter: (string|undefined), cacheId: Protocol.CacheStorage.CacheId, skipCount: (number|undefined), pageSize: (number|undefined)}} */
|
|
Protocol.CacheStorageAgent.RequestEntriesRequest;
|
|
/** @typedef {!{returnCount: number, cacheDataEntries: !Array<Protocol.CacheStorage.DataEntry>}} */
|
|
Protocol.CacheStorageAgent.RequestEntriesResponse;
|
|
/**
|
|
* @param {!Protocol.CacheStorageAgent.RequestEntriesRequest} obj
|
|
* @return {!Promise<!Protocol.CacheStorageAgent.RequestEntriesResponse>} */
|
|
Protocol.CacheStorageAgent.prototype.invoke_requestEntries = function(obj) {};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.CacheStorage.CacheId;
|
|
|
|
/** @enum {string} */
|
|
Protocol.CacheStorage.CachedResponseType = {
|
|
Basic: "basic",
|
|
Cors: "cors",
|
|
Default: "default",
|
|
Error: "error",
|
|
OpaqueResponse: "opaqueResponse",
|
|
OpaqueRedirect: "opaqueRedirect"
|
|
};
|
|
|
|
/** @typedef {!{requestURL:(string), requestMethod:(string), requestHeaders:(!Array<Protocol.CacheStorage.Header>), responseTime:(number), responseStatus:(number), responseStatusText:(string), responseType:(Protocol.CacheStorage.CachedResponseType), responseHeaders:(!Array<Protocol.CacheStorage.Header>)}} */
|
|
Protocol.CacheStorage.DataEntry;
|
|
|
|
/** @typedef {!{cacheId:(Protocol.CacheStorage.CacheId), securityOrigin:(string), cacheName:(string)}} */
|
|
Protocol.CacheStorage.Cache;
|
|
|
|
/** @typedef {!{name:(string), value:(string)}} */
|
|
Protocol.CacheStorage.Header;
|
|
|
|
/** @typedef {!{body:(string)}} */
|
|
Protocol.CacheStorage.CachedResponse;
|
|
/** @interface */
|
|
Protocol.CacheStorageDispatcher = function() {};
|
|
Protocol.Cast = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.CastAgent = function(){};
|
|
|
|
/**
|
|
* @param {string=} opt_presentationUrl
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.CastAgent.prototype.enable = function(opt_presentationUrl) {};
|
|
/** @typedef {!{presentationUrl: (string|undefined)}} */
|
|
Protocol.CastAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CastAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.CastAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.CastAgent.EnableResponse>} */
|
|
Protocol.CastAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.CastAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CastAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CastAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.CastAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.CastAgent.DisableResponse>} */
|
|
Protocol.CastAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} sinkName
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.CastAgent.prototype.setSinkToUse = function(sinkName) {};
|
|
/** @typedef {!{sinkName: string}} */
|
|
Protocol.CastAgent.SetSinkToUseRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CastAgent.SetSinkToUseResponse;
|
|
/**
|
|
* @param {!Protocol.CastAgent.SetSinkToUseRequest} obj
|
|
* @return {!Promise<!Protocol.CastAgent.SetSinkToUseResponse>} */
|
|
Protocol.CastAgent.prototype.invoke_setSinkToUse = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} sinkName
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.CastAgent.prototype.startTabMirroring = function(sinkName) {};
|
|
/** @typedef {!{sinkName: string}} */
|
|
Protocol.CastAgent.StartTabMirroringRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CastAgent.StartTabMirroringResponse;
|
|
/**
|
|
* @param {!Protocol.CastAgent.StartTabMirroringRequest} obj
|
|
* @return {!Promise<!Protocol.CastAgent.StartTabMirroringResponse>} */
|
|
Protocol.CastAgent.prototype.invoke_startTabMirroring = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} sinkName
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.CastAgent.prototype.stopCasting = function(sinkName) {};
|
|
/** @typedef {!{sinkName: string}} */
|
|
Protocol.CastAgent.StopCastingRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.CastAgent.StopCastingResponse;
|
|
/**
|
|
* @param {!Protocol.CastAgent.StopCastingRequest} obj
|
|
* @return {!Promise<!Protocol.CastAgent.StopCastingResponse>} */
|
|
Protocol.CastAgent.prototype.invoke_stopCasting = function(obj) {};
|
|
|
|
/** @typedef {!{name:(string), id:(string), session:(string|undefined)}} */
|
|
Protocol.Cast.Sink;
|
|
/** @interface */
|
|
Protocol.CastDispatcher = function() {};
|
|
/**
|
|
* @param {!Array<Protocol.Cast.Sink>} sinks
|
|
*/
|
|
Protocol.CastDispatcher.prototype.sinksUpdated = function(sinks) {};
|
|
/**
|
|
* @param {string} issueMessage
|
|
*/
|
|
Protocol.CastDispatcher.prototype.issueUpdated = function(issueMessage) {};
|
|
Protocol.DOM = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.DOMAgent = function(){};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @return {!Promise<?Array<string>>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.collectClassNamesFromSubtree = function(nodeId) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.DOMAgent.CollectClassNamesFromSubtreeRequest;
|
|
/** @typedef {!{classNames: !Array<string>}} */
|
|
Protocol.DOMAgent.CollectClassNamesFromSubtreeResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.CollectClassNamesFromSubtreeRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.CollectClassNamesFromSubtreeResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_collectClassNamesFromSubtree = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {Protocol.DOM.NodeId} targetNodeId
|
|
* @param {Protocol.DOM.NodeId=} opt_insertBeforeNodeId
|
|
* @return {!Promise<?Protocol.DOM.NodeId>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.copyTo = function(nodeId, targetNodeId, opt_insertBeforeNodeId) {};
|
|
/** @typedef {!{targetNodeId: Protocol.DOM.NodeId, nodeId: Protocol.DOM.NodeId, insertBeforeNodeId: (Protocol.DOM.NodeId|undefined)}} */
|
|
Protocol.DOMAgent.CopyToRequest;
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.DOMAgent.CopyToResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.CopyToRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.CopyToResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_copyTo = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId=} opt_nodeId
|
|
* @param {Protocol.DOM.BackendNodeId=} opt_backendNodeId
|
|
* @param {Protocol.Runtime.RemoteObjectId=} opt_objectId
|
|
* @param {number=} opt_depth
|
|
* @param {boolean=} opt_pierce
|
|
* @return {!Promise<?Protocol.DOM.Node>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.describeNode = function(opt_nodeId, opt_backendNodeId, opt_objectId, opt_depth, opt_pierce) {};
|
|
/** @typedef {!{depth: (number|undefined), objectId: (Protocol.Runtime.RemoteObjectId|undefined), nodeId: (Protocol.DOM.NodeId|undefined), backendNodeId: (Protocol.DOM.BackendNodeId|undefined), pierce: (boolean|undefined)}} */
|
|
Protocol.DOMAgent.DescribeNodeRequest;
|
|
/** @typedef {!{node: Protocol.DOM.Node}} */
|
|
Protocol.DOMAgent.DescribeNodeResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.DescribeNodeRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.DescribeNodeResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_describeNode = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.DisableResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} searchId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.discardSearchResults = function(searchId) {};
|
|
/** @typedef {!{searchId: string}} */
|
|
Protocol.DOMAgent.DiscardSearchResultsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.DiscardSearchResultsResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.DiscardSearchResultsRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.DiscardSearchResultsResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_discardSearchResults = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.EnableResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId=} opt_nodeId
|
|
* @param {Protocol.DOM.BackendNodeId=} opt_backendNodeId
|
|
* @param {Protocol.Runtime.RemoteObjectId=} opt_objectId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.focus = function(opt_nodeId, opt_backendNodeId, opt_objectId) {};
|
|
/** @typedef {!{objectId: (Protocol.Runtime.RemoteObjectId|undefined), nodeId: (Protocol.DOM.NodeId|undefined), backendNodeId: (Protocol.DOM.BackendNodeId|undefined)}} */
|
|
Protocol.DOMAgent.FocusRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.FocusResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.FocusRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.FocusResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_focus = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @return {!Promise<?Array<string>>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.getAttributes = function(nodeId) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.DOMAgent.GetAttributesRequest;
|
|
/** @typedef {!{attributes: !Array<string>}} */
|
|
Protocol.DOMAgent.GetAttributesResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.GetAttributesRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.GetAttributesResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_getAttributes = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId=} opt_nodeId
|
|
* @param {Protocol.DOM.BackendNodeId=} opt_backendNodeId
|
|
* @param {Protocol.Runtime.RemoteObjectId=} opt_objectId
|
|
* @return {!Promise<?Protocol.DOM.BoxModel>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.getBoxModel = function(opt_nodeId, opt_backendNodeId, opt_objectId) {};
|
|
/** @typedef {!{objectId: (Protocol.Runtime.RemoteObjectId|undefined), nodeId: (Protocol.DOM.NodeId|undefined), backendNodeId: (Protocol.DOM.BackendNodeId|undefined)}} */
|
|
Protocol.DOMAgent.GetBoxModelRequest;
|
|
/** @typedef {!{model: Protocol.DOM.BoxModel}} */
|
|
Protocol.DOMAgent.GetBoxModelResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.GetBoxModelRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.GetBoxModelResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_getBoxModel = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId=} opt_nodeId
|
|
* @param {Protocol.DOM.BackendNodeId=} opt_backendNodeId
|
|
* @param {Protocol.Runtime.RemoteObjectId=} opt_objectId
|
|
* @return {!Promise<?Array<Protocol.DOM.Quad>>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.getContentQuads = function(opt_nodeId, opt_backendNodeId, opt_objectId) {};
|
|
/** @typedef {!{objectId: (Protocol.Runtime.RemoteObjectId|undefined), nodeId: (Protocol.DOM.NodeId|undefined), backendNodeId: (Protocol.DOM.BackendNodeId|undefined)}} */
|
|
Protocol.DOMAgent.GetContentQuadsRequest;
|
|
/** @typedef {!{quads: !Array<Protocol.DOM.Quad>}} */
|
|
Protocol.DOMAgent.GetContentQuadsResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.GetContentQuadsRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.GetContentQuadsResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_getContentQuads = function(obj) {};
|
|
|
|
/**
|
|
* @param {number=} opt_depth
|
|
* @param {boolean=} opt_pierce
|
|
* @return {!Promise<?Protocol.DOM.Node>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.getDocument = function(opt_depth, opt_pierce) {};
|
|
/** @typedef {!{depth: (number|undefined), pierce: (boolean|undefined)}} */
|
|
Protocol.DOMAgent.GetDocumentRequest;
|
|
/** @typedef {!{root: Protocol.DOM.Node}} */
|
|
Protocol.DOMAgent.GetDocumentResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.GetDocumentRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.GetDocumentResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_getDocument = function(obj) {};
|
|
|
|
/**
|
|
* @param {number=} opt_depth
|
|
* @param {boolean=} opt_pierce
|
|
* @return {!Promise<?Array<Protocol.DOM.Node>>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.getFlattenedDocument = function(opt_depth, opt_pierce) {};
|
|
/** @typedef {!{depth: (number|undefined), pierce: (boolean|undefined)}} */
|
|
Protocol.DOMAgent.GetFlattenedDocumentRequest;
|
|
/** @typedef {!{nodes: !Array<Protocol.DOM.Node>}} */
|
|
Protocol.DOMAgent.GetFlattenedDocumentResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.GetFlattenedDocumentRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.GetFlattenedDocumentResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_getFlattenedDocument = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} x
|
|
* @param {number} y
|
|
* @param {boolean=} opt_includeUserAgentShadowDOM
|
|
* @param {boolean=} opt_ignorePointerEventsNone
|
|
* @return {!Promise<?Protocol.DOM.BackendNodeId>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.getNodeForLocation = function(x, y, opt_includeUserAgentShadowDOM, opt_ignorePointerEventsNone) {};
|
|
/** @typedef {!{y: number, x: number, ignorePointerEventsNone: (boolean|undefined), includeUserAgentShadowDOM: (boolean|undefined)}} */
|
|
Protocol.DOMAgent.GetNodeForLocationRequest;
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId, backendNodeId: Protocol.DOM.BackendNodeId, frameId: Protocol.Page.FrameId}} */
|
|
Protocol.DOMAgent.GetNodeForLocationResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.GetNodeForLocationRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.GetNodeForLocationResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_getNodeForLocation = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId=} opt_nodeId
|
|
* @param {Protocol.DOM.BackendNodeId=} opt_backendNodeId
|
|
* @param {Protocol.Runtime.RemoteObjectId=} opt_objectId
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.getOuterHTML = function(opt_nodeId, opt_backendNodeId, opt_objectId) {};
|
|
/** @typedef {!{objectId: (Protocol.Runtime.RemoteObjectId|undefined), nodeId: (Protocol.DOM.NodeId|undefined), backendNodeId: (Protocol.DOM.BackendNodeId|undefined)}} */
|
|
Protocol.DOMAgent.GetOuterHTMLRequest;
|
|
/** @typedef {!{outerHTML: string}} */
|
|
Protocol.DOMAgent.GetOuterHTMLResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.GetOuterHTMLRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.GetOuterHTMLResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_getOuterHTML = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @return {!Promise<?Protocol.DOM.NodeId>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.getRelayoutBoundary = function(nodeId) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.DOMAgent.GetRelayoutBoundaryRequest;
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.DOMAgent.GetRelayoutBoundaryResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.GetRelayoutBoundaryRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.GetRelayoutBoundaryResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_getRelayoutBoundary = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} searchId
|
|
* @param {number} fromIndex
|
|
* @param {number} toIndex
|
|
* @return {!Promise<?Array<Protocol.DOM.NodeId>>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.getSearchResults = function(searchId, fromIndex, toIndex) {};
|
|
/** @typedef {!{toIndex: number, searchId: string, fromIndex: number}} */
|
|
Protocol.DOMAgent.GetSearchResultsRequest;
|
|
/** @typedef {!{nodeIds: !Array<Protocol.DOM.NodeId>}} */
|
|
Protocol.DOMAgent.GetSearchResultsResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.GetSearchResultsRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.GetSearchResultsResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_getSearchResults = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.hideHighlight = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.HideHighlightRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.HideHighlightResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.HideHighlightRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.HideHighlightResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_hideHighlight = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.highlightNode = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.HighlightNodeRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.HighlightNodeResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.HighlightNodeRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.HighlightNodeResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_highlightNode = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.highlightRect = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.HighlightRectRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.HighlightRectResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.HighlightRectRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.HighlightRectResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_highlightRect = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.markUndoableState = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.MarkUndoableStateRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.MarkUndoableStateResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.MarkUndoableStateRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.MarkUndoableStateResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_markUndoableState = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {Protocol.DOM.NodeId} targetNodeId
|
|
* @param {Protocol.DOM.NodeId=} opt_insertBeforeNodeId
|
|
* @return {!Promise<?Protocol.DOM.NodeId>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.moveTo = function(nodeId, targetNodeId, opt_insertBeforeNodeId) {};
|
|
/** @typedef {!{targetNodeId: Protocol.DOM.NodeId, nodeId: Protocol.DOM.NodeId, insertBeforeNodeId: (Protocol.DOM.NodeId|undefined)}} */
|
|
Protocol.DOMAgent.MoveToRequest;
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.DOMAgent.MoveToResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.MoveToRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.MoveToResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_moveTo = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} query
|
|
* @param {boolean=} opt_includeUserAgentShadowDOM
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.performSearch = function(query, opt_includeUserAgentShadowDOM) {};
|
|
/** @typedef {!{query: string, includeUserAgentShadowDOM: (boolean|undefined)}} */
|
|
Protocol.DOMAgent.PerformSearchRequest;
|
|
/** @typedef {!{searchId: string, resultCount: number}} */
|
|
Protocol.DOMAgent.PerformSearchResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.PerformSearchRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.PerformSearchResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_performSearch = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} path
|
|
* @return {!Promise<?Protocol.DOM.NodeId>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.pushNodeByPathToFrontend = function(path) {};
|
|
/** @typedef {!{path: string}} */
|
|
Protocol.DOMAgent.PushNodeByPathToFrontendRequest;
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.DOMAgent.PushNodeByPathToFrontendResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.PushNodeByPathToFrontendRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.PushNodeByPathToFrontendResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_pushNodeByPathToFrontend = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<Protocol.DOM.BackendNodeId>} backendNodeIds
|
|
* @return {!Promise<?Array<Protocol.DOM.NodeId>>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.pushNodesByBackendIdsToFrontend = function(backendNodeIds) {};
|
|
/** @typedef {!{backendNodeIds: !Array<Protocol.DOM.BackendNodeId>}} */
|
|
Protocol.DOMAgent.PushNodesByBackendIdsToFrontendRequest;
|
|
/** @typedef {!{nodeIds: !Array<Protocol.DOM.NodeId>}} */
|
|
Protocol.DOMAgent.PushNodesByBackendIdsToFrontendResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.PushNodesByBackendIdsToFrontendRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.PushNodesByBackendIdsToFrontendResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_pushNodesByBackendIdsToFrontend = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {string} selector
|
|
* @return {!Promise<?Protocol.DOM.NodeId>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.querySelector = function(nodeId, selector) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId, selector: string}} */
|
|
Protocol.DOMAgent.QuerySelectorRequest;
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.DOMAgent.QuerySelectorResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.QuerySelectorRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.QuerySelectorResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_querySelector = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {string} selector
|
|
* @return {!Promise<?Array<Protocol.DOM.NodeId>>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.querySelectorAll = function(nodeId, selector) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId, selector: string}} */
|
|
Protocol.DOMAgent.QuerySelectorAllRequest;
|
|
/** @typedef {!{nodeIds: !Array<Protocol.DOM.NodeId>}} */
|
|
Protocol.DOMAgent.QuerySelectorAllResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.QuerySelectorAllRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.QuerySelectorAllResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_querySelectorAll = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.redo = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.RedoRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.RedoResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.RedoRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.RedoResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_redo = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {string} name
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.removeAttribute = function(nodeId, name) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId, name: string}} */
|
|
Protocol.DOMAgent.RemoveAttributeRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.RemoveAttributeResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.RemoveAttributeRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.RemoveAttributeResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_removeAttribute = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.removeNode = function(nodeId) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.DOMAgent.RemoveNodeRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.RemoveNodeResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.RemoveNodeRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.RemoveNodeResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_removeNode = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {number=} opt_depth
|
|
* @param {boolean=} opt_pierce
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.requestChildNodes = function(nodeId, opt_depth, opt_pierce) {};
|
|
/** @typedef {!{depth: (number|undefined), nodeId: Protocol.DOM.NodeId, pierce: (boolean|undefined)}} */
|
|
Protocol.DOMAgent.RequestChildNodesRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.RequestChildNodesResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.RequestChildNodesRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.RequestChildNodesResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_requestChildNodes = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.RemoteObjectId} objectId
|
|
* @return {!Promise<?Protocol.DOM.NodeId>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.requestNode = function(objectId) {};
|
|
/** @typedef {!{objectId: Protocol.Runtime.RemoteObjectId}} */
|
|
Protocol.DOMAgent.RequestNodeRequest;
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.DOMAgent.RequestNodeResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.RequestNodeRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.RequestNodeResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_requestNode = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId=} opt_nodeId
|
|
* @param {Protocol.DOM.BackendNodeId=} opt_backendNodeId
|
|
* @param {string=} opt_objectGroup
|
|
* @param {Protocol.Runtime.ExecutionContextId=} opt_executionContextId
|
|
* @return {!Promise<?Protocol.Runtime.RemoteObject>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.resolveNode = function(opt_nodeId, opt_backendNodeId, opt_objectGroup, opt_executionContextId) {};
|
|
/** @typedef {!{objectGroup: (string|undefined), executionContextId: (Protocol.Runtime.ExecutionContextId|undefined), nodeId: (Protocol.DOM.NodeId|undefined), backendNodeId: (Protocol.DOM.BackendNodeId|undefined)}} */
|
|
Protocol.DOMAgent.ResolveNodeRequest;
|
|
/** @typedef {!{object: Protocol.Runtime.RemoteObject}} */
|
|
Protocol.DOMAgent.ResolveNodeResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.ResolveNodeRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.ResolveNodeResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_resolveNode = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {string} name
|
|
* @param {string} value
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.setAttributeValue = function(nodeId, name, value) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId, value: string, name: string}} */
|
|
Protocol.DOMAgent.SetAttributeValueRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.SetAttributeValueResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.SetAttributeValueRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.SetAttributeValueResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_setAttributeValue = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {string} text
|
|
* @param {string=} opt_name
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.setAttributesAsText = function(nodeId, text, opt_name) {};
|
|
/** @typedef {!{text: string, nodeId: Protocol.DOM.NodeId, name: (string|undefined)}} */
|
|
Protocol.DOMAgent.SetAttributesAsTextRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.SetAttributesAsTextResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.SetAttributesAsTextRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.SetAttributesAsTextResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_setAttributesAsText = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<string>} files
|
|
* @param {Protocol.DOM.NodeId=} opt_nodeId
|
|
* @param {Protocol.DOM.BackendNodeId=} opt_backendNodeId
|
|
* @param {Protocol.Runtime.RemoteObjectId=} opt_objectId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.setFileInputFiles = function(files, opt_nodeId, opt_backendNodeId, opt_objectId) {};
|
|
/** @typedef {!{files: !Array<string>, objectId: (Protocol.Runtime.RemoteObjectId|undefined), nodeId: (Protocol.DOM.NodeId|undefined), backendNodeId: (Protocol.DOM.BackendNodeId|undefined)}} */
|
|
Protocol.DOMAgent.SetFileInputFilesRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.SetFileInputFilesResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.SetFileInputFilesRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.SetFileInputFilesResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_setFileInputFiles = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} enable
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.setNodeStackTracesEnabled = function(enable) {};
|
|
/** @typedef {!{enable: boolean}} */
|
|
Protocol.DOMAgent.SetNodeStackTracesEnabledRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.SetNodeStackTracesEnabledResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.SetNodeStackTracesEnabledRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.SetNodeStackTracesEnabledResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_setNodeStackTracesEnabled = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @return {!Promise<?Protocol.Runtime.StackTrace>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.getNodeStackTraces = function(nodeId) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.DOMAgent.GetNodeStackTracesRequest;
|
|
/** @typedef {!{creation: Protocol.Runtime.StackTrace}} */
|
|
Protocol.DOMAgent.GetNodeStackTracesResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.GetNodeStackTracesRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.GetNodeStackTracesResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_getNodeStackTraces = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.RemoteObjectId} objectId
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.getFileInfo = function(objectId) {};
|
|
/** @typedef {!{objectId: Protocol.Runtime.RemoteObjectId}} */
|
|
Protocol.DOMAgent.GetFileInfoRequest;
|
|
/** @typedef {!{path: string}} */
|
|
Protocol.DOMAgent.GetFileInfoResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.GetFileInfoRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.GetFileInfoResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_getFileInfo = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.setInspectedNode = function(nodeId) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.DOMAgent.SetInspectedNodeRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.SetInspectedNodeResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.SetInspectedNodeRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.SetInspectedNodeResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_setInspectedNode = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {string} name
|
|
* @return {!Promise<?Protocol.DOM.NodeId>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.setNodeName = function(nodeId, name) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId, name: string}} */
|
|
Protocol.DOMAgent.SetNodeNameRequest;
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.DOMAgent.SetNodeNameResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.SetNodeNameRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.SetNodeNameResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_setNodeName = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {string} value
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.setNodeValue = function(nodeId, value) {};
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId, value: string}} */
|
|
Protocol.DOMAgent.SetNodeValueRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.SetNodeValueResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.SetNodeValueRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.SetNodeValueResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_setNodeValue = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {string} outerHTML
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.setOuterHTML = function(nodeId, outerHTML) {};
|
|
/** @typedef {!{outerHTML: string, nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.DOMAgent.SetOuterHTMLRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.SetOuterHTMLResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.SetOuterHTMLRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.SetOuterHTMLResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_setOuterHTML = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.undo = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.UndoRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMAgent.UndoResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.UndoRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.UndoResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_undo = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @return {!Promise<?Protocol.DOM.BackendNodeId>}
|
|
*/
|
|
Protocol.DOMAgent.prototype.getFrameOwner = function(frameId) {};
|
|
/** @typedef {!{frameId: Protocol.Page.FrameId}} */
|
|
Protocol.DOMAgent.GetFrameOwnerRequest;
|
|
/** @typedef {!{nodeId: Protocol.DOM.NodeId, backendNodeId: Protocol.DOM.BackendNodeId}} */
|
|
Protocol.DOMAgent.GetFrameOwnerResponse;
|
|
/**
|
|
* @param {!Protocol.DOMAgent.GetFrameOwnerRequest} obj
|
|
* @return {!Promise<!Protocol.DOMAgent.GetFrameOwnerResponse>} */
|
|
Protocol.DOMAgent.prototype.invoke_getFrameOwner = function(obj) {};
|
|
|
|
/** @typedef {number} */
|
|
Protocol.DOM.NodeId;
|
|
|
|
/** @typedef {number} */
|
|
Protocol.DOM.BackendNodeId;
|
|
|
|
/** @typedef {!{nodeType:(number), nodeName:(string), backendNodeId:(Protocol.DOM.BackendNodeId)}} */
|
|
Protocol.DOM.BackendNode;
|
|
|
|
/** @enum {string} */
|
|
Protocol.DOM.PseudoType = {
|
|
FirstLine: "first-line",
|
|
FirstLetter: "first-letter",
|
|
Before: "before",
|
|
After: "after",
|
|
Backdrop: "backdrop",
|
|
Selection: "selection",
|
|
FirstLineInherited: "first-line-inherited",
|
|
Scrollbar: "scrollbar",
|
|
ScrollbarThumb: "scrollbar-thumb",
|
|
ScrollbarButton: "scrollbar-button",
|
|
ScrollbarTrack: "scrollbar-track",
|
|
ScrollbarTrackPiece: "scrollbar-track-piece",
|
|
ScrollbarCorner: "scrollbar-corner",
|
|
Resizer: "resizer",
|
|
InputListButton: "input-list-button"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.DOM.ShadowRootType = {
|
|
UserAgent: "user-agent",
|
|
Open: "open",
|
|
Closed: "closed"
|
|
};
|
|
|
|
/** @typedef {!{nodeId:(Protocol.DOM.NodeId), parentId:(Protocol.DOM.NodeId|undefined), backendNodeId:(Protocol.DOM.BackendNodeId), nodeType:(number), nodeName:(string), localName:(string), nodeValue:(string), childNodeCount:(number|undefined), children:(!Array<Protocol.DOM.Node>|undefined), attributes:(!Array<string>|undefined), documentURL:(string|undefined), baseURL:(string|undefined), publicId:(string|undefined), systemId:(string|undefined), internalSubset:(string|undefined), xmlVersion:(string|undefined), name:(string|undefined), value:(string|undefined), pseudoType:(Protocol.DOM.PseudoType|undefined), shadowRootType:(Protocol.DOM.ShadowRootType|undefined), frameId:(Protocol.Page.FrameId|undefined), contentDocument:(Protocol.DOM.Node|undefined), shadowRoots:(!Array<Protocol.DOM.Node>|undefined), templateContent:(Protocol.DOM.Node|undefined), pseudoElements:(!Array<Protocol.DOM.Node>|undefined), importedDocument:(Protocol.DOM.Node|undefined), distributedNodes:(!Array<Protocol.DOM.BackendNode>|undefined), isSVG:(boolean|undefined)}} */
|
|
Protocol.DOM.Node;
|
|
|
|
/** @typedef {!{r:(number), g:(number), b:(number), a:(number|undefined)}} */
|
|
Protocol.DOM.RGBA;
|
|
|
|
/** @typedef {!Array<!number>} */
|
|
Protocol.DOM.Quad;
|
|
|
|
/** @typedef {!{content:(Protocol.DOM.Quad), padding:(Protocol.DOM.Quad), border:(Protocol.DOM.Quad), margin:(Protocol.DOM.Quad), width:(number), height:(number), shapeOutside:(Protocol.DOM.ShapeOutsideInfo|undefined)}} */
|
|
Protocol.DOM.BoxModel;
|
|
|
|
/** @typedef {!{bounds:(Protocol.DOM.Quad), shape:(!Array<*>), marginShape:(!Array<*>)}} */
|
|
Protocol.DOM.ShapeOutsideInfo;
|
|
|
|
/** @typedef {!{x:(number), y:(number), width:(number), height:(number)}} */
|
|
Protocol.DOM.Rect;
|
|
/** @interface */
|
|
Protocol.DOMDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {string} name
|
|
* @param {string} value
|
|
*/
|
|
Protocol.DOMDispatcher.prototype.attributeModified = function(nodeId, name, value) {};
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {string} name
|
|
*/
|
|
Protocol.DOMDispatcher.prototype.attributeRemoved = function(nodeId, name) {};
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {string} characterData
|
|
*/
|
|
Protocol.DOMDispatcher.prototype.characterDataModified = function(nodeId, characterData) {};
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {number} childNodeCount
|
|
*/
|
|
Protocol.DOMDispatcher.prototype.childNodeCountUpdated = function(nodeId, childNodeCount) {};
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} parentNodeId
|
|
* @param {Protocol.DOM.NodeId} previousNodeId
|
|
* @param {Protocol.DOM.Node} node
|
|
*/
|
|
Protocol.DOMDispatcher.prototype.childNodeInserted = function(parentNodeId, previousNodeId, node) {};
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} parentNodeId
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
*/
|
|
Protocol.DOMDispatcher.prototype.childNodeRemoved = function(parentNodeId, nodeId) {};
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} insertionPointId
|
|
* @param {!Array<Protocol.DOM.BackendNode>} distributedNodes
|
|
*/
|
|
Protocol.DOMDispatcher.prototype.distributedNodesUpdated = function(insertionPointId, distributedNodes) {};
|
|
Protocol.DOMDispatcher.prototype.documentUpdated = function() {};
|
|
/**
|
|
* @param {!Array<Protocol.DOM.NodeId>} nodeIds
|
|
*/
|
|
Protocol.DOMDispatcher.prototype.inlineStyleInvalidated = function(nodeIds) {};
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} parentId
|
|
* @param {Protocol.DOM.Node} pseudoElement
|
|
*/
|
|
Protocol.DOMDispatcher.prototype.pseudoElementAdded = function(parentId, pseudoElement) {};
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} parentId
|
|
* @param {Protocol.DOM.NodeId} pseudoElementId
|
|
*/
|
|
Protocol.DOMDispatcher.prototype.pseudoElementRemoved = function(parentId, pseudoElementId) {};
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} parentId
|
|
* @param {!Array<Protocol.DOM.Node>} nodes
|
|
*/
|
|
Protocol.DOMDispatcher.prototype.setChildNodes = function(parentId, nodes) {};
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} hostId
|
|
* @param {Protocol.DOM.NodeId} rootId
|
|
*/
|
|
Protocol.DOMDispatcher.prototype.shadowRootPopped = function(hostId, rootId) {};
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} hostId
|
|
* @param {Protocol.DOM.Node} root
|
|
*/
|
|
Protocol.DOMDispatcher.prototype.shadowRootPushed = function(hostId, root) {};
|
|
Protocol.DOMDebugger = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.DOMDebuggerAgent = function(){};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.RemoteObjectId} objectId
|
|
* @param {number=} opt_depth
|
|
* @param {boolean=} opt_pierce
|
|
* @return {!Promise<?Array<Protocol.DOMDebugger.EventListener>>}
|
|
*/
|
|
Protocol.DOMDebuggerAgent.prototype.getEventListeners = function(objectId, opt_depth, opt_pierce) {};
|
|
/** @typedef {!{depth: (number|undefined), pierce: (boolean|undefined), objectId: Protocol.Runtime.RemoteObjectId}} */
|
|
Protocol.DOMDebuggerAgent.GetEventListenersRequest;
|
|
/** @typedef {!{listeners: !Array<Protocol.DOMDebugger.EventListener>}} */
|
|
Protocol.DOMDebuggerAgent.GetEventListenersResponse;
|
|
/**
|
|
* @param {!Protocol.DOMDebuggerAgent.GetEventListenersRequest} obj
|
|
* @return {!Promise<!Protocol.DOMDebuggerAgent.GetEventListenersResponse>} */
|
|
Protocol.DOMDebuggerAgent.prototype.invoke_getEventListeners = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {Protocol.DOMDebugger.DOMBreakpointType} type
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMDebuggerAgent.prototype.removeDOMBreakpoint = function(nodeId, type) {};
|
|
/** @typedef {!{type: Protocol.DOMDebugger.DOMBreakpointType, nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.DOMDebuggerAgent.RemoveDOMBreakpointRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMDebuggerAgent.RemoveDOMBreakpointResponse;
|
|
/**
|
|
* @param {!Protocol.DOMDebuggerAgent.RemoveDOMBreakpointRequest} obj
|
|
* @return {!Promise<!Protocol.DOMDebuggerAgent.RemoveDOMBreakpointResponse>} */
|
|
Protocol.DOMDebuggerAgent.prototype.invoke_removeDOMBreakpoint = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} eventName
|
|
* @param {string=} opt_targetName
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMDebuggerAgent.prototype.removeEventListenerBreakpoint = function(eventName, opt_targetName) {};
|
|
/** @typedef {!{eventName: string, targetName: (string|undefined)}} */
|
|
Protocol.DOMDebuggerAgent.RemoveEventListenerBreakpointRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMDebuggerAgent.RemoveEventListenerBreakpointResponse;
|
|
/**
|
|
* @param {!Protocol.DOMDebuggerAgent.RemoveEventListenerBreakpointRequest} obj
|
|
* @return {!Promise<!Protocol.DOMDebuggerAgent.RemoveEventListenerBreakpointResponse>} */
|
|
Protocol.DOMDebuggerAgent.prototype.invoke_removeEventListenerBreakpoint = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} eventName
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMDebuggerAgent.prototype.removeInstrumentationBreakpoint = function(eventName) {};
|
|
/** @typedef {!{eventName: string}} */
|
|
Protocol.DOMDebuggerAgent.RemoveInstrumentationBreakpointRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMDebuggerAgent.RemoveInstrumentationBreakpointResponse;
|
|
/**
|
|
* @param {!Protocol.DOMDebuggerAgent.RemoveInstrumentationBreakpointRequest} obj
|
|
* @return {!Promise<!Protocol.DOMDebuggerAgent.RemoveInstrumentationBreakpointResponse>} */
|
|
Protocol.DOMDebuggerAgent.prototype.invoke_removeInstrumentationBreakpoint = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} url
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMDebuggerAgent.prototype.removeXHRBreakpoint = function(url) {};
|
|
/** @typedef {!{url: string}} */
|
|
Protocol.DOMDebuggerAgent.RemoveXHRBreakpointRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMDebuggerAgent.RemoveXHRBreakpointResponse;
|
|
/**
|
|
* @param {!Protocol.DOMDebuggerAgent.RemoveXHRBreakpointRequest} obj
|
|
* @return {!Promise<!Protocol.DOMDebuggerAgent.RemoveXHRBreakpointResponse>} */
|
|
Protocol.DOMDebuggerAgent.prototype.invoke_removeXHRBreakpoint = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {Protocol.DOMDebugger.DOMBreakpointType} type
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMDebuggerAgent.prototype.setDOMBreakpoint = function(nodeId, type) {};
|
|
/** @typedef {!{type: Protocol.DOMDebugger.DOMBreakpointType, nodeId: Protocol.DOM.NodeId}} */
|
|
Protocol.DOMDebuggerAgent.SetDOMBreakpointRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMDebuggerAgent.SetDOMBreakpointResponse;
|
|
/**
|
|
* @param {!Protocol.DOMDebuggerAgent.SetDOMBreakpointRequest} obj
|
|
* @return {!Promise<!Protocol.DOMDebuggerAgent.SetDOMBreakpointResponse>} */
|
|
Protocol.DOMDebuggerAgent.prototype.invoke_setDOMBreakpoint = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} eventName
|
|
* @param {string=} opt_targetName
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMDebuggerAgent.prototype.setEventListenerBreakpoint = function(eventName, opt_targetName) {};
|
|
/** @typedef {!{eventName: string, targetName: (string|undefined)}} */
|
|
Protocol.DOMDebuggerAgent.SetEventListenerBreakpointRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMDebuggerAgent.SetEventListenerBreakpointResponse;
|
|
/**
|
|
* @param {!Protocol.DOMDebuggerAgent.SetEventListenerBreakpointRequest} obj
|
|
* @return {!Promise<!Protocol.DOMDebuggerAgent.SetEventListenerBreakpointResponse>} */
|
|
Protocol.DOMDebuggerAgent.prototype.invoke_setEventListenerBreakpoint = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} eventName
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMDebuggerAgent.prototype.setInstrumentationBreakpoint = function(eventName) {};
|
|
/** @typedef {!{eventName: string}} */
|
|
Protocol.DOMDebuggerAgent.SetInstrumentationBreakpointRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMDebuggerAgent.SetInstrumentationBreakpointResponse;
|
|
/**
|
|
* @param {!Protocol.DOMDebuggerAgent.SetInstrumentationBreakpointRequest} obj
|
|
* @return {!Promise<!Protocol.DOMDebuggerAgent.SetInstrumentationBreakpointResponse>} */
|
|
Protocol.DOMDebuggerAgent.prototype.invoke_setInstrumentationBreakpoint = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} url
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMDebuggerAgent.prototype.setXHRBreakpoint = function(url) {};
|
|
/** @typedef {!{url: string}} */
|
|
Protocol.DOMDebuggerAgent.SetXHRBreakpointRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMDebuggerAgent.SetXHRBreakpointResponse;
|
|
/**
|
|
* @param {!Protocol.DOMDebuggerAgent.SetXHRBreakpointRequest} obj
|
|
* @return {!Promise<!Protocol.DOMDebuggerAgent.SetXHRBreakpointResponse>} */
|
|
Protocol.DOMDebuggerAgent.prototype.invoke_setXHRBreakpoint = function(obj) {};
|
|
|
|
/** @enum {string} */
|
|
Protocol.DOMDebugger.DOMBreakpointType = {
|
|
SubtreeModified: "subtree-modified",
|
|
AttributeModified: "attribute-modified",
|
|
NodeRemoved: "node-removed"
|
|
};
|
|
|
|
/** @typedef {!{type:(string), useCapture:(boolean), passive:(boolean), once:(boolean), scriptId:(Protocol.Runtime.ScriptId), lineNumber:(number), columnNumber:(number), handler:(Protocol.Runtime.RemoteObject|undefined), originalHandler:(Protocol.Runtime.RemoteObject|undefined), backendNodeId:(Protocol.DOM.BackendNodeId|undefined)}} */
|
|
Protocol.DOMDebugger.EventListener;
|
|
/** @interface */
|
|
Protocol.DOMDebuggerDispatcher = function() {};
|
|
Protocol.DOMSnapshot = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.DOMSnapshotAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMSnapshotAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMSnapshotAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMSnapshotAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.DOMSnapshotAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.DOMSnapshotAgent.DisableResponse>} */
|
|
Protocol.DOMSnapshotAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMSnapshotAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMSnapshotAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMSnapshotAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.DOMSnapshotAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.DOMSnapshotAgent.EnableResponse>} */
|
|
Protocol.DOMSnapshotAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<string>} computedStyleWhitelist
|
|
* @param {boolean=} opt_includeEventListeners
|
|
* @param {boolean=} opt_includePaintOrder
|
|
* @param {boolean=} opt_includeUserAgentShadowTree
|
|
* @return {!Promise<?Array<Protocol.DOMSnapshot.DOMNode>>}
|
|
*/
|
|
Protocol.DOMSnapshotAgent.prototype.getSnapshot = function(computedStyleWhitelist, opt_includeEventListeners, opt_includePaintOrder, opt_includeUserAgentShadowTree) {};
|
|
/** @typedef {!{includePaintOrder: (boolean|undefined), includeEventListeners: (boolean|undefined), computedStyleWhitelist: !Array<string>, includeUserAgentShadowTree: (boolean|undefined)}} */
|
|
Protocol.DOMSnapshotAgent.GetSnapshotRequest;
|
|
/** @typedef {!{layoutTreeNodes: !Array<Protocol.DOMSnapshot.LayoutTreeNode>, domNodes: !Array<Protocol.DOMSnapshot.DOMNode>, computedStyles: !Array<Protocol.DOMSnapshot.ComputedStyle>}} */
|
|
Protocol.DOMSnapshotAgent.GetSnapshotResponse;
|
|
/**
|
|
* @param {!Protocol.DOMSnapshotAgent.GetSnapshotRequest} obj
|
|
* @return {!Promise<!Protocol.DOMSnapshotAgent.GetSnapshotResponse>} */
|
|
Protocol.DOMSnapshotAgent.prototype.invoke_getSnapshot = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<string>} computedStyles
|
|
* @param {boolean=} opt_includePaintOrder
|
|
* @param {boolean=} opt_includeDOMRects
|
|
* @return {!Promise<?Array<Protocol.DOMSnapshot.DocumentSnapshot>>}
|
|
*/
|
|
Protocol.DOMSnapshotAgent.prototype.captureSnapshot = function(computedStyles, opt_includePaintOrder, opt_includeDOMRects) {};
|
|
/** @typedef {!{includePaintOrder: (boolean|undefined), includeDOMRects: (boolean|undefined), computedStyles: !Array<string>}} */
|
|
Protocol.DOMSnapshotAgent.CaptureSnapshotRequest;
|
|
/** @typedef {!{documents: !Array<Protocol.DOMSnapshot.DocumentSnapshot>, strings: !Array<string>}} */
|
|
Protocol.DOMSnapshotAgent.CaptureSnapshotResponse;
|
|
/**
|
|
* @param {!Protocol.DOMSnapshotAgent.CaptureSnapshotRequest} obj
|
|
* @return {!Promise<!Protocol.DOMSnapshotAgent.CaptureSnapshotResponse>} */
|
|
Protocol.DOMSnapshotAgent.prototype.invoke_captureSnapshot = function(obj) {};
|
|
|
|
/** @typedef {!{nodeType:(number), nodeName:(string), nodeValue:(string), textValue:(string|undefined), inputValue:(string|undefined), inputChecked:(boolean|undefined), optionSelected:(boolean|undefined), backendNodeId:(Protocol.DOM.BackendNodeId), childNodeIndexes:(!Array<number>|undefined), attributes:(!Array<Protocol.DOMSnapshot.NameValue>|undefined), pseudoElementIndexes:(!Array<number>|undefined), layoutNodeIndex:(number|undefined), documentURL:(string|undefined), baseURL:(string|undefined), contentLanguage:(string|undefined), documentEncoding:(string|undefined), publicId:(string|undefined), systemId:(string|undefined), frameId:(Protocol.Page.FrameId|undefined), contentDocumentIndex:(number|undefined), pseudoType:(Protocol.DOM.PseudoType|undefined), shadowRootType:(Protocol.DOM.ShadowRootType|undefined), isClickable:(boolean|undefined), eventListeners:(!Array<Protocol.DOMDebugger.EventListener>|undefined), currentSourceURL:(string|undefined), originURL:(string|undefined), scrollOffsetX:(number|undefined), scrollOffsetY:(number|undefined)}} */
|
|
Protocol.DOMSnapshot.DOMNode;
|
|
|
|
/** @typedef {!{boundingBox:(Protocol.DOM.Rect), startCharacterIndex:(number), numCharacters:(number)}} */
|
|
Protocol.DOMSnapshot.InlineTextBox;
|
|
|
|
/** @typedef {!{domNodeIndex:(number), boundingBox:(Protocol.DOM.Rect), layoutText:(string|undefined), inlineTextNodes:(!Array<Protocol.DOMSnapshot.InlineTextBox>|undefined), styleIndex:(number|undefined), paintOrder:(number|undefined), isStackingContext:(boolean|undefined)}} */
|
|
Protocol.DOMSnapshot.LayoutTreeNode;
|
|
|
|
/** @typedef {!{properties:(!Array<Protocol.DOMSnapshot.NameValue>)}} */
|
|
Protocol.DOMSnapshot.ComputedStyle;
|
|
|
|
/** @typedef {!{name:(string), value:(string)}} */
|
|
Protocol.DOMSnapshot.NameValue;
|
|
|
|
/** @typedef {number} */
|
|
Protocol.DOMSnapshot.StringIndex;
|
|
|
|
/** @typedef {!Array<!Protocol.DOMSnapshot.StringIndex>} */
|
|
Protocol.DOMSnapshot.ArrayOfStrings;
|
|
|
|
/** @typedef {!{index:(!Array<number>), value:(!Array<Protocol.DOMSnapshot.StringIndex>)}} */
|
|
Protocol.DOMSnapshot.RareStringData;
|
|
|
|
/** @typedef {!{index:(!Array<number>)}} */
|
|
Protocol.DOMSnapshot.RareBooleanData;
|
|
|
|
/** @typedef {!{index:(!Array<number>), value:(!Array<number>)}} */
|
|
Protocol.DOMSnapshot.RareIntegerData;
|
|
|
|
/** @typedef {!Array<!number>} */
|
|
Protocol.DOMSnapshot.Rectangle;
|
|
|
|
/** @typedef {!{documentURL:(Protocol.DOMSnapshot.StringIndex), title:(Protocol.DOMSnapshot.StringIndex), baseURL:(Protocol.DOMSnapshot.StringIndex), contentLanguage:(Protocol.DOMSnapshot.StringIndex), encodingName:(Protocol.DOMSnapshot.StringIndex), publicId:(Protocol.DOMSnapshot.StringIndex), systemId:(Protocol.DOMSnapshot.StringIndex), frameId:(Protocol.DOMSnapshot.StringIndex), nodes:(Protocol.DOMSnapshot.NodeTreeSnapshot), layout:(Protocol.DOMSnapshot.LayoutTreeSnapshot), textBoxes:(Protocol.DOMSnapshot.TextBoxSnapshot), scrollOffsetX:(number|undefined), scrollOffsetY:(number|undefined), contentWidth:(number|undefined), contentHeight:(number|undefined)}} */
|
|
Protocol.DOMSnapshot.DocumentSnapshot;
|
|
|
|
/** @typedef {!{parentIndex:(!Array<number>|undefined), nodeType:(!Array<number>|undefined), nodeName:(!Array<Protocol.DOMSnapshot.StringIndex>|undefined), nodeValue:(!Array<Protocol.DOMSnapshot.StringIndex>|undefined), backendNodeId:(!Array<Protocol.DOM.BackendNodeId>|undefined), attributes:(!Array<Protocol.DOMSnapshot.ArrayOfStrings>|undefined), textValue:(Protocol.DOMSnapshot.RareStringData|undefined), inputValue:(Protocol.DOMSnapshot.RareStringData|undefined), inputChecked:(Protocol.DOMSnapshot.RareBooleanData|undefined), optionSelected:(Protocol.DOMSnapshot.RareBooleanData|undefined), contentDocumentIndex:(Protocol.DOMSnapshot.RareIntegerData|undefined), pseudoType:(Protocol.DOMSnapshot.RareStringData|undefined), isClickable:(Protocol.DOMSnapshot.RareBooleanData|undefined), currentSourceURL:(Protocol.DOMSnapshot.RareStringData|undefined), originURL:(Protocol.DOMSnapshot.RareStringData|undefined)}} */
|
|
Protocol.DOMSnapshot.NodeTreeSnapshot;
|
|
|
|
/** @typedef {!{nodeIndex:(!Array<number>), styles:(!Array<Protocol.DOMSnapshot.ArrayOfStrings>), bounds:(!Array<Protocol.DOMSnapshot.Rectangle>), text:(!Array<Protocol.DOMSnapshot.StringIndex>), stackingContexts:(Protocol.DOMSnapshot.RareBooleanData), paintOrders:(!Array<number>|undefined), offsetRects:(!Array<Protocol.DOMSnapshot.Rectangle>|undefined), scrollRects:(!Array<Protocol.DOMSnapshot.Rectangle>|undefined), clientRects:(!Array<Protocol.DOMSnapshot.Rectangle>|undefined)}} */
|
|
Protocol.DOMSnapshot.LayoutTreeSnapshot;
|
|
|
|
/** @typedef {!{layoutIndex:(!Array<number>), bounds:(!Array<Protocol.DOMSnapshot.Rectangle>), start:(!Array<number>), length:(!Array<number>)}} */
|
|
Protocol.DOMSnapshot.TextBoxSnapshot;
|
|
/** @interface */
|
|
Protocol.DOMSnapshotDispatcher = function() {};
|
|
Protocol.DOMStorage = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.DOMStorageAgent = function(){};
|
|
|
|
/**
|
|
* @param {Protocol.DOMStorage.StorageId} storageId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMStorageAgent.prototype.clear = function(storageId) {};
|
|
/** @typedef {!{storageId: Protocol.DOMStorage.StorageId}} */
|
|
Protocol.DOMStorageAgent.ClearRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMStorageAgent.ClearResponse;
|
|
/**
|
|
* @param {!Protocol.DOMStorageAgent.ClearRequest} obj
|
|
* @return {!Promise<!Protocol.DOMStorageAgent.ClearResponse>} */
|
|
Protocol.DOMStorageAgent.prototype.invoke_clear = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMStorageAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMStorageAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMStorageAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.DOMStorageAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.DOMStorageAgent.DisableResponse>} */
|
|
Protocol.DOMStorageAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMStorageAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMStorageAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMStorageAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.DOMStorageAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.DOMStorageAgent.EnableResponse>} */
|
|
Protocol.DOMStorageAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOMStorage.StorageId} storageId
|
|
* @return {!Promise<?Array<Protocol.DOMStorage.Item>>}
|
|
*/
|
|
Protocol.DOMStorageAgent.prototype.getDOMStorageItems = function(storageId) {};
|
|
/** @typedef {!{storageId: Protocol.DOMStorage.StorageId}} */
|
|
Protocol.DOMStorageAgent.GetDOMStorageItemsRequest;
|
|
/** @typedef {!{entries: !Array<Protocol.DOMStorage.Item>}} */
|
|
Protocol.DOMStorageAgent.GetDOMStorageItemsResponse;
|
|
/**
|
|
* @param {!Protocol.DOMStorageAgent.GetDOMStorageItemsRequest} obj
|
|
* @return {!Promise<!Protocol.DOMStorageAgent.GetDOMStorageItemsResponse>} */
|
|
Protocol.DOMStorageAgent.prototype.invoke_getDOMStorageItems = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOMStorage.StorageId} storageId
|
|
* @param {string} key
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMStorageAgent.prototype.removeDOMStorageItem = function(storageId, key) {};
|
|
/** @typedef {!{storageId: Protocol.DOMStorage.StorageId, key: string}} */
|
|
Protocol.DOMStorageAgent.RemoveDOMStorageItemRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMStorageAgent.RemoveDOMStorageItemResponse;
|
|
/**
|
|
* @param {!Protocol.DOMStorageAgent.RemoveDOMStorageItemRequest} obj
|
|
* @return {!Promise<!Protocol.DOMStorageAgent.RemoveDOMStorageItemResponse>} */
|
|
Protocol.DOMStorageAgent.prototype.invoke_removeDOMStorageItem = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOMStorage.StorageId} storageId
|
|
* @param {string} key
|
|
* @param {string} value
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DOMStorageAgent.prototype.setDOMStorageItem = function(storageId, key, value) {};
|
|
/** @typedef {!{value: string, storageId: Protocol.DOMStorage.StorageId, key: string}} */
|
|
Protocol.DOMStorageAgent.SetDOMStorageItemRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DOMStorageAgent.SetDOMStorageItemResponse;
|
|
/**
|
|
* @param {!Protocol.DOMStorageAgent.SetDOMStorageItemRequest} obj
|
|
* @return {!Promise<!Protocol.DOMStorageAgent.SetDOMStorageItemResponse>} */
|
|
Protocol.DOMStorageAgent.prototype.invoke_setDOMStorageItem = function(obj) {};
|
|
|
|
/** @typedef {!{securityOrigin:(string), isLocalStorage:(boolean)}} */
|
|
Protocol.DOMStorage.StorageId;
|
|
|
|
/** @typedef {!Array<!string>} */
|
|
Protocol.DOMStorage.Item;
|
|
/** @interface */
|
|
Protocol.DOMStorageDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.DOMStorage.StorageId} storageId
|
|
* @param {string} key
|
|
* @param {string} newValue
|
|
*/
|
|
Protocol.DOMStorageDispatcher.prototype.domStorageItemAdded = function(storageId, key, newValue) {};
|
|
/**
|
|
* @param {Protocol.DOMStorage.StorageId} storageId
|
|
* @param {string} key
|
|
*/
|
|
Protocol.DOMStorageDispatcher.prototype.domStorageItemRemoved = function(storageId, key) {};
|
|
/**
|
|
* @param {Protocol.DOMStorage.StorageId} storageId
|
|
* @param {string} key
|
|
* @param {string} oldValue
|
|
* @param {string} newValue
|
|
*/
|
|
Protocol.DOMStorageDispatcher.prototype.domStorageItemUpdated = function(storageId, key, oldValue, newValue) {};
|
|
/**
|
|
* @param {Protocol.DOMStorage.StorageId} storageId
|
|
*/
|
|
Protocol.DOMStorageDispatcher.prototype.domStorageItemsCleared = function(storageId) {};
|
|
Protocol.Database = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.DatabaseAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DatabaseAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DatabaseAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DatabaseAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.DatabaseAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.DatabaseAgent.DisableResponse>} */
|
|
Protocol.DatabaseAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DatabaseAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DatabaseAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DatabaseAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.DatabaseAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.DatabaseAgent.EnableResponse>} */
|
|
Protocol.DatabaseAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Database.DatabaseId} databaseId
|
|
* @param {string} query
|
|
* @return {!Promise<?Array<string>>}
|
|
*/
|
|
Protocol.DatabaseAgent.prototype.executeSQL = function(databaseId, query) {};
|
|
/** @typedef {!{query: string, databaseId: Protocol.Database.DatabaseId}} */
|
|
Protocol.DatabaseAgent.ExecuteSQLRequest;
|
|
/** @typedef {!{columnNames: !Array<string>, values: !Array<*>, sqlError: Protocol.Database.Error}} */
|
|
Protocol.DatabaseAgent.ExecuteSQLResponse;
|
|
/**
|
|
* @param {!Protocol.DatabaseAgent.ExecuteSQLRequest} obj
|
|
* @return {!Promise<!Protocol.DatabaseAgent.ExecuteSQLResponse>} */
|
|
Protocol.DatabaseAgent.prototype.invoke_executeSQL = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Database.DatabaseId} databaseId
|
|
* @return {!Promise<?Array<string>>}
|
|
*/
|
|
Protocol.DatabaseAgent.prototype.getDatabaseTableNames = function(databaseId) {};
|
|
/** @typedef {!{databaseId: Protocol.Database.DatabaseId}} */
|
|
Protocol.DatabaseAgent.GetDatabaseTableNamesRequest;
|
|
/** @typedef {!{tableNames: !Array<string>}} */
|
|
Protocol.DatabaseAgent.GetDatabaseTableNamesResponse;
|
|
/**
|
|
* @param {!Protocol.DatabaseAgent.GetDatabaseTableNamesRequest} obj
|
|
* @return {!Promise<!Protocol.DatabaseAgent.GetDatabaseTableNamesResponse>} */
|
|
Protocol.DatabaseAgent.prototype.invoke_getDatabaseTableNames = function(obj) {};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Database.DatabaseId;
|
|
|
|
/** @typedef {!{id:(Protocol.Database.DatabaseId), domain:(string), name:(string), version:(string)}} */
|
|
Protocol.Database.Database;
|
|
|
|
/** @typedef {!{message:(string), code:(number)}} */
|
|
Protocol.Database.Error;
|
|
/** @interface */
|
|
Protocol.DatabaseDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.Database.Database} database
|
|
*/
|
|
Protocol.DatabaseDispatcher.prototype.addDatabase = function(database) {};
|
|
Protocol.DeviceOrientation = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.DeviceOrientationAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DeviceOrientationAgent.prototype.clearDeviceOrientationOverride = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DeviceOrientationAgent.ClearDeviceOrientationOverrideRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DeviceOrientationAgent.ClearDeviceOrientationOverrideResponse;
|
|
/**
|
|
* @param {!Protocol.DeviceOrientationAgent.ClearDeviceOrientationOverrideRequest} obj
|
|
* @return {!Promise<!Protocol.DeviceOrientationAgent.ClearDeviceOrientationOverrideResponse>} */
|
|
Protocol.DeviceOrientationAgent.prototype.invoke_clearDeviceOrientationOverride = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} alpha
|
|
* @param {number} beta
|
|
* @param {number} gamma
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DeviceOrientationAgent.prototype.setDeviceOrientationOverride = function(alpha, beta, gamma) {};
|
|
/** @typedef {!{alpha: number, beta: number, gamma: number}} */
|
|
Protocol.DeviceOrientationAgent.SetDeviceOrientationOverrideRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DeviceOrientationAgent.SetDeviceOrientationOverrideResponse;
|
|
/**
|
|
* @param {!Protocol.DeviceOrientationAgent.SetDeviceOrientationOverrideRequest} obj
|
|
* @return {!Promise<!Protocol.DeviceOrientationAgent.SetDeviceOrientationOverrideResponse>} */
|
|
Protocol.DeviceOrientationAgent.prototype.invoke_setDeviceOrientationOverride = function(obj) {};
|
|
/** @interface */
|
|
Protocol.DeviceOrientationDispatcher = function() {};
|
|
Protocol.Emulation = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.EmulationAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<?boolean>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.canEmulate = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.CanEmulateRequest;
|
|
/** @typedef {!{result: boolean}} */
|
|
Protocol.EmulationAgent.CanEmulateResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.CanEmulateRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.CanEmulateResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_canEmulate = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.clearDeviceMetricsOverride = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.ClearDeviceMetricsOverrideRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.ClearDeviceMetricsOverrideResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.ClearDeviceMetricsOverrideRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.ClearDeviceMetricsOverrideResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_clearDeviceMetricsOverride = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.clearGeolocationOverride = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.ClearGeolocationOverrideRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.ClearGeolocationOverrideResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.ClearGeolocationOverrideRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.ClearGeolocationOverrideResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_clearGeolocationOverride = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.resetPageScaleFactor = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.ResetPageScaleFactorRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.ResetPageScaleFactorResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.ResetPageScaleFactorRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.ResetPageScaleFactorResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_resetPageScaleFactor = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} enabled
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setFocusEmulationEnabled = function(enabled) {};
|
|
/** @typedef {!{enabled: boolean}} */
|
|
Protocol.EmulationAgent.SetFocusEmulationEnabledRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.SetFocusEmulationEnabledResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetFocusEmulationEnabledRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetFocusEmulationEnabledResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setFocusEmulationEnabled = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} rate
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setCPUThrottlingRate = function(rate) {};
|
|
/** @typedef {!{rate: number}} */
|
|
Protocol.EmulationAgent.SetCPUThrottlingRateRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.SetCPUThrottlingRateResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetCPUThrottlingRateRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetCPUThrottlingRateResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setCPUThrottlingRate = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.RGBA=} opt_color
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setDefaultBackgroundColorOverride = function(opt_color) {};
|
|
/** @typedef {!{color: (Protocol.DOM.RGBA|undefined)}} */
|
|
Protocol.EmulationAgent.SetDefaultBackgroundColorOverrideRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.SetDefaultBackgroundColorOverrideResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetDefaultBackgroundColorOverrideRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetDefaultBackgroundColorOverrideResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setDefaultBackgroundColorOverride = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} width
|
|
* @param {number} height
|
|
* @param {number} deviceScaleFactor
|
|
* @param {boolean} mobile
|
|
* @param {number=} opt_scale
|
|
* @param {number=} opt_screenWidth
|
|
* @param {number=} opt_screenHeight
|
|
* @param {number=} opt_positionX
|
|
* @param {number=} opt_positionY
|
|
* @param {boolean=} opt_dontSetVisibleSize
|
|
* @param {Protocol.Emulation.ScreenOrientation=} opt_screenOrientation
|
|
* @param {Protocol.Page.Viewport=} opt_viewport
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setDeviceMetricsOverride = function(width, height, deviceScaleFactor, mobile, opt_scale, opt_screenWidth, opt_screenHeight, opt_positionX, opt_positionY, opt_dontSetVisibleSize, opt_screenOrientation, opt_viewport) {};
|
|
/** @typedef {!{deviceScaleFactor: number, positionX: (number|undefined), scale: (number|undefined), screenHeight: (number|undefined), mobile: boolean, screenOrientation: (Protocol.Emulation.ScreenOrientation|undefined), dontSetVisibleSize: (boolean|undefined), height: number, width: number, positionY: (number|undefined), screenWidth: (number|undefined), viewport: (Protocol.Page.Viewport|undefined)}} */
|
|
Protocol.EmulationAgent.SetDeviceMetricsOverrideRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.SetDeviceMetricsOverrideResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetDeviceMetricsOverrideRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetDeviceMetricsOverrideResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setDeviceMetricsOverride = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} hidden
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setScrollbarsHidden = function(hidden) {};
|
|
/** @typedef {!{hidden: boolean}} */
|
|
Protocol.EmulationAgent.SetScrollbarsHiddenRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.SetScrollbarsHiddenResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetScrollbarsHiddenRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetScrollbarsHiddenResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setScrollbarsHidden = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} disabled
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setDocumentCookieDisabled = function(disabled) {};
|
|
/** @typedef {!{disabled: boolean}} */
|
|
Protocol.EmulationAgent.SetDocumentCookieDisabledRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.SetDocumentCookieDisabledResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetDocumentCookieDisabledRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetDocumentCookieDisabledResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setDocumentCookieDisabled = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} enabled
|
|
* @param {string=} opt_configuration
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setEmitTouchEventsForMouse = function(enabled, opt_configuration) {};
|
|
/** @typedef {!{configuration: (string|undefined), enabled: boolean}} */
|
|
Protocol.EmulationAgent.SetEmitTouchEventsForMouseRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.SetEmitTouchEventsForMouseResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetEmitTouchEventsForMouseRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetEmitTouchEventsForMouseResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setEmitTouchEventsForMouse = function(obj) {};
|
|
|
|
/**
|
|
* @param {string=} opt_media
|
|
* @param {!Array<Protocol.Emulation.MediaFeature>=} opt_features
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setEmulatedMedia = function(opt_media, opt_features) {};
|
|
/** @typedef {!{media: (string|undefined), features: (!Array<Protocol.Emulation.MediaFeature>|undefined)}} */
|
|
Protocol.EmulationAgent.SetEmulatedMediaRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.SetEmulatedMediaResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetEmulatedMediaRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetEmulatedMediaResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setEmulatedMedia = function(obj) {};
|
|
|
|
/**
|
|
* @param {number=} opt_latitude
|
|
* @param {number=} opt_longitude
|
|
* @param {number=} opt_accuracy
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setGeolocationOverride = function(opt_latitude, opt_longitude, opt_accuracy) {};
|
|
/** @typedef {!{latitude: (number|undefined), longitude: (number|undefined), accuracy: (number|undefined)}} */
|
|
Protocol.EmulationAgent.SetGeolocationOverrideRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.SetGeolocationOverrideResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetGeolocationOverrideRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetGeolocationOverrideResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setGeolocationOverride = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} platform
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setNavigatorOverrides = function(platform) {};
|
|
/** @typedef {!{platform: string}} */
|
|
Protocol.EmulationAgent.SetNavigatorOverridesRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.SetNavigatorOverridesResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetNavigatorOverridesRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetNavigatorOverridesResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setNavigatorOverrides = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} pageScaleFactor
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setPageScaleFactor = function(pageScaleFactor) {};
|
|
/** @typedef {!{pageScaleFactor: number}} */
|
|
Protocol.EmulationAgent.SetPageScaleFactorRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.SetPageScaleFactorResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetPageScaleFactorRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetPageScaleFactorResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setPageScaleFactor = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} value
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setScriptExecutionDisabled = function(value) {};
|
|
/** @typedef {!{value: boolean}} */
|
|
Protocol.EmulationAgent.SetScriptExecutionDisabledRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.SetScriptExecutionDisabledResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetScriptExecutionDisabledRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetScriptExecutionDisabledResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setScriptExecutionDisabled = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} enabled
|
|
* @param {number=} opt_maxTouchPoints
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setTouchEmulationEnabled = function(enabled, opt_maxTouchPoints) {};
|
|
/** @typedef {!{maxTouchPoints: (number|undefined), enabled: boolean}} */
|
|
Protocol.EmulationAgent.SetTouchEmulationEnabledRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.SetTouchEmulationEnabledResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetTouchEmulationEnabledRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetTouchEmulationEnabledResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setTouchEmulationEnabled = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Emulation.VirtualTimePolicy} policy
|
|
* @param {number=} opt_budget
|
|
* @param {number=} opt_maxVirtualTimeTaskStarvationCount
|
|
* @param {boolean=} opt_waitForNavigation
|
|
* @param {Protocol.Network.TimeSinceEpoch=} opt_initialVirtualTime
|
|
* @return {!Promise<?number>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setVirtualTimePolicy = function(policy, opt_budget, opt_maxVirtualTimeTaskStarvationCount, opt_waitForNavigation, opt_initialVirtualTime) {};
|
|
/** @typedef {!{policy: Protocol.Emulation.VirtualTimePolicy, initialVirtualTime: (Protocol.Network.TimeSinceEpoch|undefined), maxVirtualTimeTaskStarvationCount: (number|undefined), waitForNavigation: (boolean|undefined), budget: (number|undefined)}} */
|
|
Protocol.EmulationAgent.SetVirtualTimePolicyRequest;
|
|
/** @typedef {!{virtualTimeTicksBase: number}} */
|
|
Protocol.EmulationAgent.SetVirtualTimePolicyResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetVirtualTimePolicyRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetVirtualTimePolicyResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setVirtualTimePolicy = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} timezoneId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setTimezoneOverride = function(timezoneId) {};
|
|
/** @typedef {!{timezoneId: string}} */
|
|
Protocol.EmulationAgent.SetTimezoneOverrideRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.SetTimezoneOverrideResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetTimezoneOverrideRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetTimezoneOverrideResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setTimezoneOverride = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} width
|
|
* @param {number} height
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setVisibleSize = function(width, height) {};
|
|
/** @typedef {!{width: number, height: number}} */
|
|
Protocol.EmulationAgent.SetVisibleSizeRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.SetVisibleSizeResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetVisibleSizeRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetVisibleSizeResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setVisibleSize = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} userAgent
|
|
* @param {string=} opt_acceptLanguage
|
|
* @param {string=} opt_platform
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.EmulationAgent.prototype.setUserAgentOverride = function(userAgent, opt_acceptLanguage, opt_platform) {};
|
|
/** @typedef {!{acceptLanguage: (string|undefined), userAgent: string, platform: (string|undefined)}} */
|
|
Protocol.EmulationAgent.SetUserAgentOverrideRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.EmulationAgent.SetUserAgentOverrideResponse;
|
|
/**
|
|
* @param {!Protocol.EmulationAgent.SetUserAgentOverrideRequest} obj
|
|
* @return {!Promise<!Protocol.EmulationAgent.SetUserAgentOverrideResponse>} */
|
|
Protocol.EmulationAgent.prototype.invoke_setUserAgentOverride = function(obj) {};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Emulation.ScreenOrientationType = {
|
|
PortraitPrimary: "portraitPrimary",
|
|
PortraitSecondary: "portraitSecondary",
|
|
LandscapePrimary: "landscapePrimary",
|
|
LandscapeSecondary: "landscapeSecondary"
|
|
};
|
|
|
|
/** @typedef {!{type:(Protocol.Emulation.ScreenOrientationType), angle:(number)}} */
|
|
Protocol.Emulation.ScreenOrientation;
|
|
|
|
/** @typedef {!{name:(string), value:(string)}} */
|
|
Protocol.Emulation.MediaFeature;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Emulation.VirtualTimePolicy = {
|
|
Advance: "advance",
|
|
Pause: "pause",
|
|
PauseIfNetworkFetchesPending: "pauseIfNetworkFetchesPending"
|
|
};
|
|
/** @interface */
|
|
Protocol.EmulationDispatcher = function() {};
|
|
Protocol.EmulationDispatcher.prototype.virtualTimeBudgetExpired = function() {};
|
|
Protocol.HeadlessExperimental = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.HeadlessExperimentalAgent = function(){};
|
|
|
|
/**
|
|
* @param {number=} opt_frameTimeTicks
|
|
* @param {number=} opt_interval
|
|
* @param {boolean=} opt_noDisplayUpdates
|
|
* @param {Protocol.HeadlessExperimental.ScreenshotParams=} opt_screenshot
|
|
* @return {!Promise<?boolean>}
|
|
*/
|
|
Protocol.HeadlessExperimentalAgent.prototype.beginFrame = function(opt_frameTimeTicks, opt_interval, opt_noDisplayUpdates, opt_screenshot) {};
|
|
/** @typedef {!{interval: (number|undefined), frameTimeTicks: (number|undefined), noDisplayUpdates: (boolean|undefined), screenshot: (Protocol.HeadlessExperimental.ScreenshotParams|undefined)}} */
|
|
Protocol.HeadlessExperimentalAgent.BeginFrameRequest;
|
|
/** @typedef {!{hasDamage: boolean, screenshotData: string}} */
|
|
Protocol.HeadlessExperimentalAgent.BeginFrameResponse;
|
|
/**
|
|
* @param {!Protocol.HeadlessExperimentalAgent.BeginFrameRequest} obj
|
|
* @return {!Promise<!Protocol.HeadlessExperimentalAgent.BeginFrameResponse>} */
|
|
Protocol.HeadlessExperimentalAgent.prototype.invoke_beginFrame = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.HeadlessExperimentalAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeadlessExperimentalAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeadlessExperimentalAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.HeadlessExperimentalAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.HeadlessExperimentalAgent.DisableResponse>} */
|
|
Protocol.HeadlessExperimentalAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.HeadlessExperimentalAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeadlessExperimentalAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeadlessExperimentalAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.HeadlessExperimentalAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.HeadlessExperimentalAgent.EnableResponse>} */
|
|
Protocol.HeadlessExperimentalAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/** @enum {string} */
|
|
Protocol.HeadlessExperimental.ScreenshotParamsFormat = {
|
|
Jpeg: "jpeg",
|
|
Png: "png"
|
|
};
|
|
|
|
/** @typedef {!{format:(Protocol.HeadlessExperimental.ScreenshotParamsFormat|undefined), quality:(number|undefined)}} */
|
|
Protocol.HeadlessExperimental.ScreenshotParams;
|
|
/** @interface */
|
|
Protocol.HeadlessExperimentalDispatcher = function() {};
|
|
/**
|
|
* @param {boolean} needsBeginFrames
|
|
*/
|
|
Protocol.HeadlessExperimentalDispatcher.prototype.needsBeginFramesChanged = function(needsBeginFrames) {};
|
|
Protocol.IO = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.IOAgent = function(){};
|
|
|
|
/**
|
|
* @param {Protocol.IO.StreamHandle} handle
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.IOAgent.prototype.close = function(handle) {};
|
|
/** @typedef {!{handle: Protocol.IO.StreamHandle}} */
|
|
Protocol.IOAgent.CloseRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.IOAgent.CloseResponse;
|
|
/**
|
|
* @param {!Protocol.IOAgent.CloseRequest} obj
|
|
* @return {!Promise<!Protocol.IOAgent.CloseResponse>} */
|
|
Protocol.IOAgent.prototype.invoke_close = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.IO.StreamHandle} handle
|
|
* @param {number=} opt_offset
|
|
* @param {number=} opt_size
|
|
* @return {!Promise<?boolean>}
|
|
*/
|
|
Protocol.IOAgent.prototype.read = function(handle, opt_offset, opt_size) {};
|
|
/** @typedef {!{size: (number|undefined), handle: Protocol.IO.StreamHandle, offset: (number|undefined)}} */
|
|
Protocol.IOAgent.ReadRequest;
|
|
/** @typedef {!{data: string, base64Encoded: boolean, eof: boolean}} */
|
|
Protocol.IOAgent.ReadResponse;
|
|
/**
|
|
* @param {!Protocol.IOAgent.ReadRequest} obj
|
|
* @return {!Promise<!Protocol.IOAgent.ReadResponse>} */
|
|
Protocol.IOAgent.prototype.invoke_read = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.RemoteObjectId} objectId
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.IOAgent.prototype.resolveBlob = function(objectId) {};
|
|
/** @typedef {!{objectId: Protocol.Runtime.RemoteObjectId}} */
|
|
Protocol.IOAgent.ResolveBlobRequest;
|
|
/** @typedef {!{uuid: string}} */
|
|
Protocol.IOAgent.ResolveBlobResponse;
|
|
/**
|
|
* @param {!Protocol.IOAgent.ResolveBlobRequest} obj
|
|
* @return {!Promise<!Protocol.IOAgent.ResolveBlobResponse>} */
|
|
Protocol.IOAgent.prototype.invoke_resolveBlob = function(obj) {};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.IO.StreamHandle;
|
|
/** @interface */
|
|
Protocol.IODispatcher = function() {};
|
|
Protocol.IndexedDB = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.IndexedDBAgent = function(){};
|
|
|
|
/**
|
|
* @param {string} securityOrigin
|
|
* @param {string} databaseName
|
|
* @param {string} objectStoreName
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.IndexedDBAgent.prototype.clearObjectStore = function(securityOrigin, databaseName, objectStoreName) {};
|
|
/** @typedef {!{objectStoreName: string, databaseName: string, securityOrigin: string}} */
|
|
Protocol.IndexedDBAgent.ClearObjectStoreRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.IndexedDBAgent.ClearObjectStoreResponse;
|
|
/**
|
|
* @param {!Protocol.IndexedDBAgent.ClearObjectStoreRequest} obj
|
|
* @return {!Promise<!Protocol.IndexedDBAgent.ClearObjectStoreResponse>} */
|
|
Protocol.IndexedDBAgent.prototype.invoke_clearObjectStore = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} securityOrigin
|
|
* @param {string} databaseName
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.IndexedDBAgent.prototype.deleteDatabase = function(securityOrigin, databaseName) {};
|
|
/** @typedef {!{databaseName: string, securityOrigin: string}} */
|
|
Protocol.IndexedDBAgent.DeleteDatabaseRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.IndexedDBAgent.DeleteDatabaseResponse;
|
|
/**
|
|
* @param {!Protocol.IndexedDBAgent.DeleteDatabaseRequest} obj
|
|
* @return {!Promise<!Protocol.IndexedDBAgent.DeleteDatabaseResponse>} */
|
|
Protocol.IndexedDBAgent.prototype.invoke_deleteDatabase = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} securityOrigin
|
|
* @param {string} databaseName
|
|
* @param {string} objectStoreName
|
|
* @param {Protocol.IndexedDB.KeyRange} keyRange
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.IndexedDBAgent.prototype.deleteObjectStoreEntries = function(securityOrigin, databaseName, objectStoreName, keyRange) {};
|
|
/** @typedef {!{objectStoreName: string, keyRange: Protocol.IndexedDB.KeyRange, databaseName: string, securityOrigin: string}} */
|
|
Protocol.IndexedDBAgent.DeleteObjectStoreEntriesRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.IndexedDBAgent.DeleteObjectStoreEntriesResponse;
|
|
/**
|
|
* @param {!Protocol.IndexedDBAgent.DeleteObjectStoreEntriesRequest} obj
|
|
* @return {!Promise<!Protocol.IndexedDBAgent.DeleteObjectStoreEntriesResponse>} */
|
|
Protocol.IndexedDBAgent.prototype.invoke_deleteObjectStoreEntries = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.IndexedDBAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.IndexedDBAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.IndexedDBAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.IndexedDBAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.IndexedDBAgent.DisableResponse>} */
|
|
Protocol.IndexedDBAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.IndexedDBAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.IndexedDBAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.IndexedDBAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.IndexedDBAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.IndexedDBAgent.EnableResponse>} */
|
|
Protocol.IndexedDBAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} securityOrigin
|
|
* @param {string} databaseName
|
|
* @param {string} objectStoreName
|
|
* @param {string} indexName
|
|
* @param {number} skipCount
|
|
* @param {number} pageSize
|
|
* @param {Protocol.IndexedDB.KeyRange=} opt_keyRange
|
|
* @return {!Promise<?Array<Protocol.IndexedDB.DataEntry>>}
|
|
*/
|
|
Protocol.IndexedDBAgent.prototype.requestData = function(securityOrigin, databaseName, objectStoreName, indexName, skipCount, pageSize, opt_keyRange) {};
|
|
/** @typedef {!{indexName: string, pageSize: number, objectStoreName: string, skipCount: number, keyRange: (Protocol.IndexedDB.KeyRange|undefined), databaseName: string, securityOrigin: string}} */
|
|
Protocol.IndexedDBAgent.RequestDataRequest;
|
|
/** @typedef {!{hasMore: boolean, objectStoreDataEntries: !Array<Protocol.IndexedDB.DataEntry>}} */
|
|
Protocol.IndexedDBAgent.RequestDataResponse;
|
|
/**
|
|
* @param {!Protocol.IndexedDBAgent.RequestDataRequest} obj
|
|
* @return {!Promise<!Protocol.IndexedDBAgent.RequestDataResponse>} */
|
|
Protocol.IndexedDBAgent.prototype.invoke_requestData = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} securityOrigin
|
|
* @param {string} databaseName
|
|
* @param {string} objectStoreName
|
|
* @return {!Promise<?number>}
|
|
*/
|
|
Protocol.IndexedDBAgent.prototype.getMetadata = function(securityOrigin, databaseName, objectStoreName) {};
|
|
/** @typedef {!{objectStoreName: string, databaseName: string, securityOrigin: string}} */
|
|
Protocol.IndexedDBAgent.GetMetadataRequest;
|
|
/** @typedef {!{entriesCount: number, keyGeneratorValue: number}} */
|
|
Protocol.IndexedDBAgent.GetMetadataResponse;
|
|
/**
|
|
* @param {!Protocol.IndexedDBAgent.GetMetadataRequest} obj
|
|
* @return {!Promise<!Protocol.IndexedDBAgent.GetMetadataResponse>} */
|
|
Protocol.IndexedDBAgent.prototype.invoke_getMetadata = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} securityOrigin
|
|
* @param {string} databaseName
|
|
* @return {!Promise<?Protocol.IndexedDB.DatabaseWithObjectStores>}
|
|
*/
|
|
Protocol.IndexedDBAgent.prototype.requestDatabase = function(securityOrigin, databaseName) {};
|
|
/** @typedef {!{databaseName: string, securityOrigin: string}} */
|
|
Protocol.IndexedDBAgent.RequestDatabaseRequest;
|
|
/** @typedef {!{databaseWithObjectStores: Protocol.IndexedDB.DatabaseWithObjectStores}} */
|
|
Protocol.IndexedDBAgent.RequestDatabaseResponse;
|
|
/**
|
|
* @param {!Protocol.IndexedDBAgent.RequestDatabaseRequest} obj
|
|
* @return {!Promise<!Protocol.IndexedDBAgent.RequestDatabaseResponse>} */
|
|
Protocol.IndexedDBAgent.prototype.invoke_requestDatabase = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} securityOrigin
|
|
* @return {!Promise<?Array<string>>}
|
|
*/
|
|
Protocol.IndexedDBAgent.prototype.requestDatabaseNames = function(securityOrigin) {};
|
|
/** @typedef {!{securityOrigin: string}} */
|
|
Protocol.IndexedDBAgent.RequestDatabaseNamesRequest;
|
|
/** @typedef {!{databaseNames: !Array<string>}} */
|
|
Protocol.IndexedDBAgent.RequestDatabaseNamesResponse;
|
|
/**
|
|
* @param {!Protocol.IndexedDBAgent.RequestDatabaseNamesRequest} obj
|
|
* @return {!Promise<!Protocol.IndexedDBAgent.RequestDatabaseNamesResponse>} */
|
|
Protocol.IndexedDBAgent.prototype.invoke_requestDatabaseNames = function(obj) {};
|
|
|
|
/** @typedef {!{name:(string), version:(number), objectStores:(!Array<Protocol.IndexedDB.ObjectStore>)}} */
|
|
Protocol.IndexedDB.DatabaseWithObjectStores;
|
|
|
|
/** @typedef {!{name:(string), keyPath:(Protocol.IndexedDB.KeyPath), autoIncrement:(boolean), indexes:(!Array<Protocol.IndexedDB.ObjectStoreIndex>)}} */
|
|
Protocol.IndexedDB.ObjectStore;
|
|
|
|
/** @typedef {!{name:(string), keyPath:(Protocol.IndexedDB.KeyPath), unique:(boolean), multiEntry:(boolean)}} */
|
|
Protocol.IndexedDB.ObjectStoreIndex;
|
|
|
|
/** @enum {string} */
|
|
Protocol.IndexedDB.KeyType = {
|
|
Number: "number",
|
|
String: "string",
|
|
Date: "date",
|
|
Array: "array"
|
|
};
|
|
|
|
/** @typedef {!{type:(Protocol.IndexedDB.KeyType), number:(number|undefined), string:(string|undefined), date:(number|undefined), array:(!Array<Protocol.IndexedDB.Key>|undefined)}} */
|
|
Protocol.IndexedDB.Key;
|
|
|
|
/** @typedef {!{lower:(Protocol.IndexedDB.Key|undefined), upper:(Protocol.IndexedDB.Key|undefined), lowerOpen:(boolean), upperOpen:(boolean)}} */
|
|
Protocol.IndexedDB.KeyRange;
|
|
|
|
/** @typedef {!{key:(Protocol.Runtime.RemoteObject), primaryKey:(Protocol.Runtime.RemoteObject), value:(Protocol.Runtime.RemoteObject)}} */
|
|
Protocol.IndexedDB.DataEntry;
|
|
|
|
/** @enum {string} */
|
|
Protocol.IndexedDB.KeyPathType = {
|
|
Null: "null",
|
|
String: "string",
|
|
Array: "array"
|
|
};
|
|
|
|
/** @typedef {!{type:(Protocol.IndexedDB.KeyPathType), string:(string|undefined), array:(!Array<string>|undefined)}} */
|
|
Protocol.IndexedDB.KeyPath;
|
|
/** @interface */
|
|
Protocol.IndexedDBDispatcher = function() {};
|
|
Protocol.Input = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.InputAgent = function(){};
|
|
|
|
/**
|
|
* @param {string} type
|
|
* @param {number=} opt_modifiers
|
|
* @param {Protocol.Input.TimeSinceEpoch=} opt_timestamp
|
|
* @param {string=} opt_text
|
|
* @param {string=} opt_unmodifiedText
|
|
* @param {string=} opt_keyIdentifier
|
|
* @param {string=} opt_code
|
|
* @param {string=} opt_key
|
|
* @param {number=} opt_windowsVirtualKeyCode
|
|
* @param {number=} opt_nativeVirtualKeyCode
|
|
* @param {boolean=} opt_autoRepeat
|
|
* @param {boolean=} opt_isKeypad
|
|
* @param {boolean=} opt_isSystemKey
|
|
* @param {number=} opt_location
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.InputAgent.prototype.dispatchKeyEvent = function(type, opt_modifiers, opt_timestamp, opt_text, opt_unmodifiedText, opt_keyIdentifier, opt_code, opt_key, opt_windowsVirtualKeyCode, opt_nativeVirtualKeyCode, opt_autoRepeat, opt_isKeypad, opt_isSystemKey, opt_location) {};
|
|
/** @typedef {!{code: (string|undefined), keyIdentifier: (string|undefined), modifiers: (number|undefined), timestamp: (Protocol.Input.TimeSinceEpoch|undefined), autoRepeat: (boolean|undefined), isSystemKey: (boolean|undefined), unmodifiedText: (string|undefined), location: (number|undefined), key: (string|undefined), text: (string|undefined), nativeVirtualKeyCode: (number|undefined), windowsVirtualKeyCode: (number|undefined), type: string, isKeypad: (boolean|undefined)}} */
|
|
Protocol.InputAgent.DispatchKeyEventRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.InputAgent.DispatchKeyEventResponse;
|
|
/**
|
|
* @param {!Protocol.InputAgent.DispatchKeyEventRequest} obj
|
|
* @return {!Promise<!Protocol.InputAgent.DispatchKeyEventResponse>} */
|
|
Protocol.InputAgent.prototype.invoke_dispatchKeyEvent = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} text
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.InputAgent.prototype.insertText = function(text) {};
|
|
/** @typedef {!{text: string}} */
|
|
Protocol.InputAgent.InsertTextRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.InputAgent.InsertTextResponse;
|
|
/**
|
|
* @param {!Protocol.InputAgent.InsertTextRequest} obj
|
|
* @return {!Promise<!Protocol.InputAgent.InsertTextResponse>} */
|
|
Protocol.InputAgent.prototype.invoke_insertText = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} type
|
|
* @param {number} x
|
|
* @param {number} y
|
|
* @param {number=} opt_modifiers
|
|
* @param {Protocol.Input.TimeSinceEpoch=} opt_timestamp
|
|
* @param {string=} opt_button
|
|
* @param {number=} opt_buttons
|
|
* @param {number=} opt_clickCount
|
|
* @param {number=} opt_deltaX
|
|
* @param {number=} opt_deltaY
|
|
* @param {string=} opt_pointerType
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.InputAgent.prototype.dispatchMouseEvent = function(type, x, y, opt_modifiers, opt_timestamp, opt_button, opt_buttons, opt_clickCount, opt_deltaX, opt_deltaY, opt_pointerType) {};
|
|
/** @typedef {!{modifiers: (number|undefined), clickCount: (number|undefined), deltaX: (number|undefined), timestamp: (Protocol.Input.TimeSinceEpoch|undefined), button: (string|undefined), buttons: (number|undefined), pointerType: (string|undefined), deltaY: (number|undefined), y: number, x: number, type: string}} */
|
|
Protocol.InputAgent.DispatchMouseEventRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.InputAgent.DispatchMouseEventResponse;
|
|
/**
|
|
* @param {!Protocol.InputAgent.DispatchMouseEventRequest} obj
|
|
* @return {!Promise<!Protocol.InputAgent.DispatchMouseEventResponse>} */
|
|
Protocol.InputAgent.prototype.invoke_dispatchMouseEvent = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} type
|
|
* @param {!Array<Protocol.Input.TouchPoint>} touchPoints
|
|
* @param {number=} opt_modifiers
|
|
* @param {Protocol.Input.TimeSinceEpoch=} opt_timestamp
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.InputAgent.prototype.dispatchTouchEvent = function(type, touchPoints, opt_modifiers, opt_timestamp) {};
|
|
/** @typedef {!{timestamp: (Protocol.Input.TimeSinceEpoch|undefined), modifiers: (number|undefined), type: string, touchPoints: !Array<Protocol.Input.TouchPoint>}} */
|
|
Protocol.InputAgent.DispatchTouchEventRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.InputAgent.DispatchTouchEventResponse;
|
|
/**
|
|
* @param {!Protocol.InputAgent.DispatchTouchEventRequest} obj
|
|
* @return {!Promise<!Protocol.InputAgent.DispatchTouchEventResponse>} */
|
|
Protocol.InputAgent.prototype.invoke_dispatchTouchEvent = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} type
|
|
* @param {number} x
|
|
* @param {number} y
|
|
* @param {string} button
|
|
* @param {Protocol.Input.TimeSinceEpoch=} opt_timestamp
|
|
* @param {number=} opt_deltaX
|
|
* @param {number=} opt_deltaY
|
|
* @param {number=} opt_modifiers
|
|
* @param {number=} opt_clickCount
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.InputAgent.prototype.emulateTouchFromMouseEvent = function(type, x, y, button, opt_timestamp, opt_deltaX, opt_deltaY, opt_modifiers, opt_clickCount) {};
|
|
/** @typedef {!{modifiers: (number|undefined), clickCount: (number|undefined), deltaX: (number|undefined), timestamp: (Protocol.Input.TimeSinceEpoch|undefined), button: string, deltaY: (number|undefined), y: number, x: number, type: string}} */
|
|
Protocol.InputAgent.EmulateTouchFromMouseEventRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.InputAgent.EmulateTouchFromMouseEventResponse;
|
|
/**
|
|
* @param {!Protocol.InputAgent.EmulateTouchFromMouseEventRequest} obj
|
|
* @return {!Promise<!Protocol.InputAgent.EmulateTouchFromMouseEventResponse>} */
|
|
Protocol.InputAgent.prototype.invoke_emulateTouchFromMouseEvent = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} ignore
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.InputAgent.prototype.setIgnoreInputEvents = function(ignore) {};
|
|
/** @typedef {!{ignore: boolean}} */
|
|
Protocol.InputAgent.SetIgnoreInputEventsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.InputAgent.SetIgnoreInputEventsResponse;
|
|
/**
|
|
* @param {!Protocol.InputAgent.SetIgnoreInputEventsRequest} obj
|
|
* @return {!Promise<!Protocol.InputAgent.SetIgnoreInputEventsResponse>} */
|
|
Protocol.InputAgent.prototype.invoke_setIgnoreInputEvents = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} x
|
|
* @param {number} y
|
|
* @param {number} scaleFactor
|
|
* @param {number=} opt_relativeSpeed
|
|
* @param {Protocol.Input.GestureSourceType=} opt_gestureSourceType
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.InputAgent.prototype.synthesizePinchGesture = function(x, y, scaleFactor, opt_relativeSpeed, opt_gestureSourceType) {};
|
|
/** @typedef {!{y: number, x: number, gestureSourceType: (Protocol.Input.GestureSourceType|undefined), relativeSpeed: (number|undefined), scaleFactor: number}} */
|
|
Protocol.InputAgent.SynthesizePinchGestureRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.InputAgent.SynthesizePinchGestureResponse;
|
|
/**
|
|
* @param {!Protocol.InputAgent.SynthesizePinchGestureRequest} obj
|
|
* @return {!Promise<!Protocol.InputAgent.SynthesizePinchGestureResponse>} */
|
|
Protocol.InputAgent.prototype.invoke_synthesizePinchGesture = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} x
|
|
* @param {number} y
|
|
* @param {number=} opt_xDistance
|
|
* @param {number=} opt_yDistance
|
|
* @param {number=} opt_xOverscroll
|
|
* @param {number=} opt_yOverscroll
|
|
* @param {boolean=} opt_preventFling
|
|
* @param {number=} opt_speed
|
|
* @param {Protocol.Input.GestureSourceType=} opt_gestureSourceType
|
|
* @param {number=} opt_repeatCount
|
|
* @param {number=} opt_repeatDelayMs
|
|
* @param {string=} opt_interactionMarkerName
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.InputAgent.prototype.synthesizeScrollGesture = function(x, y, opt_xDistance, opt_yDistance, opt_xOverscroll, opt_yOverscroll, opt_preventFling, opt_speed, opt_gestureSourceType, opt_repeatCount, opt_repeatDelayMs, opt_interactionMarkerName) {};
|
|
/** @typedef {!{xOverscroll: (number|undefined), yOverscroll: (number|undefined), preventFling: (boolean|undefined), yDistance: (number|undefined), interactionMarkerName: (string|undefined), xDistance: (number|undefined), repeatCount: (number|undefined), gestureSourceType: (Protocol.Input.GestureSourceType|undefined), repeatDelayMs: (number|undefined), y: number, x: number, speed: (number|undefined)}} */
|
|
Protocol.InputAgent.SynthesizeScrollGestureRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.InputAgent.SynthesizeScrollGestureResponse;
|
|
/**
|
|
* @param {!Protocol.InputAgent.SynthesizeScrollGestureRequest} obj
|
|
* @return {!Promise<!Protocol.InputAgent.SynthesizeScrollGestureResponse>} */
|
|
Protocol.InputAgent.prototype.invoke_synthesizeScrollGesture = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} x
|
|
* @param {number} y
|
|
* @param {number=} opt_duration
|
|
* @param {number=} opt_tapCount
|
|
* @param {Protocol.Input.GestureSourceType=} opt_gestureSourceType
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.InputAgent.prototype.synthesizeTapGesture = function(x, y, opt_duration, opt_tapCount, opt_gestureSourceType) {};
|
|
/** @typedef {!{y: number, x: number, duration: (number|undefined), gestureSourceType: (Protocol.Input.GestureSourceType|undefined), tapCount: (number|undefined)}} */
|
|
Protocol.InputAgent.SynthesizeTapGestureRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.InputAgent.SynthesizeTapGestureResponse;
|
|
/**
|
|
* @param {!Protocol.InputAgent.SynthesizeTapGestureRequest} obj
|
|
* @return {!Promise<!Protocol.InputAgent.SynthesizeTapGestureResponse>} */
|
|
Protocol.InputAgent.prototype.invoke_synthesizeTapGesture = function(obj) {};
|
|
|
|
/** @typedef {!{x:(number), y:(number), radiusX:(number|undefined), radiusY:(number|undefined), rotationAngle:(number|undefined), force:(number|undefined), id:(number|undefined)}} */
|
|
Protocol.Input.TouchPoint;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Input.GestureSourceType = {
|
|
Default: "default",
|
|
Touch: "touch",
|
|
Mouse: "mouse"
|
|
};
|
|
|
|
/** @typedef {number} */
|
|
Protocol.Input.TimeSinceEpoch;
|
|
/** @interface */
|
|
Protocol.InputDispatcher = function() {};
|
|
Protocol.Inspector = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.InspectorAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.InspectorAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.InspectorAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.InspectorAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.InspectorAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.InspectorAgent.DisableResponse>} */
|
|
Protocol.InspectorAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.InspectorAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.InspectorAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.InspectorAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.InspectorAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.InspectorAgent.EnableResponse>} */
|
|
Protocol.InspectorAgent.prototype.invoke_enable = function(obj) {};
|
|
/** @interface */
|
|
Protocol.InspectorDispatcher = function() {};
|
|
/**
|
|
* @param {string} reason
|
|
*/
|
|
Protocol.InspectorDispatcher.prototype.detached = function(reason) {};
|
|
Protocol.InspectorDispatcher.prototype.targetCrashed = function() {};
|
|
Protocol.InspectorDispatcher.prototype.targetReloadedAfterCrash = function() {};
|
|
Protocol.LayerTree = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.LayerTreeAgent = function(){};
|
|
|
|
/**
|
|
* @param {Protocol.LayerTree.LayerId} layerId
|
|
* @return {!Promise<?Array<string>>}
|
|
*/
|
|
Protocol.LayerTreeAgent.prototype.compositingReasons = function(layerId) {};
|
|
/** @typedef {!{layerId: Protocol.LayerTree.LayerId}} */
|
|
Protocol.LayerTreeAgent.CompositingReasonsRequest;
|
|
/** @typedef {!{compositingReasons: !Array<string>}} */
|
|
Protocol.LayerTreeAgent.CompositingReasonsResponse;
|
|
/**
|
|
* @param {!Protocol.LayerTreeAgent.CompositingReasonsRequest} obj
|
|
* @return {!Promise<!Protocol.LayerTreeAgent.CompositingReasonsResponse>} */
|
|
Protocol.LayerTreeAgent.prototype.invoke_compositingReasons = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.LayerTreeAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.LayerTreeAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.LayerTreeAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.LayerTreeAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.LayerTreeAgent.DisableResponse>} */
|
|
Protocol.LayerTreeAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.LayerTreeAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.LayerTreeAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.LayerTreeAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.LayerTreeAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.LayerTreeAgent.EnableResponse>} */
|
|
Protocol.LayerTreeAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<Protocol.LayerTree.PictureTile>} tiles
|
|
* @return {!Promise<?Protocol.LayerTree.SnapshotId>}
|
|
*/
|
|
Protocol.LayerTreeAgent.prototype.loadSnapshot = function(tiles) {};
|
|
/** @typedef {!{tiles: !Array<Protocol.LayerTree.PictureTile>}} */
|
|
Protocol.LayerTreeAgent.LoadSnapshotRequest;
|
|
/** @typedef {!{snapshotId: Protocol.LayerTree.SnapshotId}} */
|
|
Protocol.LayerTreeAgent.LoadSnapshotResponse;
|
|
/**
|
|
* @param {!Protocol.LayerTreeAgent.LoadSnapshotRequest} obj
|
|
* @return {!Promise<!Protocol.LayerTreeAgent.LoadSnapshotResponse>} */
|
|
Protocol.LayerTreeAgent.prototype.invoke_loadSnapshot = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.LayerTree.LayerId} layerId
|
|
* @return {!Promise<?Protocol.LayerTree.SnapshotId>}
|
|
*/
|
|
Protocol.LayerTreeAgent.prototype.makeSnapshot = function(layerId) {};
|
|
/** @typedef {!{layerId: Protocol.LayerTree.LayerId}} */
|
|
Protocol.LayerTreeAgent.MakeSnapshotRequest;
|
|
/** @typedef {!{snapshotId: Protocol.LayerTree.SnapshotId}} */
|
|
Protocol.LayerTreeAgent.MakeSnapshotResponse;
|
|
/**
|
|
* @param {!Protocol.LayerTreeAgent.MakeSnapshotRequest} obj
|
|
* @return {!Promise<!Protocol.LayerTreeAgent.MakeSnapshotResponse>} */
|
|
Protocol.LayerTreeAgent.prototype.invoke_makeSnapshot = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.LayerTree.SnapshotId} snapshotId
|
|
* @param {number=} opt_minRepeatCount
|
|
* @param {number=} opt_minDuration
|
|
* @param {Protocol.DOM.Rect=} opt_clipRect
|
|
* @return {!Promise<?Array<Protocol.LayerTree.PaintProfile>>}
|
|
*/
|
|
Protocol.LayerTreeAgent.prototype.profileSnapshot = function(snapshotId, opt_minRepeatCount, opt_minDuration, opt_clipRect) {};
|
|
/** @typedef {!{minRepeatCount: (number|undefined), snapshotId: Protocol.LayerTree.SnapshotId, clipRect: (Protocol.DOM.Rect|undefined), minDuration: (number|undefined)}} */
|
|
Protocol.LayerTreeAgent.ProfileSnapshotRequest;
|
|
/** @typedef {!{timings: !Array<Protocol.LayerTree.PaintProfile>}} */
|
|
Protocol.LayerTreeAgent.ProfileSnapshotResponse;
|
|
/**
|
|
* @param {!Protocol.LayerTreeAgent.ProfileSnapshotRequest} obj
|
|
* @return {!Promise<!Protocol.LayerTreeAgent.ProfileSnapshotResponse>} */
|
|
Protocol.LayerTreeAgent.prototype.invoke_profileSnapshot = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.LayerTree.SnapshotId} snapshotId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.LayerTreeAgent.prototype.releaseSnapshot = function(snapshotId) {};
|
|
/** @typedef {!{snapshotId: Protocol.LayerTree.SnapshotId}} */
|
|
Protocol.LayerTreeAgent.ReleaseSnapshotRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.LayerTreeAgent.ReleaseSnapshotResponse;
|
|
/**
|
|
* @param {!Protocol.LayerTreeAgent.ReleaseSnapshotRequest} obj
|
|
* @return {!Promise<!Protocol.LayerTreeAgent.ReleaseSnapshotResponse>} */
|
|
Protocol.LayerTreeAgent.prototype.invoke_releaseSnapshot = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.LayerTree.SnapshotId} snapshotId
|
|
* @param {number=} opt_fromStep
|
|
* @param {number=} opt_toStep
|
|
* @param {number=} opt_scale
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.LayerTreeAgent.prototype.replaySnapshot = function(snapshotId, opt_fromStep, opt_toStep, opt_scale) {};
|
|
/** @typedef {!{snapshotId: Protocol.LayerTree.SnapshotId, scale: (number|undefined), fromStep: (number|undefined), toStep: (number|undefined)}} */
|
|
Protocol.LayerTreeAgent.ReplaySnapshotRequest;
|
|
/** @typedef {!{dataURL: string}} */
|
|
Protocol.LayerTreeAgent.ReplaySnapshotResponse;
|
|
/**
|
|
* @param {!Protocol.LayerTreeAgent.ReplaySnapshotRequest} obj
|
|
* @return {!Promise<!Protocol.LayerTreeAgent.ReplaySnapshotResponse>} */
|
|
Protocol.LayerTreeAgent.prototype.invoke_replaySnapshot = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.LayerTree.SnapshotId} snapshotId
|
|
* @return {!Promise<?Array<!Object>>}
|
|
*/
|
|
Protocol.LayerTreeAgent.prototype.snapshotCommandLog = function(snapshotId) {};
|
|
/** @typedef {!{snapshotId: Protocol.LayerTree.SnapshotId}} */
|
|
Protocol.LayerTreeAgent.SnapshotCommandLogRequest;
|
|
/** @typedef {!{commandLog: !Array<!Object>}} */
|
|
Protocol.LayerTreeAgent.SnapshotCommandLogResponse;
|
|
/**
|
|
* @param {!Protocol.LayerTreeAgent.SnapshotCommandLogRequest} obj
|
|
* @return {!Promise<!Protocol.LayerTreeAgent.SnapshotCommandLogResponse>} */
|
|
Protocol.LayerTreeAgent.prototype.invoke_snapshotCommandLog = function(obj) {};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.LayerTree.LayerId;
|
|
|
|
/** @typedef {string} */
|
|
Protocol.LayerTree.SnapshotId;
|
|
|
|
/** @enum {string} */
|
|
Protocol.LayerTree.ScrollRectType = {
|
|
RepaintsOnScroll: "RepaintsOnScroll",
|
|
TouchEventHandler: "TouchEventHandler",
|
|
WheelEventHandler: "WheelEventHandler"
|
|
};
|
|
|
|
/** @typedef {!{rect:(Protocol.DOM.Rect), type:(Protocol.LayerTree.ScrollRectType)}} */
|
|
Protocol.LayerTree.ScrollRect;
|
|
|
|
/** @typedef {!{stickyBoxRect:(Protocol.DOM.Rect), containingBlockRect:(Protocol.DOM.Rect), nearestLayerShiftingStickyBox:(Protocol.LayerTree.LayerId|undefined), nearestLayerShiftingContainingBlock:(Protocol.LayerTree.LayerId|undefined)}} */
|
|
Protocol.LayerTree.StickyPositionConstraint;
|
|
|
|
/** @typedef {!{x:(number), y:(number), picture:(string)}} */
|
|
Protocol.LayerTree.PictureTile;
|
|
|
|
/** @typedef {!{layerId:(Protocol.LayerTree.LayerId), parentLayerId:(Protocol.LayerTree.LayerId|undefined), backendNodeId:(Protocol.DOM.BackendNodeId|undefined), offsetX:(number), offsetY:(number), width:(number), height:(number), transform:(!Array<number>|undefined), anchorX:(number|undefined), anchorY:(number|undefined), anchorZ:(number|undefined), paintCount:(number), drawsContent:(boolean), invisible:(boolean|undefined), scrollRects:(!Array<Protocol.LayerTree.ScrollRect>|undefined), stickyPositionConstraint:(Protocol.LayerTree.StickyPositionConstraint|undefined)}} */
|
|
Protocol.LayerTree.Layer;
|
|
|
|
/** @typedef {!Array<!number>} */
|
|
Protocol.LayerTree.PaintProfile;
|
|
/** @interface */
|
|
Protocol.LayerTreeDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.LayerTree.LayerId} layerId
|
|
* @param {Protocol.DOM.Rect} clip
|
|
*/
|
|
Protocol.LayerTreeDispatcher.prototype.layerPainted = function(layerId, clip) {};
|
|
/**
|
|
* @param {!Array<Protocol.LayerTree.Layer>=} opt_layers
|
|
*/
|
|
Protocol.LayerTreeDispatcher.prototype.layerTreeDidChange = function(opt_layers) {};
|
|
Protocol.Log = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.LogAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.LogAgent.prototype.clear = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.LogAgent.ClearRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.LogAgent.ClearResponse;
|
|
/**
|
|
* @param {!Protocol.LogAgent.ClearRequest} obj
|
|
* @return {!Promise<!Protocol.LogAgent.ClearResponse>} */
|
|
Protocol.LogAgent.prototype.invoke_clear = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.LogAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.LogAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.LogAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.LogAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.LogAgent.DisableResponse>} */
|
|
Protocol.LogAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.LogAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.LogAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.LogAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.LogAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.LogAgent.EnableResponse>} */
|
|
Protocol.LogAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<Protocol.Log.ViolationSetting>} config
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.LogAgent.prototype.startViolationsReport = function(config) {};
|
|
/** @typedef {!{config: !Array<Protocol.Log.ViolationSetting>}} */
|
|
Protocol.LogAgent.StartViolationsReportRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.LogAgent.StartViolationsReportResponse;
|
|
/**
|
|
* @param {!Protocol.LogAgent.StartViolationsReportRequest} obj
|
|
* @return {!Promise<!Protocol.LogAgent.StartViolationsReportResponse>} */
|
|
Protocol.LogAgent.prototype.invoke_startViolationsReport = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.LogAgent.prototype.stopViolationsReport = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.LogAgent.StopViolationsReportRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.LogAgent.StopViolationsReportResponse;
|
|
/**
|
|
* @param {!Protocol.LogAgent.StopViolationsReportRequest} obj
|
|
* @return {!Promise<!Protocol.LogAgent.StopViolationsReportResponse>} */
|
|
Protocol.LogAgent.prototype.invoke_stopViolationsReport = function(obj) {};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Log.LogEntrySource = {
|
|
XML: "xml",
|
|
Javascript: "javascript",
|
|
Network: "network",
|
|
Storage: "storage",
|
|
Appcache: "appcache",
|
|
Rendering: "rendering",
|
|
Security: "security",
|
|
Deprecation: "deprecation",
|
|
Worker: "worker",
|
|
Violation: "violation",
|
|
Intervention: "intervention",
|
|
Recommendation: "recommendation",
|
|
Other: "other"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Log.LogEntryLevel = {
|
|
Verbose: "verbose",
|
|
Info: "info",
|
|
Warning: "warning",
|
|
Error: "error"
|
|
};
|
|
|
|
/** @typedef {!{source:(Protocol.Log.LogEntrySource), level:(Protocol.Log.LogEntryLevel), text:(string), timestamp:(Protocol.Runtime.Timestamp), url:(string|undefined), lineNumber:(number|undefined), stackTrace:(Protocol.Runtime.StackTrace|undefined), networkRequestId:(Protocol.Network.RequestId|undefined), workerId:(string|undefined), args:(!Array<Protocol.Runtime.RemoteObject>|undefined)}} */
|
|
Protocol.Log.LogEntry;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Log.ViolationSettingName = {
|
|
LongTask: "longTask",
|
|
LongLayout: "longLayout",
|
|
BlockedEvent: "blockedEvent",
|
|
BlockedParser: "blockedParser",
|
|
DiscouragedAPIUse: "discouragedAPIUse",
|
|
Handler: "handler",
|
|
RecurringHandler: "recurringHandler"
|
|
};
|
|
|
|
/** @typedef {!{name:(Protocol.Log.ViolationSettingName), threshold:(number)}} */
|
|
Protocol.Log.ViolationSetting;
|
|
/** @interface */
|
|
Protocol.LogDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.Log.LogEntry} entry
|
|
*/
|
|
Protocol.LogDispatcher.prototype.entryAdded = function(entry) {};
|
|
Protocol.Memory = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.MemoryAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<?number>}
|
|
*/
|
|
Protocol.MemoryAgent.prototype.getDOMCounters = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MemoryAgent.GetDOMCountersRequest;
|
|
/** @typedef {!{nodes: number, documents: number, jsEventListeners: number}} */
|
|
Protocol.MemoryAgent.GetDOMCountersResponse;
|
|
/**
|
|
* @param {!Protocol.MemoryAgent.GetDOMCountersRequest} obj
|
|
* @return {!Promise<!Protocol.MemoryAgent.GetDOMCountersResponse>} */
|
|
Protocol.MemoryAgent.prototype.invoke_getDOMCounters = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.MemoryAgent.prototype.prepareForLeakDetection = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MemoryAgent.PrepareForLeakDetectionRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MemoryAgent.PrepareForLeakDetectionResponse;
|
|
/**
|
|
* @param {!Protocol.MemoryAgent.PrepareForLeakDetectionRequest} obj
|
|
* @return {!Promise<!Protocol.MemoryAgent.PrepareForLeakDetectionResponse>} */
|
|
Protocol.MemoryAgent.prototype.invoke_prepareForLeakDetection = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.MemoryAgent.prototype.forciblyPurgeJavaScriptMemory = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MemoryAgent.ForciblyPurgeJavaScriptMemoryRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MemoryAgent.ForciblyPurgeJavaScriptMemoryResponse;
|
|
/**
|
|
* @param {!Protocol.MemoryAgent.ForciblyPurgeJavaScriptMemoryRequest} obj
|
|
* @return {!Promise<!Protocol.MemoryAgent.ForciblyPurgeJavaScriptMemoryResponse>} */
|
|
Protocol.MemoryAgent.prototype.invoke_forciblyPurgeJavaScriptMemory = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} suppressed
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.MemoryAgent.prototype.setPressureNotificationsSuppressed = function(suppressed) {};
|
|
/** @typedef {!{suppressed: boolean}} */
|
|
Protocol.MemoryAgent.SetPressureNotificationsSuppressedRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MemoryAgent.SetPressureNotificationsSuppressedResponse;
|
|
/**
|
|
* @param {!Protocol.MemoryAgent.SetPressureNotificationsSuppressedRequest} obj
|
|
* @return {!Promise<!Protocol.MemoryAgent.SetPressureNotificationsSuppressedResponse>} */
|
|
Protocol.MemoryAgent.prototype.invoke_setPressureNotificationsSuppressed = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Memory.PressureLevel} level
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.MemoryAgent.prototype.simulatePressureNotification = function(level) {};
|
|
/** @typedef {!{level: Protocol.Memory.PressureLevel}} */
|
|
Protocol.MemoryAgent.SimulatePressureNotificationRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MemoryAgent.SimulatePressureNotificationResponse;
|
|
/**
|
|
* @param {!Protocol.MemoryAgent.SimulatePressureNotificationRequest} obj
|
|
* @return {!Promise<!Protocol.MemoryAgent.SimulatePressureNotificationResponse>} */
|
|
Protocol.MemoryAgent.prototype.invoke_simulatePressureNotification = function(obj) {};
|
|
|
|
/**
|
|
* @param {number=} opt_samplingInterval
|
|
* @param {boolean=} opt_suppressRandomness
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.MemoryAgent.prototype.startSampling = function(opt_samplingInterval, opt_suppressRandomness) {};
|
|
/** @typedef {!{samplingInterval: (number|undefined), suppressRandomness: (boolean|undefined)}} */
|
|
Protocol.MemoryAgent.StartSamplingRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MemoryAgent.StartSamplingResponse;
|
|
/**
|
|
* @param {!Protocol.MemoryAgent.StartSamplingRequest} obj
|
|
* @return {!Promise<!Protocol.MemoryAgent.StartSamplingResponse>} */
|
|
Protocol.MemoryAgent.prototype.invoke_startSampling = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.MemoryAgent.prototype.stopSampling = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MemoryAgent.StopSamplingRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MemoryAgent.StopSamplingResponse;
|
|
/**
|
|
* @param {!Protocol.MemoryAgent.StopSamplingRequest} obj
|
|
* @return {!Promise<!Protocol.MemoryAgent.StopSamplingResponse>} */
|
|
Protocol.MemoryAgent.prototype.invoke_stopSampling = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Protocol.Memory.SamplingProfile>}
|
|
*/
|
|
Protocol.MemoryAgent.prototype.getAllTimeSamplingProfile = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MemoryAgent.GetAllTimeSamplingProfileRequest;
|
|
/** @typedef {!{profile: Protocol.Memory.SamplingProfile}} */
|
|
Protocol.MemoryAgent.GetAllTimeSamplingProfileResponse;
|
|
/**
|
|
* @param {!Protocol.MemoryAgent.GetAllTimeSamplingProfileRequest} obj
|
|
* @return {!Promise<!Protocol.MemoryAgent.GetAllTimeSamplingProfileResponse>} */
|
|
Protocol.MemoryAgent.prototype.invoke_getAllTimeSamplingProfile = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Protocol.Memory.SamplingProfile>}
|
|
*/
|
|
Protocol.MemoryAgent.prototype.getBrowserSamplingProfile = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MemoryAgent.GetBrowserSamplingProfileRequest;
|
|
/** @typedef {!{profile: Protocol.Memory.SamplingProfile}} */
|
|
Protocol.MemoryAgent.GetBrowserSamplingProfileResponse;
|
|
/**
|
|
* @param {!Protocol.MemoryAgent.GetBrowserSamplingProfileRequest} obj
|
|
* @return {!Promise<!Protocol.MemoryAgent.GetBrowserSamplingProfileResponse>} */
|
|
Protocol.MemoryAgent.prototype.invoke_getBrowserSamplingProfile = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Protocol.Memory.SamplingProfile>}
|
|
*/
|
|
Protocol.MemoryAgent.prototype.getSamplingProfile = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MemoryAgent.GetSamplingProfileRequest;
|
|
/** @typedef {!{profile: Protocol.Memory.SamplingProfile}} */
|
|
Protocol.MemoryAgent.GetSamplingProfileResponse;
|
|
/**
|
|
* @param {!Protocol.MemoryAgent.GetSamplingProfileRequest} obj
|
|
* @return {!Promise<!Protocol.MemoryAgent.GetSamplingProfileResponse>} */
|
|
Protocol.MemoryAgent.prototype.invoke_getSamplingProfile = function(obj) {};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Memory.PressureLevel = {
|
|
Moderate: "moderate",
|
|
Critical: "critical"
|
|
};
|
|
|
|
/** @typedef {!{size:(number), total:(number), stack:(!Array<string>)}} */
|
|
Protocol.Memory.SamplingProfileNode;
|
|
|
|
/** @typedef {!{samples:(!Array<Protocol.Memory.SamplingProfileNode>), modules:(!Array<Protocol.Memory.Module>)}} */
|
|
Protocol.Memory.SamplingProfile;
|
|
|
|
/** @typedef {!{name:(string), uuid:(string), baseAddress:(string), size:(number)}} */
|
|
Protocol.Memory.Module;
|
|
/** @interface */
|
|
Protocol.MemoryDispatcher = function() {};
|
|
Protocol.Network = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.NetworkAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<?boolean>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.canClearBrowserCache = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.CanClearBrowserCacheRequest;
|
|
/** @typedef {!{result: boolean}} */
|
|
Protocol.NetworkAgent.CanClearBrowserCacheResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.CanClearBrowserCacheRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.CanClearBrowserCacheResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_canClearBrowserCache = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?boolean>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.canClearBrowserCookies = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.CanClearBrowserCookiesRequest;
|
|
/** @typedef {!{result: boolean}} */
|
|
Protocol.NetworkAgent.CanClearBrowserCookiesResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.CanClearBrowserCookiesRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.CanClearBrowserCookiesResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_canClearBrowserCookies = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?boolean>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.canEmulateNetworkConditions = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.CanEmulateNetworkConditionsRequest;
|
|
/** @typedef {!{result: boolean}} */
|
|
Protocol.NetworkAgent.CanEmulateNetworkConditionsResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.CanEmulateNetworkConditionsRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.CanEmulateNetworkConditionsResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_canEmulateNetworkConditions = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.clearBrowserCache = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.ClearBrowserCacheRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.ClearBrowserCacheResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.ClearBrowserCacheRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.ClearBrowserCacheResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_clearBrowserCache = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.clearBrowserCookies = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.ClearBrowserCookiesRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.ClearBrowserCookiesResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.ClearBrowserCookiesRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.ClearBrowserCookiesResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_clearBrowserCookies = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Network.InterceptionId} interceptionId
|
|
* @param {Protocol.Network.ErrorReason=} opt_errorReason
|
|
* @param {string=} opt_rawResponse
|
|
* @param {string=} opt_url
|
|
* @param {string=} opt_method
|
|
* @param {string=} opt_postData
|
|
* @param {Protocol.Network.Headers=} opt_headers
|
|
* @param {Protocol.Network.AuthChallengeResponse=} opt_authChallengeResponse
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.continueInterceptedRequest = function(interceptionId, opt_errorReason, opt_rawResponse, opt_url, opt_method, opt_postData, opt_headers, opt_authChallengeResponse) {};
|
|
/** @typedef {!{postData: (string|undefined), headers: (Protocol.Network.Headers|undefined), url: (string|undefined), authChallengeResponse: (Protocol.Network.AuthChallengeResponse|undefined), errorReason: (Protocol.Network.ErrorReason|undefined), interceptionId: Protocol.Network.InterceptionId, rawResponse: (string|undefined), method: (string|undefined)}} */
|
|
Protocol.NetworkAgent.ContinueInterceptedRequestRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.ContinueInterceptedRequestResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.ContinueInterceptedRequestRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.ContinueInterceptedRequestResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_continueInterceptedRequest = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} name
|
|
* @param {string=} opt_url
|
|
* @param {string=} opt_domain
|
|
* @param {string=} opt_path
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.deleteCookies = function(name, opt_url, opt_domain, opt_path) {};
|
|
/** @typedef {!{url: (string|undefined), path: (string|undefined), domain: (string|undefined), name: string}} */
|
|
Protocol.NetworkAgent.DeleteCookiesRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.DeleteCookiesResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.DeleteCookiesRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.DeleteCookiesResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_deleteCookies = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.DisableResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} offline
|
|
* @param {number} latency
|
|
* @param {number} downloadThroughput
|
|
* @param {number} uploadThroughput
|
|
* @param {Protocol.Network.ConnectionType=} opt_connectionType
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.emulateNetworkConditions = function(offline, latency, downloadThroughput, uploadThroughput, opt_connectionType) {};
|
|
/** @typedef {!{latency: number, offline: boolean, downloadThroughput: number, connectionType: (Protocol.Network.ConnectionType|undefined), uploadThroughput: number}} */
|
|
Protocol.NetworkAgent.EmulateNetworkConditionsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.EmulateNetworkConditionsResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.EmulateNetworkConditionsRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.EmulateNetworkConditionsResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_emulateNetworkConditions = function(obj) {};
|
|
|
|
/**
|
|
* @param {number=} opt_maxTotalBufferSize
|
|
* @param {number=} opt_maxResourceBufferSize
|
|
* @param {number=} opt_maxPostDataSize
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.enable = function(opt_maxTotalBufferSize, opt_maxResourceBufferSize, opt_maxPostDataSize) {};
|
|
/** @typedef {!{maxTotalBufferSize: (number|undefined), maxPostDataSize: (number|undefined), maxResourceBufferSize: (number|undefined)}} */
|
|
Protocol.NetworkAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.EnableResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<Protocol.Network.Cookie>>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.getAllCookies = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.GetAllCookiesRequest;
|
|
/** @typedef {!{cookies: !Array<Protocol.Network.Cookie>}} */
|
|
Protocol.NetworkAgent.GetAllCookiesResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.GetAllCookiesRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.GetAllCookiesResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_getAllCookies = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} origin
|
|
* @return {!Promise<?Array<string>>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.getCertificate = function(origin) {};
|
|
/** @typedef {!{origin: string}} */
|
|
Protocol.NetworkAgent.GetCertificateRequest;
|
|
/** @typedef {!{tableNames: !Array<string>}} */
|
|
Protocol.NetworkAgent.GetCertificateResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.GetCertificateRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.GetCertificateResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_getCertificate = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<string>=} opt_urls
|
|
* @return {!Promise<?Array<Protocol.Network.Cookie>>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.getCookies = function(opt_urls) {};
|
|
/** @typedef {!{urls: (!Array<string>|undefined)}} */
|
|
Protocol.NetworkAgent.GetCookiesRequest;
|
|
/** @typedef {!{cookies: !Array<Protocol.Network.Cookie>}} */
|
|
Protocol.NetworkAgent.GetCookiesResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.GetCookiesRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.GetCookiesResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_getCookies = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.getResponseBody = function(requestId) {};
|
|
/** @typedef {!{requestId: Protocol.Network.RequestId}} */
|
|
Protocol.NetworkAgent.GetResponseBodyRequest;
|
|
/** @typedef {!{body: string, base64Encoded: boolean}} */
|
|
Protocol.NetworkAgent.GetResponseBodyResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.GetResponseBodyRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.GetResponseBodyResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_getResponseBody = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.getRequestPostData = function(requestId) {};
|
|
/** @typedef {!{requestId: Protocol.Network.RequestId}} */
|
|
Protocol.NetworkAgent.GetRequestPostDataRequest;
|
|
/** @typedef {!{postData: string}} */
|
|
Protocol.NetworkAgent.GetRequestPostDataResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.GetRequestPostDataRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.GetRequestPostDataResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_getRequestPostData = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Network.InterceptionId} interceptionId
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.getResponseBodyForInterception = function(interceptionId) {};
|
|
/** @typedef {!{interceptionId: Protocol.Network.InterceptionId}} */
|
|
Protocol.NetworkAgent.GetResponseBodyForInterceptionRequest;
|
|
/** @typedef {!{body: string, base64Encoded: boolean}} */
|
|
Protocol.NetworkAgent.GetResponseBodyForInterceptionResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.GetResponseBodyForInterceptionRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.GetResponseBodyForInterceptionResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_getResponseBodyForInterception = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Network.InterceptionId} interceptionId
|
|
* @return {!Promise<?Protocol.IO.StreamHandle>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.takeResponseBodyForInterceptionAsStream = function(interceptionId) {};
|
|
/** @typedef {!{interceptionId: Protocol.Network.InterceptionId}} */
|
|
Protocol.NetworkAgent.TakeResponseBodyForInterceptionAsStreamRequest;
|
|
/** @typedef {!{stream: Protocol.IO.StreamHandle}} */
|
|
Protocol.NetworkAgent.TakeResponseBodyForInterceptionAsStreamResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.TakeResponseBodyForInterceptionAsStreamRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.TakeResponseBodyForInterceptionAsStreamResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_takeResponseBodyForInterceptionAsStream = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.replayXHR = function(requestId) {};
|
|
/** @typedef {!{requestId: Protocol.Network.RequestId}} */
|
|
Protocol.NetworkAgent.ReplayXHRRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.ReplayXHRResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.ReplayXHRRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.ReplayXHRResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_replayXHR = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {string} query
|
|
* @param {boolean=} opt_caseSensitive
|
|
* @param {boolean=} opt_isRegex
|
|
* @return {!Promise<?Array<Protocol.Debugger.SearchMatch>>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.searchInResponseBody = function(requestId, query, opt_caseSensitive, opt_isRegex) {};
|
|
/** @typedef {!{query: string, isRegex: (boolean|undefined), requestId: Protocol.Network.RequestId, caseSensitive: (boolean|undefined)}} */
|
|
Protocol.NetworkAgent.SearchInResponseBodyRequest;
|
|
/** @typedef {!{result: !Array<Protocol.Debugger.SearchMatch>}} */
|
|
Protocol.NetworkAgent.SearchInResponseBodyResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.SearchInResponseBodyRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.SearchInResponseBodyResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_searchInResponseBody = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<string>} urls
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.setBlockedURLs = function(urls) {};
|
|
/** @typedef {!{urls: !Array<string>}} */
|
|
Protocol.NetworkAgent.SetBlockedURLsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.SetBlockedURLsResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.SetBlockedURLsRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.SetBlockedURLsResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_setBlockedURLs = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} bypass
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.setBypassServiceWorker = function(bypass) {};
|
|
/** @typedef {!{bypass: boolean}} */
|
|
Protocol.NetworkAgent.SetBypassServiceWorkerRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.SetBypassServiceWorkerResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.SetBypassServiceWorkerRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.SetBypassServiceWorkerResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_setBypassServiceWorker = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} cacheDisabled
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.setCacheDisabled = function(cacheDisabled) {};
|
|
/** @typedef {!{cacheDisabled: boolean}} */
|
|
Protocol.NetworkAgent.SetCacheDisabledRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.SetCacheDisabledResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.SetCacheDisabledRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.SetCacheDisabledResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_setCacheDisabled = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} name
|
|
* @param {string} value
|
|
* @param {string=} opt_url
|
|
* @param {string=} opt_domain
|
|
* @param {string=} opt_path
|
|
* @param {boolean=} opt_secure
|
|
* @param {boolean=} opt_httpOnly
|
|
* @param {Protocol.Network.CookieSameSite=} opt_sameSite
|
|
* @param {Protocol.Network.TimeSinceEpoch=} opt_expires
|
|
* @return {!Promise<?boolean>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.setCookie = function(name, value, opt_url, opt_domain, opt_path, opt_secure, opt_httpOnly, opt_sameSite, opt_expires) {};
|
|
/** @typedef {!{domain: (string|undefined), name: string, url: (string|undefined), expires: (Protocol.Network.TimeSinceEpoch|undefined), value: string, sameSite: (Protocol.Network.CookieSameSite|undefined), path: (string|undefined), httpOnly: (boolean|undefined), secure: (boolean|undefined)}} */
|
|
Protocol.NetworkAgent.SetCookieRequest;
|
|
/** @typedef {!{success: boolean}} */
|
|
Protocol.NetworkAgent.SetCookieResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.SetCookieRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.SetCookieResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_setCookie = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<Protocol.Network.CookieParam>} cookies
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.setCookies = function(cookies) {};
|
|
/** @typedef {!{cookies: !Array<Protocol.Network.CookieParam>}} */
|
|
Protocol.NetworkAgent.SetCookiesRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.SetCookiesResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.SetCookiesRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.SetCookiesResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_setCookies = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} maxTotalSize
|
|
* @param {number} maxResourceSize
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.setDataSizeLimitsForTest = function(maxTotalSize, maxResourceSize) {};
|
|
/** @typedef {!{maxResourceSize: number, maxTotalSize: number}} */
|
|
Protocol.NetworkAgent.SetDataSizeLimitsForTestRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.SetDataSizeLimitsForTestResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.SetDataSizeLimitsForTestRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.SetDataSizeLimitsForTestResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_setDataSizeLimitsForTest = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Network.Headers} headers
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.setExtraHTTPHeaders = function(headers) {};
|
|
/** @typedef {!{headers: Protocol.Network.Headers}} */
|
|
Protocol.NetworkAgent.SetExtraHTTPHeadersRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.SetExtraHTTPHeadersResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.SetExtraHTTPHeadersRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.SetExtraHTTPHeadersResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_setExtraHTTPHeaders = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<Protocol.Network.RequestPattern>} patterns
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.setRequestInterception = function(patterns) {};
|
|
/** @typedef {!{patterns: !Array<Protocol.Network.RequestPattern>}} */
|
|
Protocol.NetworkAgent.SetRequestInterceptionRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.SetRequestInterceptionResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.SetRequestInterceptionRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.SetRequestInterceptionResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_setRequestInterception = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} userAgent
|
|
* @param {string=} opt_acceptLanguage
|
|
* @param {string=} opt_platform
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.NetworkAgent.prototype.setUserAgentOverride = function(userAgent, opt_acceptLanguage, opt_platform) {};
|
|
/** @typedef {!{acceptLanguage: (string|undefined), userAgent: string, platform: (string|undefined)}} */
|
|
Protocol.NetworkAgent.SetUserAgentOverrideRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.NetworkAgent.SetUserAgentOverrideResponse;
|
|
/**
|
|
* @param {!Protocol.NetworkAgent.SetUserAgentOverrideRequest} obj
|
|
* @return {!Promise<!Protocol.NetworkAgent.SetUserAgentOverrideResponse>} */
|
|
Protocol.NetworkAgent.prototype.invoke_setUserAgentOverride = function(obj) {};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Network.ResourceType = {
|
|
Document: "Document",
|
|
Stylesheet: "Stylesheet",
|
|
Image: "Image",
|
|
Media: "Media",
|
|
Font: "Font",
|
|
Script: "Script",
|
|
TextTrack: "TextTrack",
|
|
XHR: "XHR",
|
|
Fetch: "Fetch",
|
|
EventSource: "EventSource",
|
|
WebSocket: "WebSocket",
|
|
Manifest: "Manifest",
|
|
SignedExchange: "SignedExchange",
|
|
Ping: "Ping",
|
|
CSPViolationReport: "CSPViolationReport",
|
|
Other: "Other"
|
|
};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Network.LoaderId;
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Network.RequestId;
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Network.InterceptionId;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Network.ErrorReason = {
|
|
Failed: "Failed",
|
|
Aborted: "Aborted",
|
|
TimedOut: "TimedOut",
|
|
AccessDenied: "AccessDenied",
|
|
ConnectionClosed: "ConnectionClosed",
|
|
ConnectionReset: "ConnectionReset",
|
|
ConnectionRefused: "ConnectionRefused",
|
|
ConnectionAborted: "ConnectionAborted",
|
|
ConnectionFailed: "ConnectionFailed",
|
|
NameNotResolved: "NameNotResolved",
|
|
InternetDisconnected: "InternetDisconnected",
|
|
AddressUnreachable: "AddressUnreachable",
|
|
BlockedByClient: "BlockedByClient",
|
|
BlockedByResponse: "BlockedByResponse"
|
|
};
|
|
|
|
/** @typedef {number} */
|
|
Protocol.Network.TimeSinceEpoch;
|
|
|
|
/** @typedef {number} */
|
|
Protocol.Network.MonotonicTime;
|
|
|
|
/** @typedef {!Object} */
|
|
Protocol.Network.Headers;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Network.ConnectionType = {
|
|
None: "none",
|
|
Cellular2g: "cellular2g",
|
|
Cellular3g: "cellular3g",
|
|
Cellular4g: "cellular4g",
|
|
Bluetooth: "bluetooth",
|
|
Ethernet: "ethernet",
|
|
Wifi: "wifi",
|
|
Wimax: "wimax",
|
|
Other: "other"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Network.CookieSameSite = {
|
|
Strict: "Strict",
|
|
Lax: "Lax",
|
|
None: "None"
|
|
};
|
|
|
|
/** @typedef {!{requestTime:(number), proxyStart:(number), proxyEnd:(number), dnsStart:(number), dnsEnd:(number), connectStart:(number), connectEnd:(number), sslStart:(number), sslEnd:(number), workerStart:(number), workerReady:(number), sendStart:(number), sendEnd:(number), pushStart:(number), pushEnd:(number), receiveHeadersEnd:(number)}} */
|
|
Protocol.Network.ResourceTiming;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Network.ResourcePriority = {
|
|
VeryLow: "VeryLow",
|
|
Low: "Low",
|
|
Medium: "Medium",
|
|
High: "High",
|
|
VeryHigh: "VeryHigh"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Network.RequestReferrerPolicy = {
|
|
UnsafeUrl: "unsafe-url",
|
|
NoReferrerWhenDowngrade: "no-referrer-when-downgrade",
|
|
NoReferrer: "no-referrer",
|
|
Origin: "origin",
|
|
OriginWhenCrossOrigin: "origin-when-cross-origin",
|
|
SameOrigin: "same-origin",
|
|
StrictOrigin: "strict-origin",
|
|
StrictOriginWhenCrossOrigin: "strict-origin-when-cross-origin"
|
|
};
|
|
|
|
/** @typedef {!{url:(string), urlFragment:(string|undefined), method:(string), headers:(Protocol.Network.Headers), postData:(string|undefined), hasPostData:(boolean|undefined), mixedContentType:(Protocol.Security.MixedContentType|undefined), initialPriority:(Protocol.Network.ResourcePriority), referrerPolicy:(Protocol.Network.RequestReferrerPolicy), isLinkPreload:(boolean|undefined)}} */
|
|
Protocol.Network.Request;
|
|
|
|
/** @typedef {!{status:(string), origin:(string), logDescription:(string), logId:(string), timestamp:(Protocol.Network.TimeSinceEpoch), hashAlgorithm:(string), signatureAlgorithm:(string), signatureData:(string)}} */
|
|
Protocol.Network.SignedCertificateTimestamp;
|
|
|
|
/** @typedef {!{protocol:(string), keyExchange:(string), keyExchangeGroup:(string|undefined), cipher:(string), mac:(string|undefined), certificateId:(Protocol.Security.CertificateId), subjectName:(string), sanList:(!Array<string>), issuer:(string), validFrom:(Protocol.Network.TimeSinceEpoch), validTo:(Protocol.Network.TimeSinceEpoch), signedCertificateTimestampList:(!Array<Protocol.Network.SignedCertificateTimestamp>), certificateTransparencyCompliance:(Protocol.Network.CertificateTransparencyCompliance)}} */
|
|
Protocol.Network.SecurityDetails;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Network.CertificateTransparencyCompliance = {
|
|
Unknown: "unknown",
|
|
NotCompliant: "not-compliant",
|
|
Compliant: "compliant"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Network.BlockedReason = {
|
|
Other: "other",
|
|
Csp: "csp",
|
|
MixedContent: "mixed-content",
|
|
Origin: "origin",
|
|
Inspector: "inspector",
|
|
SubresourceFilter: "subresource-filter",
|
|
ContentType: "content-type",
|
|
CollapsedByClient: "collapsed-by-client"
|
|
};
|
|
|
|
/** @typedef {!{url:(string), status:(number), statusText:(string), headers:(Protocol.Network.Headers), headersText:(string|undefined), mimeType:(string), requestHeaders:(Protocol.Network.Headers|undefined), requestHeadersText:(string|undefined), connectionReused:(boolean), connectionId:(number), remoteIPAddress:(string|undefined), remotePort:(number|undefined), fromDiskCache:(boolean|undefined), fromServiceWorker:(boolean|undefined), fromPrefetchCache:(boolean|undefined), encodedDataLength:(number), timing:(Protocol.Network.ResourceTiming|undefined), protocol:(string|undefined), securityState:(Protocol.Security.SecurityState), securityDetails:(Protocol.Network.SecurityDetails|undefined)}} */
|
|
Protocol.Network.Response;
|
|
|
|
/** @typedef {!{headers:(Protocol.Network.Headers)}} */
|
|
Protocol.Network.WebSocketRequest;
|
|
|
|
/** @typedef {!{status:(number), statusText:(string), headers:(Protocol.Network.Headers), headersText:(string|undefined), requestHeaders:(Protocol.Network.Headers|undefined), requestHeadersText:(string|undefined)}} */
|
|
Protocol.Network.WebSocketResponse;
|
|
|
|
/** @typedef {!{opcode:(number), mask:(boolean), payloadData:(string)}} */
|
|
Protocol.Network.WebSocketFrame;
|
|
|
|
/** @typedef {!{url:(string), type:(Protocol.Network.ResourceType), response:(Protocol.Network.Response|undefined), bodySize:(number)}} */
|
|
Protocol.Network.CachedResource;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Network.InitiatorType = {
|
|
Parser: "parser",
|
|
Script: "script",
|
|
Preload: "preload",
|
|
SignedExchange: "SignedExchange",
|
|
Other: "other"
|
|
};
|
|
|
|
/** @typedef {!{type:(Protocol.Network.InitiatorType), stack:(Protocol.Runtime.StackTrace|undefined), url:(string|undefined), lineNumber:(number|undefined)}} */
|
|
Protocol.Network.Initiator;
|
|
|
|
/** @typedef {!{name:(string), value:(string), domain:(string), path:(string), expires:(number), size:(number), httpOnly:(boolean), secure:(boolean), session:(boolean), sameSite:(Protocol.Network.CookieSameSite|undefined)}} */
|
|
Protocol.Network.Cookie;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Network.SetCookieBlockedReason = {
|
|
SecureOnly: "SecureOnly",
|
|
SameSiteStrict: "SameSiteStrict",
|
|
SameSiteLax: "SameSiteLax",
|
|
SameSiteExtended: "SameSiteExtended",
|
|
SameSiteUnspecifiedTreatedAsLax: "SameSiteUnspecifiedTreatedAsLax",
|
|
SameSiteNoneInsecure: "SameSiteNoneInsecure",
|
|
UserPreferences: "UserPreferences",
|
|
SyntaxError: "SyntaxError",
|
|
SchemeNotSupported: "SchemeNotSupported",
|
|
OverwriteSecure: "OverwriteSecure",
|
|
InvalidDomain: "InvalidDomain",
|
|
InvalidPrefix: "InvalidPrefix",
|
|
UnknownError: "UnknownError"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Network.CookieBlockedReason = {
|
|
SecureOnly: "SecureOnly",
|
|
NotOnPath: "NotOnPath",
|
|
DomainMismatch: "DomainMismatch",
|
|
SameSiteStrict: "SameSiteStrict",
|
|
SameSiteLax: "SameSiteLax",
|
|
SameSiteExtended: "SameSiteExtended",
|
|
SameSiteUnspecifiedTreatedAsLax: "SameSiteUnspecifiedTreatedAsLax",
|
|
SameSiteNoneInsecure: "SameSiteNoneInsecure",
|
|
UserPreferences: "UserPreferences",
|
|
UnknownError: "UnknownError"
|
|
};
|
|
|
|
/** @typedef {!{blockedReasons:(!Array<Protocol.Network.SetCookieBlockedReason>), cookieLine:(string), cookie:(Protocol.Network.Cookie|undefined)}} */
|
|
Protocol.Network.BlockedSetCookieWithReason;
|
|
|
|
/** @typedef {!{blockedReasons:(!Array<Protocol.Network.CookieBlockedReason>), cookie:(Protocol.Network.Cookie)}} */
|
|
Protocol.Network.BlockedCookieWithReason;
|
|
|
|
/** @typedef {!{name:(string), value:(string), url:(string|undefined), domain:(string|undefined), path:(string|undefined), secure:(boolean|undefined), httpOnly:(boolean|undefined), sameSite:(Protocol.Network.CookieSameSite|undefined), expires:(Protocol.Network.TimeSinceEpoch|undefined)}} */
|
|
Protocol.Network.CookieParam;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Network.AuthChallengeSource = {
|
|
Server: "Server",
|
|
Proxy: "Proxy"
|
|
};
|
|
|
|
/** @typedef {!{source:(Protocol.Network.AuthChallengeSource|undefined), origin:(string), scheme:(string), realm:(string)}} */
|
|
Protocol.Network.AuthChallenge;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Network.AuthChallengeResponseResponse = {
|
|
Default: "Default",
|
|
CancelAuth: "CancelAuth",
|
|
ProvideCredentials: "ProvideCredentials"
|
|
};
|
|
|
|
/** @typedef {!{response:(Protocol.Network.AuthChallengeResponseResponse), username:(string|undefined), password:(string|undefined)}} */
|
|
Protocol.Network.AuthChallengeResponse;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Network.InterceptionStage = {
|
|
Request: "Request",
|
|
HeadersReceived: "HeadersReceived"
|
|
};
|
|
|
|
/** @typedef {!{urlPattern:(string|undefined), resourceType:(Protocol.Network.ResourceType|undefined), interceptionStage:(Protocol.Network.InterceptionStage|undefined)}} */
|
|
Protocol.Network.RequestPattern;
|
|
|
|
/** @typedef {!{label:(string), signature:(string), integrity:(string), certUrl:(string|undefined), certSha256:(string|undefined), validityUrl:(string), date:(number), expires:(number), certificates:(!Array<string>|undefined)}} */
|
|
Protocol.Network.SignedExchangeSignature;
|
|
|
|
/** @typedef {!{requestUrl:(string), responseCode:(number), responseHeaders:(Protocol.Network.Headers), signatures:(!Array<Protocol.Network.SignedExchangeSignature>), headerIntegrity:(string)}} */
|
|
Protocol.Network.SignedExchangeHeader;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Network.SignedExchangeErrorField = {
|
|
SignatureSig: "signatureSig",
|
|
SignatureIntegrity: "signatureIntegrity",
|
|
SignatureCertUrl: "signatureCertUrl",
|
|
SignatureCertSha256: "signatureCertSha256",
|
|
SignatureValidityUrl: "signatureValidityUrl",
|
|
SignatureTimestamps: "signatureTimestamps"
|
|
};
|
|
|
|
/** @typedef {!{message:(string), signatureIndex:(number|undefined), errorField:(Protocol.Network.SignedExchangeErrorField|undefined)}} */
|
|
Protocol.Network.SignedExchangeError;
|
|
|
|
/** @typedef {!{outerResponse:(Protocol.Network.Response), header:(Protocol.Network.SignedExchangeHeader|undefined), securityDetails:(Protocol.Network.SecurityDetails|undefined), errors:(!Array<Protocol.Network.SignedExchangeError>|undefined)}} */
|
|
Protocol.Network.SignedExchangeInfo;
|
|
/** @interface */
|
|
Protocol.NetworkDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {Protocol.Network.MonotonicTime} timestamp
|
|
* @param {number} dataLength
|
|
* @param {number} encodedDataLength
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.dataReceived = function(requestId, timestamp, dataLength, encodedDataLength) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {Protocol.Network.MonotonicTime} timestamp
|
|
* @param {string} eventName
|
|
* @param {string} eventId
|
|
* @param {string} data
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.eventSourceMessageReceived = function(requestId, timestamp, eventName, eventId, data) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {Protocol.Network.MonotonicTime} timestamp
|
|
* @param {Protocol.Network.ResourceType} type
|
|
* @param {string} errorText
|
|
* @param {boolean=} opt_canceled
|
|
* @param {Protocol.Network.BlockedReason=} opt_blockedReason
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.loadingFailed = function(requestId, timestamp, type, errorText, opt_canceled, opt_blockedReason) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {Protocol.Network.MonotonicTime} timestamp
|
|
* @param {number} encodedDataLength
|
|
* @param {boolean=} opt_shouldReportCorbBlocking
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.loadingFinished = function(requestId, timestamp, encodedDataLength, opt_shouldReportCorbBlocking) {};
|
|
/**
|
|
* @param {Protocol.Network.InterceptionId} interceptionId
|
|
* @param {Protocol.Network.Request} request
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @param {Protocol.Network.ResourceType} resourceType
|
|
* @param {boolean} isNavigationRequest
|
|
* @param {boolean=} opt_isDownload
|
|
* @param {string=} opt_redirectUrl
|
|
* @param {Protocol.Network.AuthChallenge=} opt_authChallenge
|
|
* @param {Protocol.Network.ErrorReason=} opt_responseErrorReason
|
|
* @param {number=} opt_responseStatusCode
|
|
* @param {Protocol.Network.Headers=} opt_responseHeaders
|
|
* @param {Protocol.Network.RequestId=} opt_requestId
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.requestIntercepted = function(interceptionId, request, frameId, resourceType, isNavigationRequest, opt_isDownload, opt_redirectUrl, opt_authChallenge, opt_responseErrorReason, opt_responseStatusCode, opt_responseHeaders, opt_requestId) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.requestServedFromCache = function(requestId) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {Protocol.Network.LoaderId} loaderId
|
|
* @param {string} documentURL
|
|
* @param {Protocol.Network.Request} request
|
|
* @param {Protocol.Network.MonotonicTime} timestamp
|
|
* @param {Protocol.Network.TimeSinceEpoch} wallTime
|
|
* @param {Protocol.Network.Initiator} initiator
|
|
* @param {Protocol.Network.Response=} opt_redirectResponse
|
|
* @param {Protocol.Network.ResourceType=} opt_type
|
|
* @param {Protocol.Page.FrameId=} opt_frameId
|
|
* @param {boolean=} opt_hasUserGesture
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.requestWillBeSent = function(requestId, loaderId, documentURL, request, timestamp, wallTime, initiator, opt_redirectResponse, opt_type, opt_frameId, opt_hasUserGesture) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {Protocol.Network.ResourcePriority} newPriority
|
|
* @param {Protocol.Network.MonotonicTime} timestamp
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.resourceChangedPriority = function(requestId, newPriority, timestamp) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {Protocol.Network.SignedExchangeInfo} info
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.signedExchangeReceived = function(requestId, info) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {Protocol.Network.LoaderId} loaderId
|
|
* @param {Protocol.Network.MonotonicTime} timestamp
|
|
* @param {Protocol.Network.ResourceType} type
|
|
* @param {Protocol.Network.Response} response
|
|
* @param {Protocol.Page.FrameId=} opt_frameId
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.responseReceived = function(requestId, loaderId, timestamp, type, response, opt_frameId) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {Protocol.Network.MonotonicTime} timestamp
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.webSocketClosed = function(requestId, timestamp) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {string} url
|
|
* @param {Protocol.Network.Initiator=} opt_initiator
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.webSocketCreated = function(requestId, url, opt_initiator) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {Protocol.Network.MonotonicTime} timestamp
|
|
* @param {string} errorMessage
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.webSocketFrameError = function(requestId, timestamp, errorMessage) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {Protocol.Network.MonotonicTime} timestamp
|
|
* @param {Protocol.Network.WebSocketFrame} response
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.webSocketFrameReceived = function(requestId, timestamp, response) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {Protocol.Network.MonotonicTime} timestamp
|
|
* @param {Protocol.Network.WebSocketFrame} response
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.webSocketFrameSent = function(requestId, timestamp, response) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {Protocol.Network.MonotonicTime} timestamp
|
|
* @param {Protocol.Network.WebSocketResponse} response
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.webSocketHandshakeResponseReceived = function(requestId, timestamp, response) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {Protocol.Network.MonotonicTime} timestamp
|
|
* @param {Protocol.Network.TimeSinceEpoch} wallTime
|
|
* @param {Protocol.Network.WebSocketRequest} request
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.webSocketWillSendHandshakeRequest = function(requestId, timestamp, wallTime, request) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {!Array<Protocol.Network.BlockedCookieWithReason>} blockedCookies
|
|
* @param {Protocol.Network.Headers} headers
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.requestWillBeSentExtraInfo = function(requestId, blockedCookies, headers) {};
|
|
/**
|
|
* @param {Protocol.Network.RequestId} requestId
|
|
* @param {!Array<Protocol.Network.BlockedSetCookieWithReason>} blockedCookies
|
|
* @param {Protocol.Network.Headers} headers
|
|
* @param {string=} opt_headersText
|
|
*/
|
|
Protocol.NetworkDispatcher.prototype.responseReceivedExtraInfo = function(requestId, blockedCookies, headers, opt_headersText) {};
|
|
Protocol.Overlay = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.OverlayAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.DisableResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.EnableResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
* @param {boolean=} opt_includeDistance
|
|
* @param {boolean=} opt_includeStyle
|
|
* @return {!Promise<?Object>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.getHighlightObjectForTest = function(nodeId, opt_includeDistance, opt_includeStyle) {};
|
|
/** @typedef {!{includeDistance: (boolean|undefined), nodeId: Protocol.DOM.NodeId, includeStyle: (boolean|undefined)}} */
|
|
Protocol.OverlayAgent.GetHighlightObjectForTestRequest;
|
|
/** @typedef {!{highlight: !Object}} */
|
|
Protocol.OverlayAgent.GetHighlightObjectForTestResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.GetHighlightObjectForTestRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.GetHighlightObjectForTestResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_getHighlightObjectForTest = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.hideHighlight = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.HideHighlightRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.HideHighlightResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.HideHighlightRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.HideHighlightResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_hideHighlight = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @param {Protocol.DOM.RGBA=} opt_contentColor
|
|
* @param {Protocol.DOM.RGBA=} opt_contentOutlineColor
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.highlightFrame = function(frameId, opt_contentColor, opt_contentOutlineColor) {};
|
|
/** @typedef {!{contentOutlineColor: (Protocol.DOM.RGBA|undefined), contentColor: (Protocol.DOM.RGBA|undefined), frameId: Protocol.Page.FrameId}} */
|
|
Protocol.OverlayAgent.HighlightFrameRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.HighlightFrameResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.HighlightFrameRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.HighlightFrameResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_highlightFrame = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Overlay.HighlightConfig} highlightConfig
|
|
* @param {Protocol.DOM.NodeId=} opt_nodeId
|
|
* @param {Protocol.DOM.BackendNodeId=} opt_backendNodeId
|
|
* @param {Protocol.Runtime.RemoteObjectId=} opt_objectId
|
|
* @param {string=} opt_selector
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.highlightNode = function(highlightConfig, opt_nodeId, opt_backendNodeId, opt_objectId, opt_selector) {};
|
|
/** @typedef {!{selector: (string|undefined), objectId: (Protocol.Runtime.RemoteObjectId|undefined), highlightConfig: Protocol.Overlay.HighlightConfig, backendNodeId: (Protocol.DOM.BackendNodeId|undefined), nodeId: (Protocol.DOM.NodeId|undefined)}} */
|
|
Protocol.OverlayAgent.HighlightNodeRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.HighlightNodeResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.HighlightNodeRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.HighlightNodeResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_highlightNode = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.DOM.Quad} quad
|
|
* @param {Protocol.DOM.RGBA=} opt_color
|
|
* @param {Protocol.DOM.RGBA=} opt_outlineColor
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.highlightQuad = function(quad, opt_color, opt_outlineColor) {};
|
|
/** @typedef {!{color: (Protocol.DOM.RGBA|undefined), quad: Protocol.DOM.Quad, outlineColor: (Protocol.DOM.RGBA|undefined)}} */
|
|
Protocol.OverlayAgent.HighlightQuadRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.HighlightQuadResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.HighlightQuadRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.HighlightQuadResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_highlightQuad = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} x
|
|
* @param {number} y
|
|
* @param {number} width
|
|
* @param {number} height
|
|
* @param {Protocol.DOM.RGBA=} opt_color
|
|
* @param {Protocol.DOM.RGBA=} opt_outlineColor
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.highlightRect = function(x, y, width, height, opt_color, opt_outlineColor) {};
|
|
/** @typedef {!{color: (Protocol.DOM.RGBA|undefined), height: number, width: number, y: number, x: number, outlineColor: (Protocol.DOM.RGBA|undefined)}} */
|
|
Protocol.OverlayAgent.HighlightRectRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.HighlightRectResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.HighlightRectRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.HighlightRectResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_highlightRect = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Overlay.InspectMode} mode
|
|
* @param {Protocol.Overlay.HighlightConfig=} opt_highlightConfig
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.setInspectMode = function(mode, opt_highlightConfig) {};
|
|
/** @typedef {!{mode: Protocol.Overlay.InspectMode, highlightConfig: (Protocol.Overlay.HighlightConfig|undefined)}} */
|
|
Protocol.OverlayAgent.SetInspectModeRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.SetInspectModeResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.SetInspectModeRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.SetInspectModeResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_setInspectMode = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} show
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.setShowAdHighlights = function(show) {};
|
|
/** @typedef {!{show: boolean}} */
|
|
Protocol.OverlayAgent.SetShowAdHighlightsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.SetShowAdHighlightsResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.SetShowAdHighlightsRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.SetShowAdHighlightsResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_setShowAdHighlights = function(obj) {};
|
|
|
|
/**
|
|
* @param {string=} opt_message
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.setPausedInDebuggerMessage = function(opt_message) {};
|
|
/** @typedef {!{message: (string|undefined)}} */
|
|
Protocol.OverlayAgent.SetPausedInDebuggerMessageRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.SetPausedInDebuggerMessageResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.SetPausedInDebuggerMessageRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.SetPausedInDebuggerMessageResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_setPausedInDebuggerMessage = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} show
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.setShowDebugBorders = function(show) {};
|
|
/** @typedef {!{show: boolean}} */
|
|
Protocol.OverlayAgent.SetShowDebugBordersRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.SetShowDebugBordersResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.SetShowDebugBordersRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.SetShowDebugBordersResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_setShowDebugBorders = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} show
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.setShowFPSCounter = function(show) {};
|
|
/** @typedef {!{show: boolean}} */
|
|
Protocol.OverlayAgent.SetShowFPSCounterRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.SetShowFPSCounterResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.SetShowFPSCounterRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.SetShowFPSCounterResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_setShowFPSCounter = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} result
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.setShowPaintRects = function(result) {};
|
|
/** @typedef {!{result: boolean}} */
|
|
Protocol.OverlayAgent.SetShowPaintRectsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.SetShowPaintRectsResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.SetShowPaintRectsRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.SetShowPaintRectsResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_setShowPaintRects = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} result
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.setShowLayoutShiftRegions = function(result) {};
|
|
/** @typedef {!{result: boolean}} */
|
|
Protocol.OverlayAgent.SetShowLayoutShiftRegionsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.SetShowLayoutShiftRegionsResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.SetShowLayoutShiftRegionsRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.SetShowLayoutShiftRegionsResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_setShowLayoutShiftRegions = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} show
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.setShowScrollBottleneckRects = function(show) {};
|
|
/** @typedef {!{show: boolean}} */
|
|
Protocol.OverlayAgent.SetShowScrollBottleneckRectsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.SetShowScrollBottleneckRectsResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.SetShowScrollBottleneckRectsRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.SetShowScrollBottleneckRectsResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_setShowScrollBottleneckRects = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} show
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.setShowHitTestBorders = function(show) {};
|
|
/** @typedef {!{show: boolean}} */
|
|
Protocol.OverlayAgent.SetShowHitTestBordersRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.SetShowHitTestBordersResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.SetShowHitTestBordersRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.SetShowHitTestBordersResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_setShowHitTestBorders = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} show
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.OverlayAgent.prototype.setShowViewportSizeOnResize = function(show) {};
|
|
/** @typedef {!{show: boolean}} */
|
|
Protocol.OverlayAgent.SetShowViewportSizeOnResizeRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.OverlayAgent.SetShowViewportSizeOnResizeResponse;
|
|
/**
|
|
* @param {!Protocol.OverlayAgent.SetShowViewportSizeOnResizeRequest} obj
|
|
* @return {!Promise<!Protocol.OverlayAgent.SetShowViewportSizeOnResizeResponse>} */
|
|
Protocol.OverlayAgent.prototype.invoke_setShowViewportSizeOnResize = function(obj) {};
|
|
|
|
/** @typedef {!{showInfo:(boolean|undefined), showStyles:(boolean|undefined), showRulers:(boolean|undefined), showExtensionLines:(boolean|undefined), contentColor:(Protocol.DOM.RGBA|undefined), paddingColor:(Protocol.DOM.RGBA|undefined), borderColor:(Protocol.DOM.RGBA|undefined), marginColor:(Protocol.DOM.RGBA|undefined), eventTargetColor:(Protocol.DOM.RGBA|undefined), shapeColor:(Protocol.DOM.RGBA|undefined), shapeMarginColor:(Protocol.DOM.RGBA|undefined), cssGridColor:(Protocol.DOM.RGBA|undefined)}} */
|
|
Protocol.Overlay.HighlightConfig;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Overlay.InspectMode = {
|
|
SearchForNode: "searchForNode",
|
|
SearchForUAShadowDOM: "searchForUAShadowDOM",
|
|
CaptureAreaScreenshot: "captureAreaScreenshot",
|
|
ShowDistances: "showDistances",
|
|
None: "none"
|
|
};
|
|
/** @interface */
|
|
Protocol.OverlayDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.DOM.BackendNodeId} backendNodeId
|
|
*/
|
|
Protocol.OverlayDispatcher.prototype.inspectNodeRequested = function(backendNodeId) {};
|
|
/**
|
|
* @param {Protocol.DOM.NodeId} nodeId
|
|
*/
|
|
Protocol.OverlayDispatcher.prototype.nodeHighlightRequested = function(nodeId) {};
|
|
/**
|
|
* @param {Protocol.Page.Viewport} viewport
|
|
*/
|
|
Protocol.OverlayDispatcher.prototype.screenshotRequested = function(viewport) {};
|
|
Protocol.OverlayDispatcher.prototype.inspectModeCanceled = function() {};
|
|
Protocol.Page = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.PageAgent = function(){};
|
|
|
|
/**
|
|
* @param {string} scriptSource
|
|
* @return {!Promise<?Protocol.Page.ScriptIdentifier>}
|
|
*/
|
|
Protocol.PageAgent.prototype.addScriptToEvaluateOnLoad = function(scriptSource) {};
|
|
/** @typedef {!{scriptSource: string}} */
|
|
Protocol.PageAgent.AddScriptToEvaluateOnLoadRequest;
|
|
/** @typedef {!{identifier: Protocol.Page.ScriptIdentifier}} */
|
|
Protocol.PageAgent.AddScriptToEvaluateOnLoadResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.AddScriptToEvaluateOnLoadRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.AddScriptToEvaluateOnLoadResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_addScriptToEvaluateOnLoad = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} source
|
|
* @param {string=} opt_worldName
|
|
* @return {!Promise<?Protocol.Page.ScriptIdentifier>}
|
|
*/
|
|
Protocol.PageAgent.prototype.addScriptToEvaluateOnNewDocument = function(source, opt_worldName) {};
|
|
/** @typedef {!{source: string, worldName: (string|undefined)}} */
|
|
Protocol.PageAgent.AddScriptToEvaluateOnNewDocumentRequest;
|
|
/** @typedef {!{identifier: Protocol.Page.ScriptIdentifier}} */
|
|
Protocol.PageAgent.AddScriptToEvaluateOnNewDocumentResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.AddScriptToEvaluateOnNewDocumentRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.AddScriptToEvaluateOnNewDocumentResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_addScriptToEvaluateOnNewDocument = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.bringToFront = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.BringToFrontRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.BringToFrontResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.BringToFrontRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.BringToFrontResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_bringToFront = function(obj) {};
|
|
|
|
/**
|
|
* @param {string=} opt_format
|
|
* @param {number=} opt_quality
|
|
* @param {Protocol.Page.Viewport=} opt_clip
|
|
* @param {boolean=} opt_fromSurface
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.PageAgent.prototype.captureScreenshot = function(opt_format, opt_quality, opt_clip, opt_fromSurface) {};
|
|
/** @typedef {!{fromSurface: (boolean|undefined), quality: (number|undefined), clip: (Protocol.Page.Viewport|undefined), format: (string|undefined)}} */
|
|
Protocol.PageAgent.CaptureScreenshotRequest;
|
|
/** @typedef {!{data: string}} */
|
|
Protocol.PageAgent.CaptureScreenshotResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.CaptureScreenshotRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.CaptureScreenshotResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_captureScreenshot = function(obj) {};
|
|
|
|
/**
|
|
* @param {string=} opt_format
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.PageAgent.prototype.captureSnapshot = function(opt_format) {};
|
|
/** @typedef {!{format: (string|undefined)}} */
|
|
Protocol.PageAgent.CaptureSnapshotRequest;
|
|
/** @typedef {!{data: string}} */
|
|
Protocol.PageAgent.CaptureSnapshotResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.CaptureSnapshotRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.CaptureSnapshotResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_captureSnapshot = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.clearDeviceMetricsOverride = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.ClearDeviceMetricsOverrideRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.ClearDeviceMetricsOverrideResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.ClearDeviceMetricsOverrideRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.ClearDeviceMetricsOverrideResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_clearDeviceMetricsOverride = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.clearDeviceOrientationOverride = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.ClearDeviceOrientationOverrideRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.ClearDeviceOrientationOverrideResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.ClearDeviceOrientationOverrideRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.ClearDeviceOrientationOverrideResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_clearDeviceOrientationOverride = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.clearGeolocationOverride = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.ClearGeolocationOverrideRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.ClearGeolocationOverrideResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.ClearGeolocationOverrideRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.ClearGeolocationOverrideResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_clearGeolocationOverride = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @param {string=} opt_worldName
|
|
* @param {boolean=} opt_grantUniveralAccess
|
|
* @return {!Promise<?Protocol.Runtime.ExecutionContextId>}
|
|
*/
|
|
Protocol.PageAgent.prototype.createIsolatedWorld = function(frameId, opt_worldName, opt_grantUniveralAccess) {};
|
|
/** @typedef {!{grantUniveralAccess: (boolean|undefined), worldName: (string|undefined), frameId: Protocol.Page.FrameId}} */
|
|
Protocol.PageAgent.CreateIsolatedWorldRequest;
|
|
/** @typedef {!{executionContextId: Protocol.Runtime.ExecutionContextId}} */
|
|
Protocol.PageAgent.CreateIsolatedWorldResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.CreateIsolatedWorldRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.CreateIsolatedWorldResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_createIsolatedWorld = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} cookieName
|
|
* @param {string} url
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.deleteCookie = function(cookieName, url) {};
|
|
/** @typedef {!{url: string, cookieName: string}} */
|
|
Protocol.PageAgent.DeleteCookieRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.DeleteCookieResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.DeleteCookieRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.DeleteCookieResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_deleteCookie = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.DisableResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.EnableResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.PageAgent.prototype.getAppManifest = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.GetAppManifestRequest;
|
|
/** @typedef {!{url: string, errors: !Array<Protocol.Page.AppManifestError>, data: string}} */
|
|
Protocol.PageAgent.GetAppManifestResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.GetAppManifestRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.GetAppManifestResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_getAppManifest = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<string>>}
|
|
*/
|
|
Protocol.PageAgent.prototype.getInstallabilityErrors = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.GetInstallabilityErrorsRequest;
|
|
/** @typedef {!{errors: !Array<string>}} */
|
|
Protocol.PageAgent.GetInstallabilityErrorsResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.GetInstallabilityErrorsRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.GetInstallabilityErrorsResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_getInstallabilityErrors = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<Protocol.Network.Cookie>>}
|
|
*/
|
|
Protocol.PageAgent.prototype.getCookies = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.GetCookiesRequest;
|
|
/** @typedef {!{cookies: !Array<Protocol.Network.Cookie>}} */
|
|
Protocol.PageAgent.GetCookiesResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.GetCookiesRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.GetCookiesResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_getCookies = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Protocol.Page.FrameTree>}
|
|
*/
|
|
Protocol.PageAgent.prototype.getFrameTree = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.GetFrameTreeRequest;
|
|
/** @typedef {!{frameTree: Protocol.Page.FrameTree}} */
|
|
Protocol.PageAgent.GetFrameTreeResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.GetFrameTreeRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.GetFrameTreeResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_getFrameTree = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Protocol.Page.LayoutViewport>}
|
|
*/
|
|
Protocol.PageAgent.prototype.getLayoutMetrics = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.GetLayoutMetricsRequest;
|
|
/** @typedef {!{visualViewport: Protocol.Page.VisualViewport, layoutViewport: Protocol.Page.LayoutViewport, contentSize: Protocol.DOM.Rect}} */
|
|
Protocol.PageAgent.GetLayoutMetricsResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.GetLayoutMetricsRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.GetLayoutMetricsResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_getLayoutMetrics = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?number>}
|
|
*/
|
|
Protocol.PageAgent.prototype.getNavigationHistory = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.GetNavigationHistoryRequest;
|
|
/** @typedef {!{currentIndex: number, entries: !Array<Protocol.Page.NavigationEntry>}} */
|
|
Protocol.PageAgent.GetNavigationHistoryResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.GetNavigationHistoryRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.GetNavigationHistoryResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_getNavigationHistory = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.resetNavigationHistory = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.ResetNavigationHistoryRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.ResetNavigationHistoryResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.ResetNavigationHistoryRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.ResetNavigationHistoryResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_resetNavigationHistory = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @param {string} url
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.PageAgent.prototype.getResourceContent = function(frameId, url) {};
|
|
/** @typedef {!{url: string, frameId: Protocol.Page.FrameId}} */
|
|
Protocol.PageAgent.GetResourceContentRequest;
|
|
/** @typedef {!{content: string, base64Encoded: boolean}} */
|
|
Protocol.PageAgent.GetResourceContentResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.GetResourceContentRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.GetResourceContentResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_getResourceContent = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Protocol.Page.FrameResourceTree>}
|
|
*/
|
|
Protocol.PageAgent.prototype.getResourceTree = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.GetResourceTreeRequest;
|
|
/** @typedef {!{frameTree: Protocol.Page.FrameResourceTree}} */
|
|
Protocol.PageAgent.GetResourceTreeResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.GetResourceTreeRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.GetResourceTreeResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_getResourceTree = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} accept
|
|
* @param {string=} opt_promptText
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.handleJavaScriptDialog = function(accept, opt_promptText) {};
|
|
/** @typedef {!{promptText: (string|undefined), accept: boolean}} */
|
|
Protocol.PageAgent.HandleJavaScriptDialogRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.HandleJavaScriptDialogResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.HandleJavaScriptDialogRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.HandleJavaScriptDialogResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_handleJavaScriptDialog = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} url
|
|
* @param {string=} opt_referrer
|
|
* @param {Protocol.Page.TransitionType=} opt_transitionType
|
|
* @param {Protocol.Page.FrameId=} opt_frameId
|
|
* @return {!Promise<?Protocol.Page.FrameId>}
|
|
*/
|
|
Protocol.PageAgent.prototype.navigate = function(url, opt_referrer, opt_transitionType, opt_frameId) {};
|
|
/** @typedef {!{url: string, referrer: (string|undefined), frameId: (Protocol.Page.FrameId|undefined), transitionType: (Protocol.Page.TransitionType|undefined)}} */
|
|
Protocol.PageAgent.NavigateRequest;
|
|
/** @typedef {!{loaderId: Protocol.Network.LoaderId, errorText: string, frameId: Protocol.Page.FrameId}} */
|
|
Protocol.PageAgent.NavigateResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.NavigateRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.NavigateResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_navigate = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} entryId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.navigateToHistoryEntry = function(entryId) {};
|
|
/** @typedef {!{entryId: number}} */
|
|
Protocol.PageAgent.NavigateToHistoryEntryRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.NavigateToHistoryEntryResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.NavigateToHistoryEntryRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.NavigateToHistoryEntryResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_navigateToHistoryEntry = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean=} opt_landscape
|
|
* @param {boolean=} opt_displayHeaderFooter
|
|
* @param {boolean=} opt_printBackground
|
|
* @param {number=} opt_scale
|
|
* @param {number=} opt_paperWidth
|
|
* @param {number=} opt_paperHeight
|
|
* @param {number=} opt_marginTop
|
|
* @param {number=} opt_marginBottom
|
|
* @param {number=} opt_marginLeft
|
|
* @param {number=} opt_marginRight
|
|
* @param {string=} opt_pageRanges
|
|
* @param {boolean=} opt_ignoreInvalidPageRanges
|
|
* @param {string=} opt_headerTemplate
|
|
* @param {string=} opt_footerTemplate
|
|
* @param {boolean=} opt_preferCSSPageSize
|
|
* @param {string=} opt_transferMode
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.PageAgent.prototype.printToPDF = function(opt_landscape, opt_displayHeaderFooter, opt_printBackground, opt_scale, opt_paperWidth, opt_paperHeight, opt_marginTop, opt_marginBottom, opt_marginLeft, opt_marginRight, opt_pageRanges, opt_ignoreInvalidPageRanges, opt_headerTemplate, opt_footerTemplate, opt_preferCSSPageSize, opt_transferMode) {};
|
|
/** @typedef {!{paperHeight: (number|undefined), scale: (number|undefined), footerTemplate: (string|undefined), displayHeaderFooter: (boolean|undefined), transferMode: (string|undefined), marginBottom: (number|undefined), paperWidth: (number|undefined), headerTemplate: (string|undefined), marginLeft: (number|undefined), preferCSSPageSize: (boolean|undefined), printBackground: (boolean|undefined), marginRight: (number|undefined), ignoreInvalidPageRanges: (boolean|undefined), pageRanges: (string|undefined), marginTop: (number|undefined), landscape: (boolean|undefined)}} */
|
|
Protocol.PageAgent.PrintToPDFRequest;
|
|
/** @typedef {!{data: string, stream: Protocol.IO.StreamHandle}} */
|
|
Protocol.PageAgent.PrintToPDFResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.PrintToPDFRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.PrintToPDFResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_printToPDF = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean=} opt_ignoreCache
|
|
* @param {string=} opt_scriptToEvaluateOnLoad
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.reload = function(opt_ignoreCache, opt_scriptToEvaluateOnLoad) {};
|
|
/** @typedef {!{scriptToEvaluateOnLoad: (string|undefined), ignoreCache: (boolean|undefined)}} */
|
|
Protocol.PageAgent.ReloadRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.ReloadResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.ReloadRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.ReloadResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_reload = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Page.ScriptIdentifier} identifier
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.removeScriptToEvaluateOnLoad = function(identifier) {};
|
|
/** @typedef {!{identifier: Protocol.Page.ScriptIdentifier}} */
|
|
Protocol.PageAgent.RemoveScriptToEvaluateOnLoadRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.RemoveScriptToEvaluateOnLoadResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.RemoveScriptToEvaluateOnLoadRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.RemoveScriptToEvaluateOnLoadResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_removeScriptToEvaluateOnLoad = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Page.ScriptIdentifier} identifier
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.removeScriptToEvaluateOnNewDocument = function(identifier) {};
|
|
/** @typedef {!{identifier: Protocol.Page.ScriptIdentifier}} */
|
|
Protocol.PageAgent.RemoveScriptToEvaluateOnNewDocumentRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.RemoveScriptToEvaluateOnNewDocumentResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.RemoveScriptToEvaluateOnNewDocumentRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.RemoveScriptToEvaluateOnNewDocumentResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_removeScriptToEvaluateOnNewDocument = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} sessionId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.screencastFrameAck = function(sessionId) {};
|
|
/** @typedef {!{sessionId: number}} */
|
|
Protocol.PageAgent.ScreencastFrameAckRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.ScreencastFrameAckResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.ScreencastFrameAckRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.ScreencastFrameAckResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_screencastFrameAck = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @param {string} url
|
|
* @param {string} query
|
|
* @param {boolean=} opt_caseSensitive
|
|
* @param {boolean=} opt_isRegex
|
|
* @return {!Promise<?Array<Protocol.Debugger.SearchMatch>>}
|
|
*/
|
|
Protocol.PageAgent.prototype.searchInResource = function(frameId, url, query, opt_caseSensitive, opt_isRegex) {};
|
|
/** @typedef {!{url: string, query: string, caseSensitive: (boolean|undefined), isRegex: (boolean|undefined), frameId: Protocol.Page.FrameId}} */
|
|
Protocol.PageAgent.SearchInResourceRequest;
|
|
/** @typedef {!{result: !Array<Protocol.Debugger.SearchMatch>}} */
|
|
Protocol.PageAgent.SearchInResourceResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.SearchInResourceRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.SearchInResourceResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_searchInResource = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} enabled
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.setAdBlockingEnabled = function(enabled) {};
|
|
/** @typedef {!{enabled: boolean}} */
|
|
Protocol.PageAgent.SetAdBlockingEnabledRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.SetAdBlockingEnabledResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.SetAdBlockingEnabledRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.SetAdBlockingEnabledResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_setAdBlockingEnabled = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} enabled
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.setBypassCSP = function(enabled) {};
|
|
/** @typedef {!{enabled: boolean}} */
|
|
Protocol.PageAgent.SetBypassCSPRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.SetBypassCSPResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.SetBypassCSPRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.SetBypassCSPResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_setBypassCSP = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} width
|
|
* @param {number} height
|
|
* @param {number} deviceScaleFactor
|
|
* @param {boolean} mobile
|
|
* @param {number=} opt_scale
|
|
* @param {number=} opt_screenWidth
|
|
* @param {number=} opt_screenHeight
|
|
* @param {number=} opt_positionX
|
|
* @param {number=} opt_positionY
|
|
* @param {boolean=} opt_dontSetVisibleSize
|
|
* @param {Protocol.Emulation.ScreenOrientation=} opt_screenOrientation
|
|
* @param {Protocol.Page.Viewport=} opt_viewport
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.setDeviceMetricsOverride = function(width, height, deviceScaleFactor, mobile, opt_scale, opt_screenWidth, opt_screenHeight, opt_positionX, opt_positionY, opt_dontSetVisibleSize, opt_screenOrientation, opt_viewport) {};
|
|
/** @typedef {!{deviceScaleFactor: number, positionX: (number|undefined), scale: (number|undefined), screenHeight: (number|undefined), mobile: boolean, screenOrientation: (Protocol.Emulation.ScreenOrientation|undefined), dontSetVisibleSize: (boolean|undefined), height: number, width: number, positionY: (number|undefined), screenWidth: (number|undefined), viewport: (Protocol.Page.Viewport|undefined)}} */
|
|
Protocol.PageAgent.SetDeviceMetricsOverrideRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.SetDeviceMetricsOverrideResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.SetDeviceMetricsOverrideRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.SetDeviceMetricsOverrideResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_setDeviceMetricsOverride = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} alpha
|
|
* @param {number} beta
|
|
* @param {number} gamma
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.setDeviceOrientationOverride = function(alpha, beta, gamma) {};
|
|
/** @typedef {!{alpha: number, beta: number, gamma: number}} */
|
|
Protocol.PageAgent.SetDeviceOrientationOverrideRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.SetDeviceOrientationOverrideResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.SetDeviceOrientationOverrideRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.SetDeviceOrientationOverrideResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_setDeviceOrientationOverride = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Page.FontFamilies} fontFamilies
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.setFontFamilies = function(fontFamilies) {};
|
|
/** @typedef {!{fontFamilies: Protocol.Page.FontFamilies}} */
|
|
Protocol.PageAgent.SetFontFamiliesRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.SetFontFamiliesResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.SetFontFamiliesRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.SetFontFamiliesResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_setFontFamilies = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Page.FontSizes} fontSizes
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.setFontSizes = function(fontSizes) {};
|
|
/** @typedef {!{fontSizes: Protocol.Page.FontSizes}} */
|
|
Protocol.PageAgent.SetFontSizesRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.SetFontSizesResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.SetFontSizesRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.SetFontSizesResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_setFontSizes = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @param {string} html
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.setDocumentContent = function(frameId, html) {};
|
|
/** @typedef {!{html: string, frameId: Protocol.Page.FrameId}} */
|
|
Protocol.PageAgent.SetDocumentContentRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.SetDocumentContentResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.SetDocumentContentRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.SetDocumentContentResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_setDocumentContent = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} behavior
|
|
* @param {string=} opt_downloadPath
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.setDownloadBehavior = function(behavior, opt_downloadPath) {};
|
|
/** @typedef {!{downloadPath: (string|undefined), behavior: string}} */
|
|
Protocol.PageAgent.SetDownloadBehaviorRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.SetDownloadBehaviorResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.SetDownloadBehaviorRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.SetDownloadBehaviorResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_setDownloadBehavior = function(obj) {};
|
|
|
|
/**
|
|
* @param {number=} opt_latitude
|
|
* @param {number=} opt_longitude
|
|
* @param {number=} opt_accuracy
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.setGeolocationOverride = function(opt_latitude, opt_longitude, opt_accuracy) {};
|
|
/** @typedef {!{latitude: (number|undefined), longitude: (number|undefined), accuracy: (number|undefined)}} */
|
|
Protocol.PageAgent.SetGeolocationOverrideRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.SetGeolocationOverrideResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.SetGeolocationOverrideRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.SetGeolocationOverrideResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_setGeolocationOverride = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} enabled
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.setLifecycleEventsEnabled = function(enabled) {};
|
|
/** @typedef {!{enabled: boolean}} */
|
|
Protocol.PageAgent.SetLifecycleEventsEnabledRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.SetLifecycleEventsEnabledResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.SetLifecycleEventsEnabledRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.SetLifecycleEventsEnabledResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_setLifecycleEventsEnabled = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} enabled
|
|
* @param {string=} opt_configuration
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.setTouchEmulationEnabled = function(enabled, opt_configuration) {};
|
|
/** @typedef {!{configuration: (string|undefined), enabled: boolean}} */
|
|
Protocol.PageAgent.SetTouchEmulationEnabledRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.SetTouchEmulationEnabledResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.SetTouchEmulationEnabledRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.SetTouchEmulationEnabledResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_setTouchEmulationEnabled = function(obj) {};
|
|
|
|
/**
|
|
* @param {string=} opt_format
|
|
* @param {number=} opt_quality
|
|
* @param {number=} opt_maxWidth
|
|
* @param {number=} opt_maxHeight
|
|
* @param {number=} opt_everyNthFrame
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.startScreencast = function(opt_format, opt_quality, opt_maxWidth, opt_maxHeight, opt_everyNthFrame) {};
|
|
/** @typedef {!{everyNthFrame: (number|undefined), quality: (number|undefined), maxHeight: (number|undefined), maxWidth: (number|undefined), format: (string|undefined)}} */
|
|
Protocol.PageAgent.StartScreencastRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.StartScreencastResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.StartScreencastRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.StartScreencastResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_startScreencast = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.stopLoading = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.StopLoadingRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.StopLoadingResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.StopLoadingRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.StopLoadingResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_stopLoading = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.crash = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.CrashRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.CrashResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.CrashRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.CrashResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_crash = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.close = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.CloseRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.CloseResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.CloseRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.CloseResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_close = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} state
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.setWebLifecycleState = function(state) {};
|
|
/** @typedef {!{state: string}} */
|
|
Protocol.PageAgent.SetWebLifecycleStateRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.SetWebLifecycleStateResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.SetWebLifecycleStateRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.SetWebLifecycleStateResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_setWebLifecycleState = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.stopScreencast = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.StopScreencastRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.StopScreencastResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.StopScreencastRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.StopScreencastResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_stopScreencast = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} enabled
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.setProduceCompilationCache = function(enabled) {};
|
|
/** @typedef {!{enabled: boolean}} */
|
|
Protocol.PageAgent.SetProduceCompilationCacheRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.SetProduceCompilationCacheResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.SetProduceCompilationCacheRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.SetProduceCompilationCacheResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_setProduceCompilationCache = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} url
|
|
* @param {string} data
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.addCompilationCache = function(url, data) {};
|
|
/** @typedef {!{url: string, data: string}} */
|
|
Protocol.PageAgent.AddCompilationCacheRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.AddCompilationCacheResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.AddCompilationCacheRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.AddCompilationCacheResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_addCompilationCache = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.clearCompilationCache = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.ClearCompilationCacheRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.ClearCompilationCacheResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.ClearCompilationCacheRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.ClearCompilationCacheResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_clearCompilationCache = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} message
|
|
* @param {string=} opt_group
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.generateTestReport = function(message, opt_group) {};
|
|
/** @typedef {!{message: string, group: (string|undefined)}} */
|
|
Protocol.PageAgent.GenerateTestReportRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.GenerateTestReportResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.GenerateTestReportRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.GenerateTestReportResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_generateTestReport = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.waitForDebugger = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.WaitForDebuggerRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.WaitForDebuggerResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.WaitForDebuggerRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.WaitForDebuggerResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_waitForDebugger = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} enabled
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.setInterceptFileChooserDialog = function(enabled) {};
|
|
/** @typedef {!{enabled: boolean}} */
|
|
Protocol.PageAgent.SetInterceptFileChooserDialogRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.SetInterceptFileChooserDialogResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.SetInterceptFileChooserDialogRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.SetInterceptFileChooserDialogResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_setInterceptFileChooserDialog = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} action
|
|
* @param {!Array<string>=} opt_files
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PageAgent.prototype.handleFileChooser = function(action, opt_files) {};
|
|
/** @typedef {!{action: string, files: (!Array<string>|undefined)}} */
|
|
Protocol.PageAgent.HandleFileChooserRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PageAgent.HandleFileChooserResponse;
|
|
/**
|
|
* @param {!Protocol.PageAgent.HandleFileChooserRequest} obj
|
|
* @return {!Promise<!Protocol.PageAgent.HandleFileChooserResponse>} */
|
|
Protocol.PageAgent.prototype.invoke_handleFileChooser = function(obj) {};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Page.FrameId;
|
|
|
|
/** @typedef {!{id:(Protocol.Page.FrameId), parentId:(string|undefined), loaderId:(Protocol.Network.LoaderId), name:(string|undefined), url:(string), urlFragment:(string|undefined), securityOrigin:(string), mimeType:(string), unreachableUrl:(string|undefined)}} */
|
|
Protocol.Page.Frame;
|
|
|
|
/** @typedef {!{url:(string), type:(Protocol.Network.ResourceType), mimeType:(string), lastModified:(Protocol.Network.TimeSinceEpoch|undefined), contentSize:(number|undefined), failed:(boolean|undefined), canceled:(boolean|undefined)}} */
|
|
Protocol.Page.FrameResource;
|
|
|
|
/** @typedef {!{frame:(Protocol.Page.Frame), childFrames:(!Array<Protocol.Page.FrameResourceTree>|undefined), resources:(!Array<Protocol.Page.FrameResource>)}} */
|
|
Protocol.Page.FrameResourceTree;
|
|
|
|
/** @typedef {!{frame:(Protocol.Page.Frame), childFrames:(!Array<Protocol.Page.FrameTree>|undefined)}} */
|
|
Protocol.Page.FrameTree;
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Page.ScriptIdentifier;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Page.TransitionType = {
|
|
Link: "link",
|
|
Typed: "typed",
|
|
Address_bar: "address_bar",
|
|
Auto_bookmark: "auto_bookmark",
|
|
Auto_subframe: "auto_subframe",
|
|
Manual_subframe: "manual_subframe",
|
|
Generated: "generated",
|
|
Auto_toplevel: "auto_toplevel",
|
|
Form_submit: "form_submit",
|
|
Reload: "reload",
|
|
Keyword: "keyword",
|
|
Keyword_generated: "keyword_generated",
|
|
Other: "other"
|
|
};
|
|
|
|
/** @typedef {!{id:(number), url:(string), userTypedURL:(string), title:(string), transitionType:(Protocol.Page.TransitionType)}} */
|
|
Protocol.Page.NavigationEntry;
|
|
|
|
/** @typedef {!{offsetTop:(number), pageScaleFactor:(number), deviceWidth:(number), deviceHeight:(number), scrollOffsetX:(number), scrollOffsetY:(number), timestamp:(Protocol.Network.TimeSinceEpoch|undefined)}} */
|
|
Protocol.Page.ScreencastFrameMetadata;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Page.DialogType = {
|
|
Alert: "alert",
|
|
Confirm: "confirm",
|
|
Prompt: "prompt",
|
|
Beforeunload: "beforeunload"
|
|
};
|
|
|
|
/** @typedef {!{message:(string), critical:(number), line:(number), column:(number)}} */
|
|
Protocol.Page.AppManifestError;
|
|
|
|
/** @typedef {!{pageX:(number), pageY:(number), clientWidth:(number), clientHeight:(number)}} */
|
|
Protocol.Page.LayoutViewport;
|
|
|
|
/** @typedef {!{offsetX:(number), offsetY:(number), pageX:(number), pageY:(number), clientWidth:(number), clientHeight:(number), scale:(number), zoom:(number|undefined)}} */
|
|
Protocol.Page.VisualViewport;
|
|
|
|
/** @typedef {!{x:(number), y:(number), width:(number), height:(number), scale:(number)}} */
|
|
Protocol.Page.Viewport;
|
|
|
|
/** @typedef {!{standard:(string|undefined), fixed:(string|undefined), serif:(string|undefined), sansSerif:(string|undefined), cursive:(string|undefined), fantasy:(string|undefined), pictograph:(string|undefined)}} */
|
|
Protocol.Page.FontFamilies;
|
|
|
|
/** @typedef {!{standard:(number|undefined), fixed:(number|undefined)}} */
|
|
Protocol.Page.FontSizes;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Page.ClientNavigationReason = {
|
|
FormSubmissionGet: "formSubmissionGet",
|
|
FormSubmissionPost: "formSubmissionPost",
|
|
HttpHeaderRefresh: "httpHeaderRefresh",
|
|
ScriptInitiated: "scriptInitiated",
|
|
MetaTagRefresh: "metaTagRefresh",
|
|
PageBlockInterstitial: "pageBlockInterstitial",
|
|
Reload: "reload"
|
|
};
|
|
/** @interface */
|
|
Protocol.PageDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.Network.MonotonicTime} timestamp
|
|
*/
|
|
Protocol.PageDispatcher.prototype.domContentEventFired = function(timestamp) {};
|
|
/**
|
|
* @param {string} mode
|
|
*/
|
|
Protocol.PageDispatcher.prototype.fileChooserOpened = function(mode) {};
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @param {Protocol.Page.FrameId} parentFrameId
|
|
* @param {Protocol.Runtime.StackTrace=} opt_stack
|
|
*/
|
|
Protocol.PageDispatcher.prototype.frameAttached = function(frameId, parentFrameId, opt_stack) {};
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
*/
|
|
Protocol.PageDispatcher.prototype.frameClearedScheduledNavigation = function(frameId) {};
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
*/
|
|
Protocol.PageDispatcher.prototype.frameDetached = function(frameId) {};
|
|
/**
|
|
* @param {Protocol.Page.Frame} frame
|
|
*/
|
|
Protocol.PageDispatcher.prototype.frameNavigated = function(frame) {};
|
|
Protocol.PageDispatcher.prototype.frameResized = function() {};
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @param {Protocol.Page.ClientNavigationReason} reason
|
|
* @param {string} url
|
|
*/
|
|
Protocol.PageDispatcher.prototype.frameRequestedNavigation = function(frameId, reason, url) {};
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @param {number} delay
|
|
* @param {string} reason
|
|
* @param {string} url
|
|
*/
|
|
Protocol.PageDispatcher.prototype.frameScheduledNavigation = function(frameId, delay, reason, url) {};
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
*/
|
|
Protocol.PageDispatcher.prototype.frameStartedLoading = function(frameId) {};
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
*/
|
|
Protocol.PageDispatcher.prototype.frameStoppedLoading = function(frameId) {};
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @param {string} url
|
|
*/
|
|
Protocol.PageDispatcher.prototype.downloadWillBegin = function(frameId, url) {};
|
|
Protocol.PageDispatcher.prototype.interstitialHidden = function() {};
|
|
Protocol.PageDispatcher.prototype.interstitialShown = function() {};
|
|
/**
|
|
* @param {boolean} result
|
|
* @param {string} userInput
|
|
*/
|
|
Protocol.PageDispatcher.prototype.javascriptDialogClosed = function(result, userInput) {};
|
|
/**
|
|
* @param {string} url
|
|
* @param {string} message
|
|
* @param {Protocol.Page.DialogType} type
|
|
* @param {boolean} hasBrowserHandler
|
|
* @param {string=} opt_defaultPrompt
|
|
*/
|
|
Protocol.PageDispatcher.prototype.javascriptDialogOpening = function(url, message, type, hasBrowserHandler, opt_defaultPrompt) {};
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @param {Protocol.Network.LoaderId} loaderId
|
|
* @param {string} name
|
|
* @param {Protocol.Network.MonotonicTime} timestamp
|
|
*/
|
|
Protocol.PageDispatcher.prototype.lifecycleEvent = function(frameId, loaderId, name, timestamp) {};
|
|
/**
|
|
* @param {Protocol.Network.MonotonicTime} timestamp
|
|
*/
|
|
Protocol.PageDispatcher.prototype.loadEventFired = function(timestamp) {};
|
|
/**
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @param {string} url
|
|
*/
|
|
Protocol.PageDispatcher.prototype.navigatedWithinDocument = function(frameId, url) {};
|
|
/**
|
|
* @param {string} data
|
|
* @param {Protocol.Page.ScreencastFrameMetadata} metadata
|
|
* @param {number} sessionId
|
|
*/
|
|
Protocol.PageDispatcher.prototype.screencastFrame = function(data, metadata, sessionId) {};
|
|
/**
|
|
* @param {boolean} visible
|
|
*/
|
|
Protocol.PageDispatcher.prototype.screencastVisibilityChanged = function(visible) {};
|
|
/**
|
|
* @param {string} url
|
|
* @param {string} windowName
|
|
* @param {!Array<string>} windowFeatures
|
|
* @param {boolean} userGesture
|
|
*/
|
|
Protocol.PageDispatcher.prototype.windowOpen = function(url, windowName, windowFeatures, userGesture) {};
|
|
/**
|
|
* @param {string} url
|
|
* @param {string} data
|
|
*/
|
|
Protocol.PageDispatcher.prototype.compilationCacheProduced = function(url, data) {};
|
|
Protocol.Performance = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.PerformanceAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PerformanceAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PerformanceAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PerformanceAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.PerformanceAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.PerformanceAgent.DisableResponse>} */
|
|
Protocol.PerformanceAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PerformanceAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PerformanceAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PerformanceAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.PerformanceAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.PerformanceAgent.EnableResponse>} */
|
|
Protocol.PerformanceAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} timeDomain
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.PerformanceAgent.prototype.setTimeDomain = function(timeDomain) {};
|
|
/** @typedef {!{timeDomain: string}} */
|
|
Protocol.PerformanceAgent.SetTimeDomainRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PerformanceAgent.SetTimeDomainResponse;
|
|
/**
|
|
* @param {!Protocol.PerformanceAgent.SetTimeDomainRequest} obj
|
|
* @return {!Promise<!Protocol.PerformanceAgent.SetTimeDomainResponse>} */
|
|
Protocol.PerformanceAgent.prototype.invoke_setTimeDomain = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<Protocol.Performance.Metric>>}
|
|
*/
|
|
Protocol.PerformanceAgent.prototype.getMetrics = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.PerformanceAgent.GetMetricsRequest;
|
|
/** @typedef {!{metrics: !Array<Protocol.Performance.Metric>}} */
|
|
Protocol.PerformanceAgent.GetMetricsResponse;
|
|
/**
|
|
* @param {!Protocol.PerformanceAgent.GetMetricsRequest} obj
|
|
* @return {!Promise<!Protocol.PerformanceAgent.GetMetricsResponse>} */
|
|
Protocol.PerformanceAgent.prototype.invoke_getMetrics = function(obj) {};
|
|
|
|
/** @typedef {!{name:(string), value:(number)}} */
|
|
Protocol.Performance.Metric;
|
|
/** @interface */
|
|
Protocol.PerformanceDispatcher = function() {};
|
|
/**
|
|
* @param {!Array<Protocol.Performance.Metric>} metrics
|
|
* @param {string} title
|
|
*/
|
|
Protocol.PerformanceDispatcher.prototype.metrics = function(metrics, title) {};
|
|
Protocol.Security = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.SecurityAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.SecurityAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.SecurityAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.SecurityAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.SecurityAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.SecurityAgent.DisableResponse>} */
|
|
Protocol.SecurityAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.SecurityAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.SecurityAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.SecurityAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.SecurityAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.SecurityAgent.EnableResponse>} */
|
|
Protocol.SecurityAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} ignore
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.SecurityAgent.prototype.setIgnoreCertificateErrors = function(ignore) {};
|
|
/** @typedef {!{ignore: boolean}} */
|
|
Protocol.SecurityAgent.SetIgnoreCertificateErrorsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.SecurityAgent.SetIgnoreCertificateErrorsResponse;
|
|
/**
|
|
* @param {!Protocol.SecurityAgent.SetIgnoreCertificateErrorsRequest} obj
|
|
* @return {!Promise<!Protocol.SecurityAgent.SetIgnoreCertificateErrorsResponse>} */
|
|
Protocol.SecurityAgent.prototype.invoke_setIgnoreCertificateErrors = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} eventId
|
|
* @param {Protocol.Security.CertificateErrorAction} action
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.SecurityAgent.prototype.handleCertificateError = function(eventId, action) {};
|
|
/** @typedef {!{eventId: number, action: Protocol.Security.CertificateErrorAction}} */
|
|
Protocol.SecurityAgent.HandleCertificateErrorRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.SecurityAgent.HandleCertificateErrorResponse;
|
|
/**
|
|
* @param {!Protocol.SecurityAgent.HandleCertificateErrorRequest} obj
|
|
* @return {!Promise<!Protocol.SecurityAgent.HandleCertificateErrorResponse>} */
|
|
Protocol.SecurityAgent.prototype.invoke_handleCertificateError = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} override
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.SecurityAgent.prototype.setOverrideCertificateErrors = function(override) {};
|
|
/** @typedef {!{override: boolean}} */
|
|
Protocol.SecurityAgent.SetOverrideCertificateErrorsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.SecurityAgent.SetOverrideCertificateErrorsResponse;
|
|
/**
|
|
* @param {!Protocol.SecurityAgent.SetOverrideCertificateErrorsRequest} obj
|
|
* @return {!Promise<!Protocol.SecurityAgent.SetOverrideCertificateErrorsResponse>} */
|
|
Protocol.SecurityAgent.prototype.invoke_setOverrideCertificateErrors = function(obj) {};
|
|
|
|
/** @typedef {number} */
|
|
Protocol.Security.CertificateId;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Security.MixedContentType = {
|
|
Blockable: "blockable",
|
|
OptionallyBlockable: "optionally-blockable",
|
|
None: "none"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Security.SecurityState = {
|
|
Unknown: "unknown",
|
|
Neutral: "neutral",
|
|
Insecure: "insecure",
|
|
Secure: "secure",
|
|
Info: "info",
|
|
InsecureBroken: "insecure-broken"
|
|
};
|
|
|
|
/** @typedef {!{protocol:(string), keyExchange:(string), keyExchangeGroup:(string|undefined), cipher:(string), mac:(string|undefined), certificate:(!Array<string>), subjectName:(string), issuer:(string), validFrom:(Protocol.Network.TimeSinceEpoch), validTo:(Protocol.Network.TimeSinceEpoch), certifcateHasWeakSignature:(boolean), modernSSL:(boolean), obsoleteSslProtocol:(boolean), obsoleteSslKeyExchange:(boolean), obsoleteSslCipher:(boolean), obsoleteSslSignature:(boolean)}} */
|
|
Protocol.Security.CertificateSecurityState;
|
|
|
|
/** @typedef {!{securityState:(Protocol.Security.SecurityState), certificateSecurityState:(Protocol.Security.CertificateSecurityState|undefined), securityStateIssueIds:(!Array<string>)}} */
|
|
Protocol.Security.VisibleSecurityState;
|
|
|
|
/** @typedef {!{securityState:(Protocol.Security.SecurityState), title:(string), summary:(string), description:(string), mixedContentType:(Protocol.Security.MixedContentType), certificate:(!Array<string>), recommendations:(!Array<string>|undefined)}} */
|
|
Protocol.Security.SecurityStateExplanation;
|
|
|
|
/** @typedef {!{ranMixedContent:(boolean), displayedMixedContent:(boolean), containedMixedForm:(boolean), ranContentWithCertErrors:(boolean), displayedContentWithCertErrors:(boolean), ranInsecureContentStyle:(Protocol.Security.SecurityState), displayedInsecureContentStyle:(Protocol.Security.SecurityState)}} */
|
|
Protocol.Security.InsecureContentStatus;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Security.CertificateErrorAction = {
|
|
Continue: "continue",
|
|
Cancel: "cancel"
|
|
};
|
|
/** @interface */
|
|
Protocol.SecurityDispatcher = function() {};
|
|
/**
|
|
* @param {number} eventId
|
|
* @param {string} errorType
|
|
* @param {string} requestURL
|
|
*/
|
|
Protocol.SecurityDispatcher.prototype.certificateError = function(eventId, errorType, requestURL) {};
|
|
/**
|
|
* @param {Protocol.Security.VisibleSecurityState} visibleSecurityState
|
|
*/
|
|
Protocol.SecurityDispatcher.prototype.visibleSecurityStateChanged = function(visibleSecurityState) {};
|
|
/**
|
|
* @param {Protocol.Security.SecurityState} securityState
|
|
* @param {boolean} schemeIsCryptographic
|
|
* @param {!Array<Protocol.Security.SecurityStateExplanation>} explanations
|
|
* @param {Protocol.Security.InsecureContentStatus} insecureContentStatus
|
|
* @param {string=} opt_summary
|
|
*/
|
|
Protocol.SecurityDispatcher.prototype.securityStateChanged = function(securityState, schemeIsCryptographic, explanations, insecureContentStatus, opt_summary) {};
|
|
Protocol.ServiceWorker = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.ServiceWorkerAgent = function(){};
|
|
|
|
/**
|
|
* @param {string} origin
|
|
* @param {Protocol.ServiceWorker.RegistrationID} registrationId
|
|
* @param {string} data
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ServiceWorkerAgent.prototype.deliverPushMessage = function(origin, registrationId, data) {};
|
|
/** @typedef {!{origin: string, registrationId: Protocol.ServiceWorker.RegistrationID, data: string}} */
|
|
Protocol.ServiceWorkerAgent.DeliverPushMessageRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ServiceWorkerAgent.DeliverPushMessageResponse;
|
|
/**
|
|
* @param {!Protocol.ServiceWorkerAgent.DeliverPushMessageRequest} obj
|
|
* @return {!Promise<!Protocol.ServiceWorkerAgent.DeliverPushMessageResponse>} */
|
|
Protocol.ServiceWorkerAgent.prototype.invoke_deliverPushMessage = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ServiceWorkerAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ServiceWorkerAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ServiceWorkerAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.ServiceWorkerAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.ServiceWorkerAgent.DisableResponse>} */
|
|
Protocol.ServiceWorkerAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} origin
|
|
* @param {Protocol.ServiceWorker.RegistrationID} registrationId
|
|
* @param {string} tag
|
|
* @param {boolean} lastChance
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ServiceWorkerAgent.prototype.dispatchSyncEvent = function(origin, registrationId, tag, lastChance) {};
|
|
/** @typedef {!{origin: string, registrationId: Protocol.ServiceWorker.RegistrationID, tag: string, lastChance: boolean}} */
|
|
Protocol.ServiceWorkerAgent.DispatchSyncEventRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ServiceWorkerAgent.DispatchSyncEventResponse;
|
|
/**
|
|
* @param {!Protocol.ServiceWorkerAgent.DispatchSyncEventRequest} obj
|
|
* @return {!Promise<!Protocol.ServiceWorkerAgent.DispatchSyncEventResponse>} */
|
|
Protocol.ServiceWorkerAgent.prototype.invoke_dispatchSyncEvent = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} origin
|
|
* @param {Protocol.ServiceWorker.RegistrationID} registrationId
|
|
* @param {string} tag
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ServiceWorkerAgent.prototype.dispatchPeriodicSyncEvent = function(origin, registrationId, tag) {};
|
|
/** @typedef {!{origin: string, registrationId: Protocol.ServiceWorker.RegistrationID, tag: string}} */
|
|
Protocol.ServiceWorkerAgent.DispatchPeriodicSyncEventRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ServiceWorkerAgent.DispatchPeriodicSyncEventResponse;
|
|
/**
|
|
* @param {!Protocol.ServiceWorkerAgent.DispatchPeriodicSyncEventRequest} obj
|
|
* @return {!Promise<!Protocol.ServiceWorkerAgent.DispatchPeriodicSyncEventResponse>} */
|
|
Protocol.ServiceWorkerAgent.prototype.invoke_dispatchPeriodicSyncEvent = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ServiceWorkerAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ServiceWorkerAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ServiceWorkerAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.ServiceWorkerAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.ServiceWorkerAgent.EnableResponse>} */
|
|
Protocol.ServiceWorkerAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} versionId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ServiceWorkerAgent.prototype.inspectWorker = function(versionId) {};
|
|
/** @typedef {!{versionId: string}} */
|
|
Protocol.ServiceWorkerAgent.InspectWorkerRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ServiceWorkerAgent.InspectWorkerResponse;
|
|
/**
|
|
* @param {!Protocol.ServiceWorkerAgent.InspectWorkerRequest} obj
|
|
* @return {!Promise<!Protocol.ServiceWorkerAgent.InspectWorkerResponse>} */
|
|
Protocol.ServiceWorkerAgent.prototype.invoke_inspectWorker = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} forceUpdateOnPageLoad
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ServiceWorkerAgent.prototype.setForceUpdateOnPageLoad = function(forceUpdateOnPageLoad) {};
|
|
/** @typedef {!{forceUpdateOnPageLoad: boolean}} */
|
|
Protocol.ServiceWorkerAgent.SetForceUpdateOnPageLoadRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ServiceWorkerAgent.SetForceUpdateOnPageLoadResponse;
|
|
/**
|
|
* @param {!Protocol.ServiceWorkerAgent.SetForceUpdateOnPageLoadRequest} obj
|
|
* @return {!Promise<!Protocol.ServiceWorkerAgent.SetForceUpdateOnPageLoadResponse>} */
|
|
Protocol.ServiceWorkerAgent.prototype.invoke_setForceUpdateOnPageLoad = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} scopeURL
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ServiceWorkerAgent.prototype.skipWaiting = function(scopeURL) {};
|
|
/** @typedef {!{scopeURL: string}} */
|
|
Protocol.ServiceWorkerAgent.SkipWaitingRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ServiceWorkerAgent.SkipWaitingResponse;
|
|
/**
|
|
* @param {!Protocol.ServiceWorkerAgent.SkipWaitingRequest} obj
|
|
* @return {!Promise<!Protocol.ServiceWorkerAgent.SkipWaitingResponse>} */
|
|
Protocol.ServiceWorkerAgent.prototype.invoke_skipWaiting = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} scopeURL
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ServiceWorkerAgent.prototype.startWorker = function(scopeURL) {};
|
|
/** @typedef {!{scopeURL: string}} */
|
|
Protocol.ServiceWorkerAgent.StartWorkerRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ServiceWorkerAgent.StartWorkerResponse;
|
|
/**
|
|
* @param {!Protocol.ServiceWorkerAgent.StartWorkerRequest} obj
|
|
* @return {!Promise<!Protocol.ServiceWorkerAgent.StartWorkerResponse>} */
|
|
Protocol.ServiceWorkerAgent.prototype.invoke_startWorker = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ServiceWorkerAgent.prototype.stopAllWorkers = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ServiceWorkerAgent.StopAllWorkersRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ServiceWorkerAgent.StopAllWorkersResponse;
|
|
/**
|
|
* @param {!Protocol.ServiceWorkerAgent.StopAllWorkersRequest} obj
|
|
* @return {!Promise<!Protocol.ServiceWorkerAgent.StopAllWorkersResponse>} */
|
|
Protocol.ServiceWorkerAgent.prototype.invoke_stopAllWorkers = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} versionId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ServiceWorkerAgent.prototype.stopWorker = function(versionId) {};
|
|
/** @typedef {!{versionId: string}} */
|
|
Protocol.ServiceWorkerAgent.StopWorkerRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ServiceWorkerAgent.StopWorkerResponse;
|
|
/**
|
|
* @param {!Protocol.ServiceWorkerAgent.StopWorkerRequest} obj
|
|
* @return {!Promise<!Protocol.ServiceWorkerAgent.StopWorkerResponse>} */
|
|
Protocol.ServiceWorkerAgent.prototype.invoke_stopWorker = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} scopeURL
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ServiceWorkerAgent.prototype.unregister = function(scopeURL) {};
|
|
/** @typedef {!{scopeURL: string}} */
|
|
Protocol.ServiceWorkerAgent.UnregisterRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ServiceWorkerAgent.UnregisterResponse;
|
|
/**
|
|
* @param {!Protocol.ServiceWorkerAgent.UnregisterRequest} obj
|
|
* @return {!Promise<!Protocol.ServiceWorkerAgent.UnregisterResponse>} */
|
|
Protocol.ServiceWorkerAgent.prototype.invoke_unregister = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} scopeURL
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ServiceWorkerAgent.prototype.updateRegistration = function(scopeURL) {};
|
|
/** @typedef {!{scopeURL: string}} */
|
|
Protocol.ServiceWorkerAgent.UpdateRegistrationRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ServiceWorkerAgent.UpdateRegistrationResponse;
|
|
/**
|
|
* @param {!Protocol.ServiceWorkerAgent.UpdateRegistrationRequest} obj
|
|
* @return {!Promise<!Protocol.ServiceWorkerAgent.UpdateRegistrationResponse>} */
|
|
Protocol.ServiceWorkerAgent.prototype.invoke_updateRegistration = function(obj) {};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.ServiceWorker.RegistrationID;
|
|
|
|
/** @typedef {!{registrationId:(Protocol.ServiceWorker.RegistrationID), scopeURL:(string), isDeleted:(boolean)}} */
|
|
Protocol.ServiceWorker.ServiceWorkerRegistration;
|
|
|
|
/** @enum {string} */
|
|
Protocol.ServiceWorker.ServiceWorkerVersionRunningStatus = {
|
|
Stopped: "stopped",
|
|
Starting: "starting",
|
|
Running: "running",
|
|
Stopping: "stopping"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.ServiceWorker.ServiceWorkerVersionStatus = {
|
|
New: "new",
|
|
Installing: "installing",
|
|
Installed: "installed",
|
|
Activating: "activating",
|
|
Activated: "activated",
|
|
Redundant: "redundant"
|
|
};
|
|
|
|
/** @typedef {!{versionId:(string), registrationId:(Protocol.ServiceWorker.RegistrationID), scriptURL:(string), runningStatus:(Protocol.ServiceWorker.ServiceWorkerVersionRunningStatus), status:(Protocol.ServiceWorker.ServiceWorkerVersionStatus), scriptLastModified:(number|undefined), scriptResponseTime:(number|undefined), controlledClients:(!Array<Protocol.Target.TargetID>|undefined), targetId:(Protocol.Target.TargetID|undefined)}} */
|
|
Protocol.ServiceWorker.ServiceWorkerVersion;
|
|
|
|
/** @typedef {!{errorMessage:(string), registrationId:(Protocol.ServiceWorker.RegistrationID), versionId:(string), sourceURL:(string), lineNumber:(number), columnNumber:(number)}} */
|
|
Protocol.ServiceWorker.ServiceWorkerErrorMessage;
|
|
/** @interface */
|
|
Protocol.ServiceWorkerDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.ServiceWorker.ServiceWorkerErrorMessage} errorMessage
|
|
*/
|
|
Protocol.ServiceWorkerDispatcher.prototype.workerErrorReported = function(errorMessage) {};
|
|
/**
|
|
* @param {!Array<Protocol.ServiceWorker.ServiceWorkerRegistration>} registrations
|
|
*/
|
|
Protocol.ServiceWorkerDispatcher.prototype.workerRegistrationUpdated = function(registrations) {};
|
|
/**
|
|
* @param {!Array<Protocol.ServiceWorker.ServiceWorkerVersion>} versions
|
|
*/
|
|
Protocol.ServiceWorkerDispatcher.prototype.workerVersionUpdated = function(versions) {};
|
|
Protocol.Storage = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.StorageAgent = function(){};
|
|
|
|
/**
|
|
* @param {string} origin
|
|
* @param {string} storageTypes
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.StorageAgent.prototype.clearDataForOrigin = function(origin, storageTypes) {};
|
|
/** @typedef {!{origin: string, storageTypes: string}} */
|
|
Protocol.StorageAgent.ClearDataForOriginRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.StorageAgent.ClearDataForOriginResponse;
|
|
/**
|
|
* @param {!Protocol.StorageAgent.ClearDataForOriginRequest} obj
|
|
* @return {!Promise<!Protocol.StorageAgent.ClearDataForOriginResponse>} */
|
|
Protocol.StorageAgent.prototype.invoke_clearDataForOrigin = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} origin
|
|
* @return {!Promise<?number>}
|
|
*/
|
|
Protocol.StorageAgent.prototype.getUsageAndQuota = function(origin) {};
|
|
/** @typedef {!{origin: string}} */
|
|
Protocol.StorageAgent.GetUsageAndQuotaRequest;
|
|
/** @typedef {!{usage: number, usageBreakdown: !Array<Protocol.Storage.UsageForType>, quota: number}} */
|
|
Protocol.StorageAgent.GetUsageAndQuotaResponse;
|
|
/**
|
|
* @param {!Protocol.StorageAgent.GetUsageAndQuotaRequest} obj
|
|
* @return {!Promise<!Protocol.StorageAgent.GetUsageAndQuotaResponse>} */
|
|
Protocol.StorageAgent.prototype.invoke_getUsageAndQuota = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} origin
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.StorageAgent.prototype.trackCacheStorageForOrigin = function(origin) {};
|
|
/** @typedef {!{origin: string}} */
|
|
Protocol.StorageAgent.TrackCacheStorageForOriginRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.StorageAgent.TrackCacheStorageForOriginResponse;
|
|
/**
|
|
* @param {!Protocol.StorageAgent.TrackCacheStorageForOriginRequest} obj
|
|
* @return {!Promise<!Protocol.StorageAgent.TrackCacheStorageForOriginResponse>} */
|
|
Protocol.StorageAgent.prototype.invoke_trackCacheStorageForOrigin = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} origin
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.StorageAgent.prototype.trackIndexedDBForOrigin = function(origin) {};
|
|
/** @typedef {!{origin: string}} */
|
|
Protocol.StorageAgent.TrackIndexedDBForOriginRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.StorageAgent.TrackIndexedDBForOriginResponse;
|
|
/**
|
|
* @param {!Protocol.StorageAgent.TrackIndexedDBForOriginRequest} obj
|
|
* @return {!Promise<!Protocol.StorageAgent.TrackIndexedDBForOriginResponse>} */
|
|
Protocol.StorageAgent.prototype.invoke_trackIndexedDBForOrigin = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} origin
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.StorageAgent.prototype.untrackCacheStorageForOrigin = function(origin) {};
|
|
/** @typedef {!{origin: string}} */
|
|
Protocol.StorageAgent.UntrackCacheStorageForOriginRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.StorageAgent.UntrackCacheStorageForOriginResponse;
|
|
/**
|
|
* @param {!Protocol.StorageAgent.UntrackCacheStorageForOriginRequest} obj
|
|
* @return {!Promise<!Protocol.StorageAgent.UntrackCacheStorageForOriginResponse>} */
|
|
Protocol.StorageAgent.prototype.invoke_untrackCacheStorageForOrigin = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} origin
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.StorageAgent.prototype.untrackIndexedDBForOrigin = function(origin) {};
|
|
/** @typedef {!{origin: string}} */
|
|
Protocol.StorageAgent.UntrackIndexedDBForOriginRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.StorageAgent.UntrackIndexedDBForOriginResponse;
|
|
/**
|
|
* @param {!Protocol.StorageAgent.UntrackIndexedDBForOriginRequest} obj
|
|
* @return {!Promise<!Protocol.StorageAgent.UntrackIndexedDBForOriginResponse>} */
|
|
Protocol.StorageAgent.prototype.invoke_untrackIndexedDBForOrigin = function(obj) {};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Storage.StorageType = {
|
|
Appcache: "appcache",
|
|
Cookies: "cookies",
|
|
File_systems: "file_systems",
|
|
Indexeddb: "indexeddb",
|
|
Local_storage: "local_storage",
|
|
Shader_cache: "shader_cache",
|
|
Websql: "websql",
|
|
Service_workers: "service_workers",
|
|
Cache_storage: "cache_storage",
|
|
All: "all",
|
|
Other: "other"
|
|
};
|
|
|
|
/** @typedef {!{storageType:(Protocol.Storage.StorageType), usage:(number)}} */
|
|
Protocol.Storage.UsageForType;
|
|
/** @interface */
|
|
Protocol.StorageDispatcher = function() {};
|
|
/**
|
|
* @param {string} origin
|
|
* @param {string} cacheName
|
|
*/
|
|
Protocol.StorageDispatcher.prototype.cacheStorageContentUpdated = function(origin, cacheName) {};
|
|
/**
|
|
* @param {string} origin
|
|
*/
|
|
Protocol.StorageDispatcher.prototype.cacheStorageListUpdated = function(origin) {};
|
|
/**
|
|
* @param {string} origin
|
|
* @param {string} databaseName
|
|
* @param {string} objectStoreName
|
|
*/
|
|
Protocol.StorageDispatcher.prototype.indexedDBContentUpdated = function(origin, databaseName, objectStoreName) {};
|
|
/**
|
|
* @param {string} origin
|
|
*/
|
|
Protocol.StorageDispatcher.prototype.indexedDBListUpdated = function(origin) {};
|
|
Protocol.SystemInfo = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.SystemInfoAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<?Protocol.SystemInfo.GPUInfo>}
|
|
*/
|
|
Protocol.SystemInfoAgent.prototype.getInfo = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.SystemInfoAgent.GetInfoRequest;
|
|
/** @typedef {!{gpu: Protocol.SystemInfo.GPUInfo, commandLine: string, modelName: string, modelVersion: string}} */
|
|
Protocol.SystemInfoAgent.GetInfoResponse;
|
|
/**
|
|
* @param {!Protocol.SystemInfoAgent.GetInfoRequest} obj
|
|
* @return {!Promise<!Protocol.SystemInfoAgent.GetInfoResponse>} */
|
|
Protocol.SystemInfoAgent.prototype.invoke_getInfo = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<Protocol.SystemInfo.ProcessInfo>>}
|
|
*/
|
|
Protocol.SystemInfoAgent.prototype.getProcessInfo = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.SystemInfoAgent.GetProcessInfoRequest;
|
|
/** @typedef {!{processInfo: !Array<Protocol.SystemInfo.ProcessInfo>}} */
|
|
Protocol.SystemInfoAgent.GetProcessInfoResponse;
|
|
/**
|
|
* @param {!Protocol.SystemInfoAgent.GetProcessInfoRequest} obj
|
|
* @return {!Promise<!Protocol.SystemInfoAgent.GetProcessInfoResponse>} */
|
|
Protocol.SystemInfoAgent.prototype.invoke_getProcessInfo = function(obj) {};
|
|
|
|
/** @typedef {!{vendorId:(number), deviceId:(number), subSysId:(number|undefined), revision:(number|undefined), vendorString:(string), deviceString:(string), driverVendor:(string), driverVersion:(string)}} */
|
|
Protocol.SystemInfo.GPUDevice;
|
|
|
|
/** @typedef {!{width:(number), height:(number)}} */
|
|
Protocol.SystemInfo.Size;
|
|
|
|
/** @typedef {!{profile:(string), maxResolution:(Protocol.SystemInfo.Size), minResolution:(Protocol.SystemInfo.Size)}} */
|
|
Protocol.SystemInfo.VideoDecodeAcceleratorCapability;
|
|
|
|
/** @typedef {!{profile:(string), maxResolution:(Protocol.SystemInfo.Size), maxFramerateNumerator:(number), maxFramerateDenominator:(number)}} */
|
|
Protocol.SystemInfo.VideoEncodeAcceleratorCapability;
|
|
|
|
/** @enum {string} */
|
|
Protocol.SystemInfo.SubsamplingFormat = {
|
|
Yuv420: "yuv420",
|
|
Yuv422: "yuv422",
|
|
Yuv444: "yuv444"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.SystemInfo.ImageType = {
|
|
Jpeg: "jpeg",
|
|
Webp: "webp",
|
|
Unknown: "unknown"
|
|
};
|
|
|
|
/** @typedef {!{imageType:(Protocol.SystemInfo.ImageType), maxDimensions:(Protocol.SystemInfo.Size), minDimensions:(Protocol.SystemInfo.Size), subsamplings:(!Array<Protocol.SystemInfo.SubsamplingFormat>)}} */
|
|
Protocol.SystemInfo.ImageDecodeAcceleratorCapability;
|
|
|
|
/** @typedef {!{devices:(!Array<Protocol.SystemInfo.GPUDevice>), auxAttributes:(!Object|undefined), featureStatus:(!Object|undefined), driverBugWorkarounds:(!Array<string>), videoDecoding:(!Array<Protocol.SystemInfo.VideoDecodeAcceleratorCapability>), videoEncoding:(!Array<Protocol.SystemInfo.VideoEncodeAcceleratorCapability>), imageDecoding:(!Array<Protocol.SystemInfo.ImageDecodeAcceleratorCapability>)}} */
|
|
Protocol.SystemInfo.GPUInfo;
|
|
|
|
/** @typedef {!{type:(string), id:(number), cpuTime:(number)}} */
|
|
Protocol.SystemInfo.ProcessInfo;
|
|
/** @interface */
|
|
Protocol.SystemInfoDispatcher = function() {};
|
|
Protocol.Target = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.TargetAgent = function(){};
|
|
|
|
/**
|
|
* @param {Protocol.Target.TargetID} targetId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.TargetAgent.prototype.activateTarget = function(targetId) {};
|
|
/** @typedef {!{targetId: Protocol.Target.TargetID}} */
|
|
Protocol.TargetAgent.ActivateTargetRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TargetAgent.ActivateTargetResponse;
|
|
/**
|
|
* @param {!Protocol.TargetAgent.ActivateTargetRequest} obj
|
|
* @return {!Promise<!Protocol.TargetAgent.ActivateTargetResponse>} */
|
|
Protocol.TargetAgent.prototype.invoke_activateTarget = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Target.TargetID} targetId
|
|
* @param {boolean=} opt_flatten
|
|
* @return {!Promise<?Protocol.Target.SessionID>}
|
|
*/
|
|
Protocol.TargetAgent.prototype.attachToTarget = function(targetId, opt_flatten) {};
|
|
/** @typedef {!{targetId: Protocol.Target.TargetID, flatten: (boolean|undefined)}} */
|
|
Protocol.TargetAgent.AttachToTargetRequest;
|
|
/** @typedef {!{sessionId: Protocol.Target.SessionID}} */
|
|
Protocol.TargetAgent.AttachToTargetResponse;
|
|
/**
|
|
* @param {!Protocol.TargetAgent.AttachToTargetRequest} obj
|
|
* @return {!Promise<!Protocol.TargetAgent.AttachToTargetResponse>} */
|
|
Protocol.TargetAgent.prototype.invoke_attachToTarget = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Protocol.Target.SessionID>}
|
|
*/
|
|
Protocol.TargetAgent.prototype.attachToBrowserTarget = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TargetAgent.AttachToBrowserTargetRequest;
|
|
/** @typedef {!{sessionId: Protocol.Target.SessionID}} */
|
|
Protocol.TargetAgent.AttachToBrowserTargetResponse;
|
|
/**
|
|
* @param {!Protocol.TargetAgent.AttachToBrowserTargetRequest} obj
|
|
* @return {!Promise<!Protocol.TargetAgent.AttachToBrowserTargetResponse>} */
|
|
Protocol.TargetAgent.prototype.invoke_attachToBrowserTarget = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Target.TargetID} targetId
|
|
* @return {!Promise<?boolean>}
|
|
*/
|
|
Protocol.TargetAgent.prototype.closeTarget = function(targetId) {};
|
|
/** @typedef {!{targetId: Protocol.Target.TargetID}} */
|
|
Protocol.TargetAgent.CloseTargetRequest;
|
|
/** @typedef {!{success: boolean}} */
|
|
Protocol.TargetAgent.CloseTargetResponse;
|
|
/**
|
|
* @param {!Protocol.TargetAgent.CloseTargetRequest} obj
|
|
* @return {!Promise<!Protocol.TargetAgent.CloseTargetResponse>} */
|
|
Protocol.TargetAgent.prototype.invoke_closeTarget = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Target.TargetID} targetId
|
|
* @param {string=} opt_bindingName
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.TargetAgent.prototype.exposeDevToolsProtocol = function(targetId, opt_bindingName) {};
|
|
/** @typedef {!{targetId: Protocol.Target.TargetID, bindingName: (string|undefined)}} */
|
|
Protocol.TargetAgent.ExposeDevToolsProtocolRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TargetAgent.ExposeDevToolsProtocolResponse;
|
|
/**
|
|
* @param {!Protocol.TargetAgent.ExposeDevToolsProtocolRequest} obj
|
|
* @return {!Promise<!Protocol.TargetAgent.ExposeDevToolsProtocolResponse>} */
|
|
Protocol.TargetAgent.prototype.invoke_exposeDevToolsProtocol = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Protocol.Target.BrowserContextID>}
|
|
*/
|
|
Protocol.TargetAgent.prototype.createBrowserContext = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TargetAgent.CreateBrowserContextRequest;
|
|
/** @typedef {!{browserContextId: Protocol.Target.BrowserContextID}} */
|
|
Protocol.TargetAgent.CreateBrowserContextResponse;
|
|
/**
|
|
* @param {!Protocol.TargetAgent.CreateBrowserContextRequest} obj
|
|
* @return {!Promise<!Protocol.TargetAgent.CreateBrowserContextResponse>} */
|
|
Protocol.TargetAgent.prototype.invoke_createBrowserContext = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<Protocol.Target.BrowserContextID>>}
|
|
*/
|
|
Protocol.TargetAgent.prototype.getBrowserContexts = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TargetAgent.GetBrowserContextsRequest;
|
|
/** @typedef {!{browserContextIds: !Array<Protocol.Target.BrowserContextID>}} */
|
|
Protocol.TargetAgent.GetBrowserContextsResponse;
|
|
/**
|
|
* @param {!Protocol.TargetAgent.GetBrowserContextsRequest} obj
|
|
* @return {!Promise<!Protocol.TargetAgent.GetBrowserContextsResponse>} */
|
|
Protocol.TargetAgent.prototype.invoke_getBrowserContexts = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} url
|
|
* @param {number=} opt_width
|
|
* @param {number=} opt_height
|
|
* @param {Protocol.Target.BrowserContextID=} opt_browserContextId
|
|
* @param {boolean=} opt_enableBeginFrameControl
|
|
* @param {boolean=} opt_newWindow
|
|
* @param {boolean=} opt_background
|
|
* @return {!Promise<?Protocol.Target.TargetID>}
|
|
*/
|
|
Protocol.TargetAgent.prototype.createTarget = function(url, opt_width, opt_height, opt_browserContextId, opt_enableBeginFrameControl, opt_newWindow, opt_background) {};
|
|
/** @typedef {!{browserContextId: (Protocol.Target.BrowserContextID|undefined), url: string, newWindow: (boolean|undefined), width: (number|undefined), enableBeginFrameControl: (boolean|undefined), background: (boolean|undefined), height: (number|undefined)}} */
|
|
Protocol.TargetAgent.CreateTargetRequest;
|
|
/** @typedef {!{targetId: Protocol.Target.TargetID}} */
|
|
Protocol.TargetAgent.CreateTargetResponse;
|
|
/**
|
|
* @param {!Protocol.TargetAgent.CreateTargetRequest} obj
|
|
* @return {!Promise<!Protocol.TargetAgent.CreateTargetResponse>} */
|
|
Protocol.TargetAgent.prototype.invoke_createTarget = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Target.SessionID=} opt_sessionId
|
|
* @param {Protocol.Target.TargetID=} opt_targetId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.TargetAgent.prototype.detachFromTarget = function(opt_sessionId, opt_targetId) {};
|
|
/** @typedef {!{sessionId: (Protocol.Target.SessionID|undefined), targetId: (Protocol.Target.TargetID|undefined)}} */
|
|
Protocol.TargetAgent.DetachFromTargetRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TargetAgent.DetachFromTargetResponse;
|
|
/**
|
|
* @param {!Protocol.TargetAgent.DetachFromTargetRequest} obj
|
|
* @return {!Promise<!Protocol.TargetAgent.DetachFromTargetResponse>} */
|
|
Protocol.TargetAgent.prototype.invoke_detachFromTarget = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Target.BrowserContextID} browserContextId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.TargetAgent.prototype.disposeBrowserContext = function(browserContextId) {};
|
|
/** @typedef {!{browserContextId: Protocol.Target.BrowserContextID}} */
|
|
Protocol.TargetAgent.DisposeBrowserContextRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TargetAgent.DisposeBrowserContextResponse;
|
|
/**
|
|
* @param {!Protocol.TargetAgent.DisposeBrowserContextRequest} obj
|
|
* @return {!Promise<!Protocol.TargetAgent.DisposeBrowserContextResponse>} */
|
|
Protocol.TargetAgent.prototype.invoke_disposeBrowserContext = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Target.TargetID=} opt_targetId
|
|
* @return {!Promise<?Protocol.Target.TargetInfo>}
|
|
*/
|
|
Protocol.TargetAgent.prototype.getTargetInfo = function(opt_targetId) {};
|
|
/** @typedef {!{targetId: (Protocol.Target.TargetID|undefined)}} */
|
|
Protocol.TargetAgent.GetTargetInfoRequest;
|
|
/** @typedef {!{targetInfo: Protocol.Target.TargetInfo}} */
|
|
Protocol.TargetAgent.GetTargetInfoResponse;
|
|
/**
|
|
* @param {!Protocol.TargetAgent.GetTargetInfoRequest} obj
|
|
* @return {!Promise<!Protocol.TargetAgent.GetTargetInfoResponse>} */
|
|
Protocol.TargetAgent.prototype.invoke_getTargetInfo = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<Protocol.Target.TargetInfo>>}
|
|
*/
|
|
Protocol.TargetAgent.prototype.getTargets = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TargetAgent.GetTargetsRequest;
|
|
/** @typedef {!{targetInfos: !Array<Protocol.Target.TargetInfo>}} */
|
|
Protocol.TargetAgent.GetTargetsResponse;
|
|
/**
|
|
* @param {!Protocol.TargetAgent.GetTargetsRequest} obj
|
|
* @return {!Promise<!Protocol.TargetAgent.GetTargetsResponse>} */
|
|
Protocol.TargetAgent.prototype.invoke_getTargets = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} message
|
|
* @param {Protocol.Target.SessionID=} opt_sessionId
|
|
* @param {Protocol.Target.TargetID=} opt_targetId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.TargetAgent.prototype.sendMessageToTarget = function(message, opt_sessionId, opt_targetId) {};
|
|
/** @typedef {!{message: string, targetId: (Protocol.Target.TargetID|undefined), sessionId: (Protocol.Target.SessionID|undefined)}} */
|
|
Protocol.TargetAgent.SendMessageToTargetRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TargetAgent.SendMessageToTargetResponse;
|
|
/**
|
|
* @param {!Protocol.TargetAgent.SendMessageToTargetRequest} obj
|
|
* @return {!Promise<!Protocol.TargetAgent.SendMessageToTargetResponse>} */
|
|
Protocol.TargetAgent.prototype.invoke_sendMessageToTarget = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} autoAttach
|
|
* @param {boolean} waitForDebuggerOnStart
|
|
* @param {boolean=} opt_flatten
|
|
* @param {boolean=} opt_windowOpen
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.TargetAgent.prototype.setAutoAttach = function(autoAttach, waitForDebuggerOnStart, opt_flatten, opt_windowOpen) {};
|
|
/** @typedef {!{waitForDebuggerOnStart: boolean, autoAttach: boolean, flatten: (boolean|undefined), windowOpen: (boolean|undefined)}} */
|
|
Protocol.TargetAgent.SetAutoAttachRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TargetAgent.SetAutoAttachResponse;
|
|
/**
|
|
* @param {!Protocol.TargetAgent.SetAutoAttachRequest} obj
|
|
* @return {!Promise<!Protocol.TargetAgent.SetAutoAttachResponse>} */
|
|
Protocol.TargetAgent.prototype.invoke_setAutoAttach = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} discover
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.TargetAgent.prototype.setDiscoverTargets = function(discover) {};
|
|
/** @typedef {!{discover: boolean}} */
|
|
Protocol.TargetAgent.SetDiscoverTargetsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TargetAgent.SetDiscoverTargetsResponse;
|
|
/**
|
|
* @param {!Protocol.TargetAgent.SetDiscoverTargetsRequest} obj
|
|
* @return {!Promise<!Protocol.TargetAgent.SetDiscoverTargetsResponse>} */
|
|
Protocol.TargetAgent.prototype.invoke_setDiscoverTargets = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<Protocol.Target.RemoteLocation>} locations
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.TargetAgent.prototype.setRemoteLocations = function(locations) {};
|
|
/** @typedef {!{locations: !Array<Protocol.Target.RemoteLocation>}} */
|
|
Protocol.TargetAgent.SetRemoteLocationsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TargetAgent.SetRemoteLocationsResponse;
|
|
/**
|
|
* @param {!Protocol.TargetAgent.SetRemoteLocationsRequest} obj
|
|
* @return {!Promise<!Protocol.TargetAgent.SetRemoteLocationsResponse>} */
|
|
Protocol.TargetAgent.prototype.invoke_setRemoteLocations = function(obj) {};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Target.TargetID;
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Target.SessionID;
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Target.BrowserContextID;
|
|
|
|
/** @typedef {!{targetId:(Protocol.Target.TargetID), type:(string), title:(string), url:(string), attached:(boolean), openerId:(Protocol.Target.TargetID|undefined), browserContextId:(Protocol.Target.BrowserContextID|undefined)}} */
|
|
Protocol.Target.TargetInfo;
|
|
|
|
/** @typedef {!{host:(string), port:(number)}} */
|
|
Protocol.Target.RemoteLocation;
|
|
/** @interface */
|
|
Protocol.TargetDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.Target.SessionID} sessionId
|
|
* @param {Protocol.Target.TargetInfo} targetInfo
|
|
* @param {boolean} waitingForDebugger
|
|
*/
|
|
Protocol.TargetDispatcher.prototype.attachedToTarget = function(sessionId, targetInfo, waitingForDebugger) {};
|
|
/**
|
|
* @param {Protocol.Target.SessionID} sessionId
|
|
* @param {Protocol.Target.TargetID=} opt_targetId
|
|
*/
|
|
Protocol.TargetDispatcher.prototype.detachedFromTarget = function(sessionId, opt_targetId) {};
|
|
/**
|
|
* @param {Protocol.Target.SessionID} sessionId
|
|
* @param {string} message
|
|
* @param {Protocol.Target.TargetID=} opt_targetId
|
|
*/
|
|
Protocol.TargetDispatcher.prototype.receivedMessageFromTarget = function(sessionId, message, opt_targetId) {};
|
|
/**
|
|
* @param {Protocol.Target.TargetInfo} targetInfo
|
|
*/
|
|
Protocol.TargetDispatcher.prototype.targetCreated = function(targetInfo) {};
|
|
/**
|
|
* @param {Protocol.Target.TargetID} targetId
|
|
*/
|
|
Protocol.TargetDispatcher.prototype.targetDestroyed = function(targetId) {};
|
|
/**
|
|
* @param {Protocol.Target.TargetID} targetId
|
|
* @param {string} status
|
|
* @param {number} errorCode
|
|
*/
|
|
Protocol.TargetDispatcher.prototype.targetCrashed = function(targetId, status, errorCode) {};
|
|
/**
|
|
* @param {Protocol.Target.TargetInfo} targetInfo
|
|
*/
|
|
Protocol.TargetDispatcher.prototype.targetInfoChanged = function(targetInfo) {};
|
|
Protocol.Tethering = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.TetheringAgent = function(){};
|
|
|
|
/**
|
|
* @param {number} port
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.TetheringAgent.prototype.bind = function(port) {};
|
|
/** @typedef {!{port: number}} */
|
|
Protocol.TetheringAgent.BindRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TetheringAgent.BindResponse;
|
|
/**
|
|
* @param {!Protocol.TetheringAgent.BindRequest} obj
|
|
* @return {!Promise<!Protocol.TetheringAgent.BindResponse>} */
|
|
Protocol.TetheringAgent.prototype.invoke_bind = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} port
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.TetheringAgent.prototype.unbind = function(port) {};
|
|
/** @typedef {!{port: number}} */
|
|
Protocol.TetheringAgent.UnbindRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TetheringAgent.UnbindResponse;
|
|
/**
|
|
* @param {!Protocol.TetheringAgent.UnbindRequest} obj
|
|
* @return {!Promise<!Protocol.TetheringAgent.UnbindResponse>} */
|
|
Protocol.TetheringAgent.prototype.invoke_unbind = function(obj) {};
|
|
/** @interface */
|
|
Protocol.TetheringDispatcher = function() {};
|
|
/**
|
|
* @param {number} port
|
|
* @param {string} connectionId
|
|
*/
|
|
Protocol.TetheringDispatcher.prototype.accepted = function(port, connectionId) {};
|
|
Protocol.Tracing = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.TracingAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.TracingAgent.prototype.end = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TracingAgent.EndRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TracingAgent.EndResponse;
|
|
/**
|
|
* @param {!Protocol.TracingAgent.EndRequest} obj
|
|
* @return {!Promise<!Protocol.TracingAgent.EndResponse>} */
|
|
Protocol.TracingAgent.prototype.invoke_end = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<string>>}
|
|
*/
|
|
Protocol.TracingAgent.prototype.getCategories = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TracingAgent.GetCategoriesRequest;
|
|
/** @typedef {!{categories: !Array<string>}} */
|
|
Protocol.TracingAgent.GetCategoriesResponse;
|
|
/**
|
|
* @param {!Protocol.TracingAgent.GetCategoriesRequest} obj
|
|
* @return {!Promise<!Protocol.TracingAgent.GetCategoriesResponse>} */
|
|
Protocol.TracingAgent.prototype.invoke_getCategories = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} syncId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.TracingAgent.prototype.recordClockSyncMarker = function(syncId) {};
|
|
/** @typedef {!{syncId: string}} */
|
|
Protocol.TracingAgent.RecordClockSyncMarkerRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TracingAgent.RecordClockSyncMarkerResponse;
|
|
/**
|
|
* @param {!Protocol.TracingAgent.RecordClockSyncMarkerRequest} obj
|
|
* @return {!Promise<!Protocol.TracingAgent.RecordClockSyncMarkerResponse>} */
|
|
Protocol.TracingAgent.prototype.invoke_recordClockSyncMarker = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean=} opt_deterministic
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.TracingAgent.prototype.requestMemoryDump = function(opt_deterministic) {};
|
|
/** @typedef {!{deterministic: (boolean|undefined)}} */
|
|
Protocol.TracingAgent.RequestMemoryDumpRequest;
|
|
/** @typedef {!{dumpGuid: string, success: boolean}} */
|
|
Protocol.TracingAgent.RequestMemoryDumpResponse;
|
|
/**
|
|
* @param {!Protocol.TracingAgent.RequestMemoryDumpRequest} obj
|
|
* @return {!Promise<!Protocol.TracingAgent.RequestMemoryDumpResponse>} */
|
|
Protocol.TracingAgent.prototype.invoke_requestMemoryDump = function(obj) {};
|
|
|
|
/**
|
|
* @param {string=} opt_categories
|
|
* @param {string=} opt_options
|
|
* @param {number=} opt_bufferUsageReportingInterval
|
|
* @param {string=} opt_transferMode
|
|
* @param {Protocol.Tracing.StreamFormat=} opt_streamFormat
|
|
* @param {Protocol.Tracing.StreamCompression=} opt_streamCompression
|
|
* @param {Protocol.Tracing.TraceConfig=} opt_traceConfig
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.TracingAgent.prototype.start = function(opt_categories, opt_options, opt_bufferUsageReportingInterval, opt_transferMode, opt_streamFormat, opt_streamCompression, opt_traceConfig) {};
|
|
/** @typedef {!{traceConfig: (Protocol.Tracing.TraceConfig|undefined), transferMode: (string|undefined), bufferUsageReportingInterval: (number|undefined), streamFormat: (Protocol.Tracing.StreamFormat|undefined), options: (string|undefined), categories: (string|undefined), streamCompression: (Protocol.Tracing.StreamCompression|undefined)}} */
|
|
Protocol.TracingAgent.StartRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.TracingAgent.StartResponse;
|
|
/**
|
|
* @param {!Protocol.TracingAgent.StartRequest} obj
|
|
* @return {!Promise<!Protocol.TracingAgent.StartResponse>} */
|
|
Protocol.TracingAgent.prototype.invoke_start = function(obj) {};
|
|
|
|
/** @typedef {!Object} */
|
|
Protocol.Tracing.MemoryDumpConfig;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Tracing.TraceConfigRecordMode = {
|
|
RecordUntilFull: "recordUntilFull",
|
|
RecordContinuously: "recordContinuously",
|
|
RecordAsMuchAsPossible: "recordAsMuchAsPossible",
|
|
EchoToConsole: "echoToConsole"
|
|
};
|
|
|
|
/** @typedef {!{recordMode:(Protocol.Tracing.TraceConfigRecordMode|undefined), enableSampling:(boolean|undefined), enableSystrace:(boolean|undefined), enableArgumentFilter:(boolean|undefined), includedCategories:(!Array<string>|undefined), excludedCategories:(!Array<string>|undefined), syntheticDelays:(!Array<string>|undefined), memoryDumpConfig:(Protocol.Tracing.MemoryDumpConfig|undefined)}} */
|
|
Protocol.Tracing.TraceConfig;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Tracing.StreamFormat = {
|
|
Json: "json",
|
|
Proto: "proto"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Tracing.StreamCompression = {
|
|
None: "none",
|
|
Gzip: "gzip"
|
|
};
|
|
/** @interface */
|
|
Protocol.TracingDispatcher = function() {};
|
|
/**
|
|
* @param {number=} opt_percentFull
|
|
* @param {number=} opt_eventCount
|
|
* @param {number=} opt_value
|
|
*/
|
|
Protocol.TracingDispatcher.prototype.bufferUsage = function(opt_percentFull, opt_eventCount, opt_value) {};
|
|
/**
|
|
* @param {!Array<!Object>} value
|
|
*/
|
|
Protocol.TracingDispatcher.prototype.dataCollected = function(value) {};
|
|
/**
|
|
* @param {boolean} dataLossOccurred
|
|
* @param {Protocol.IO.StreamHandle=} opt_stream
|
|
* @param {Protocol.Tracing.StreamFormat=} opt_traceFormat
|
|
* @param {Protocol.Tracing.StreamCompression=} opt_streamCompression
|
|
*/
|
|
Protocol.TracingDispatcher.prototype.tracingComplete = function(dataLossOccurred, opt_stream, opt_traceFormat, opt_streamCompression) {};
|
|
Protocol.Fetch = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.FetchAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.FetchAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.FetchAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.FetchAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.FetchAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.FetchAgent.DisableResponse>} */
|
|
Protocol.FetchAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<Protocol.Fetch.RequestPattern>=} opt_patterns
|
|
* @param {boolean=} opt_handleAuthRequests
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.FetchAgent.prototype.enable = function(opt_patterns, opt_handleAuthRequests) {};
|
|
/** @typedef {!{patterns: (!Array<Protocol.Fetch.RequestPattern>|undefined), handleAuthRequests: (boolean|undefined)}} */
|
|
Protocol.FetchAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.FetchAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.FetchAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.FetchAgent.EnableResponse>} */
|
|
Protocol.FetchAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Fetch.RequestId} requestId
|
|
* @param {Protocol.Network.ErrorReason} errorReason
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.FetchAgent.prototype.failRequest = function(requestId, errorReason) {};
|
|
/** @typedef {!{requestId: Protocol.Fetch.RequestId, errorReason: Protocol.Network.ErrorReason}} */
|
|
Protocol.FetchAgent.FailRequestRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.FetchAgent.FailRequestResponse;
|
|
/**
|
|
* @param {!Protocol.FetchAgent.FailRequestRequest} obj
|
|
* @return {!Promise<!Protocol.FetchAgent.FailRequestResponse>} */
|
|
Protocol.FetchAgent.prototype.invoke_failRequest = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Fetch.RequestId} requestId
|
|
* @param {number} responseCode
|
|
* @param {!Array<Protocol.Fetch.HeaderEntry>=} opt_responseHeaders
|
|
* @param {string=} opt_binaryResponseHeaders
|
|
* @param {string=} opt_body
|
|
* @param {string=} opt_responsePhrase
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.FetchAgent.prototype.fulfillRequest = function(requestId, responseCode, opt_responseHeaders, opt_binaryResponseHeaders, opt_body, opt_responsePhrase) {};
|
|
/** @typedef {!{body: (string|undefined), binaryResponseHeaders: (string|undefined), requestId: Protocol.Fetch.RequestId, responseCode: number, responsePhrase: (string|undefined), responseHeaders: (!Array<Protocol.Fetch.HeaderEntry>|undefined)}} */
|
|
Protocol.FetchAgent.FulfillRequestRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.FetchAgent.FulfillRequestResponse;
|
|
/**
|
|
* @param {!Protocol.FetchAgent.FulfillRequestRequest} obj
|
|
* @return {!Promise<!Protocol.FetchAgent.FulfillRequestResponse>} */
|
|
Protocol.FetchAgent.prototype.invoke_fulfillRequest = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Fetch.RequestId} requestId
|
|
* @param {string=} opt_url
|
|
* @param {string=} opt_method
|
|
* @param {string=} opt_postData
|
|
* @param {!Array<Protocol.Fetch.HeaderEntry>=} opt_headers
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.FetchAgent.prototype.continueRequest = function(requestId, opt_url, opt_method, opt_postData, opt_headers) {};
|
|
/** @typedef {!{url: (string|undefined), headers: (!Array<Protocol.Fetch.HeaderEntry>|undefined), requestId: Protocol.Fetch.RequestId, postData: (string|undefined), method: (string|undefined)}} */
|
|
Protocol.FetchAgent.ContinueRequestRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.FetchAgent.ContinueRequestResponse;
|
|
/**
|
|
* @param {!Protocol.FetchAgent.ContinueRequestRequest} obj
|
|
* @return {!Promise<!Protocol.FetchAgent.ContinueRequestResponse>} */
|
|
Protocol.FetchAgent.prototype.invoke_continueRequest = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Fetch.RequestId} requestId
|
|
* @param {Protocol.Fetch.AuthChallengeResponse} authChallengeResponse
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.FetchAgent.prototype.continueWithAuth = function(requestId, authChallengeResponse) {};
|
|
/** @typedef {!{authChallengeResponse: Protocol.Fetch.AuthChallengeResponse, requestId: Protocol.Fetch.RequestId}} */
|
|
Protocol.FetchAgent.ContinueWithAuthRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.FetchAgent.ContinueWithAuthResponse;
|
|
/**
|
|
* @param {!Protocol.FetchAgent.ContinueWithAuthRequest} obj
|
|
* @return {!Promise<!Protocol.FetchAgent.ContinueWithAuthResponse>} */
|
|
Protocol.FetchAgent.prototype.invoke_continueWithAuth = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Fetch.RequestId} requestId
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.FetchAgent.prototype.getResponseBody = function(requestId) {};
|
|
/** @typedef {!{requestId: Protocol.Fetch.RequestId}} */
|
|
Protocol.FetchAgent.GetResponseBodyRequest;
|
|
/** @typedef {!{body: string, base64Encoded: boolean}} */
|
|
Protocol.FetchAgent.GetResponseBodyResponse;
|
|
/**
|
|
* @param {!Protocol.FetchAgent.GetResponseBodyRequest} obj
|
|
* @return {!Promise<!Protocol.FetchAgent.GetResponseBodyResponse>} */
|
|
Protocol.FetchAgent.prototype.invoke_getResponseBody = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Fetch.RequestId} requestId
|
|
* @return {!Promise<?Protocol.IO.StreamHandle>}
|
|
*/
|
|
Protocol.FetchAgent.prototype.takeResponseBodyAsStream = function(requestId) {};
|
|
/** @typedef {!{requestId: Protocol.Fetch.RequestId}} */
|
|
Protocol.FetchAgent.TakeResponseBodyAsStreamRequest;
|
|
/** @typedef {!{stream: Protocol.IO.StreamHandle}} */
|
|
Protocol.FetchAgent.TakeResponseBodyAsStreamResponse;
|
|
/**
|
|
* @param {!Protocol.FetchAgent.TakeResponseBodyAsStreamRequest} obj
|
|
* @return {!Promise<!Protocol.FetchAgent.TakeResponseBodyAsStreamResponse>} */
|
|
Protocol.FetchAgent.prototype.invoke_takeResponseBodyAsStream = function(obj) {};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Fetch.RequestId;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Fetch.RequestStage = {
|
|
Request: "Request",
|
|
Response: "Response"
|
|
};
|
|
|
|
/** @typedef {!{urlPattern:(string|undefined), resourceType:(Protocol.Network.ResourceType|undefined), requestStage:(Protocol.Fetch.RequestStage|undefined)}} */
|
|
Protocol.Fetch.RequestPattern;
|
|
|
|
/** @typedef {!{name:(string), value:(string)}} */
|
|
Protocol.Fetch.HeaderEntry;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Fetch.AuthChallengeSource = {
|
|
Server: "Server",
|
|
Proxy: "Proxy"
|
|
};
|
|
|
|
/** @typedef {!{source:(Protocol.Fetch.AuthChallengeSource|undefined), origin:(string), scheme:(string), realm:(string)}} */
|
|
Protocol.Fetch.AuthChallenge;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Fetch.AuthChallengeResponseResponse = {
|
|
Default: "Default",
|
|
CancelAuth: "CancelAuth",
|
|
ProvideCredentials: "ProvideCredentials"
|
|
};
|
|
|
|
/** @typedef {!{response:(Protocol.Fetch.AuthChallengeResponseResponse), username:(string|undefined), password:(string|undefined)}} */
|
|
Protocol.Fetch.AuthChallengeResponse;
|
|
/** @interface */
|
|
Protocol.FetchDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.Fetch.RequestId} requestId
|
|
* @param {Protocol.Network.Request} request
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @param {Protocol.Network.ResourceType} resourceType
|
|
* @param {Protocol.Network.ErrorReason=} opt_responseErrorReason
|
|
* @param {number=} opt_responseStatusCode
|
|
* @param {!Array<Protocol.Fetch.HeaderEntry>=} opt_responseHeaders
|
|
* @param {Protocol.Fetch.RequestId=} opt_networkId
|
|
*/
|
|
Protocol.FetchDispatcher.prototype.requestPaused = function(requestId, request, frameId, resourceType, opt_responseErrorReason, opt_responseStatusCode, opt_responseHeaders, opt_networkId) {};
|
|
/**
|
|
* @param {Protocol.Fetch.RequestId} requestId
|
|
* @param {Protocol.Network.Request} request
|
|
* @param {Protocol.Page.FrameId} frameId
|
|
* @param {Protocol.Network.ResourceType} resourceType
|
|
* @param {Protocol.Fetch.AuthChallenge} authChallenge
|
|
*/
|
|
Protocol.FetchDispatcher.prototype.authRequired = function(requestId, request, frameId, resourceType, authChallenge) {};
|
|
Protocol.WebAudio = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.WebAudioAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.WebAudioAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.WebAudioAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.WebAudioAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.WebAudioAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.WebAudioAgent.EnableResponse>} */
|
|
Protocol.WebAudioAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.WebAudioAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.WebAudioAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.WebAudioAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.WebAudioAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.WebAudioAgent.DisableResponse>} */
|
|
Protocol.WebAudioAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.WebAudio.GraphObjectId} contextId
|
|
* @return {!Promise<?Protocol.WebAudio.ContextRealtimeData>}
|
|
*/
|
|
Protocol.WebAudioAgent.prototype.getRealtimeData = function(contextId) {};
|
|
/** @typedef {!{contextId: Protocol.WebAudio.GraphObjectId}} */
|
|
Protocol.WebAudioAgent.GetRealtimeDataRequest;
|
|
/** @typedef {!{realtimeData: Protocol.WebAudio.ContextRealtimeData}} */
|
|
Protocol.WebAudioAgent.GetRealtimeDataResponse;
|
|
/**
|
|
* @param {!Protocol.WebAudioAgent.GetRealtimeDataRequest} obj
|
|
* @return {!Promise<!Protocol.WebAudioAgent.GetRealtimeDataResponse>} */
|
|
Protocol.WebAudioAgent.prototype.invoke_getRealtimeData = function(obj) {};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.WebAudio.GraphObjectId;
|
|
|
|
/** @enum {string} */
|
|
Protocol.WebAudio.ContextType = {
|
|
Realtime: "realtime",
|
|
Offline: "offline"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.WebAudio.ContextState = {
|
|
Suspended: "suspended",
|
|
Running: "running",
|
|
Closed: "closed"
|
|
};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.WebAudio.NodeType;
|
|
|
|
/** @enum {string} */
|
|
Protocol.WebAudio.ChannelCountMode = {
|
|
ClampedMax: "clamped-max",
|
|
Explicit: "explicit",
|
|
Max: "max"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.WebAudio.ChannelInterpretation = {
|
|
Discrete: "discrete",
|
|
Speakers: "speakers"
|
|
};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.WebAudio.ParamType;
|
|
|
|
/** @enum {string} */
|
|
Protocol.WebAudio.AutomationRate = {
|
|
ARate: "a-rate",
|
|
KRate: "k-rate"
|
|
};
|
|
|
|
/** @typedef {!{currentTime:(number), renderCapacity:(number), callbackIntervalMean:(number), callbackIntervalVariance:(number)}} */
|
|
Protocol.WebAudio.ContextRealtimeData;
|
|
|
|
/** @typedef {!{contextId:(Protocol.WebAudio.GraphObjectId), contextType:(Protocol.WebAudio.ContextType), contextState:(Protocol.WebAudio.ContextState), realtimeData:(Protocol.WebAudio.ContextRealtimeData|undefined), callbackBufferSize:(number), maxOutputChannelCount:(number), sampleRate:(number)}} */
|
|
Protocol.WebAudio.BaseAudioContext;
|
|
|
|
/** @typedef {!{listenerId:(Protocol.WebAudio.GraphObjectId), contextId:(Protocol.WebAudio.GraphObjectId)}} */
|
|
Protocol.WebAudio.AudioListener;
|
|
|
|
/** @typedef {!{nodeId:(Protocol.WebAudio.GraphObjectId), contextId:(Protocol.WebAudio.GraphObjectId), nodeType:(Protocol.WebAudio.NodeType), numberOfInputs:(number), numberOfOutputs:(number), channelCount:(number), channelCountMode:(Protocol.WebAudio.ChannelCountMode), channelInterpretation:(Protocol.WebAudio.ChannelInterpretation)}} */
|
|
Protocol.WebAudio.AudioNode;
|
|
|
|
/** @typedef {!{paramId:(Protocol.WebAudio.GraphObjectId), nodeId:(Protocol.WebAudio.GraphObjectId), contextId:(Protocol.WebAudio.GraphObjectId), paramType:(Protocol.WebAudio.ParamType), rate:(Protocol.WebAudio.AutomationRate), defaultValue:(number), minValue:(number), maxValue:(number)}} */
|
|
Protocol.WebAudio.AudioParam;
|
|
/** @interface */
|
|
Protocol.WebAudioDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.WebAudio.BaseAudioContext} context
|
|
*/
|
|
Protocol.WebAudioDispatcher.prototype.contextCreated = function(context) {};
|
|
/**
|
|
* @param {Protocol.WebAudio.GraphObjectId} contextId
|
|
*/
|
|
Protocol.WebAudioDispatcher.prototype.contextWillBeDestroyed = function(contextId) {};
|
|
/**
|
|
* @param {Protocol.WebAudio.BaseAudioContext} context
|
|
*/
|
|
Protocol.WebAudioDispatcher.prototype.contextChanged = function(context) {};
|
|
/**
|
|
* @param {Protocol.WebAudio.AudioListener} listener
|
|
*/
|
|
Protocol.WebAudioDispatcher.prototype.audioListenerCreated = function(listener) {};
|
|
/**
|
|
* @param {Protocol.WebAudio.GraphObjectId} contextId
|
|
* @param {Protocol.WebAudio.GraphObjectId} listenerId
|
|
*/
|
|
Protocol.WebAudioDispatcher.prototype.audioListenerWillBeDestroyed = function(contextId, listenerId) {};
|
|
/**
|
|
* @param {Protocol.WebAudio.AudioNode} node
|
|
*/
|
|
Protocol.WebAudioDispatcher.prototype.audioNodeCreated = function(node) {};
|
|
/**
|
|
* @param {Protocol.WebAudio.GraphObjectId} contextId
|
|
* @param {Protocol.WebAudio.GraphObjectId} nodeId
|
|
*/
|
|
Protocol.WebAudioDispatcher.prototype.audioNodeWillBeDestroyed = function(contextId, nodeId) {};
|
|
/**
|
|
* @param {Protocol.WebAudio.AudioParam} param
|
|
*/
|
|
Protocol.WebAudioDispatcher.prototype.audioParamCreated = function(param) {};
|
|
/**
|
|
* @param {Protocol.WebAudio.GraphObjectId} contextId
|
|
* @param {Protocol.WebAudio.GraphObjectId} nodeId
|
|
* @param {Protocol.WebAudio.GraphObjectId} paramId
|
|
*/
|
|
Protocol.WebAudioDispatcher.prototype.audioParamWillBeDestroyed = function(contextId, nodeId, paramId) {};
|
|
/**
|
|
* @param {Protocol.WebAudio.GraphObjectId} contextId
|
|
* @param {Protocol.WebAudio.GraphObjectId} sourceId
|
|
* @param {Protocol.WebAudio.GraphObjectId} destinationId
|
|
* @param {number=} opt_sourceOutputIndex
|
|
* @param {number=} opt_destinationInputIndex
|
|
*/
|
|
Protocol.WebAudioDispatcher.prototype.nodesConnected = function(contextId, sourceId, destinationId, opt_sourceOutputIndex, opt_destinationInputIndex) {};
|
|
/**
|
|
* @param {Protocol.WebAudio.GraphObjectId} contextId
|
|
* @param {Protocol.WebAudio.GraphObjectId} sourceId
|
|
* @param {Protocol.WebAudio.GraphObjectId} destinationId
|
|
* @param {number=} opt_sourceOutputIndex
|
|
* @param {number=} opt_destinationInputIndex
|
|
*/
|
|
Protocol.WebAudioDispatcher.prototype.nodesDisconnected = function(contextId, sourceId, destinationId, opt_sourceOutputIndex, opt_destinationInputIndex) {};
|
|
/**
|
|
* @param {Protocol.WebAudio.GraphObjectId} contextId
|
|
* @param {Protocol.WebAudio.GraphObjectId} sourceId
|
|
* @param {Protocol.WebAudio.GraphObjectId} destinationId
|
|
* @param {number=} opt_sourceOutputIndex
|
|
*/
|
|
Protocol.WebAudioDispatcher.prototype.nodeParamConnected = function(contextId, sourceId, destinationId, opt_sourceOutputIndex) {};
|
|
/**
|
|
* @param {Protocol.WebAudio.GraphObjectId} contextId
|
|
* @param {Protocol.WebAudio.GraphObjectId} sourceId
|
|
* @param {Protocol.WebAudio.GraphObjectId} destinationId
|
|
* @param {number=} opt_sourceOutputIndex
|
|
*/
|
|
Protocol.WebAudioDispatcher.prototype.nodeParamDisconnected = function(contextId, sourceId, destinationId, opt_sourceOutputIndex) {};
|
|
Protocol.WebAuthn = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.WebAuthnAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.WebAuthnAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.WebAuthnAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.WebAuthnAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.WebAuthnAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.WebAuthnAgent.EnableResponse>} */
|
|
Protocol.WebAuthnAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.WebAuthnAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.WebAuthnAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.WebAuthnAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.WebAuthnAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.WebAuthnAgent.DisableResponse>} */
|
|
Protocol.WebAuthnAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.WebAuthn.VirtualAuthenticatorOptions} options
|
|
* @return {!Promise<?Protocol.WebAuthn.AuthenticatorId>}
|
|
*/
|
|
Protocol.WebAuthnAgent.prototype.addVirtualAuthenticator = function(options) {};
|
|
/** @typedef {!{options: Protocol.WebAuthn.VirtualAuthenticatorOptions}} */
|
|
Protocol.WebAuthnAgent.AddVirtualAuthenticatorRequest;
|
|
/** @typedef {!{authenticatorId: Protocol.WebAuthn.AuthenticatorId}} */
|
|
Protocol.WebAuthnAgent.AddVirtualAuthenticatorResponse;
|
|
/**
|
|
* @param {!Protocol.WebAuthnAgent.AddVirtualAuthenticatorRequest} obj
|
|
* @return {!Promise<!Protocol.WebAuthnAgent.AddVirtualAuthenticatorResponse>} */
|
|
Protocol.WebAuthnAgent.prototype.invoke_addVirtualAuthenticator = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.WebAuthn.AuthenticatorId} authenticatorId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.WebAuthnAgent.prototype.removeVirtualAuthenticator = function(authenticatorId) {};
|
|
/** @typedef {!{authenticatorId: Protocol.WebAuthn.AuthenticatorId}} */
|
|
Protocol.WebAuthnAgent.RemoveVirtualAuthenticatorRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.WebAuthnAgent.RemoveVirtualAuthenticatorResponse;
|
|
/**
|
|
* @param {!Protocol.WebAuthnAgent.RemoveVirtualAuthenticatorRequest} obj
|
|
* @return {!Promise<!Protocol.WebAuthnAgent.RemoveVirtualAuthenticatorResponse>} */
|
|
Protocol.WebAuthnAgent.prototype.invoke_removeVirtualAuthenticator = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.WebAuthn.AuthenticatorId} authenticatorId
|
|
* @param {Protocol.WebAuthn.Credential} credential
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.WebAuthnAgent.prototype.addCredential = function(authenticatorId, credential) {};
|
|
/** @typedef {!{authenticatorId: Protocol.WebAuthn.AuthenticatorId, credential: Protocol.WebAuthn.Credential}} */
|
|
Protocol.WebAuthnAgent.AddCredentialRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.WebAuthnAgent.AddCredentialResponse;
|
|
/**
|
|
* @param {!Protocol.WebAuthnAgent.AddCredentialRequest} obj
|
|
* @return {!Promise<!Protocol.WebAuthnAgent.AddCredentialResponse>} */
|
|
Protocol.WebAuthnAgent.prototype.invoke_addCredential = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.WebAuthn.AuthenticatorId} authenticatorId
|
|
* @param {string} credentialId
|
|
* @return {!Promise<?Protocol.WebAuthn.Credential>}
|
|
*/
|
|
Protocol.WebAuthnAgent.prototype.getCredential = function(authenticatorId, credentialId) {};
|
|
/** @typedef {!{credentialId: string, authenticatorId: Protocol.WebAuthn.AuthenticatorId}} */
|
|
Protocol.WebAuthnAgent.GetCredentialRequest;
|
|
/** @typedef {!{credential: Protocol.WebAuthn.Credential}} */
|
|
Protocol.WebAuthnAgent.GetCredentialResponse;
|
|
/**
|
|
* @param {!Protocol.WebAuthnAgent.GetCredentialRequest} obj
|
|
* @return {!Promise<!Protocol.WebAuthnAgent.GetCredentialResponse>} */
|
|
Protocol.WebAuthnAgent.prototype.invoke_getCredential = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.WebAuthn.AuthenticatorId} authenticatorId
|
|
* @return {!Promise<?Array<Protocol.WebAuthn.Credential>>}
|
|
*/
|
|
Protocol.WebAuthnAgent.prototype.getCredentials = function(authenticatorId) {};
|
|
/** @typedef {!{authenticatorId: Protocol.WebAuthn.AuthenticatorId}} */
|
|
Protocol.WebAuthnAgent.GetCredentialsRequest;
|
|
/** @typedef {!{credentials: !Array<Protocol.WebAuthn.Credential>}} */
|
|
Protocol.WebAuthnAgent.GetCredentialsResponse;
|
|
/**
|
|
* @param {!Protocol.WebAuthnAgent.GetCredentialsRequest} obj
|
|
* @return {!Promise<!Protocol.WebAuthnAgent.GetCredentialsResponse>} */
|
|
Protocol.WebAuthnAgent.prototype.invoke_getCredentials = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.WebAuthn.AuthenticatorId} authenticatorId
|
|
* @param {string} credentialId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.WebAuthnAgent.prototype.removeCredential = function(authenticatorId, credentialId) {};
|
|
/** @typedef {!{credentialId: string, authenticatorId: Protocol.WebAuthn.AuthenticatorId}} */
|
|
Protocol.WebAuthnAgent.RemoveCredentialRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.WebAuthnAgent.RemoveCredentialResponse;
|
|
/**
|
|
* @param {!Protocol.WebAuthnAgent.RemoveCredentialRequest} obj
|
|
* @return {!Promise<!Protocol.WebAuthnAgent.RemoveCredentialResponse>} */
|
|
Protocol.WebAuthnAgent.prototype.invoke_removeCredential = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.WebAuthn.AuthenticatorId} authenticatorId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.WebAuthnAgent.prototype.clearCredentials = function(authenticatorId) {};
|
|
/** @typedef {!{authenticatorId: Protocol.WebAuthn.AuthenticatorId}} */
|
|
Protocol.WebAuthnAgent.ClearCredentialsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.WebAuthnAgent.ClearCredentialsResponse;
|
|
/**
|
|
* @param {!Protocol.WebAuthnAgent.ClearCredentialsRequest} obj
|
|
* @return {!Promise<!Protocol.WebAuthnAgent.ClearCredentialsResponse>} */
|
|
Protocol.WebAuthnAgent.prototype.invoke_clearCredentials = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.WebAuthn.AuthenticatorId} authenticatorId
|
|
* @param {boolean} isUserVerified
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.WebAuthnAgent.prototype.setUserVerified = function(authenticatorId, isUserVerified) {};
|
|
/** @typedef {!{authenticatorId: Protocol.WebAuthn.AuthenticatorId, isUserVerified: boolean}} */
|
|
Protocol.WebAuthnAgent.SetUserVerifiedRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.WebAuthnAgent.SetUserVerifiedResponse;
|
|
/**
|
|
* @param {!Protocol.WebAuthnAgent.SetUserVerifiedRequest} obj
|
|
* @return {!Promise<!Protocol.WebAuthnAgent.SetUserVerifiedResponse>} */
|
|
Protocol.WebAuthnAgent.prototype.invoke_setUserVerified = function(obj) {};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.WebAuthn.AuthenticatorId;
|
|
|
|
/** @enum {string} */
|
|
Protocol.WebAuthn.AuthenticatorProtocol = {
|
|
U2f: "u2f",
|
|
Ctap2: "ctap2"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.WebAuthn.AuthenticatorTransport = {
|
|
Usb: "usb",
|
|
Nfc: "nfc",
|
|
Ble: "ble",
|
|
Cable: "cable",
|
|
Internal: "internal"
|
|
};
|
|
|
|
/** @typedef {!{protocol:(Protocol.WebAuthn.AuthenticatorProtocol), transport:(Protocol.WebAuthn.AuthenticatorTransport), hasResidentKey:(boolean|undefined), hasUserVerification:(boolean|undefined), automaticPresenceSimulation:(boolean|undefined), isUserVerified:(boolean|undefined)}} */
|
|
Protocol.WebAuthn.VirtualAuthenticatorOptions;
|
|
|
|
/** @typedef {!{credentialId:(string), isResidentCredential:(boolean), rpId:(string|undefined), privateKey:(string), userHandle:(string|undefined), signCount:(number)}} */
|
|
Protocol.WebAuthn.Credential;
|
|
/** @interface */
|
|
Protocol.WebAuthnDispatcher = function() {};
|
|
Protocol.Media = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.MediaAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.MediaAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MediaAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MediaAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.MediaAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.MediaAgent.EnableResponse>} */
|
|
Protocol.MediaAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.MediaAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MediaAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.MediaAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.MediaAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.MediaAgent.DisableResponse>} */
|
|
Protocol.MediaAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Media.PlayerId;
|
|
|
|
/** @typedef {number} */
|
|
Protocol.Media.Timestamp;
|
|
|
|
/** @typedef {!{name:(string), value:(string|undefined)}} */
|
|
Protocol.Media.PlayerProperty;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Media.PlayerEventType = {
|
|
PlaybackEvent: "playbackEvent",
|
|
SystemEvent: "systemEvent",
|
|
MessageEvent: "messageEvent"
|
|
};
|
|
|
|
/** @typedef {!{type:(Protocol.Media.PlayerEventType), timestamp:(Protocol.Media.Timestamp), name:(string), value:(string)}} */
|
|
Protocol.Media.PlayerEvent;
|
|
/** @interface */
|
|
Protocol.MediaDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.Media.PlayerId} playerId
|
|
* @param {!Array<Protocol.Media.PlayerProperty>} properties
|
|
*/
|
|
Protocol.MediaDispatcher.prototype.playerPropertiesChanged = function(playerId, properties) {};
|
|
/**
|
|
* @param {Protocol.Media.PlayerId} playerId
|
|
* @param {!Array<Protocol.Media.PlayerEvent>} events
|
|
*/
|
|
Protocol.MediaDispatcher.prototype.playerEventsAdded = function(playerId, events) {};
|
|
/**
|
|
* @param {!Array<Protocol.Media.PlayerId>} players
|
|
*/
|
|
Protocol.MediaDispatcher.prototype.playersCreated = function(players) {};
|
|
Protocol.Console = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.ConsoleAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ConsoleAgent.prototype.clearMessages = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ConsoleAgent.ClearMessagesRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ConsoleAgent.ClearMessagesResponse;
|
|
/**
|
|
* @param {!Protocol.ConsoleAgent.ClearMessagesRequest} obj
|
|
* @return {!Promise<!Protocol.ConsoleAgent.ClearMessagesResponse>} */
|
|
Protocol.ConsoleAgent.prototype.invoke_clearMessages = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ConsoleAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ConsoleAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ConsoleAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.ConsoleAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.ConsoleAgent.DisableResponse>} */
|
|
Protocol.ConsoleAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ConsoleAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ConsoleAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ConsoleAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.ConsoleAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.ConsoleAgent.EnableResponse>} */
|
|
Protocol.ConsoleAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Console.ConsoleMessageSource = {
|
|
XML: "xml",
|
|
Javascript: "javascript",
|
|
Network: "network",
|
|
ConsoleAPI: "console-api",
|
|
Storage: "storage",
|
|
Appcache: "appcache",
|
|
Rendering: "rendering",
|
|
Security: "security",
|
|
Other: "other",
|
|
Deprecation: "deprecation",
|
|
Worker: "worker"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Console.ConsoleMessageLevel = {
|
|
Log: "log",
|
|
Warning: "warning",
|
|
Error: "error",
|
|
Debug: "debug",
|
|
Info: "info"
|
|
};
|
|
|
|
/** @typedef {!{source:(Protocol.Console.ConsoleMessageSource), level:(Protocol.Console.ConsoleMessageLevel), text:(string), url:(string|undefined), line:(number|undefined), column:(number|undefined)}} */
|
|
Protocol.Console.ConsoleMessage;
|
|
/** @interface */
|
|
Protocol.ConsoleDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.Console.ConsoleMessage} message
|
|
*/
|
|
Protocol.ConsoleDispatcher.prototype.messageAdded = function(message) {};
|
|
Protocol.Debugger = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.DebuggerAgent = function(){};
|
|
|
|
/**
|
|
* @param {Protocol.Debugger.Location} location
|
|
* @param {string=} opt_targetCallFrames
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.continueToLocation = function(location, opt_targetCallFrames) {};
|
|
/** @typedef {!{location: Protocol.Debugger.Location, targetCallFrames: (string|undefined)}} */
|
|
Protocol.DebuggerAgent.ContinueToLocationRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.ContinueToLocationResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.ContinueToLocationRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.ContinueToLocationResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_continueToLocation = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.DisableResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @param {number=} opt_maxScriptsCacheSize
|
|
* @return {!Promise<?Protocol.Runtime.UniqueDebuggerId>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.enable = function(opt_maxScriptsCacheSize) {};
|
|
/** @typedef {!{maxScriptsCacheSize: (number|undefined)}} */
|
|
Protocol.DebuggerAgent.EnableRequest;
|
|
/** @typedef {!{debuggerId: Protocol.Runtime.UniqueDebuggerId}} */
|
|
Protocol.DebuggerAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.EnableResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Debugger.CallFrameId} callFrameId
|
|
* @param {string} expression
|
|
* @param {string=} opt_objectGroup
|
|
* @param {boolean=} opt_includeCommandLineAPI
|
|
* @param {boolean=} opt_silent
|
|
* @param {boolean=} opt_returnByValue
|
|
* @param {boolean=} opt_generatePreview
|
|
* @param {boolean=} opt_throwOnSideEffect
|
|
* @param {Protocol.Runtime.TimeDelta=} opt_timeout
|
|
* @return {!Promise<?Protocol.Runtime.RemoteObject>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.evaluateOnCallFrame = function(callFrameId, expression, opt_objectGroup, opt_includeCommandLineAPI, opt_silent, opt_returnByValue, opt_generatePreview, opt_throwOnSideEffect, opt_timeout) {};
|
|
/** @typedef {!{objectGroup: (string|undefined), includeCommandLineAPI: (boolean|undefined), silent: (boolean|undefined), throwOnSideEffect: (boolean|undefined), generatePreview: (boolean|undefined), returnByValue: (boolean|undefined), callFrameId: Protocol.Debugger.CallFrameId, timeout: (Protocol.Runtime.TimeDelta|undefined), expression: string}} */
|
|
Protocol.DebuggerAgent.EvaluateOnCallFrameRequest;
|
|
/** @typedef {!{exceptionDetails: Protocol.Runtime.ExceptionDetails, result: Protocol.Runtime.RemoteObject}} */
|
|
Protocol.DebuggerAgent.EvaluateOnCallFrameResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.EvaluateOnCallFrameRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.EvaluateOnCallFrameResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_evaluateOnCallFrame = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Debugger.Location} start
|
|
* @param {Protocol.Debugger.Location=} opt_end
|
|
* @param {boolean=} opt_restrictToFunction
|
|
* @return {!Promise<?Array<Protocol.Debugger.BreakLocation>>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.getPossibleBreakpoints = function(start, opt_end, opt_restrictToFunction) {};
|
|
/** @typedef {!{start: Protocol.Debugger.Location, end: (Protocol.Debugger.Location|undefined), restrictToFunction: (boolean|undefined)}} */
|
|
Protocol.DebuggerAgent.GetPossibleBreakpointsRequest;
|
|
/** @typedef {!{locations: !Array<Protocol.Debugger.BreakLocation>}} */
|
|
Protocol.DebuggerAgent.GetPossibleBreakpointsResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.GetPossibleBreakpointsRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.GetPossibleBreakpointsResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_getPossibleBreakpoints = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.ScriptId} scriptId
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.getScriptSource = function(scriptId) {};
|
|
/** @typedef {!{scriptId: Protocol.Runtime.ScriptId}} */
|
|
Protocol.DebuggerAgent.GetScriptSourceRequest;
|
|
/** @typedef {!{scriptSource: string}} */
|
|
Protocol.DebuggerAgent.GetScriptSourceResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.GetScriptSourceRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.GetScriptSourceResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_getScriptSource = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.ScriptId} scriptId
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.getWasmBytecode = function(scriptId) {};
|
|
/** @typedef {!{scriptId: Protocol.Runtime.ScriptId}} */
|
|
Protocol.DebuggerAgent.GetWasmBytecodeRequest;
|
|
/** @typedef {!{bytecode: string}} */
|
|
Protocol.DebuggerAgent.GetWasmBytecodeResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.GetWasmBytecodeRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.GetWasmBytecodeResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_getWasmBytecode = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.StackTraceId} stackTraceId
|
|
* @return {!Promise<?Protocol.Runtime.StackTrace>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.getStackTrace = function(stackTraceId) {};
|
|
/** @typedef {!{stackTraceId: Protocol.Runtime.StackTraceId}} */
|
|
Protocol.DebuggerAgent.GetStackTraceRequest;
|
|
/** @typedef {!{stackTrace: Protocol.Runtime.StackTrace}} */
|
|
Protocol.DebuggerAgent.GetStackTraceResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.GetStackTraceRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.GetStackTraceResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_getStackTrace = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.pause = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.PauseRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.PauseResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.PauseRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.PauseResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_pause = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.StackTraceId} parentStackTraceId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.pauseOnAsyncCall = function(parentStackTraceId) {};
|
|
/** @typedef {!{parentStackTraceId: Protocol.Runtime.StackTraceId}} */
|
|
Protocol.DebuggerAgent.PauseOnAsyncCallRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.PauseOnAsyncCallResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.PauseOnAsyncCallRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.PauseOnAsyncCallResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_pauseOnAsyncCall = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Debugger.BreakpointId} breakpointId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.removeBreakpoint = function(breakpointId) {};
|
|
/** @typedef {!{breakpointId: Protocol.Debugger.BreakpointId}} */
|
|
Protocol.DebuggerAgent.RemoveBreakpointRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.RemoveBreakpointResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.RemoveBreakpointRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.RemoveBreakpointResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_removeBreakpoint = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Debugger.CallFrameId} callFrameId
|
|
* @return {!Promise<?Array<Protocol.Debugger.CallFrame>>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.restartFrame = function(callFrameId) {};
|
|
/** @typedef {!{callFrameId: Protocol.Debugger.CallFrameId}} */
|
|
Protocol.DebuggerAgent.RestartFrameRequest;
|
|
/** @typedef {!{asyncStackTrace: Protocol.Runtime.StackTrace, asyncStackTraceId: Protocol.Runtime.StackTraceId, callFrames: !Array<Protocol.Debugger.CallFrame>}} */
|
|
Protocol.DebuggerAgent.RestartFrameResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.RestartFrameRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.RestartFrameResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_restartFrame = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.resume = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.ResumeRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.ResumeResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.ResumeRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.ResumeResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_resume = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.ScriptId} scriptId
|
|
* @param {string} query
|
|
* @param {boolean=} opt_caseSensitive
|
|
* @param {boolean=} opt_isRegex
|
|
* @return {!Promise<?Array<Protocol.Debugger.SearchMatch>>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.searchInContent = function(scriptId, query, opt_caseSensitive, opt_isRegex) {};
|
|
/** @typedef {!{query: string, scriptId: Protocol.Runtime.ScriptId, isRegex: (boolean|undefined), caseSensitive: (boolean|undefined)}} */
|
|
Protocol.DebuggerAgent.SearchInContentRequest;
|
|
/** @typedef {!{result: !Array<Protocol.Debugger.SearchMatch>}} */
|
|
Protocol.DebuggerAgent.SearchInContentResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.SearchInContentRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.SearchInContentResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_searchInContent = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} maxDepth
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.setAsyncCallStackDepth = function(maxDepth) {};
|
|
/** @typedef {!{maxDepth: number}} */
|
|
Protocol.DebuggerAgent.SetAsyncCallStackDepthRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.SetAsyncCallStackDepthResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.SetAsyncCallStackDepthRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.SetAsyncCallStackDepthResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_setAsyncCallStackDepth = function(obj) {};
|
|
|
|
/**
|
|
* @param {!Array<string>} patterns
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.setBlackboxPatterns = function(patterns) {};
|
|
/** @typedef {!{patterns: !Array<string>}} */
|
|
Protocol.DebuggerAgent.SetBlackboxPatternsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.SetBlackboxPatternsResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.SetBlackboxPatternsRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.SetBlackboxPatternsResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_setBlackboxPatterns = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.ScriptId} scriptId
|
|
* @param {!Array<Protocol.Debugger.ScriptPosition>} positions
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.setBlackboxedRanges = function(scriptId, positions) {};
|
|
/** @typedef {!{positions: !Array<Protocol.Debugger.ScriptPosition>, scriptId: Protocol.Runtime.ScriptId}} */
|
|
Protocol.DebuggerAgent.SetBlackboxedRangesRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.SetBlackboxedRangesResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.SetBlackboxedRangesRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.SetBlackboxedRangesResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_setBlackboxedRanges = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Debugger.Location} location
|
|
* @param {string=} opt_condition
|
|
* @return {!Promise<?Protocol.Debugger.BreakpointId>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.setBreakpoint = function(location, opt_condition) {};
|
|
/** @typedef {!{location: Protocol.Debugger.Location, condition: (string|undefined)}} */
|
|
Protocol.DebuggerAgent.SetBreakpointRequest;
|
|
/** @typedef {!{actualLocation: Protocol.Debugger.Location, breakpointId: Protocol.Debugger.BreakpointId}} */
|
|
Protocol.DebuggerAgent.SetBreakpointResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.SetBreakpointRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.SetBreakpointResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_setBreakpoint = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} instrumentation
|
|
* @return {!Promise<?Protocol.Debugger.BreakpointId>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.setInstrumentationBreakpoint = function(instrumentation) {};
|
|
/** @typedef {!{instrumentation: string}} */
|
|
Protocol.DebuggerAgent.SetInstrumentationBreakpointRequest;
|
|
/** @typedef {!{breakpointId: Protocol.Debugger.BreakpointId}} */
|
|
Protocol.DebuggerAgent.SetInstrumentationBreakpointResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.SetInstrumentationBreakpointRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.SetInstrumentationBreakpointResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_setInstrumentationBreakpoint = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} lineNumber
|
|
* @param {string=} opt_url
|
|
* @param {string=} opt_urlRegex
|
|
* @param {string=} opt_scriptHash
|
|
* @param {number=} opt_columnNumber
|
|
* @param {string=} opt_condition
|
|
* @return {!Promise<?Protocol.Debugger.BreakpointId>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.setBreakpointByUrl = function(lineNumber, opt_url, opt_urlRegex, opt_scriptHash, opt_columnNumber, opt_condition) {};
|
|
/** @typedef {!{columnNumber: (number|undefined), urlRegex: (string|undefined), url: (string|undefined), lineNumber: number, scriptHash: (string|undefined), condition: (string|undefined)}} */
|
|
Protocol.DebuggerAgent.SetBreakpointByUrlRequest;
|
|
/** @typedef {!{breakpointId: Protocol.Debugger.BreakpointId, locations: !Array<Protocol.Debugger.Location>}} */
|
|
Protocol.DebuggerAgent.SetBreakpointByUrlResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.SetBreakpointByUrlRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.SetBreakpointByUrlResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_setBreakpointByUrl = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.RemoteObjectId} objectId
|
|
* @param {string=} opt_condition
|
|
* @return {!Promise<?Protocol.Debugger.BreakpointId>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.setBreakpointOnFunctionCall = function(objectId, opt_condition) {};
|
|
/** @typedef {!{condition: (string|undefined), objectId: Protocol.Runtime.RemoteObjectId}} */
|
|
Protocol.DebuggerAgent.SetBreakpointOnFunctionCallRequest;
|
|
/** @typedef {!{breakpointId: Protocol.Debugger.BreakpointId}} */
|
|
Protocol.DebuggerAgent.SetBreakpointOnFunctionCallResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.SetBreakpointOnFunctionCallRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.SetBreakpointOnFunctionCallResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_setBreakpointOnFunctionCall = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} active
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.setBreakpointsActive = function(active) {};
|
|
/** @typedef {!{active: boolean}} */
|
|
Protocol.DebuggerAgent.SetBreakpointsActiveRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.SetBreakpointsActiveResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.SetBreakpointsActiveRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.SetBreakpointsActiveResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_setBreakpointsActive = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} state
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.setPauseOnExceptions = function(state) {};
|
|
/** @typedef {!{state: string}} */
|
|
Protocol.DebuggerAgent.SetPauseOnExceptionsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.SetPauseOnExceptionsResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.SetPauseOnExceptionsRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.SetPauseOnExceptionsResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_setPauseOnExceptions = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.CallArgument} newValue
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.setReturnValue = function(newValue) {};
|
|
/** @typedef {!{newValue: Protocol.Runtime.CallArgument}} */
|
|
Protocol.DebuggerAgent.SetReturnValueRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.SetReturnValueResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.SetReturnValueRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.SetReturnValueResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_setReturnValue = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.ScriptId} scriptId
|
|
* @param {string} scriptSource
|
|
* @param {boolean=} opt_dryRun
|
|
* @return {!Promise<?Array<Protocol.Debugger.CallFrame>>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.setScriptSource = function(scriptId, scriptSource, opt_dryRun) {};
|
|
/** @typedef {!{scriptId: Protocol.Runtime.ScriptId, dryRun: (boolean|undefined), scriptSource: string}} */
|
|
Protocol.DebuggerAgent.SetScriptSourceRequest;
|
|
/** @typedef {!{stackChanged: boolean, asyncStackTrace: Protocol.Runtime.StackTrace, exceptionDetails: Protocol.Runtime.ExceptionDetails, callFrames: !Array<Protocol.Debugger.CallFrame>, asyncStackTraceId: Protocol.Runtime.StackTraceId}} */
|
|
Protocol.DebuggerAgent.SetScriptSourceResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.SetScriptSourceRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.SetScriptSourceResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_setScriptSource = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} skip
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.setSkipAllPauses = function(skip) {};
|
|
/** @typedef {!{skip: boolean}} */
|
|
Protocol.DebuggerAgent.SetSkipAllPausesRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.SetSkipAllPausesResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.SetSkipAllPausesRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.SetSkipAllPausesResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_setSkipAllPauses = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} scopeNumber
|
|
* @param {string} variableName
|
|
* @param {Protocol.Runtime.CallArgument} newValue
|
|
* @param {Protocol.Debugger.CallFrameId} callFrameId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.setVariableValue = function(scopeNumber, variableName, newValue, callFrameId) {};
|
|
/** @typedef {!{callFrameId: Protocol.Debugger.CallFrameId, scopeNumber: number, variableName: string, newValue: Protocol.Runtime.CallArgument}} */
|
|
Protocol.DebuggerAgent.SetVariableValueRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.SetVariableValueResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.SetVariableValueRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.SetVariableValueResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_setVariableValue = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean=} opt_breakOnAsyncCall
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.stepInto = function(opt_breakOnAsyncCall) {};
|
|
/** @typedef {!{breakOnAsyncCall: (boolean|undefined)}} */
|
|
Protocol.DebuggerAgent.StepIntoRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.StepIntoResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.StepIntoRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.StepIntoResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_stepInto = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.stepOut = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.StepOutRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.StepOutResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.StepOutRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.StepOutResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_stepOut = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.DebuggerAgent.prototype.stepOver = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.StepOverRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.DebuggerAgent.StepOverResponse;
|
|
/**
|
|
* @param {!Protocol.DebuggerAgent.StepOverRequest} obj
|
|
* @return {!Promise<!Protocol.DebuggerAgent.StepOverResponse>} */
|
|
Protocol.DebuggerAgent.prototype.invoke_stepOver = function(obj) {};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Debugger.BreakpointId;
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Debugger.CallFrameId;
|
|
|
|
/** @typedef {!{scriptId:(Protocol.Runtime.ScriptId), lineNumber:(number), columnNumber:(number|undefined)}} */
|
|
Protocol.Debugger.Location;
|
|
|
|
/** @typedef {!{lineNumber:(number), columnNumber:(number)}} */
|
|
Protocol.Debugger.ScriptPosition;
|
|
|
|
/** @typedef {!{callFrameId:(Protocol.Debugger.CallFrameId), functionName:(string), functionLocation:(Protocol.Debugger.Location|undefined), location:(Protocol.Debugger.Location), url:(string), scopeChain:(!Array<Protocol.Debugger.Scope>), this:(Protocol.Runtime.RemoteObject), returnValue:(Protocol.Runtime.RemoteObject|undefined)}} */
|
|
Protocol.Debugger.CallFrame;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Debugger.ScopeType = {
|
|
Global: "global",
|
|
Local: "local",
|
|
With: "with",
|
|
Closure: "closure",
|
|
Catch: "catch",
|
|
Block: "block",
|
|
Script: "script",
|
|
Eval: "eval",
|
|
Module: "module"
|
|
};
|
|
|
|
/** @typedef {!{type:(Protocol.Debugger.ScopeType), object:(Protocol.Runtime.RemoteObject), name:(string|undefined), startLocation:(Protocol.Debugger.Location|undefined), endLocation:(Protocol.Debugger.Location|undefined)}} */
|
|
Protocol.Debugger.Scope;
|
|
|
|
/** @typedef {!{lineNumber:(number), lineContent:(string)}} */
|
|
Protocol.Debugger.SearchMatch;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Debugger.BreakLocationType = {
|
|
DebuggerStatement: "debuggerStatement",
|
|
Call: "call",
|
|
Return: "return"
|
|
};
|
|
|
|
/** @typedef {!{scriptId:(Protocol.Runtime.ScriptId), lineNumber:(number), columnNumber:(number|undefined), type:(Protocol.Debugger.BreakLocationType|undefined)}} */
|
|
Protocol.Debugger.BreakLocation;
|
|
/** @constructor */
|
|
Protocol.DebuggerDispatcher = function() {};
|
|
/**
|
|
* @param {Protocol.Debugger.BreakpointId} breakpointId
|
|
* @param {Protocol.Debugger.Location} location
|
|
*/
|
|
Protocol.DebuggerDispatcher.prototype.breakpointResolved = function(breakpointId, location) {};
|
|
/**
|
|
* @param {!Array<Protocol.Debugger.CallFrame>} callFrames
|
|
* @param {string} reason
|
|
* @param {!Object=} opt_data
|
|
* @param {!Array<string>=} opt_hitBreakpoints
|
|
* @param {Protocol.Runtime.StackTrace=} opt_asyncStackTrace
|
|
* @param {Protocol.Runtime.StackTraceId=} opt_asyncStackTraceId
|
|
* @param {Protocol.Runtime.StackTraceId=} opt_asyncCallStackTraceId
|
|
*/
|
|
Protocol.DebuggerDispatcher.prototype.paused = function(callFrames, reason, opt_data, opt_hitBreakpoints, opt_asyncStackTrace, opt_asyncStackTraceId, opt_asyncCallStackTraceId) {};
|
|
Protocol.DebuggerDispatcher.prototype.resumed = function() {};
|
|
/**
|
|
* @param {Protocol.Runtime.ScriptId} scriptId
|
|
* @param {string} url
|
|
* @param {number} startLine
|
|
* @param {number} startColumn
|
|
* @param {number} endLine
|
|
* @param {number} endColumn
|
|
* @param {Protocol.Runtime.ExecutionContextId} executionContextId
|
|
* @param {string} hash
|
|
* @param {!Object=} opt_executionContextAuxData
|
|
* @param {string=} opt_sourceMapURL
|
|
* @param {boolean=} opt_hasSourceURL
|
|
* @param {boolean=} opt_isModule
|
|
* @param {number=} opt_length
|
|
* @param {Protocol.Runtime.StackTrace=} opt_stackTrace
|
|
*/
|
|
Protocol.DebuggerDispatcher.prototype.scriptFailedToParse = function(scriptId, url, startLine, startColumn, endLine, endColumn, executionContextId, hash, opt_executionContextAuxData, opt_sourceMapURL, opt_hasSourceURL, opt_isModule, opt_length, opt_stackTrace) {};
|
|
/**
|
|
* @param {Protocol.Runtime.ScriptId} scriptId
|
|
* @param {string} url
|
|
* @param {number} startLine
|
|
* @param {number} startColumn
|
|
* @param {number} endLine
|
|
* @param {number} endColumn
|
|
* @param {Protocol.Runtime.ExecutionContextId} executionContextId
|
|
* @param {string} hash
|
|
* @param {!Object=} opt_executionContextAuxData
|
|
* @param {boolean=} opt_isLiveEdit
|
|
* @param {string=} opt_sourceMapURL
|
|
* @param {boolean=} opt_hasSourceURL
|
|
* @param {boolean=} opt_isModule
|
|
* @param {number=} opt_length
|
|
* @param {Protocol.Runtime.StackTrace=} opt_stackTrace
|
|
*/
|
|
Protocol.DebuggerDispatcher.prototype.scriptParsed = function(scriptId, url, startLine, startColumn, endLine, endColumn, executionContextId, hash, opt_executionContextAuxData, opt_isLiveEdit, opt_sourceMapURL, opt_hasSourceURL, opt_isModule, opt_length, opt_stackTrace) {};
|
|
Protocol.HeapProfiler = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.HeapProfilerAgent = function(){};
|
|
|
|
/**
|
|
* @param {Protocol.HeapProfiler.HeapSnapshotObjectId} heapObjectId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.HeapProfilerAgent.prototype.addInspectedHeapObject = function(heapObjectId) {};
|
|
/** @typedef {!{heapObjectId: Protocol.HeapProfiler.HeapSnapshotObjectId}} */
|
|
Protocol.HeapProfilerAgent.AddInspectedHeapObjectRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeapProfilerAgent.AddInspectedHeapObjectResponse;
|
|
/**
|
|
* @param {!Protocol.HeapProfilerAgent.AddInspectedHeapObjectRequest} obj
|
|
* @return {!Promise<!Protocol.HeapProfilerAgent.AddInspectedHeapObjectResponse>} */
|
|
Protocol.HeapProfilerAgent.prototype.invoke_addInspectedHeapObject = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.HeapProfilerAgent.prototype.collectGarbage = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeapProfilerAgent.CollectGarbageRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeapProfilerAgent.CollectGarbageResponse;
|
|
/**
|
|
* @param {!Protocol.HeapProfilerAgent.CollectGarbageRequest} obj
|
|
* @return {!Promise<!Protocol.HeapProfilerAgent.CollectGarbageResponse>} */
|
|
Protocol.HeapProfilerAgent.prototype.invoke_collectGarbage = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.HeapProfilerAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeapProfilerAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeapProfilerAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.HeapProfilerAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.HeapProfilerAgent.DisableResponse>} */
|
|
Protocol.HeapProfilerAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.HeapProfilerAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeapProfilerAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeapProfilerAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.HeapProfilerAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.HeapProfilerAgent.EnableResponse>} */
|
|
Protocol.HeapProfilerAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.RemoteObjectId} objectId
|
|
* @return {!Promise<?Protocol.HeapProfiler.HeapSnapshotObjectId>}
|
|
*/
|
|
Protocol.HeapProfilerAgent.prototype.getHeapObjectId = function(objectId) {};
|
|
/** @typedef {!{objectId: Protocol.Runtime.RemoteObjectId}} */
|
|
Protocol.HeapProfilerAgent.GetHeapObjectIdRequest;
|
|
/** @typedef {!{heapSnapshotObjectId: Protocol.HeapProfiler.HeapSnapshotObjectId}} */
|
|
Protocol.HeapProfilerAgent.GetHeapObjectIdResponse;
|
|
/**
|
|
* @param {!Protocol.HeapProfilerAgent.GetHeapObjectIdRequest} obj
|
|
* @return {!Promise<!Protocol.HeapProfilerAgent.GetHeapObjectIdResponse>} */
|
|
Protocol.HeapProfilerAgent.prototype.invoke_getHeapObjectId = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.HeapProfiler.HeapSnapshotObjectId} objectId
|
|
* @param {string=} opt_objectGroup
|
|
* @return {!Promise<?Protocol.Runtime.RemoteObject>}
|
|
*/
|
|
Protocol.HeapProfilerAgent.prototype.getObjectByHeapObjectId = function(objectId, opt_objectGroup) {};
|
|
/** @typedef {!{objectGroup: (string|undefined), objectId: Protocol.HeapProfiler.HeapSnapshotObjectId}} */
|
|
Protocol.HeapProfilerAgent.GetObjectByHeapObjectIdRequest;
|
|
/** @typedef {!{result: Protocol.Runtime.RemoteObject}} */
|
|
Protocol.HeapProfilerAgent.GetObjectByHeapObjectIdResponse;
|
|
/**
|
|
* @param {!Protocol.HeapProfilerAgent.GetObjectByHeapObjectIdRequest} obj
|
|
* @return {!Promise<!Protocol.HeapProfilerAgent.GetObjectByHeapObjectIdResponse>} */
|
|
Protocol.HeapProfilerAgent.prototype.invoke_getObjectByHeapObjectId = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Protocol.HeapProfiler.SamplingHeapProfile>}
|
|
*/
|
|
Protocol.HeapProfilerAgent.prototype.getSamplingProfile = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeapProfilerAgent.GetSamplingProfileRequest;
|
|
/** @typedef {!{profile: Protocol.HeapProfiler.SamplingHeapProfile}} */
|
|
Protocol.HeapProfilerAgent.GetSamplingProfileResponse;
|
|
/**
|
|
* @param {!Protocol.HeapProfilerAgent.GetSamplingProfileRequest} obj
|
|
* @return {!Promise<!Protocol.HeapProfilerAgent.GetSamplingProfileResponse>} */
|
|
Protocol.HeapProfilerAgent.prototype.invoke_getSamplingProfile = function(obj) {};
|
|
|
|
/**
|
|
* @param {number=} opt_samplingInterval
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.HeapProfilerAgent.prototype.startSampling = function(opt_samplingInterval) {};
|
|
/** @typedef {!{samplingInterval: (number|undefined)}} */
|
|
Protocol.HeapProfilerAgent.StartSamplingRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeapProfilerAgent.StartSamplingResponse;
|
|
/**
|
|
* @param {!Protocol.HeapProfilerAgent.StartSamplingRequest} obj
|
|
* @return {!Promise<!Protocol.HeapProfilerAgent.StartSamplingResponse>} */
|
|
Protocol.HeapProfilerAgent.prototype.invoke_startSampling = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean=} opt_trackAllocations
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.HeapProfilerAgent.prototype.startTrackingHeapObjects = function(opt_trackAllocations) {};
|
|
/** @typedef {!{trackAllocations: (boolean|undefined)}} */
|
|
Protocol.HeapProfilerAgent.StartTrackingHeapObjectsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeapProfilerAgent.StartTrackingHeapObjectsResponse;
|
|
/**
|
|
* @param {!Protocol.HeapProfilerAgent.StartTrackingHeapObjectsRequest} obj
|
|
* @return {!Promise<!Protocol.HeapProfilerAgent.StartTrackingHeapObjectsResponse>} */
|
|
Protocol.HeapProfilerAgent.prototype.invoke_startTrackingHeapObjects = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Protocol.HeapProfiler.SamplingHeapProfile>}
|
|
*/
|
|
Protocol.HeapProfilerAgent.prototype.stopSampling = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeapProfilerAgent.StopSamplingRequest;
|
|
/** @typedef {!{profile: Protocol.HeapProfiler.SamplingHeapProfile}} */
|
|
Protocol.HeapProfilerAgent.StopSamplingResponse;
|
|
/**
|
|
* @param {!Protocol.HeapProfilerAgent.StopSamplingRequest} obj
|
|
* @return {!Promise<!Protocol.HeapProfilerAgent.StopSamplingResponse>} */
|
|
Protocol.HeapProfilerAgent.prototype.invoke_stopSampling = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean=} opt_reportProgress
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.HeapProfilerAgent.prototype.stopTrackingHeapObjects = function(opt_reportProgress) {};
|
|
/** @typedef {!{reportProgress: (boolean|undefined)}} */
|
|
Protocol.HeapProfilerAgent.StopTrackingHeapObjectsRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeapProfilerAgent.StopTrackingHeapObjectsResponse;
|
|
/**
|
|
* @param {!Protocol.HeapProfilerAgent.StopTrackingHeapObjectsRequest} obj
|
|
* @return {!Promise<!Protocol.HeapProfilerAgent.StopTrackingHeapObjectsResponse>} */
|
|
Protocol.HeapProfilerAgent.prototype.invoke_stopTrackingHeapObjects = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean=} opt_reportProgress
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.HeapProfilerAgent.prototype.takeHeapSnapshot = function(opt_reportProgress) {};
|
|
/** @typedef {!{reportProgress: (boolean|undefined)}} */
|
|
Protocol.HeapProfilerAgent.TakeHeapSnapshotRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.HeapProfilerAgent.TakeHeapSnapshotResponse;
|
|
/**
|
|
* @param {!Protocol.HeapProfilerAgent.TakeHeapSnapshotRequest} obj
|
|
* @return {!Promise<!Protocol.HeapProfilerAgent.TakeHeapSnapshotResponse>} */
|
|
Protocol.HeapProfilerAgent.prototype.invoke_takeHeapSnapshot = function(obj) {};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.HeapProfiler.HeapSnapshotObjectId;
|
|
|
|
/** @typedef {!{callFrame:(Protocol.Runtime.CallFrame), selfSize:(number), id:(number), children:(!Array<Protocol.HeapProfiler.SamplingHeapProfileNode>)}} */
|
|
Protocol.HeapProfiler.SamplingHeapProfileNode;
|
|
|
|
/** @typedef {!{size:(number), nodeId:(number), ordinal:(number)}} */
|
|
Protocol.HeapProfiler.SamplingHeapProfileSample;
|
|
|
|
/** @typedef {!{head:(Protocol.HeapProfiler.SamplingHeapProfileNode), samples:(!Array<Protocol.HeapProfiler.SamplingHeapProfileSample>)}} */
|
|
Protocol.HeapProfiler.SamplingHeapProfile;
|
|
/** @constructor */
|
|
Protocol.HeapProfilerDispatcher = function() {};
|
|
/**
|
|
* @param {string} chunk
|
|
*/
|
|
Protocol.HeapProfilerDispatcher.prototype.addHeapSnapshotChunk = function(chunk) {};
|
|
/**
|
|
* @param {!Array<number>} statsUpdate
|
|
*/
|
|
Protocol.HeapProfilerDispatcher.prototype.heapStatsUpdate = function(statsUpdate) {};
|
|
/**
|
|
* @param {number} lastSeenObjectId
|
|
* @param {number} timestamp
|
|
*/
|
|
Protocol.HeapProfilerDispatcher.prototype.lastSeenObjectId = function(lastSeenObjectId, timestamp) {};
|
|
/**
|
|
* @param {number} done
|
|
* @param {number} total
|
|
* @param {boolean=} opt_finished
|
|
*/
|
|
Protocol.HeapProfilerDispatcher.prototype.reportHeapSnapshotProgress = function(done, total, opt_finished) {};
|
|
Protocol.HeapProfilerDispatcher.prototype.resetProfiles = function() {};
|
|
Protocol.Profiler = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.ProfilerAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ProfilerAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.ProfilerAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.ProfilerAgent.DisableResponse>} */
|
|
Protocol.ProfilerAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ProfilerAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.ProfilerAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.ProfilerAgent.EnableResponse>} */
|
|
Protocol.ProfilerAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<Protocol.Profiler.ScriptCoverage>>}
|
|
*/
|
|
Protocol.ProfilerAgent.prototype.getBestEffortCoverage = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.GetBestEffortCoverageRequest;
|
|
/** @typedef {!{result: !Array<Protocol.Profiler.ScriptCoverage>}} */
|
|
Protocol.ProfilerAgent.GetBestEffortCoverageResponse;
|
|
/**
|
|
* @param {!Protocol.ProfilerAgent.GetBestEffortCoverageRequest} obj
|
|
* @return {!Promise<!Protocol.ProfilerAgent.GetBestEffortCoverageResponse>} */
|
|
Protocol.ProfilerAgent.prototype.invoke_getBestEffortCoverage = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} interval
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ProfilerAgent.prototype.setSamplingInterval = function(interval) {};
|
|
/** @typedef {!{interval: number}} */
|
|
Protocol.ProfilerAgent.SetSamplingIntervalRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.SetSamplingIntervalResponse;
|
|
/**
|
|
* @param {!Protocol.ProfilerAgent.SetSamplingIntervalRequest} obj
|
|
* @return {!Promise<!Protocol.ProfilerAgent.SetSamplingIntervalResponse>} */
|
|
Protocol.ProfilerAgent.prototype.invoke_setSamplingInterval = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ProfilerAgent.prototype.start = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.StartRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.StartResponse;
|
|
/**
|
|
* @param {!Protocol.ProfilerAgent.StartRequest} obj
|
|
* @return {!Promise<!Protocol.ProfilerAgent.StartResponse>} */
|
|
Protocol.ProfilerAgent.prototype.invoke_start = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean=} opt_callCount
|
|
* @param {boolean=} opt_detailed
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ProfilerAgent.prototype.startPreciseCoverage = function(opt_callCount, opt_detailed) {};
|
|
/** @typedef {!{detailed: (boolean|undefined), callCount: (boolean|undefined)}} */
|
|
Protocol.ProfilerAgent.StartPreciseCoverageRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.StartPreciseCoverageResponse;
|
|
/**
|
|
* @param {!Protocol.ProfilerAgent.StartPreciseCoverageRequest} obj
|
|
* @return {!Promise<!Protocol.ProfilerAgent.StartPreciseCoverageResponse>} */
|
|
Protocol.ProfilerAgent.prototype.invoke_startPreciseCoverage = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ProfilerAgent.prototype.startTypeProfile = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.StartTypeProfileRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.StartTypeProfileResponse;
|
|
/**
|
|
* @param {!Protocol.ProfilerAgent.StartTypeProfileRequest} obj
|
|
* @return {!Promise<!Protocol.ProfilerAgent.StartTypeProfileResponse>} */
|
|
Protocol.ProfilerAgent.prototype.invoke_startTypeProfile = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Protocol.Profiler.Profile>}
|
|
*/
|
|
Protocol.ProfilerAgent.prototype.stop = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.StopRequest;
|
|
/** @typedef {!{profile: Protocol.Profiler.Profile}} */
|
|
Protocol.ProfilerAgent.StopResponse;
|
|
/**
|
|
* @param {!Protocol.ProfilerAgent.StopRequest} obj
|
|
* @return {!Promise<!Protocol.ProfilerAgent.StopResponse>} */
|
|
Protocol.ProfilerAgent.prototype.invoke_stop = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ProfilerAgent.prototype.stopPreciseCoverage = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.StopPreciseCoverageRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.StopPreciseCoverageResponse;
|
|
/**
|
|
* @param {!Protocol.ProfilerAgent.StopPreciseCoverageRequest} obj
|
|
* @return {!Promise<!Protocol.ProfilerAgent.StopPreciseCoverageResponse>} */
|
|
Protocol.ProfilerAgent.prototype.invoke_stopPreciseCoverage = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.ProfilerAgent.prototype.stopTypeProfile = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.StopTypeProfileRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.StopTypeProfileResponse;
|
|
/**
|
|
* @param {!Protocol.ProfilerAgent.StopTypeProfileRequest} obj
|
|
* @return {!Promise<!Protocol.ProfilerAgent.StopTypeProfileResponse>} */
|
|
Protocol.ProfilerAgent.prototype.invoke_stopTypeProfile = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<Protocol.Profiler.ScriptCoverage>>}
|
|
*/
|
|
Protocol.ProfilerAgent.prototype.takePreciseCoverage = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.TakePreciseCoverageRequest;
|
|
/** @typedef {!{result: !Array<Protocol.Profiler.ScriptCoverage>}} */
|
|
Protocol.ProfilerAgent.TakePreciseCoverageResponse;
|
|
/**
|
|
* @param {!Protocol.ProfilerAgent.TakePreciseCoverageRequest} obj
|
|
* @return {!Promise<!Protocol.ProfilerAgent.TakePreciseCoverageResponse>} */
|
|
Protocol.ProfilerAgent.prototype.invoke_takePreciseCoverage = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<Protocol.Profiler.ScriptTypeProfile>>}
|
|
*/
|
|
Protocol.ProfilerAgent.prototype.takeTypeProfile = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.ProfilerAgent.TakeTypeProfileRequest;
|
|
/** @typedef {!{result: !Array<Protocol.Profiler.ScriptTypeProfile>}} */
|
|
Protocol.ProfilerAgent.TakeTypeProfileResponse;
|
|
/**
|
|
* @param {!Protocol.ProfilerAgent.TakeTypeProfileRequest} obj
|
|
* @return {!Promise<!Protocol.ProfilerAgent.TakeTypeProfileResponse>} */
|
|
Protocol.ProfilerAgent.prototype.invoke_takeTypeProfile = function(obj) {};
|
|
|
|
/** @typedef {!{id:(number), callFrame:(Protocol.Runtime.CallFrame), hitCount:(number|undefined), children:(!Array<number>|undefined), deoptReason:(string|undefined), positionTicks:(!Array<Protocol.Profiler.PositionTickInfo>|undefined)}} */
|
|
Protocol.Profiler.ProfileNode;
|
|
|
|
/** @typedef {!{nodes:(!Array<Protocol.Profiler.ProfileNode>), startTime:(number), endTime:(number), samples:(!Array<number>|undefined), timeDeltas:(!Array<number>|undefined)}} */
|
|
Protocol.Profiler.Profile;
|
|
|
|
/** @typedef {!{line:(number), ticks:(number)}} */
|
|
Protocol.Profiler.PositionTickInfo;
|
|
|
|
/** @typedef {!{startOffset:(number), endOffset:(number), count:(number)}} */
|
|
Protocol.Profiler.CoverageRange;
|
|
|
|
/** @typedef {!{functionName:(string), ranges:(!Array<Protocol.Profiler.CoverageRange>), isBlockCoverage:(boolean)}} */
|
|
Protocol.Profiler.FunctionCoverage;
|
|
|
|
/** @typedef {!{scriptId:(Protocol.Runtime.ScriptId), url:(string), functions:(!Array<Protocol.Profiler.FunctionCoverage>)}} */
|
|
Protocol.Profiler.ScriptCoverage;
|
|
|
|
/** @typedef {!{name:(string)}} */
|
|
Protocol.Profiler.TypeObject;
|
|
|
|
/** @typedef {!{offset:(number), types:(!Array<Protocol.Profiler.TypeObject>)}} */
|
|
Protocol.Profiler.TypeProfileEntry;
|
|
|
|
/** @typedef {!{scriptId:(Protocol.Runtime.ScriptId), url:(string), entries:(!Array<Protocol.Profiler.TypeProfileEntry>)}} */
|
|
Protocol.Profiler.ScriptTypeProfile;
|
|
/** @interface */
|
|
Protocol.ProfilerDispatcher = function() {};
|
|
/**
|
|
* @param {string} id
|
|
* @param {Protocol.Debugger.Location} location
|
|
* @param {Protocol.Profiler.Profile} profile
|
|
* @param {string=} opt_title
|
|
*/
|
|
Protocol.ProfilerDispatcher.prototype.consoleProfileFinished = function(id, location, profile, opt_title) {};
|
|
/**
|
|
* @param {string} id
|
|
* @param {Protocol.Debugger.Location} location
|
|
* @param {string=} opt_title
|
|
*/
|
|
Protocol.ProfilerDispatcher.prototype.consoleProfileStarted = function(id, location, opt_title) {};
|
|
Protocol.Runtime = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.RuntimeAgent = function(){};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.RemoteObjectId} promiseObjectId
|
|
* @param {boolean=} opt_returnByValue
|
|
* @param {boolean=} opt_generatePreview
|
|
* @return {!Promise<?Protocol.Runtime.RemoteObject>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.awaitPromise = function(promiseObjectId, opt_returnByValue, opt_generatePreview) {};
|
|
/** @typedef {!{returnByValue: (boolean|undefined), generatePreview: (boolean|undefined), promiseObjectId: Protocol.Runtime.RemoteObjectId}} */
|
|
Protocol.RuntimeAgent.AwaitPromiseRequest;
|
|
/** @typedef {!{exceptionDetails: Protocol.Runtime.ExceptionDetails, result: Protocol.Runtime.RemoteObject}} */
|
|
Protocol.RuntimeAgent.AwaitPromiseResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.AwaitPromiseRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.AwaitPromiseResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_awaitPromise = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} functionDeclaration
|
|
* @param {Protocol.Runtime.RemoteObjectId=} opt_objectId
|
|
* @param {!Array<Protocol.Runtime.CallArgument>=} opt__arguments
|
|
* @param {boolean=} opt_silent
|
|
* @param {boolean=} opt_returnByValue
|
|
* @param {boolean=} opt_generatePreview
|
|
* @param {boolean=} opt_userGesture
|
|
* @param {boolean=} opt_awaitPromise
|
|
* @param {Protocol.Runtime.ExecutionContextId=} opt_executionContextId
|
|
* @param {string=} opt_objectGroup
|
|
* @return {!Promise<?Protocol.Runtime.RemoteObject>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.callFunctionOn = function(functionDeclaration, opt_objectId, opt__arguments, opt_silent, opt_returnByValue, opt_generatePreview, opt_userGesture, opt_awaitPromise, opt_executionContextId, opt_objectGroup) {};
|
|
/** @typedef {!{objectGroup: (string|undefined), silent: (boolean|undefined), objectId: (Protocol.Runtime.RemoteObjectId|undefined), functionDeclaration: string, generatePreview: (boolean|undefined), executionContextId: (Protocol.Runtime.ExecutionContextId|undefined), returnByValue: (boolean|undefined), _arguments: (!Array<Protocol.Runtime.CallArgument>|undefined), userGesture: (boolean|undefined), awaitPromise: (boolean|undefined)}} */
|
|
Protocol.RuntimeAgent.CallFunctionOnRequest;
|
|
/** @typedef {!{exceptionDetails: Protocol.Runtime.ExceptionDetails, result: Protocol.Runtime.RemoteObject}} */
|
|
Protocol.RuntimeAgent.CallFunctionOnResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.CallFunctionOnRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.CallFunctionOnResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_callFunctionOn = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} expression
|
|
* @param {string} sourceURL
|
|
* @param {boolean} persistScript
|
|
* @param {Protocol.Runtime.ExecutionContextId=} opt_executionContextId
|
|
* @return {!Promise<?Protocol.Runtime.ScriptId>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.compileScript = function(expression, sourceURL, persistScript, opt_executionContextId) {};
|
|
/** @typedef {!{persistScript: boolean, sourceURL: string, expression: string, executionContextId: (Protocol.Runtime.ExecutionContextId|undefined)}} */
|
|
Protocol.RuntimeAgent.CompileScriptRequest;
|
|
/** @typedef {!{scriptId: Protocol.Runtime.ScriptId, exceptionDetails: Protocol.Runtime.ExceptionDetails}} */
|
|
Protocol.RuntimeAgent.CompileScriptResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.CompileScriptRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.CompileScriptResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_compileScript = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.disable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.DisableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.DisableResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.DisableRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.DisableResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_disable = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.discardConsoleEntries = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.DiscardConsoleEntriesRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.DiscardConsoleEntriesResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.DiscardConsoleEntriesRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.DiscardConsoleEntriesResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_discardConsoleEntries = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.enable = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.EnableRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.EnableResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.EnableRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.EnableResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_enable = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} expression
|
|
* @param {string=} opt_objectGroup
|
|
* @param {boolean=} opt_includeCommandLineAPI
|
|
* @param {boolean=} opt_silent
|
|
* @param {Protocol.Runtime.ExecutionContextId=} opt_contextId
|
|
* @param {boolean=} opt_returnByValue
|
|
* @param {boolean=} opt_generatePreview
|
|
* @param {boolean=} opt_userGesture
|
|
* @param {boolean=} opt_awaitPromise
|
|
* @param {boolean=} opt_throwOnSideEffect
|
|
* @param {Protocol.Runtime.TimeDelta=} opt_timeout
|
|
* @param {boolean=} opt_disableBreaks
|
|
* @param {boolean=} opt_replMode
|
|
* @return {!Promise<?Protocol.Runtime.RemoteObject>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.evaluate = function(expression, opt_objectGroup, opt_includeCommandLineAPI, opt_silent, opt_contextId, opt_returnByValue, opt_generatePreview, opt_userGesture, opt_awaitPromise, opt_throwOnSideEffect, opt_timeout, opt_disableBreaks, opt_replMode) {};
|
|
/** @typedef {!{objectGroup: (string|undefined), includeCommandLineAPI: (boolean|undefined), contextId: (Protocol.Runtime.ExecutionContextId|undefined), silent: (boolean|undefined), throwOnSideEffect: (boolean|undefined), generatePreview: (boolean|undefined), replMode: (boolean|undefined), returnByValue: (boolean|undefined), timeout: (Protocol.Runtime.TimeDelta|undefined), expression: string, userGesture: (boolean|undefined), disableBreaks: (boolean|undefined), awaitPromise: (boolean|undefined)}} */
|
|
Protocol.RuntimeAgent.EvaluateRequest;
|
|
/** @typedef {!{exceptionDetails: Protocol.Runtime.ExceptionDetails, result: Protocol.Runtime.RemoteObject}} */
|
|
Protocol.RuntimeAgent.EvaluateResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.EvaluateRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.EvaluateResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_evaluate = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?string>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.getIsolateId = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.GetIsolateIdRequest;
|
|
/** @typedef {!{id: string}} */
|
|
Protocol.RuntimeAgent.GetIsolateIdResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.GetIsolateIdRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.GetIsolateIdResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_getIsolateId = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<?number>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.getHeapUsage = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.GetHeapUsageRequest;
|
|
/** @typedef {!{totalSize: number, usedSize: number}} */
|
|
Protocol.RuntimeAgent.GetHeapUsageResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.GetHeapUsageRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.GetHeapUsageResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_getHeapUsage = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.RemoteObjectId} objectId
|
|
* @param {boolean=} opt_ownProperties
|
|
* @param {boolean=} opt_accessorPropertiesOnly
|
|
* @param {boolean=} opt_generatePreview
|
|
* @return {!Promise<?Array<Protocol.Runtime.PropertyDescriptor>>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.getProperties = function(objectId, opt_ownProperties, opt_accessorPropertiesOnly, opt_generatePreview) {};
|
|
/** @typedef {!{ownProperties: (boolean|undefined), generatePreview: (boolean|undefined), accessorPropertiesOnly: (boolean|undefined), objectId: Protocol.Runtime.RemoteObjectId}} */
|
|
Protocol.RuntimeAgent.GetPropertiesRequest;
|
|
/** @typedef {!{internalProperties: !Array<Protocol.Runtime.InternalPropertyDescriptor>, exceptionDetails: Protocol.Runtime.ExceptionDetails, result: !Array<Protocol.Runtime.PropertyDescriptor>, privateProperties: !Array<Protocol.Runtime.PrivatePropertyDescriptor>}} */
|
|
Protocol.RuntimeAgent.GetPropertiesResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.GetPropertiesRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.GetPropertiesResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_getProperties = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.ExecutionContextId=} opt_executionContextId
|
|
* @return {!Promise<?Array<string>>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.globalLexicalScopeNames = function(opt_executionContextId) {};
|
|
/** @typedef {!{executionContextId: (Protocol.Runtime.ExecutionContextId|undefined)}} */
|
|
Protocol.RuntimeAgent.GlobalLexicalScopeNamesRequest;
|
|
/** @typedef {!{names: !Array<string>}} */
|
|
Protocol.RuntimeAgent.GlobalLexicalScopeNamesResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.GlobalLexicalScopeNamesRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.GlobalLexicalScopeNamesResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_globalLexicalScopeNames = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.RemoteObjectId} prototypeObjectId
|
|
* @param {string=} opt_objectGroup
|
|
* @return {!Promise<?Protocol.Runtime.RemoteObject>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.queryObjects = function(prototypeObjectId, opt_objectGroup) {};
|
|
/** @typedef {!{prototypeObjectId: Protocol.Runtime.RemoteObjectId, objectGroup: (string|undefined)}} */
|
|
Protocol.RuntimeAgent.QueryObjectsRequest;
|
|
/** @typedef {!{objects: Protocol.Runtime.RemoteObject}} */
|
|
Protocol.RuntimeAgent.QueryObjectsResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.QueryObjectsRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.QueryObjectsResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_queryObjects = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.RemoteObjectId} objectId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.releaseObject = function(objectId) {};
|
|
/** @typedef {!{objectId: Protocol.Runtime.RemoteObjectId}} */
|
|
Protocol.RuntimeAgent.ReleaseObjectRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.ReleaseObjectResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.ReleaseObjectRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.ReleaseObjectResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_releaseObject = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} objectGroup
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.releaseObjectGroup = function(objectGroup) {};
|
|
/** @typedef {!{objectGroup: string}} */
|
|
Protocol.RuntimeAgent.ReleaseObjectGroupRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.ReleaseObjectGroupResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.ReleaseObjectGroupRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.ReleaseObjectGroupResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_releaseObjectGroup = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.runIfWaitingForDebugger = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.RunIfWaitingForDebuggerRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.RunIfWaitingForDebuggerResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.RunIfWaitingForDebuggerRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.RunIfWaitingForDebuggerResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_runIfWaitingForDebugger = function(obj) {};
|
|
|
|
/**
|
|
* @param {Protocol.Runtime.ScriptId} scriptId
|
|
* @param {Protocol.Runtime.ExecutionContextId=} opt_executionContextId
|
|
* @param {string=} opt_objectGroup
|
|
* @param {boolean=} opt_silent
|
|
* @param {boolean=} opt_includeCommandLineAPI
|
|
* @param {boolean=} opt_returnByValue
|
|
* @param {boolean=} opt_generatePreview
|
|
* @param {boolean=} opt_awaitPromise
|
|
* @return {!Promise<?Protocol.Runtime.RemoteObject>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.runScript = function(scriptId, opt_executionContextId, opt_objectGroup, opt_silent, opt_includeCommandLineAPI, opt_returnByValue, opt_generatePreview, opt_awaitPromise) {};
|
|
/** @typedef {!{objectGroup: (string|undefined), includeCommandLineAPI: (boolean|undefined), silent: (boolean|undefined), generatePreview: (boolean|undefined), executionContextId: (Protocol.Runtime.ExecutionContextId|undefined), returnByValue: (boolean|undefined), scriptId: Protocol.Runtime.ScriptId, awaitPromise: (boolean|undefined)}} */
|
|
Protocol.RuntimeAgent.RunScriptRequest;
|
|
/** @typedef {!{exceptionDetails: Protocol.Runtime.ExceptionDetails, result: Protocol.Runtime.RemoteObject}} */
|
|
Protocol.RuntimeAgent.RunScriptResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.RunScriptRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.RunScriptResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_runScript = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} maxDepth
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.setAsyncCallStackDepth = function(maxDepth) {};
|
|
/** @typedef {!{maxDepth: number}} */
|
|
Protocol.RuntimeAgent.SetAsyncCallStackDepthRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.SetAsyncCallStackDepthResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.SetAsyncCallStackDepthRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.SetAsyncCallStackDepthResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_setAsyncCallStackDepth = function(obj) {};
|
|
|
|
/**
|
|
* @param {boolean} enabled
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.setCustomObjectFormatterEnabled = function(enabled) {};
|
|
/** @typedef {!{enabled: boolean}} */
|
|
Protocol.RuntimeAgent.SetCustomObjectFormatterEnabledRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.SetCustomObjectFormatterEnabledResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.SetCustomObjectFormatterEnabledRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.SetCustomObjectFormatterEnabledResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_setCustomObjectFormatterEnabled = function(obj) {};
|
|
|
|
/**
|
|
* @param {number} size
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.setMaxCallStackSizeToCapture = function(size) {};
|
|
/** @typedef {!{size: number}} */
|
|
Protocol.RuntimeAgent.SetMaxCallStackSizeToCaptureRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.SetMaxCallStackSizeToCaptureResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.SetMaxCallStackSizeToCaptureRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.SetMaxCallStackSizeToCaptureResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_setMaxCallStackSizeToCapture = function(obj) {};
|
|
|
|
/**
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.terminateExecution = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.TerminateExecutionRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.TerminateExecutionResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.TerminateExecutionRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.TerminateExecutionResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_terminateExecution = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} name
|
|
* @param {Protocol.Runtime.ExecutionContextId=} opt_executionContextId
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.addBinding = function(name, opt_executionContextId) {};
|
|
/** @typedef {!{name: string, executionContextId: (Protocol.Runtime.ExecutionContextId|undefined)}} */
|
|
Protocol.RuntimeAgent.AddBindingRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.AddBindingResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.AddBindingRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.AddBindingResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_addBinding = function(obj) {};
|
|
|
|
/**
|
|
* @param {string} name
|
|
* @return {!Promise<undefined>}
|
|
*/
|
|
Protocol.RuntimeAgent.prototype.removeBinding = function(name) {};
|
|
/** @typedef {!{name: string}} */
|
|
Protocol.RuntimeAgent.RemoveBindingRequest;
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.RuntimeAgent.RemoveBindingResponse;
|
|
/**
|
|
* @param {!Protocol.RuntimeAgent.RemoveBindingRequest} obj
|
|
* @return {!Promise<!Protocol.RuntimeAgent.RemoveBindingResponse>} */
|
|
Protocol.RuntimeAgent.prototype.invoke_removeBinding = function(obj) {};
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Runtime.ScriptId;
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Runtime.RemoteObjectId;
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Runtime.UnserializableValue;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Runtime.RemoteObjectType = {
|
|
Object: "object",
|
|
Function: "function",
|
|
Undefined: "undefined",
|
|
String: "string",
|
|
Number: "number",
|
|
Boolean: "boolean",
|
|
Symbol: "symbol",
|
|
Bigint: "bigint"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Runtime.RemoteObjectSubtype = {
|
|
Array: "array",
|
|
Null: "null",
|
|
Node: "node",
|
|
Regexp: "regexp",
|
|
Date: "date",
|
|
Map: "map",
|
|
Set: "set",
|
|
Weakmap: "weakmap",
|
|
Weakset: "weakset",
|
|
Iterator: "iterator",
|
|
Generator: "generator",
|
|
Error: "error",
|
|
Proxy: "proxy",
|
|
Promise: "promise",
|
|
Typedarray: "typedarray",
|
|
Arraybuffer: "arraybuffer",
|
|
Dataview: "dataview"
|
|
};
|
|
|
|
/** @typedef {!{type:(Protocol.Runtime.RemoteObjectType), subtype:(Protocol.Runtime.RemoteObjectSubtype|undefined), className:(string|undefined), value:(*|undefined), unserializableValue:(Protocol.Runtime.UnserializableValue|undefined), description:(string|undefined), objectId:(Protocol.Runtime.RemoteObjectId|undefined), preview:(Protocol.Runtime.ObjectPreview|undefined), customPreview:(Protocol.Runtime.CustomPreview|undefined)}} */
|
|
Protocol.Runtime.RemoteObject;
|
|
|
|
/** @typedef {!{header:(string), bodyGetterId:(Protocol.Runtime.RemoteObjectId|undefined)}} */
|
|
Protocol.Runtime.CustomPreview;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Runtime.ObjectPreviewType = {
|
|
Object: "object",
|
|
Function: "function",
|
|
Undefined: "undefined",
|
|
String: "string",
|
|
Number: "number",
|
|
Boolean: "boolean",
|
|
Symbol: "symbol",
|
|
Bigint: "bigint"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Runtime.ObjectPreviewSubtype = {
|
|
Array: "array",
|
|
Null: "null",
|
|
Node: "node",
|
|
Regexp: "regexp",
|
|
Date: "date",
|
|
Map: "map",
|
|
Set: "set",
|
|
Weakmap: "weakmap",
|
|
Weakset: "weakset",
|
|
Iterator: "iterator",
|
|
Generator: "generator",
|
|
Error: "error"
|
|
};
|
|
|
|
/** @typedef {!{type:(Protocol.Runtime.ObjectPreviewType), subtype:(Protocol.Runtime.ObjectPreviewSubtype|undefined), description:(string|undefined), overflow:(boolean), properties:(!Array<Protocol.Runtime.PropertyPreview>), entries:(!Array<Protocol.Runtime.EntryPreview>|undefined)}} */
|
|
Protocol.Runtime.ObjectPreview;
|
|
|
|
/** @enum {string} */
|
|
Protocol.Runtime.PropertyPreviewType = {
|
|
Object: "object",
|
|
Function: "function",
|
|
Undefined: "undefined",
|
|
String: "string",
|
|
Number: "number",
|
|
Boolean: "boolean",
|
|
Symbol: "symbol",
|
|
Accessor: "accessor",
|
|
Bigint: "bigint"
|
|
};
|
|
|
|
/** @enum {string} */
|
|
Protocol.Runtime.PropertyPreviewSubtype = {
|
|
Array: "array",
|
|
Null: "null",
|
|
Node: "node",
|
|
Regexp: "regexp",
|
|
Date: "date",
|
|
Map: "map",
|
|
Set: "set",
|
|
Weakmap: "weakmap",
|
|
Weakset: "weakset",
|
|
Iterator: "iterator",
|
|
Generator: "generator",
|
|
Error: "error"
|
|
};
|
|
|
|
/** @typedef {!{name:(string), type:(Protocol.Runtime.PropertyPreviewType), value:(string|undefined), valuePreview:(Protocol.Runtime.ObjectPreview|undefined), subtype:(Protocol.Runtime.PropertyPreviewSubtype|undefined)}} */
|
|
Protocol.Runtime.PropertyPreview;
|
|
|
|
/** @typedef {!{key:(Protocol.Runtime.ObjectPreview|undefined), value:(Protocol.Runtime.ObjectPreview)}} */
|
|
Protocol.Runtime.EntryPreview;
|
|
|
|
/** @typedef {!{name:(string), value:(Protocol.Runtime.RemoteObject|undefined), writable:(boolean|undefined), get:(Protocol.Runtime.RemoteObject|undefined), set:(Protocol.Runtime.RemoteObject|undefined), configurable:(boolean), enumerable:(boolean), wasThrown:(boolean|undefined), isOwn:(boolean|undefined), symbol:(Protocol.Runtime.RemoteObject|undefined)}} */
|
|
Protocol.Runtime.PropertyDescriptor;
|
|
|
|
/** @typedef {!{name:(string), value:(Protocol.Runtime.RemoteObject|undefined)}} */
|
|
Protocol.Runtime.InternalPropertyDescriptor;
|
|
|
|
/** @typedef {!{name:(string), value:(Protocol.Runtime.RemoteObject)}} */
|
|
Protocol.Runtime.PrivatePropertyDescriptor;
|
|
|
|
/** @typedef {!{value:(*|undefined), unserializableValue:(Protocol.Runtime.UnserializableValue|undefined), objectId:(Protocol.Runtime.RemoteObjectId|undefined)}} */
|
|
Protocol.Runtime.CallArgument;
|
|
|
|
/** @typedef {number} */
|
|
Protocol.Runtime.ExecutionContextId;
|
|
|
|
/** @typedef {!{id:(Protocol.Runtime.ExecutionContextId), origin:(string), name:(string), auxData:(!Object|undefined)}} */
|
|
Protocol.Runtime.ExecutionContextDescription;
|
|
|
|
/** @typedef {!{exceptionId:(number), text:(string), lineNumber:(number), columnNumber:(number), scriptId:(Protocol.Runtime.ScriptId|undefined), url:(string|undefined), stackTrace:(Protocol.Runtime.StackTrace|undefined), exception:(Protocol.Runtime.RemoteObject|undefined), executionContextId:(Protocol.Runtime.ExecutionContextId|undefined)}} */
|
|
Protocol.Runtime.ExceptionDetails;
|
|
|
|
/** @typedef {number} */
|
|
Protocol.Runtime.Timestamp;
|
|
|
|
/** @typedef {number} */
|
|
Protocol.Runtime.TimeDelta;
|
|
|
|
/** @typedef {!{functionName:(string), scriptId:(Protocol.Runtime.ScriptId), url:(string), lineNumber:(number), columnNumber:(number)}} */
|
|
Protocol.Runtime.CallFrame;
|
|
|
|
/** @typedef {!{description:(string|undefined), callFrames:(!Array<Protocol.Runtime.CallFrame>), parent:(Protocol.Runtime.StackTrace|undefined), parentId:(Protocol.Runtime.StackTraceId|undefined)}} */
|
|
Protocol.Runtime.StackTrace;
|
|
|
|
/** @typedef {string} */
|
|
Protocol.Runtime.UniqueDebuggerId;
|
|
|
|
/** @typedef {!{id:(string), debuggerId:(Protocol.Runtime.UniqueDebuggerId|undefined)}} */
|
|
Protocol.Runtime.StackTraceId;
|
|
/** @constructor */
|
|
Protocol.RuntimeDispatcher = function() {};
|
|
/**
|
|
* @param {string} name
|
|
* @param {string} payload
|
|
* @param {Protocol.Runtime.ExecutionContextId} executionContextId
|
|
*/
|
|
Protocol.RuntimeDispatcher.prototype.bindingCalled = function(name, payload, executionContextId) {};
|
|
/**
|
|
* @param {string} type
|
|
* @param {!Array<Protocol.Runtime.RemoteObject>} args
|
|
* @param {Protocol.Runtime.ExecutionContextId} executionContextId
|
|
* @param {Protocol.Runtime.Timestamp} timestamp
|
|
* @param {Protocol.Runtime.StackTrace=} opt_stackTrace
|
|
* @param {string=} opt_context
|
|
*/
|
|
Protocol.RuntimeDispatcher.prototype.consoleAPICalled = function(type, args, executionContextId, timestamp, opt_stackTrace, opt_context) {};
|
|
/**
|
|
* @param {string} reason
|
|
* @param {number} exceptionId
|
|
*/
|
|
Protocol.RuntimeDispatcher.prototype.exceptionRevoked = function(reason, exceptionId) {};
|
|
/**
|
|
* @param {Protocol.Runtime.Timestamp} timestamp
|
|
* @param {Protocol.Runtime.ExceptionDetails} exceptionDetails
|
|
*/
|
|
Protocol.RuntimeDispatcher.prototype.exceptionThrown = function(timestamp, exceptionDetails) {};
|
|
/**
|
|
* @param {Protocol.Runtime.ExecutionContextDescription} context
|
|
*/
|
|
Protocol.RuntimeDispatcher.prototype.executionContextCreated = function(context) {};
|
|
/**
|
|
* @param {Protocol.Runtime.ExecutionContextId} executionContextId
|
|
*/
|
|
Protocol.RuntimeDispatcher.prototype.executionContextDestroyed = function(executionContextId) {};
|
|
Protocol.RuntimeDispatcher.prototype.executionContextsCleared = function() {};
|
|
/**
|
|
* @param {Protocol.Runtime.RemoteObject} object
|
|
* @param {!Object} hints
|
|
*/
|
|
Protocol.RuntimeDispatcher.prototype.inspectRequested = function(object, hints) {};
|
|
Protocol.Schema = {};
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
Protocol.SchemaAgent = function(){};
|
|
|
|
/**
|
|
* @return {!Promise<?Array<Protocol.Schema.Domain>>}
|
|
*/
|
|
Protocol.SchemaAgent.prototype.getDomains = function() {};
|
|
/** @typedef {Object|undefined} */
|
|
Protocol.SchemaAgent.GetDomainsRequest;
|
|
/** @typedef {!{domains: !Array<Protocol.Schema.Domain>}} */
|
|
Protocol.SchemaAgent.GetDomainsResponse;
|
|
/**
|
|
* @param {!Protocol.SchemaAgent.GetDomainsRequest} obj
|
|
* @return {!Promise<!Protocol.SchemaAgent.GetDomainsResponse>} */
|
|
Protocol.SchemaAgent.prototype.invoke_getDomains = function(obj) {};
|
|
|
|
/** @typedef {!{name:(string), version:(string)}} */
|
|
Protocol.Schema.Domain;
|
|
/** @interface */
|
|
Protocol.SchemaDispatcher = function() {};
|
|
/** @return {!Protocol.AccessibilityAgent}*/
|
|
Protocol.TargetBase.prototype.accessibilityAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.AccessibilityDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerAccessibilityDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.AnimationAgent}*/
|
|
Protocol.TargetBase.prototype.animationAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.AnimationDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerAnimationDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.ApplicationCacheAgent}*/
|
|
Protocol.TargetBase.prototype.applicationCacheAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.ApplicationCacheDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerApplicationCacheDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.AuditsAgent}*/
|
|
Protocol.TargetBase.prototype.auditsAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.AuditsDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerAuditsDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.BackgroundServiceAgent}*/
|
|
Protocol.TargetBase.prototype.backgroundServiceAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.BackgroundServiceDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerBackgroundServiceDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.BrowserAgent}*/
|
|
Protocol.TargetBase.prototype.browserAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.BrowserDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerBrowserDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.CSSAgent}*/
|
|
Protocol.TargetBase.prototype.cssAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.CSSDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerCSSDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.CacheStorageAgent}*/
|
|
Protocol.TargetBase.prototype.cacheStorageAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.CacheStorageDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerCacheStorageDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.CastAgent}*/
|
|
Protocol.TargetBase.prototype.castAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.CastDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerCastDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.DOMAgent}*/
|
|
Protocol.TargetBase.prototype.domAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.DOMDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerDOMDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.DOMDebuggerAgent}*/
|
|
Protocol.TargetBase.prototype.domdebuggerAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.DOMDebuggerDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerDOMDebuggerDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.DOMSnapshotAgent}*/
|
|
Protocol.TargetBase.prototype.domsnapshotAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.DOMSnapshotDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerDOMSnapshotDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.DOMStorageAgent}*/
|
|
Protocol.TargetBase.prototype.domstorageAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.DOMStorageDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerDOMStorageDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.DatabaseAgent}*/
|
|
Protocol.TargetBase.prototype.databaseAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.DatabaseDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerDatabaseDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.DeviceOrientationAgent}*/
|
|
Protocol.TargetBase.prototype.deviceOrientationAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.DeviceOrientationDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerDeviceOrientationDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.EmulationAgent}*/
|
|
Protocol.TargetBase.prototype.emulationAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.EmulationDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerEmulationDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.HeadlessExperimentalAgent}*/
|
|
Protocol.TargetBase.prototype.headlessExperimentalAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.HeadlessExperimentalDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerHeadlessExperimentalDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.IOAgent}*/
|
|
Protocol.TargetBase.prototype.ioAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.IODispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerIODispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.IndexedDBAgent}*/
|
|
Protocol.TargetBase.prototype.indexedDBAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.IndexedDBDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerIndexedDBDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.InputAgent}*/
|
|
Protocol.TargetBase.prototype.inputAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.InputDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerInputDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.InspectorAgent}*/
|
|
Protocol.TargetBase.prototype.inspectorAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.InspectorDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerInspectorDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.LayerTreeAgent}*/
|
|
Protocol.TargetBase.prototype.layerTreeAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.LayerTreeDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerLayerTreeDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.LogAgent}*/
|
|
Protocol.TargetBase.prototype.logAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.LogDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerLogDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.MemoryAgent}*/
|
|
Protocol.TargetBase.prototype.memoryAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.MemoryDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerMemoryDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.NetworkAgent}*/
|
|
Protocol.TargetBase.prototype.networkAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.NetworkDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerNetworkDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.OverlayAgent}*/
|
|
Protocol.TargetBase.prototype.overlayAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.OverlayDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerOverlayDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.PageAgent}*/
|
|
Protocol.TargetBase.prototype.pageAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.PageDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerPageDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.PerformanceAgent}*/
|
|
Protocol.TargetBase.prototype.performanceAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.PerformanceDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerPerformanceDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.SecurityAgent}*/
|
|
Protocol.TargetBase.prototype.securityAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.SecurityDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerSecurityDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.ServiceWorkerAgent}*/
|
|
Protocol.TargetBase.prototype.serviceWorkerAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.ServiceWorkerDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerServiceWorkerDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.StorageAgent}*/
|
|
Protocol.TargetBase.prototype.storageAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.StorageDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerStorageDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.SystemInfoAgent}*/
|
|
Protocol.TargetBase.prototype.systemInfoAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.SystemInfoDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerSystemInfoDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.TargetAgent}*/
|
|
Protocol.TargetBase.prototype.targetAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.TargetDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerTargetDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.TetheringAgent}*/
|
|
Protocol.TargetBase.prototype.tetheringAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.TetheringDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerTetheringDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.TracingAgent}*/
|
|
Protocol.TargetBase.prototype.tracingAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.TracingDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerTracingDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.FetchAgent}*/
|
|
Protocol.TargetBase.prototype.fetchAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.FetchDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerFetchDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.WebAudioAgent}*/
|
|
Protocol.TargetBase.prototype.webAudioAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.WebAudioDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerWebAudioDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.WebAuthnAgent}*/
|
|
Protocol.TargetBase.prototype.webAuthnAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.WebAuthnDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerWebAuthnDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.MediaAgent}*/
|
|
Protocol.TargetBase.prototype.mediaAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.MediaDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerMediaDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.ConsoleAgent}*/
|
|
Protocol.TargetBase.prototype.consoleAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.ConsoleDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerConsoleDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.DebuggerAgent}*/
|
|
Protocol.TargetBase.prototype.debuggerAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.DebuggerDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerDebuggerDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.HeapProfilerAgent}*/
|
|
Protocol.TargetBase.prototype.heapProfilerAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.HeapProfilerDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerHeapProfilerDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.ProfilerAgent}*/
|
|
Protocol.TargetBase.prototype.profilerAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.ProfilerDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerProfilerDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.RuntimeAgent}*/
|
|
Protocol.TargetBase.prototype.runtimeAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.RuntimeDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerRuntimeDispatcher = function(dispatcher) {}
|
|
/** @return {!Protocol.SchemaAgent}*/
|
|
Protocol.TargetBase.prototype.schemaAgent = function(){};
|
|
/**
|
|
* @param {!Protocol.SchemaDispatcher} dispatcher
|
|
*/
|
|
Protocol.TargetBase.prototype.registerSchemaDispatcher = function(dispatcher) {}
|