webdriverio-automation/node_modules/devtools-protocol/externs/protocol_externs.js

WebdriverIO-Automation android ios project

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.prototy