Skip to main content
Deno 2 is finally here 🎉️
Learn more
Latest
interface default.Events
import { type default } from "https://deno.land/x/pptr@1.2.0/vendor/devtools-protocol/protocol-mapping.d.ts";
const { Events } = default;

Properties

Console.messageAdded: [Protocol.Console.MessageAddedEvent]

Issued when new console message is added.

Debugger.breakpointResolved: [Protocol.Debugger.BreakpointResolvedEvent]

Fired when breakpoint is resolved to an actual script and location.

Debugger.paused: [Protocol.Debugger.PausedEvent]

Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria.

Debugger.resumed: []

Fired when the virtual machine resumed execution.

Debugger.scriptFailedToParse: [Protocol.Debugger.ScriptFailedToParseEvent]

Fired when virtual machine fails to parse the script.

Debugger.scriptParsed: [Protocol.Debugger.ScriptParsedEvent]

Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.

HeapProfiler.addHeapSnapshotChunk: [Protocol.HeapProfiler.AddHeapSnapshotChunkEvent]
HeapProfiler.heapStatsUpdate: [Protocol.HeapProfiler.HeapStatsUpdateEvent]

If heap objects tracking has been started then backend may send update for one or more fragments

HeapProfiler.lastSeenObjectId: [Protocol.HeapProfiler.LastSeenObjectIdEvent]

If heap objects tracking has been started then backend regularly sends a current value for last seen object id and corresponding timestamp. If the were changes in the heap since last event then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.

HeapProfiler.reportHeapSnapshotProgress: [Protocol.HeapProfiler.ReportHeapSnapshotProgressEvent]
HeapProfiler.resetProfiles: []
Profiler.consoleProfileFinished: [Protocol.Profiler.ConsoleProfileFinishedEvent]
Profiler.consoleProfileStarted: [Protocol.Profiler.ConsoleProfileStartedEvent]

Sent when new profile recording is started using console.profile() call.

Profiler.preciseCoverageDeltaUpdate: [Protocol.Profiler.PreciseCoverageDeltaUpdateEvent]

