Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
// Copyright (c) 2020 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
/**
* This file is auto-generated, do not edit manually. *
* Re-generate with: npm run generate-protocol-resources.
*/
/**
* API generated from Protocol commands and events.
*/
declare namespace ProtocolProxyApi {
declare interface ProtocolApi {
Accessibility: AccessibilityApi;
Animation: AnimationApi;
ApplicationCache: ApplicationCacheApi;
Audits: AuditsApi;
BackgroundService: BackgroundServiceApi;
Browser: BrowserApi;
CSS: CSSApi;
CacheStorage: CacheStorageApi;
Cast: CastApi;
DOM: DOMApi;
DOMDebugger: DOMDebuggerApi;
DOMSnapshot: DOMSnapshotApi;
DOMStorage: DOMStorageApi;
Database: DatabaseApi;
DeviceOrientation: DeviceOrientationApi;
Emulation: EmulationApi;
HeadlessExperimental: HeadlessExperimentalApi;
IO: IOApi;
IndexedDB: IndexedDBApi;
Input: InputApi;
Inspector: InspectorApi;
LayerTree: LayerTreeApi;
Log: LogApi;
Memory: MemoryApi;
Network: NetworkApi;
Overlay: OverlayApi;
Page: PageApi;
Performance: PerformanceApi;
Security: SecurityApi;
ServiceWorker: ServiceWorkerApi;
Storage: StorageApi;
SystemInfo: SystemInfoApi;
Target: TargetApi;
Tethering: TetheringApi;
Tracing: TracingApi;
Fetch: FetchApi;
WebAudio: WebAudioApi;
WebAuthn: WebAuthnApi;
Media: MediaApi;
Console: ConsoleApi;
Debugger: DebuggerApi;
HeapProfiler: HeapProfilerApi;
Profiler: ProfilerApi;
Runtime: RuntimeApi;
Schema: SchemaApi;
}
export interface AccessibilityApi {
/**
* Disables the accessibility domain.
*/
disable(): Promise;
/**
* Enables the accessibility domain which causes `AXNodeId`s to remain consistent between method calls.
* This turns on accessibility for the page, which can impact performance until accessibility is disabled.
*/
enable(): Promise;
/**
* Fetches the accessibility node and partial accessibility tree for this DOM node, if it exists.
*/
getPartialAXTree(params: Protocol.Accessibility.GetPartialAXTreeRequest):
Promise;
/**
* Fetches the entire accessibility tree
*/
getFullAXTree(): Promise;
}
export interface AnimationApi {
/**
* Disables animation domain notifications.
*/
disable(): Promise;
/**
* Enables animation domain notifications.
*/
enable(): Promise;
/**
* Returns the current time of the an animation.
*/
getCurrentTime(params: Protocol.Animation.GetCurrentTimeRequest):
Promise;
/**
* Gets the playback rate of the document timeline.
*/
getPlaybackRate(): Promise;
/**
* Releases a set of animations to no longer be manipulated.
*/
releaseAnimations(params: Protocol.Animation.ReleaseAnimationsRequest): Promise;
/**
* Gets the remote object of the Animation.
*/
resolveAnimation(params: Protocol.Animation.ResolveAnimationRequest):
Promise;
/**
* Seek a set of animations to a particular time within each animation.
*/
seekAnimations(params: Protocol.Animation.SeekAnimationsRequest): Promise;
/**
* Sets the paused state of a set of animations.
*/
setPaused(params: Protocol.Animation.SetPausedRequest): Promise;
/**
* Sets the playback rate of the document timeline.
*/
setPlaybackRate(params: Protocol.Animation.SetPlaybackRateRequest): Promise;
/**
* Sets the timing of an animation node.
*/
setTiming(params: Protocol.Animation.SetTimingRequest): Promise;
/**
* Event for when an animation has been cancelled.
*/
on(event: 'animationCanceled', listener: (params: Protocol.Animation.AnimationCanceledEvent) => void): void;
/**
* Event for each animation that has been created.
*/
on(event: 'animationCreated', listener: (params: Protocol.Animation.AnimationCreatedEvent) => void): void;
/**
* Event for animation that has been started.
*/
on(event: 'animationStarted', listener: (params: Protocol.Animation.AnimationStartedEvent) => void): void;
}
export interface ApplicationCacheApi {
/**
* Enables application cache domain notifications.
*/
enable(): Promise;
/**
* Returns relevant application cache data for the document in given frame.
*/
getApplicationCacheForFrame(params: Protocol.ApplicationCache.GetApplicationCacheForFrameRequest):
Promise;
/**
* Returns array of frame identifiers with manifest urls for each frame containing a document
* associated with some application cache.
*/
getFramesWithManifests(): Promise;
/**
* Returns manifest URL for document in the given frame.
*/
getManifestForFrame(params: Protocol.ApplicationCache.GetManifestForFrameRequest):
Promise;
on(event: 'applicationCacheStatusUpdated',
listener: (params: Protocol.ApplicationCache.ApplicationCacheStatusUpdatedEvent) => void): void;
on(event: 'networkStateUpdated',
listener: (params: Protocol.ApplicationCache.NetworkStateUpdatedEvent) => void): void;
}
export interface AuditsApi {
/**
* Returns the response body and size if it were re-encoded with the specified settings. Only
* applies to images.
*/
getEncodedResponse(params: Protocol.Audits.GetEncodedResponseRequest):
Promise;
/**
* Disables issues domain, prevents further issues from being reported to the client.
*/
disable(): Promise;
/**
* Enables issues domain, sends the issues collected so far to the client by means of the
* `issueAdded` event.
*/
enable(): Promise;
on(event: 'issueAdded', listener: (params: Protocol.Audits.IssueAddedEvent) => void): void;
}
export interface BackgroundServiceApi {
/**
* Enables event updates for the service.
*/
startObserving(params: Protocol.BackgroundService.StartObservingRequest): Promise;
/**
* Disables event updates for the service.
*/
stopObserving(params: Protocol.BackgroundService.StopObservingRequest): Promise;
/**
* Set the recording state for the service.
*/
setRecording(params: Protocol.BackgroundService.SetRecordingRequest): Promise;
/**
* Clears all stored data for the service.
*/
clearEvents(params: Protocol.BackgroundService.ClearEventsRequest): Promise;
/**
* Called when the recording state for the service has been updated.
*/
on(event: 'recordingStateChanged',
listener: (params: Protocol.BackgroundService.RecordingStateChangedEvent) => void): void;
/**
* Called with all existing backgroundServiceEvents when enabled, and all new
* events afterwards if enabled and recording.
*/
on(event: 'backgroundServiceEventReceived',
listener: (params: Protocol.BackgroundService.BackgroundServiceEventReceivedEvent) => void): void;
}
export interface BrowserApi {
/**
* Set permission settings for given origin.
*/
setPermission(params: Protocol.Browser.SetPermissionRequest): Promise;
/**
* Grant specific permissions to the given origin and reject all others.
*/
grantPermissions(params: Protocol.Browser.GrantPermissionsRequest): Promise;
/**
* Reset all permission management for all origins.
*/
resetPermissions(params: Protocol.Browser.ResetPermissionsRequest): Promise;
/**
* Close browser gracefully.
*/
close(): Promise;
/**
* Crashes browser on the main thread.
*/
crash(): Promise;
/**
* Crashes GPU process.
*/
crashGpuProcess(): Promise;
/**
* Returns version information.
*/
getVersion(): Promise;
/**
* Returns the command line switches for the browser process if, and only if
* --enable-automation is on the commandline.
*/
getBrowserCommandLine(): Promise;
/**
* Get Chrome histograms.
*/
getHistograms(params: Protocol.Browser.GetHistogramsRequest): Promise;
/**
* Get a Chrome histogram by name.
*/
getHistogram(params: Protocol.Browser.GetHistogramRequest): Promise;
/**
* Get position and size of the browser window.
*/
getWindowBounds(params: Protocol.Browser.GetWindowBoundsRequest): Promise;
/**
* Get the browser window that contains the devtools target.
*/
getWindowForTarget(params: Protocol.Browser.GetWindowForTargetRequest):
Promise;
/**
* Set position and/or size of the browser window.
*/
setWindowBounds(params: Protocol.Browser.SetWindowBoundsRequest): Promise;
/**
* Set dock tile details, platform-specific.
*/
setDockTile(params: Protocol.Browser.SetDockTileRequest): Promise;
}
export interface CSSApi {
/**
* Inserts a new rule with the given `ruleText` in a stylesheet with given `styleSheetId`, at the
* position specified by `location`.
*/
addRule(params: Protocol.CSS.AddRuleRequest): Promise;
/**
* Returns all class names from specified stylesheet.
*/
collectClassNames(params: Protocol.CSS.CollectClassNamesRequest): Promise;
/**
* Creates a new special "via-inspector" stylesheet in the frame with given `frameId`.
*/
createStyleSheet(params: Protocol.CSS.CreateStyleSheetRequest): Promise;
/**
* Disables the CSS agent for the given page.
*/
disable(): Promise;
/**
* Enables the CSS agent for the given page. Clients should not assume that the CSS agent has been
* enabled until the result of this command is received.
*/
enable(): Promise;
/**
* Ensures that the given node will have specified pseudo-classes whenever its style is computed by
* the browser.
*/
forcePseudoState(params: Protocol.CSS.ForcePseudoStateRequest): Promise;
getBackgroundColors(params: Protocol.CSS.GetBackgroundColorsRequest):
Promise;
/**
* Returns the computed style for a DOM node identified by `nodeId`.
*/
getComputedStyleForNode(params: Protocol.CSS.GetComputedStyleForNodeRequest):
Promise;
/**
* Returns the styles defined inline (explicitly in the "style" attribute and implicitly, using DOM
* attributes) for a DOM node identified by `nodeId`.
*/
getInlineStylesForNode(params: Protocol.CSS.GetInlineStylesForNodeRequest):
Promise;
/**
* Returns requested styles for a DOM node identified by `nodeId`.
*/
getMatchedStylesForNode(params: Protocol.CSS.GetMatchedStylesForNodeRequest):
Promise;
/**
* Returns all media queries parsed by the rendering engine.
*/
getMediaQueries(): Promise;
/**
* Requests information about platform fonts which we used to render child TextNodes in the given
* node.
*/
getPlatformFontsForNode(params: Protocol.CSS.GetPlatformFontsForNodeRequest):
Promise;
/**
* Returns the current textual content for a stylesheet.
*/
getStyleSheetText(params: Protocol.CSS.GetStyleSheetTextRequest): Promise;
/**
* Find a rule with the given active property for the given node and set the new value for this
* property
*/
setEffectivePropertyValueForNode(params: Protocol.CSS.SetEffectivePropertyValueForNodeRequest): Promise;
/**
* Modifies the keyframe rule key text.
*/
setKeyframeKey(params: Protocol.CSS.SetKeyframeKeyRequest): Promise;
/**
* Modifies the rule selector.
*/
setMediaText(params: Protocol.CSS.SetMediaTextRequest): Promise;
/**
* Modifies the rule selector.
*/
setRuleSelector(params: Protocol.CSS.SetRuleSelectorRequest): Promise;
/**
* Sets the new stylesheet text.
*/
setStyleSheetText(params: Protocol.CSS.SetStyleSheetTextRequest): Promise;
/**
* Applies specified style edits one after another in the given order.
*/
setStyleTexts(params: Protocol.CSS.SetStyleTextsRequest): Promise;
/**
* Enables the selector recording.
*/
startRuleUsageTracking(): Promise;
/**
* Stop tracking rule usage and return the list of rules that were used since last call to
* `takeCoverageDelta` (or since start of coverage instrumentation)
*/
stopRuleUsageTracking(): Promise;
/**
* Obtain list of rules that became used since last call to this method (or since start of coverage
* instrumentation)
*/
takeCoverageDelta(): Promise;
/**
* Fires whenever a web font is updated. A non-empty font parameter indicates a successfully loaded
* web font
*/
on(event: 'fontsUpdated', listener: (params: Protocol.CSS.FontsUpdatedEvent) => void): void;
/**
* Fires whenever a MediaQuery result changes (for example, after a browser window has been
* resized.) The current implementation considers only viewport-dependent media features.
*/
on(event: 'mediaQueryResultChanged', listener: () => void): void;
/**
* Fired whenever an active document stylesheet is added.
*/
on(event: 'styleSheetAdded', listener: (params: Protocol.CSS.StyleSheetAddedEvent) => void): void;
/**
* Fired whenever a stylesheet is changed as a result of the client operation.
*/
on(event: 'styleSheetChanged', listener: (params: Protocol.CSS.StyleSheetChangedEvent) => void): void;
/**
* Fired whenever an active document stylesheet is removed.
*/
on(event: 'styleSheetRemoved', listener: (params: Protocol.CSS.StyleSheetRemovedEvent) => void): void;
}
export interface CacheStorageApi {
/**
* Deletes a cache.
*/
deleteCache(params: Protocol.CacheStorage.DeleteCacheRequest): Promise;
/**
* Deletes a cache entry.
*/
deleteEntry(params: Protocol.CacheStorage.DeleteEntryRequest): Promise;
/**
* Requests cache names.
*/
requestCacheNames(params: Protocol.CacheStorage.RequestCacheNamesRequest):
Promise;
/**
* Fetches cache entry.
*/
requestCachedResponse(params: Protocol.CacheStorage.RequestCachedResponseRequest):
Promise;
/**
* Requests data from cache.
*/
requestEntries(params: Protocol.CacheStorage.RequestEntriesRequest):
Promise;
}
export interface CastApi {
/**
* Starts observing for sinks that can be used for tab mirroring, and if set,
* sinks compatible with |presentationUrl| as well. When sinks are found, a
* |sinksUpdated| event is fired.
* Also starts observing for issue messages. When an issue is added or removed,
* an |issueUpdated| event is fired.
*/
enable(params: Protocol.Cast.EnableRequest): Promise;
/**
* Stops observing for sinks and issues.
*/
disable(): Promise;
/**
* Sets a sink to be used when the web page requests the browser to choose a
* sink via Presentation API, Remote Playback API, or Cast SDK.
*/
setSinkToUse(params: Protocol.Cast.SetSinkToUseRequest): Promise;
/**
* Starts mirroring the tab to the sink.
*/
startTabMirroring(params: Protocol.Cast.StartTabMirroringRequest): Promise;
/**
* Stops the active Cast session on the sink.
*/
stopCasting(params: Protocol.Cast.StopCastingRequest): Promise;
/**
* This is fired whenever the list of available sinks changes. A sink is a
* device or a software surface that you can cast to.
*/
on(event: 'sinksUpdated', listener: (params: Protocol.Cast.SinksUpdatedEvent) => void): void;
/**
* This is fired whenever the outstanding issue/error message changes.
* |issueMessage| is empty if there is no issue.
*/
on(event: 'issueUpdated', listener: (params: Protocol.Cast.IssueUpdatedEvent) => void): void;
}
export interface DOMApi {
/**
* Collects class names for the node with given id and all of it's child nodes.
*/
collectClassNamesFromSubtree(params: Protocol.DOM.CollectClassNamesFromSubtreeRequest):
Promise;
/**
* Creates a deep copy of the specified node and places it into the target container before the
* given anchor.
*/
copyTo(params: Protocol.DOM.CopyToRequest): Promise;
/**
* Describes node given its id, does not require domain to be enabled. Does not start tracking any
* objects, can be used for automation.
*/
describeNode(params: Protocol.DOM.DescribeNodeRequest): Promise;
/**
* Scrolls the specified rect of the given node into view if not already visible.
* Note: exactly one between nodeId, backendNodeId and objectId should be passed
* to identify the node.
*/
scrollIntoViewIfNeeded(params: Protocol.DOM.ScrollIntoViewIfNeededRequest): Promise;
/**
* Disables DOM agent for the given page.
*/
disable(): Promise;
/**
* Discards search results from the session with the given id. `getSearchResults` should no longer
* be called for that search.
*/
discardSearchResults(params: Protocol.DOM.DiscardSearchResultsRequest): Promise;
/**
* Enables DOM agent for the given page.
*/
enable(): Promise;
/**
* Focuses the given element.
*/
focus(params: Protocol.DOM.FocusRequest): Promise;
/**
* Returns attributes for the specified node.
*/
getAttributes(params: Protocol.DOM.GetAttributesRequest): Promise;
/**
* Returns boxes for the given node.
*/
getBoxModel(params: Protocol.DOM.GetBoxModelRequest): Promise;
/**
* Returns quads that describe node position on the page. This method
* might return multiple quads for inline nodes.
*/
getContentQuads(params: Protocol.DOM.GetContentQuadsRequest): Promise;
/**
* Returns the root DOM node (and optionally the subtree) to the caller.
*/
getDocument(params: Protocol.DOM.GetDocumentRequest): Promise;
/**
* Returns the root DOM node (and optionally the subtree) to the caller.
*/
getFlattenedDocument(params: Protocol.DOM.GetFlattenedDocumentRequest):
Promise;
/**
* Returns node id at given location. Depending on whether DOM domain is enabled, nodeId is
* either returned or not.
*/
getNodeForLocation(params: Protocol.DOM.GetNodeForLocationRequest):
Promise;
/**
* Returns node's HTML markup.
*/
getOuterHTML(params: Protocol.DOM.GetOuterHTMLRequest): Promise;
/**
* Returns the id of the nearest ancestor that is a relayout boundary.
*/
getRelayoutBoundary(params: Protocol.DOM.GetRelayoutBoundaryRequest):
Promise;
/**
* Returns search results from given `fromIndex` to given `toIndex` from the search with the given
* identifier.
*/
getSearchResults(params: Protocol.DOM.GetSearchResultsRequest): Promise;
/**
* Hides any highlight.
*/
hideHighlight(): Promise;
/**
* Highlights DOM node.
*/
highlightNode(): Promise;
/**
* Highlights given rectangle.
*/
highlightRect(): Promise;
/**
* Marks last undoable state.
*/
markUndoableState(): Promise;
/**
* Moves node into the new container, places it before the given anchor.
*/
moveTo(params: Protocol.DOM.MoveToRequest): Promise;
/**
* Searches for a given string in the DOM tree. Use `getSearchResults` to access search results or
* `cancelSearch` to end this search session.
*/
performSearch(params: Protocol.DOM.PerformSearchRequest): Promise;
/**
* Requests that the node is sent to the caller given its path. // FIXME, use XPath
*/
pushNodeByPathToFrontend(params: Protocol.DOM.PushNodeByPathToFrontendRequest):
Promise;
/**
* Requests that a batch of nodes is sent to the caller given their backend node ids.
*/
pushNodesByBackendIdsToFrontend(params: Protocol.DOM.PushNodesByBackendIdsToFrontendRequest):
Promise;
/**
* Executes `querySelector` on a given node.
*/
querySelector(params: Protocol.DOM.QuerySelectorRequest): Promise;
/**
* Executes `querySelectorAll` on a given node.
*/
querySelectorAll(params: Protocol.DOM.QuerySelectorAllRequest): Promise;
/**
* Re-does the last undone action.
*/
redo(): Promise;
/**
* Removes attribute with given name from an element with given id.
*/
removeAttribute(params: Protocol.DOM.RemoveAttributeRequest): Promise;
/**
* Removes node with given id.
*/
removeNode(params: Protocol.DOM.RemoveNodeRequest): Promise;
/**
* Requests that children of the node with given id are returned to the caller in form of
* `setChildNodes` events where not only immediate children are retrieved, but all children down to
* the specified depth.
*/
requestChildNodes(params: Protocol.DOM.RequestChildNodesRequest): Promise;
/**
* Requests that the node is sent to the caller given the JavaScript node object reference. All
* nodes that form the path from the node to the root are also sent to the client as a series of
* `setChildNodes` notifications.
*/
requestNode(params: Protocol.DOM.RequestNodeRequest): Promise;
/**
* Resolves the JavaScript node object for a given NodeId or BackendNodeId.
*/
resolveNode(params: Protocol.DOM.ResolveNodeRequest): Promise;
/**
* Sets attribute for an element with given id.
*/
setAttributeValue(params: Protocol.DOM.SetAttributeValueRequest): Promise;
/**
* Sets attributes on element with given id. This method is useful when user edits some existing
* attribute value and types in several attribute name/value pairs.
*/
setAttributesAsText(params: Protocol.DOM.SetAttributesAsTextRequest): Promise;
/**
* Sets files for the given file input element.
*/
setFileInputFiles(params: Protocol.DOM.SetFileInputFilesRequest): Promise;
/**
* Sets if stack traces should be captured for Nodes. See `Node.getNodeStackTraces`. Default is disabled.
*/
setNodeStackTracesEnabled(params: Protocol.DOM.SetNodeStackTracesEnabledRequest): Promise;
/**
* Gets stack traces associated with a Node. As of now, only provides stack trace for Node creation.
*/
getNodeStackTraces(params: Protocol.DOM.GetNodeStackTracesRequest):
Promise;
/**
* Returns file information for the given
* File wrapper.
*/
getFileInfo(params: Protocol.DOM.GetFileInfoRequest): Promise;
/**
* Enables console to refer to the node with given id via $x (see Command Line API for more details
* $x functions).
*/
setInspectedNode(params: Protocol.DOM.SetInspectedNodeRequest): Promise;
/**
* Sets node name for a node with given id.
*/
setNodeName(params: Protocol.DOM.SetNodeNameRequest): Promise;
/**
* Sets node value for a node with given id.
*/
setNodeValue(params: Protocol.DOM.SetNodeValueRequest): Promise;
/**
* Sets node HTML markup, returns new node id.
*/
setOuterHTML(params: Protocol.DOM.SetOuterHTMLRequest): Promise;
/**
* Undoes the last performed action.
*/
undo(): Promise;
/**
* Returns iframe node that owns iframe with the given domain.
*/
getFrameOwner(params: Protocol.DOM.GetFrameOwnerRequest): Promise;
/**
* Fired when `Element`'s attribute is modified.
*/
on(event: 'attributeModified', listener: (params: Protocol.DOM.AttributeModifiedEvent) => void): void;
/**
* Fired when `Element`'s attribute is removed.
*/
on(event: 'attributeRemoved', listener: (params: Protocol.DOM.AttributeRemovedEvent) => void): void;
/**
* Mirrors `DOMCharacterDataModified` event.
*/
on(event: 'characterDataModified', listener: (params: Protocol.DOM.CharacterDataModifiedEvent) => void): void;
/**
* Fired when `Container`'s child node count has changed.
*/
on(event: 'childNodeCountUpdated', listener: (params: Protocol.DOM.ChildNodeCountUpdatedEvent) => void): void;
/**
* Mirrors `DOMNodeInserted` event.
*/
on(event: 'childNodeInserted', listener: (params: Protocol.DOM.ChildNodeInsertedEvent) => void): void;
/**
* Mirrors `DOMNodeRemoved` event.
*/
on(event: 'childNodeRemoved', listener: (params: Protocol.DOM.ChildNodeRemovedEvent) => void): void;
/**
* Called when distrubution is changed.
*/
on(event: 'distributedNodesUpdated', listener: (params: Protocol.DOM.DistributedNodesUpdatedEvent) => void): void;
/**
* Fired when `Document` has been totally updated. Node ids are no longer valid.
*/
on(event: 'documentUpdated', listener: () => void): void;
/**
* Fired when `Element`'s inline style is modified via a CSS property modification.
*/
on(event: 'inlineStyleInvalidated', listener: (params: Protocol.DOM.InlineStyleInvalidatedEvent) => void): void;
/**
* Called when a pseudo element is added to an element.
*/
on(event: 'pseudoElementAdded', listener: (params: Protocol.DOM.PseudoElementAddedEvent) => void): void;
/**
* Called when a pseudo element is removed from an element.
*/
on(event: 'pseudoElementRemoved', listener: (params: Protocol.DOM.PseudoElementRemovedEvent) => void): void;
/**
* Fired when backend wants to provide client with the missing DOM structure. This happens upon
* most of the calls requesting node ids.
*/
on(event: 'setChildNodes', listener: (params: Protocol.DOM.SetChildNodesEvent) => void): void;
/**
* Called when shadow root is popped from the element.
*/
on(event: 'shadowRootPopped', listener: (params: Protocol.DOM.ShadowRootPoppedEvent) => void): void;
/**
* Called when shadow root is pushed into the element.
*/
on(event: 'shadowRootPushed', listener: (params: Protocol.DOM.ShadowRootPushedEvent) => void): void;
}
export interface DOMDebuggerApi {
/**
* Returns event listeners of the given object.
*/
getEventListeners(params: Protocol.DOMDebugger.GetEventListenersRequest):
Promise;
/**
* Removes DOM breakpoint that was set using `setDOMBreakpoint`.
*/
removeDOMBreakpoint(params: Protocol.DOMDebugger.RemoveDOMBreakpointRequest): Promise;
/**
* Removes breakpoint on particular DOM event.
*/
removeEventListenerBreakpoint(params: Protocol.DOMDebugger.RemoveEventListenerBreakpointRequest): Promise;
/**
* Removes breakpoint on particular native event.
*/
removeInstrumentationBreakpoint(params: Protocol.DOMDebugger.RemoveInstrumentationBreakpointRequest): Promise;
/**
* Removes breakpoint from XMLHttpRequest.
*/
removeXHRBreakpoint(params: Protocol.DOMDebugger.RemoveXHRBreakpointRequest): Promise;
/**
* Sets breakpoint on particular operation with DOM.
*/
setDOMBreakpoint(params: Protocol.DOMDebugger.SetDOMBreakpointRequest): Promise;
/**
* Sets breakpoint on particular DOM event.
*/
setEventListenerBreakpoint(params: Protocol.DOMDebugger.SetEventListenerBreakpointRequest): Promise;
/**
* Sets breakpoint on particular native event.
*/
setInstrumentationBreakpoint(params: Protocol.DOMDebugger.SetInstrumentationBreakpointRequest): Promise;
/**
* Sets breakpoint on XMLHttpRequest.
*/
setXHRBreakpoint(params: Protocol.DOMDebugger.SetXHRBreakpointRequest): Promise;
}
export interface DOMSnapshotApi {
/**
* Disables DOM snapshot agent for the given page.
*/
disable(): Promise;
/**
* Enables DOM snapshot agent for the given page.
*/
enable(): Promise;
/**
* Returns a document snapshot, including the full DOM tree of the root node (including iframes,
* template contents, and imported documents) in a flattened array, as well as layout and
* white-listed computed style information for the nodes. Shadow DOM in the returned DOM tree is
* flattened.
*/
getSnapshot(params: Protocol.DOMSnapshot.GetSnapshotRequest): Promise;
/**
* Returns a document snapshot, including the full DOM tree of the root node (including iframes,
* template contents, and imported documents) in a flattened array, as well as layout and
* white-listed computed style information for the nodes. Shadow DOM in the returned DOM tree is
* flattened.
*/
captureSnapshot(params: Protocol.DOMSnapshot.CaptureSnapshotRequest):
Promise;
}
export interface DOMStorageApi {
clear(params: Protocol.DOMStorage.ClearRequest): Promise;
/**
* Disables storage tracking, prevents storage events from being sent to the client.
*/
disable(): Promise;
/**
* Enables storage tracking, storage events will now be delivered to the client.
*/
enable(): Promise;
getDOMStorageItems(params: Protocol.DOMStorage.GetDOMStorageItemsRequest):
Promise;
removeDOMStorageItem(params: Protocol.DOMStorage.RemoveDOMStorageItemRequest): Promise;
setDOMStorageItem(params: Protocol.DOMStorage.SetDOMStorageItemRequest): Promise;
on(event: 'domStorageItemAdded', listener: (params: Protocol.DOMStorage.DomStorageItemAddedEvent) => void): void;
on(event: 'domStorageItemRemoved',
listener: (params: Protocol.DOMStorage.DomStorageItemRemovedEvent) => void): void;
on(event: 'domStorageItemUpdated',
listener: (params: Protocol.DOMStorage.DomStorageItemUpdatedEvent) => void): void;
on(event: 'domStorageItemsCleared',
listener: (params: Protocol.DOMStorage.DomStorageItemsClearedEvent) => void): void;
}
export interface DatabaseApi {
/**
* Disables database tracking, prevents database events from being sent to the client.
*/
disable(): Promise;
/**
* Enables database tracking, database events will now be delivered to the client.
*/
enable(): Promise;
executeSQL(params: Protocol.Database.ExecuteSQLRequest): Promise;
getDatabaseTableNames(params: Protocol.Database.GetDatabaseTableNamesRequest):
Promise;
on(event: 'addDatabase', listener: (params: Protocol.Database.AddDatabaseEvent) => void): void;
}
export interface DeviceOrientationApi {
/**
* Clears the overridden Device Orientation.
*/
clearDeviceOrientationOverride(): Promise;
/**
* Overrides the Device Orientation.
*/
setDeviceOrientationOverride(params: Protocol.DeviceOrientation.SetDeviceOrientationOverrideRequest): Promise;
}
export interface EmulationApi {
/**
* Tells whether emulation is supported.
*/
canEmulate(): Promise;
/**
* Clears the overriden device metrics.
*/
clearDeviceMetricsOverride(): Promise;
/**
* Clears the overriden Geolocation Position and Error.
*/
clearGeolocationOverride(): Promise;
/**
* Requests that page scale factor is reset to initial values.
*/
resetPageScaleFactor(): Promise;
/**
* Enables or disables simulating a focused and active page.
*/
setFocusEmulationEnabled(params: Protocol.Emulation.SetFocusEmulationEnabledRequest): Promise;
/**
* Enables CPU throttling to emulate slow CPUs.
*/
setCPUThrottlingRate(params: Protocol.Emulation.SetCPUThrottlingRateRequest): Promise;
/**
* Sets or clears an override of the default background color of the frame. This override is used
* if the content does not specify one.
*/
setDefaultBackgroundColorOverride(params: Protocol.Emulation.SetDefaultBackgroundColorOverrideRequest):
Promise;
/**
* Overrides the values of device screen dimensions (window.screen.width, window.screen.height,
* window.innerWidth, window.innerHeight, and "device-width"/"device-height"-related CSS media
* query results).
*/
setDeviceMetricsOverride(params: Protocol.Emulation.SetDeviceMetricsOverrideRequest): Promise;
setScrollbarsHidden(params: Protocol.Emulation.SetScrollbarsHiddenRequest): Promise;
setDocumentCookieDisabled(params: Protocol.Emulation.SetDocumentCookieDisabledRequest): Promise;
setEmitTouchEventsForMouse(params: Protocol.Emulation.SetEmitTouchEventsForMouseRequest): Promise;
/**
* Emulates the given media type or media feature for CSS media queries.
*/
setEmulatedMedia(params: Protocol.Emulation.SetEmulatedMediaRequest): Promise;
/**
* Emulates the given vision deficiency.
*/
setEmulatedVisionDeficiency(params: Protocol.Emulation.SetEmulatedVisionDeficiencyRequest): Promise;
/**
* Overrides the Geolocation Position or Error. Omitting any of the parameters emulates position
* unavailable.
*/
setGeolocationOverride(params: Protocol.Emulation.SetGeolocationOverrideRequest): Promise;
/**
* Overrides value returned by the javascript navigator object.
*/
setNavigatorOverrides(params: Protocol.Emulation.SetNavigatorOverridesRequest): Promise;
/**
* Sets a specified page scale factor.
*/
setPageScaleFactor(params: Protocol.Emulation.SetPageScaleFactorRequest): Promise;
/**
* Switches script execution in the page.
*/
setScriptExecutionDisabled(params: Protocol.Emulation.SetScriptExecutionDisabledRequest): Promise;
/**
* Enables touch on platforms which do not support them.
*/
setTouchEmulationEnabled(params: Protocol.Emulation.SetTouchEmulationEnabledRequest): Promise;
/**
* Turns on virtual time for all frames (replacing real-time with a synthetic time source) and sets
* the current virtual time policy. Note this supersedes any previous time budget.
*/
setVirtualTimePolicy(params: Protocol.Emulation.SetVirtualTimePolicyRequest):
Promise;
/**
* Overrides default host system locale with the specified one.
*/
setLocaleOverride(params: Protocol.Emulation.SetLocaleOverrideRequest): Promise;
/**
* Overrides default host system timezone with the specified one.
*/
setTimezoneOverride(params: Protocol.Emulation.SetTimezoneOverrideRequest): Promise;
/**
* Resizes the frame/viewport of the page. Note that this does not affect the frame's container
* (e.g. browser window). Can be used to produce screenshots of the specified size. Not supported
* on Android.
*/
setVisibleSize(params: Protocol.Emulation.SetVisibleSizeRequest): Promise;
/**
* Allows overriding user agent with the given string.
*/
setUserAgentOverride(params: Protocol.Emulation.SetUserAgentOverrideRequest): Promise;
/**
* Notification sent after the virtual time budget for the current VirtualTimePolicy has run out.
*/
on(event: 'virtualTimeBudgetExpired', listener: () => void): void;
}
export interface HeadlessExperimentalApi {
/**
* Sends a BeginFrame to the target and returns when the frame was completed. Optionally captures a
* screenshot from the resulting frame. Requires that the target was created with enabled
* BeginFrameControl. Designed for use with --run-all-compositor-stages-before-draw, see also
* https://goo.gl/3zHXhB for more background.
*/
beginFrame(params: Protocol.HeadlessExperimental.BeginFrameRequest):
Promise;
/**
* Disables headless events for the target.
*/
disable(): Promise;
/**
* Enables headless events for the target.
*/
enable(): Promise;
/**
* Issued when the target starts or stops needing BeginFrames.
* Deprecated. Issue beginFrame unconditionally instead and use result from
* beginFrame to detect whether the frames were suppressed.
*/
on(event: 'needsBeginFramesChanged',
listener: (params: Protocol.HeadlessExperimental.NeedsBeginFramesChangedEvent) => void): void;
}
// eslint thinks this is us prefixing our interfaces but it's not!
// eslint-disable-next-line @typescript-eslint/interface-name-prefix
export interface IOApi {
/**
* Close the stream, discard any temporary backing storage.
*/
close(params: Protocol.IO.CloseRequest): Promise;
/**
* Read a chunk of the stream
*/
read(params: Protocol.IO.ReadRequest): Promise;
/**
* Return UUID of Blob object specified by a remote object id.
*/
resolveBlob(params: Protocol.IO.ResolveBlobRequest): Promise;
}
// eslint thinks this is us prefixing our interfaces but it's not!
// eslint-disable-next-line @typescript-eslint/interface-name-prefix
export interface IndexedDBApi {
/**
* Clears all entries from an object store.
*/
clearObjectStore(params: Protocol.IndexedDB.ClearObjectStoreRequest): Promise;
/**
* Deletes a database.
*/
deleteDatabase(params: Protocol.IndexedDB.DeleteDatabaseRequest): Promise;
/**
* Delete a range of entries from an object store
*/
deleteObjectStoreEntries(params: Protocol.IndexedDB.DeleteObjectStoreEntriesRequest): Promise;
/**
* Disables events from backend.
*/
disable(): Promise;
/**
* Enables events from backend.
*/
enable(): Promise;
/**
* Requests data from object store or index.
*/
requestData(params: Protocol.IndexedDB.RequestDataRequest): Promise;
/**
* Gets metadata of an object store
*/
getMetadata(params: Protocol.IndexedDB.GetMetadataRequest): Promise;
/**
* Requests database with given name in given frame.
*/
requestDatabase(params: Protocol.IndexedDB.RequestDatabaseRequest):
Promise;
/**
* Requests database names for given security origin.
*/
requestDatabaseNames(params: Protocol.IndexedDB.RequestDatabaseNamesRequest):
Promise;
}
// eslint thinks this is us prefixing our interfaces but it's not!
// eslint-disable-next-line @typescript-eslint/interface-name-prefix
export interface InputApi {
/**
* Dispatches a key event to the page.
*/
dispatchKeyEvent(params: Protocol.Input.DispatchKeyEventRequest): Promise;
/**
* This method emulates inserting text that doesn't come from a key press,
* for example an emoji keyboard or an IME.
*/
insertText(params: Protocol.Input.InsertTextRequest): Promise;
/**
* Dispatches a mouse event to the page.
*/
dispatchMouseEvent(params: Protocol.Input.DispatchMouseEventRequest): Promise;
/**
* Dispatches a touch event to the page.
*/
dispatchTouchEvent(params: Protocol.Input.DispatchTouchEventRequest): Promise;
/**
* Emulates touch event from the mouse event parameters.
*/
emulateTouchFromMouseEvent(params: Protocol.Input.EmulateTouchFromMouseEventRequest): Promise;
/**
* Ignores input events (useful while auditing page).
*/
setIgnoreInputEvents(params: Protocol.Input.SetIgnoreInputEventsRequest): Promise;
/**
* Synthesizes a pinch gesture over a time period by issuing appropriate touch events.
*/
synthesizePinchGesture(params: Protocol.Input.SynthesizePinchGestureRequest): Promise;
/**
* Synthesizes a scroll gesture over a time period by issuing appropriate touch events.
*/
synthesizeScrollGesture(params: Protocol.Input.SynthesizeScrollGestureRequest): Promise;
/**
* Synthesizes a tap gesture over a time period by issuing appropriate touch events.
*/
synthesizeTapGesture(params: Protocol.Input.SynthesizeTapGestureRequest): Promise;
}
// eslint thinks this is us prefixing our interfaces but it's not!
// eslint-disable-next-line @typescript-eslint/interface-name-prefix
export interface InspectorApi {
/**
* Disables inspector domain notifications.
*/
disable(): Promise;
/**
* Enables inspector domain notifications.
*/
enable(): Promise;
/**
* Fired when remote debugging connection is about to be terminated. Contains detach reason.
*/
on(event: 'detached', listener: (params: Protocol.Inspector.DetachedEvent) => void): void;
/**
* Fired when debugging target has crashed
*/
on(event: 'targetCrashed', listener: () => void): void;
/**
* Fired when debugging target has reloaded after crash
*/
on(event: 'targetReloadedAfterCrash', listener: () => void): void;
}
export interface LayerTreeApi {
/**
* Provides the reasons why the given layer was composited.
*/
compositingReasons(params: Protocol.LayerTree.CompositingReasonsRequest):
Promise;
/**
* Disables compositing tree inspection.
*/
disable(): Promise;
/**
* Enables compositing tree inspection.
*/
enable(): Promise;
/**
* Returns the snapshot identifier.
*/
loadSnapshot(params: Protocol.LayerTree.LoadSnapshotRequest): Promise;
/**
* Returns the layer snapshot identifier.
*/
makeSnapshot(params: Protocol.LayerTree.MakeSnapshotRequest): Promise;
profileSnapshot(params: Protocol.LayerTree.ProfileSnapshotRequest):
Promise;
/**
* Releases layer snapshot captured by the back-end.
*/
releaseSnapshot(params: Protocol.LayerTree.ReleaseSnapshotRequest): Promise;
/**
* Replays the layer snapshot and returns the resulting bitmap.
*/
replaySnapshot(params: Protocol.LayerTree.ReplaySnapshotRequest):
Promise;
/**
* Replays the layer snapshot and returns canvas log.
*/
snapshotCommandLog(params: Protocol.LayerTree.SnapshotCommandLogRequest):
Promise;
on(event: 'layerPainted', listener: (params: Protocol.LayerTree.LayerPaintedEvent) => void): void;
on(event: 'layerTreeDidChange', listener: (params: Protocol.LayerTree.LayerTreeDidChangeEvent) => void): void;
}
export interface LogApi {
/**
* Clears the log.
*/
clear(): Promise;
/**
* Disables log domain, prevents further log entries from being reported to the client.
*/
disable(): Promise;
/**
* Enables log domain, sends the entries collected so far to the client by means of the
* `entryAdded` notification.
*/
enable(): Promise;
/**
* start violation reporting.
*/
startViolationsReport(params: Protocol.Log.StartViolationsReportRequest): Promise;
/**
* Stop violation reporting.
*/
stopViolationsReport(): Promise;
/**
* Issued when new message was logged.
*/
on(event: 'entryAdded', listener: (params: Protocol.Log.EntryAddedEvent) => void): void;
}
export interface MemoryApi {
getDOMCounters(): Promise;
prepareForLeakDetection(): Promise;
/**
* Simulate OomIntervention by purging V8 memory.
*/
forciblyPurgeJavaScriptMemory(): Promise;
/**
* Enable/disable suppressing memory pressure notifications in all processes.
*/
setPressureNotificationsSuppressed(params: Protocol.Memory.SetPressureNotificationsSuppressedRequest):
Promise;
/**
* Simulate a memory pressure notification in all processes.
*/
simulatePressureNotification(params: Protocol.Memory.SimulatePressureNotificationRequest): Promise;
/**
* Start collecting native memory profile.
*/
startSampling(params: Protocol.Memory.StartSamplingRequest): Promise;
/**
* Stop collecting native memory profile.
*/
stopSampling(): Promise;
/**
* Retrieve native memory allocations profile
* collected since renderer process startup.
*/
getAllTimeSamplingProfile(): Promise;
/**
* Retrieve native memory allocations profile
* collected since browser process startup.
*/
getBrowserSamplingProfile(): Promise;
/**
* Retrieve native memory allocations profile collected since last
* `startSampling` call.
*/
getSamplingProfile(): Promise;
}
export interface NetworkApi {
/**
* Tells whether clearing browser cache is supported.
*/
canClearBrowserCache(): Promise;
/**
* Tells whether clearing browser cookies is supported.
*/
canClearBrowserCookies(): Promise;
/**
* Tells whether emulation of network conditions is supported.
*/
canEmulateNetworkConditions(): Promise;
/**
* Clears browser cache.
*/
clearBrowserCache(): Promise;
/**
* Clears browser cookies.
*/
clearBrowserCookies(): Promise;
/**
* Response to Network.requestIntercepted which either modifies the request to continue with any
* modifications, or blocks it, or completes it with the provided response bytes. If a network
* fetch occurs as a result which encounters a redirect an additional Network.requestIntercepted
* event will be sent with the same InterceptionId.
* Deprecated, use Fetch.continueRequest, Fetch.fulfillRequest and Fetch.failRequest instead.
*/
continueInterceptedRequest(params: Protocol.Network.ContinueInterceptedRequestRequest): Promise;
/**
* Deletes browser cookies with matching name and url or domain/path pair.
*/
deleteCookies(params: Protocol.Network.DeleteCookiesRequest): Promise;
/**
* Disables network tracking, prevents network events from being sent to the client.
*/
disable(): Promise;
/**
* Activates emulation of network conditions.
*/
emulateNetworkConditions(params: Protocol.Network.EmulateNetworkConditionsRequest): Promise;
/**
* Enables network tracking, network events will now be delivered to the client.
*/
enable(params: Protocol.Network.EnableRequest): Promise;
/**
* Returns all browser cookies. Depending on the backend support, will return detailed cookie
* information in the `cookies` field.
*/
getAllCookies(): Promise;
/**
* Returns the DER-encoded certificate.
*/
getCertificate(params: Protocol.Network.GetCertificateRequest): Promise;
/**
* Returns all browser cookies for the current URL. Depending on the backend support, will return
* detailed cookie information in the `cookies` field.
*/
getCookies(params: Protocol.Network.GetCookiesRequest): Promise;
/**
* Returns content served for the given request.
*/
getResponseBody(params: Protocol.Network.GetResponseBodyRequest): Promise;
/**
* Returns post data sent with the request. Returns an error when no data was sent with the request.
*/
getRequestPostData(params: Protocol.Network.GetRequestPostDataRequest):
Promise;
/**
* Returns content served for the given currently intercepted request.
*/
getResponseBodyForInterception(params: Protocol.Network.GetResponseBodyForInterceptionRequest):
Promise;
/**
* Returns a handle to the stream representing the response body. Note that after this command,
* the intercepted request can't be continued as is -- you either need to cancel it or to provide
* the response body. The stream only supports sequential read, IO.read will fail if the position
* is specified.
*/
takeResponseBodyForInterceptionAsStream(params: Protocol.Network.TakeResponseBodyForInterceptionAsStreamRequest):
Promise;
/**
* This method sends a new XMLHttpRequest which is identical to the original one. The following
* parameters should be identical: method, url, async, request body, extra headers, withCredentials
* attribute, user, password.
*/
replayXHR(params: Protocol.Network.ReplayXHRRequest): Promise;
/**
* Searches for given string in response content.
*/
searchInResponseBody(params: Protocol.Network.SearchInResponseBodyRequest):
Promise;
/**
* Blocks URLs from loading.
*/
setBlockedURLs(params: Protocol.Network.SetBlockedURLsRequest): Promise;
/**
* Toggles ignoring of service worker for each request.
*/
setBypassServiceWorker(params: Protocol.Network.SetBypassServiceWorkerRequest): Promise;
/**
* Toggles ignoring cache for each request. If `true`, cache will not be used.
*/
setCacheDisabled(params: Protocol.Network.SetCacheDisabledRequest): Promise;
/**
* Sets a cookie with the given cookie data; may overwrite equivalent cookies if they exist.
*/
setCookie(params: Protocol.Network.SetCookieRequest): Promise;
/**
* Sets given cookies.
*/
setCookies(params: Protocol.Network.SetCookiesRequest): Promise;
/**
* For testing.
*/
setDataSizeLimitsForTest(params: Protocol.Network.SetDataSizeLimitsForTestRequest): Promise;
/**
* Specifies whether to always send extra HTTP headers with the requests from this page.
*/
setExtraHTTPHeaders(params: Protocol.Network.SetExtraHTTPHeadersRequest): Promise;
/**
* Sets the requests to intercept that match the provided patterns and optionally resource types.
* Deprecated, please use Fetch.enable instead.
*/
setRequestInterception(params: Protocol.Network.SetRequestInterceptionRequest): Promise;
/**
* Allows overriding user agent with the given string.
*/
setUserAgentOverride(params: Protocol.Network.SetUserAgentOverrideRequest): Promise;
/**
* Fired when data chunk was received over the network.
*/
on(event: 'dataReceived', listener: (params: Protocol.Network.DataReceivedEvent) => void): void;
/**
* Fired when EventSource message is received.
*/
on(event: 'eventSourceMessageReceived',
listener: (params: Protocol.Network.EventSourceMessageReceivedEvent) => void): void;
/**
* Fired when HTTP request has failed to load.
*/
on(event: 'loadingFailed', listener: (params: Protocol.Network.LoadingFailedEvent) => void): void;
/**
* Fired when HTTP request has finished loading.
*/
on(event: 'loadingFinished', listener: (params: Protocol.Network.LoadingFinishedEvent) => void): void;
/**
* Details of an intercepted HTTP request, which must be either allowed, blocked, modified or
* mocked.
* Deprecated, use Fetch.requestPaused instead.
*/
on(event: 'requestIntercepted', listener: (params: Protocol.Network.RequestInterceptedEvent) => void): void;
/**
* Fired if request ended up loading from cache.
*/
on(event: 'requestServedFromCache', listener: (params: Protocol.Network.RequestServedFromCacheEvent) => void): void;
/**
* Fired when page is about to send HTTP request.
*/
on(event: 'requestWillBeSent', listener: (params: Protocol.Network.RequestWillBeSentEvent) => void): void;
/**
* Fired when resource loading priority is changed
*/
on(event: 'resourceChangedPriority',
listener: (params: Protocol.Network.ResourceChangedPriorityEvent) => void): void;
/**
* Fired when a signed exchange was received over the network
*/
on(event: 'signedExchangeReceived', listener: (params: Protocol.Network.SignedExchangeReceivedEvent) => void): void;
/**
* Fired when HTTP response is available.
*/
on(event: 'responseReceived', listener: (params: Protocol.Network.ResponseReceivedEvent) => void): void;
/**
* Fired when WebSocket is closed.
*/
on(event: 'webSocketClosed', listener: (params: Protocol.Network.WebSocketClosedEvent) => void): void;
/**
* Fired upon WebSocket creation.
*/
on(event: 'webSocketCreated', listener: (params: Protocol.Network.WebSocketCreatedEvent) => void): void;
/**
* Fired when WebSocket message error occurs.
*/
on(event: 'webSocketFrameError', listener: (params: Protocol.Network.WebSocketFrameErrorEvent) => void): void;
/**
* Fired when WebSocket message is received.
*/
on(event: 'webSocketFrameReceived', listener: (params: Protocol.Network.WebSocketFrameReceivedEvent) => void): void;
/**
* Fired when WebSocket message is sent.
*/
on(event: 'webSocketFrameSent', listener: (params: Protocol.Network.WebSocketFrameSentEvent) => void): void;
/**
* Fired when WebSocket handshake response becomes available.
*/
on(event: 'webSocketHandshakeResponseReceived',
listener: (params: Protocol.Network.WebSocketHandshakeResponseReceivedEvent) => void): void;
/**
* Fired when WebSocket is about to initiate handshake.
*/
on(event: 'webSocketWillSendHandshakeRequest',
listener: (params: Protocol.Network.WebSocketWillSendHandshakeRequestEvent) => void): void;
/**
* Fired when additional information about a requestWillBeSent event is available from the
* network stack. Not every requestWillBeSent event will have an additional
* requestWillBeSentExtraInfo fired for it, and there is no guarantee whether requestWillBeSent
* or requestWillBeSentExtraInfo will be fired first for the same request.
*/
on(event: 'requestWillBeSentExtraInfo',
listener: (params: Protocol.Network.RequestWillBeSentExtraInfoEvent) => void): void;
/**
* Fired when additional information about a responseReceived event is available from the network
* stack. Not every responseReceived event will have an additional responseReceivedExtraInfo for
* it, and responseReceivedExtraInfo may be fired before or after responseReceived.
*/
on(event: 'responseReceivedExtraInfo',
listener: (params: Protocol.Network.ResponseReceivedExtraInfoEvent) => void): void;
}
export interface OverlayApi {
/**
* Disables domain notifications.
*/
disable(): Promise;
/**
* Enables domain notifications.
*/
enable(): Promise;
/**
* For testing.
*/
getHighlightObjectForTest(params: Protocol.Overlay.GetHighlightObjectForTestRequest):
Promise;
/**
* Hides any highlight.
*/
hideHighlight(): Promise;
/**
* Highlights owner element of the frame with given id.
*/
highlightFrame(params: Protocol.Overlay.HighlightFrameRequest): Promise;
/**
* Highlights DOM node with given id or with the given JavaScript object wrapper. Either nodeId or
* objectId must be specified.
*/
highlightNode(params: Protocol.Overlay.HighlightNodeRequest): Promise;
/**
* Highlights given quad. Coordinates are absolute with respect to the main frame viewport.
*/
highlightQuad(params: Protocol.Overlay.HighlightQuadRequest): Promise;
/**
* Highlights given rectangle. Coordinates are absolute with respect to the main frame viewport.
*/
highlightRect(params: Protocol.Overlay.HighlightRectRequest): Promise;
/**
* Enters the 'inspect' mode. In this mode, elements that user is hovering over are highlighted.
* Backend then generates 'inspectNodeRequested' event upon element selection.
*/
setInspectMode(params: Protocol.Overlay.SetInspectModeRequest): Promise