Reports coverage delta since the last poll (either from an event like this, or from takePreciseCoverage for the current isolate. May only be sent if precise code coverage has been started. This event can be trigged by the embedder to, for example, trigger collection of coverage data immediatelly at a certain point in time.

Runtime.bindingCalled: [Protocol.Runtime.BindingCalledEvent]

Notification is issued every time when binding is called.

Runtime.consoleAPICalled: [Protocol.Runtime.ConsoleAPICalledEvent]

Issued when console API was called.

Runtime.exceptionRevoked: [Protocol.Runtime.ExceptionRevokedEvent]

Issued when unhandled exception was revoked.

Runtime.exceptionThrown: [Protocol.Runtime.ExceptionThrownEvent]

Issued when exception was thrown and unhandled.

Runtime.executionContextCreated: [Protocol.Runtime.ExecutionContextCreatedEvent]

Issued when new execution context is created.

Runtime.executionContextDestroyed: [Protocol.Runtime.ExecutionContextDestroyedEvent]

Issued when execution context is destroyed.

Runtime.executionContextsCleared: []

Issued when all executionContexts were cleared in browser

Runtime.inspectRequested: [Protocol.Runtime.InspectRequestedEvent]

Issued when object should be inspected (for example, as a result of inspect() command line API call).

Animation.animationCanceled: [Protocol.Animation.AnimationCanceledEvent]

Event for when an animation has been cancelled.

Animation.animationCreated: [Protocol.Animation.AnimationCreatedEvent]

Event for each animation that has been created.

Animation.animationStarted: [Protocol.Animation.AnimationStartedEvent]

Event for animation that has been started.

ApplicationCache.applicationCacheStatusUpdated: [Protocol.ApplicationCache.ApplicationCacheStatusUpdatedEvent]
ApplicationCache.networkStateUpdated: [Protocol.ApplicationCache.NetworkStateUpdatedEvent]
Audits.issueAdded: [Protocol.Audits.IssueAddedEvent]
BackgroundService.recordingStateChanged: [Protocol.BackgroundService.RecordingStateChangedEvent]

Called when the recording state for the service has been updated.

BackgroundService.backgroundServiceEventReceived: [Protocol.BackgroundService.BackgroundServiceEventReceivedEvent]

Called with all existing backgroundServiceEvents when enabled, and all new events afterwards if enabled and recording.

CSS.fontsUpdated: [Protocol.CSS.FontsUpdatedEvent]

Fires whenever a web font is updated. A non-empty font parameter indicates a successfully loaded web font

CSS.mediaQueryResultChanged: []

Fires whenever a MediaQuery result changes (for example, after a browser window has been resized.) The current implementation considers only viewport-dependent media features.

CSS.styleSheetAdded: [Protocol.CSS.StyleSheetAddedEvent]

Fired whenever an active document stylesheet is added.

CSS.styleSheetChanged: [Protocol.CSS.StyleSheetChangedEvent]

Fired whenever a stylesheet is changed as a result of the client operation.

CSS.styleSheetRemoved: [Protocol.CSS.StyleSheetRemovedEvent]

Fired whenever an active document stylesheet is removed.

Cast.sinksUpdated: [Protocol.Cast.SinksUpdatedEvent]

This is fired whenever the list of available sinks changes. A sink is a device or a software surface that you can cast to.

Cast.issueUpdated: [Protocol.Cast.IssueUpdatedEvent]

This is fired whenever the outstanding issue/error message changes. |issueMessage| is empty if there is no issue.

DOM.attributeModified: [Protocol.DOM.AttributeModifiedEvent]

Fired when Element's attribute is modified.

DOM.attributeRemoved: [Protocol.DOM.AttributeRemovedEvent]

Fired when Element's attribute is removed.

DOM.characterDataModified: [Protocol.DOM.CharacterDataModifiedEvent]

Mirrors DOMCharacterDataModified event.

DOM.childNodeCountUpdated: [Protocol.DOM.ChildNodeCountUpdatedEvent]

Fired when Container's child node count has changed.

DOM.childNodeInserted: [Protocol.DOM.ChildNodeInsertedEvent]

Mirrors DOMNodeInserted event.

DOM.childNodeRemoved: [Protocol.DOM.ChildNodeRemovedEvent]

Mirrors DOMNodeRemoved event.

DOM.distributedNodesUpdated: [Protocol.DOM.DistributedNodesUpdatedEvent]

Called when distrubution is changed.

DOM.documentUpdated: []

Fired when Document has been totally updated. Node ids are no longer valid.

DOM.inlineStyleInvalidated: [Protocol.DOM.InlineStyleInvalidatedEvent]

Fired when Element's inline style is modified via a CSS property modification.

DOM.pseudoElementAdded: [Protocol.DOM.PseudoElementAddedEvent]

Called when a pseudo element is added to an element.

DOM.pseudoElementRemoved: [Protocol.DOM.PseudoElementRemovedEvent]

Called when a pseudo element is removed from an element.

DOM.setChildNodes: [Protocol.DOM.SetChildNodesEvent]

Fired when backend wants to provide client with the missing DOM structure. This happens upon most of the calls requesting node ids.

DOM.shadowRootPopped: [Protocol.DOM.ShadowRootPoppedEvent]

Called when shadow root is popped from the element.

DOM.shadowRootPushed: [Protocol.DOM.ShadowRootPushedEvent]

Called when shadow root is pushed into the element.

DOMStorage.domStorageItemAdded: [Protocol.DOMStorage.DomStorageItemAddedEvent]
DOMStorage.domStorageItemRemoved: [Protocol.DOMStorage.DomStorageItemRemovedEvent]
DOMStorage.domStorageItemUpdated: [Protocol.DOMStorage.DomStorageItemUpdatedEvent]
DOMStorage.domStorageItemsCleared: [Protocol.DOMStorage.DomStorageItemsClearedEvent]
Database.addDatabase: [Protocol.Database.AddDatabaseEvent]
Emulation.virtualTimeBudgetExpired: []

Notification sent after the virtual time budget for the current VirtualTimePolicy has run out.

HeadlessExperimental.needsBeginFramesChanged: [Protocol.HeadlessExperimental.NeedsBeginFramesChangedEvent]

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.

Inspector.detached: [Protocol.Inspector.DetachedEvent]

Fired when remote debugging connection is about to be terminated. Contains detach reason.

Inspector.targetCrashed: []

Fired when debugging target has crashed

Inspector.targetReloadedAfterCrash: []

Fired when debugging target has reloaded after crash

LayerTree.layerPainted: [Protocol.LayerTree.LayerPaintedEvent]
LayerTree.layerTreeDidChange: [Protocol.LayerTree.LayerTreeDidChangeEvent]
Log.entryAdded: [Protocol.Log.EntryAddedEvent]

Issued when new message was logged.

Network.dataReceived: [Protocol.Network.DataReceivedEvent]

Fired when data chunk was received over the network.

Network.eventSourceMessageReceived: [Protocol.Network.EventSourceMessageReceivedEvent]

Fired when EventSource message is received.

Network.loadingFailed: [Protocol.Network.LoadingFailedEvent]

Fired when HTTP request has failed to load.

Network.loadingFinished: [Protocol.Network.LoadingFinishedEvent]

Fired when HTTP request has finished loading.

Network.requestIntercepted: [Protocol.Network.RequestInterceptedEvent]

Details of an intercepted HTTP request, which must be either allowed, blocked, modified or mocked. Deprecated, use Fetch.requestPaused instead.

Network.requestServedFromCache: [Protocol.Network.RequestServedFromCacheEvent]

Fired if request ended up loading from cache.

Network.requestWillBeSent: [Protocol.Network.RequestWillBeSentEvent]

Fired when page is about to send HTTP request.

Network.resourceChangedPriority: [Protocol.Network.ResourceChangedPriorityEvent]

Fired when resource loading priority is changed

Network.signedExchangeReceived: [Protocol.Network.SignedExchangeReceivedEvent]

Fired when a signed exchange was received over the network

Network.responseReceived: [Protocol.Network.ResponseReceivedEvent]

Fired when HTTP response is available.

Network.webSocketClosed: [Protocol.Network.WebSocketClosedEvent]

Fired when WebSocket is closed.

Network.webSocketCreated: [Protocol.Network.WebSocketCreatedEvent]

Fired upon WebSocket creation.

Network.webSocketFrameError: [Protocol.Network.WebSocketFrameErrorEvent]

Fired when WebSocket message error occurs.

Network.webSocketFrameReceived: [Protocol.Network.WebSocketFrameReceivedEvent]

Fired when WebSocket message is received.

Network.webSocketFrameSent: [Protocol.Network.WebSocketFrameSentEvent]

Fired when WebSocket message is sent.

Network.webSocketHandshakeResponseReceived: [Protocol.Network.WebSocketHandshakeResponseReceivedEvent]

Fired when WebSocket handshake response becomes available.

Network.webSocketWillSendHandshakeRequest: [Protocol.Network.WebSocketWillSendHandshakeRequestEvent]

Fired when WebSocket is about to initiate handshake.

Network.requestWillBeSentExtraInfo: [Protocol.Network.RequestWillBeSentExtraInfoEvent]

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.

Network.responseReceivedExtraInfo: [Protocol.Network.ResponseReceivedExtraInfoEvent]

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.

Overlay.inspectNodeRequested: [Protocol.Overlay.InspectNodeRequestedEvent]

Fired when the node should be inspected. This happens after call to setInspectMode or when user manually inspects an element.

Overlay.nodeHighlightRequested: [Protocol.Overlay.NodeHighlightRequestedEvent]

Fired when the node should be highlighted. This happens after call to setInspectMode.

Overlay.screenshotRequested: [Protocol.Overlay.ScreenshotRequestedEvent]

Fired when user asks to capture screenshot of some area on the page.

Overlay.inspectModeCanceled: []

Fired when user cancels the inspect mode.

Page.domContentEventFired: [Protocol.Page.DomContentEventFiredEvent]
Page.fileChooserOpened: [Protocol.Page.FileChooserOpenedEvent]

Emitted only when page.interceptFileChooser is enabled.

Page.frameAttached: [Protocol.Page.FrameAttachedEvent]

Fired when frame has been attached to its parent.

Page.frameClearedScheduledNavigation: [Protocol.Page.FrameClearedScheduledNavigationEvent]

Fired when frame no longer has a scheduled navigation.

Page.frameDetached: [Protocol.Page.FrameDetachedEvent]

Fired when frame has been detached from its parent.

Page.frameNavigated: [Protocol.Page.FrameNavigatedEvent]

Fired once navigation of the frame has completed. Frame is now associated with the new loader.

Page.frameResized: []
Page.frameRequestedNavigation: [Protocol.Page.FrameRequestedNavigationEvent]

Fired when a renderer-initiated navigation is requested. Navigation may still be cancelled after the event is issued.

Page.frameScheduledNavigation: [Protocol.Page.FrameScheduledNavigationEvent]

Fired when frame schedules a potential navigation.

Page.frameStartedLoading: [Protocol.Page.FrameStartedLoadingEvent]

Fired when frame has started loading.

Page.frameStoppedLoading: [Protocol.Page.FrameStoppedLoadingEvent]

Fired when frame has stopped loading.

Page.downloadWillBegin: [Protocol.Page.DownloadWillBeginEvent]

Fired when page is about to start a download.

Page.downloadProgress: [Protocol.Page.DownloadProgressEvent]

Fired when download makes progress. Last call has |done| == true.

Page.interstitialHidden: []

Fired when interstitial page was hidden

Page.interstitialShown: []

Fired when interstitial page was shown

Page.javascriptDialogClosed: [Protocol.Page.JavascriptDialogClosedEvent]

Fired when a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload) has been closed.

Page.javascriptDialogOpening: [Protocol.Page.JavascriptDialogOpeningEvent]

Fired when a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload) is about to open.

Page.lifecycleEvent: [Protocol.Page.LifecycleEventEvent]

Fired for top level page lifecycle events such as navigation, load, paint, etc.

Page.loadEventFired: [Protocol.Page.LoadEventFiredEvent]
Page.navigatedWithinDocument: [Protocol.Page.NavigatedWithinDocumentEvent]

Fired when same-document navigation happens, e.g. due to history API usage or anchor navigation.

Page.screencastFrame: [Protocol.Page.ScreencastFrameEvent]

Compressed image data requested by the startScreencast.

Page.screencastVisibilityChanged: [Protocol.Page.ScreencastVisibilityChangedEvent]

Fired when the page with currently enabled screencast was shown or hidden `.

Page.windowOpen: [Protocol.Page.WindowOpenEvent]

Fired when a new window is going to be opened, via window.open(), link click, form submission, etc.

Page.compilationCacheProduced: [Protocol.Page.CompilationCacheProducedEvent]

Issued for every compilation cache generated. Is only available if Page.setGenerateCompilationCache is enabled.

Performance.metrics: [Protocol.Performance.MetricsEvent]

Current values of the metrics.

Security.certificateError: [Protocol.Security.CertificateErrorEvent]

There is a certificate error. If overriding certificate errors is enabled, then it should be handled with the handleCertificateError command. Note: this event does not fire if the certificate error has been allowed internally. Only one client per target should override certificate errors at the same time.

Security.visibleSecurityStateChanged: [Protocol.Security.VisibleSecurityStateChangedEvent]

The security state of the page changed.

Security.securityStateChanged: [Protocol.Security.SecurityStateChangedEvent]

The security state of the page changed.

ServiceWorker.workerErrorReported: [Protocol.ServiceWorker.WorkerErrorReportedEvent]
ServiceWorker.workerRegistrationUpdated: [Protocol.ServiceWorker.WorkerRegistrationUpdatedEvent]
ServiceWorker.workerVersionUpdated: [Protocol.ServiceWorker.WorkerVersionUpdatedEvent]
Storage.cacheStorageContentUpdated: [Protocol.Storage.CacheStorageContentUpdatedEvent]

A cache's contents have been modified.

Storage.cacheStorageListUpdated: [Protocol.Storage.CacheStorageListUpdatedEvent]

A cache has been added/deleted.

Storage.indexedDBContentUpdated: [Protocol.Storage.IndexedDBContentUpdatedEvent]

The origin's IndexedDB object store has been modified.

Storage.indexedDBListUpdated: [Protocol.Storage.IndexedDBListUpdatedEvent]

The origin's IndexedDB database list has been modified.

Target.attachedToTarget: [Protocol.Target.AttachedToTargetEvent]

Issued when attached to target because of auto-attach or attachToTarget command.

Target.detachedFromTarget: [Protocol.Target.DetachedFromTargetEvent]

Issued when detached from target for any reason (including detachFromTarget command). Can be issued multiple times per target if multiple sessions have been attached to it.

Target.receivedMessageFromTarget: [Protocol.Target.ReceivedMessageFromTargetEvent]

Notifies about a new protocol message received from the session (as reported in attachedToTarget event).

Target.targetCreated: [Protocol.Target.TargetCreatedEvent]

Issued when a possible inspection target is created.

Target.targetDestroyed: [Protocol.Target.TargetDestroyedEvent]

Issued when a target is destroyed.

Target.targetCrashed: [Protocol.Target.TargetCrashedEvent]

Issued when a target has crashed.

Target.targetInfoChanged: [Protocol.Target.TargetInfoChangedEvent]

Issued when some information about a target has changed. This only happens between targetCreated and targetDestroyed.

Tethering.accepted: [Protocol.Tethering.AcceptedEvent]

Informs that port was successfully bound and got a specified connection id.

Tracing.bufferUsage: [Protocol.Tracing.BufferUsageEvent]
Tracing.dataCollected: [Protocol.Tracing.DataCollectedEvent]

Contains an bucket of collected trace events. When tracing is stopped collected events will be send as a sequence of dataCollected events followed by tracingComplete event.

Tracing.tracingComplete: [Protocol.Tracing.TracingCompleteEvent]

Signals that tracing is stopped and there is no trace buffers pending flush, all data were delivered via dataCollected events.

Fetch.requestPaused: [Protocol.Fetch.RequestPausedEvent]

Issued when the domain is enabled and the request URL matches the specified filter. The request is paused until the client responds with one of continueRequest, failRequest or fulfillRequest. The stage of the request can be determined by presence of responseErrorReason and responseStatusCode -- the request is at the response stage if either of these fields is present and in the request stage otherwise.

Fetch.authRequired: [Protocol.Fetch.AuthRequiredEvent]

Issued when the domain is enabled with handleAuthRequests set to true. The request is paused until client responds with continueWithAuth.

WebAudio.contextCreated: [Protocol.WebAudio.ContextCreatedEvent]

Notifies that a new BaseAudioContext has been created.

WebAudio.contextWillBeDestroyed: [Protocol.WebAudio.ContextWillBeDestroyedEvent]

Notifies that an existing BaseAudioContext will be destroyed.

WebAudio.contextChanged: [Protocol.WebAudio.ContextChangedEvent]

Notifies that existing BaseAudioContext has changed some properties (id stays the same)..

WebAudio.audioListenerCreated: [Protocol.WebAudio.AudioListenerCreatedEvent]

Notifies that the construction of an AudioListener has finished.

WebAudio.audioListenerWillBeDestroyed: [Protocol.WebAudio.AudioListenerWillBeDestroyedEvent]

Notifies that a new AudioListener has been created.

WebAudio.audioNodeCreated: [Protocol.WebAudio.AudioNodeCreatedEvent]

Notifies that a new AudioNode has been created.

WebAudio.audioNodeWillBeDestroyed: [Protocol.WebAudio.AudioNodeWillBeDestroyedEvent]

Notifies that an existing AudioNode has been destroyed.

WebAudio.audioParamCreated: [Protocol.WebAudio.AudioParamCreatedEvent]

Notifies that a new AudioParam has been created.

WebAudio.audioParamWillBeDestroyed: [Protocol.WebAudio.AudioParamWillBeDestroyedEvent]

Notifies that an existing AudioParam has been destroyed.

WebAudio.nodesConnected: [Protocol.WebAudio.NodesConnectedEvent]

Notifies that two AudioNodes are connected.

WebAudio.nodesDisconnected: [Protocol.WebAudio.NodesDisconnectedEvent]

Notifies that AudioNodes are disconnected. The destination can be null, and it means all the outgoing connections from the source are disconnected.

WebAudio.nodeParamConnected: [Protocol.WebAudio.NodeParamConnectedEvent]

Notifies that an AudioNode is connected to an AudioParam.

WebAudio.nodeParamDisconnected: [Protocol.WebAudio.NodeParamDisconnectedEvent]

Notifies that an AudioNode is disconnected to an AudioParam.

Media.playerPropertiesChanged: [Protocol.Media.PlayerPropertiesChangedEvent]

This can be called multiple times, and can be used to set / override / remove player properties. A null propValue indicates removal.

Media.playerEventsAdded: [Protocol.Media.PlayerEventsAddedEvent]

Send events as a list, allowing them to be batched on the browser for less congestion. If batched, events must ALWAYS be in chronological order.

Media.playerMessagesLogged: [Protocol.Media.PlayerMessagesLoggedEvent]

Send a list of any messages that need to be delivered.

Media.playerErrorsRaised: [Protocol.Media.PlayerErrorsRaisedEvent]

Send a list of any errors that need to be delivered.

Media.playersCreated: [Protocol.Media.PlayersCreatedEvent]

Called whenever a player is created, or when a new agent joins and recieves a list of active players. If an agent is restored, it will recieve the full list of player ids and all events again.