devtools-protocol 0.0.1493946 → 0.0.1495869

package/types/protocol-proxy-api.d.ts

@@ -176,6 +176,9 @@ export namespace ProtocolProxyApi {
          */
         getScriptSource(params: Protocol.Debugger.GetScriptSourceRequest): Promise<Protocol.Debugger.GetScriptSourceResponse>;
 
+        /**
+         * @experimental
+         */
         disassembleWasmModule(params: Protocol.Debugger.DisassembleWasmModuleRequest): Promise<Protocol.Debugger.DisassembleWasmModuleResponse>;
 
         /**
@@ -183,16 +186,19 @@ export namespace ProtocolProxyApi {
          * stream. If disassembly is complete, this API will invalidate the streamId
          * and return an empty chunk. Any subsequent calls for the now invalid stream
          * will return errors.
+         * @experimental
          */
         nextWasmDisassemblyChunk(params: Protocol.Debugger.NextWasmDisassemblyChunkRequest): Promise<Protocol.Debugger.NextWasmDisassemblyChunkResponse>;
 
         /**
          * This command is deprecated. Use getScriptSource instead.
+         * @deprecated
          */
         getWasmBytecode(params: Protocol.Debugger.GetWasmBytecodeRequest): Promise<Protocol.Debugger.GetWasmBytecodeResponse>;
 
         /**
          * Returns stack trace with given `stackTraceId`.
+         * @experimental
          */
         getStackTrace(params: Protocol.Debugger.GetStackTraceRequest): Promise<Protocol.Debugger.GetStackTraceResponse>;
 
@@ -201,6 +207,10 @@ export namespace ProtocolProxyApi {
          */
         pause(): Promise<void>;
 
+        /**
+         * @deprecated
+         * @experimental
+         */
         pauseOnAsyncCall(params: Protocol.Debugger.PauseOnAsyncCallRequest): Promise<void>;
 
         /**
@@ -244,6 +254,7 @@ export namespace ProtocolProxyApi {
          * Replace previous blackbox execution contexts with passed ones. Forces backend to skip
          * stepping/pausing in scripts in these execution contexts. VM will try to leave blackboxed script by
          * performing 'step in' several times, finally resorting to 'step out' if unsuccessful.
+         * @experimental
          */
         setBlackboxExecutionContexts(params: Protocol.Debugger.SetBlackboxExecutionContextsRequest): Promise<void>;
 
@@ -251,6 +262,7 @@ export namespace ProtocolProxyApi {
          * Replace previous blackbox patterns with passed ones. Forces backend to skip stepping/pausing in
          * scripts with url matching one of the patterns. VM will try to leave blackboxed script by
          * performing 'step in' several times, finally resorting to 'step out' if unsuccessful.
+         * @experimental
          */
         setBlackboxPatterns(params: Protocol.Debugger.SetBlackboxPatternsRequest): Promise<void>;
 
@@ -259,6 +271,7 @@ export namespace ProtocolProxyApi {
          * scripts by performing 'step in' several times, finally resorting to 'step out' if unsuccessful.
          * Positions array contains positions where blackbox state is changed. First interval isn't
          * blackboxed. Array should be sorted.
+         * @experimental
          */
         setBlackboxedRanges(params: Protocol.Debugger.SetBlackboxedRangesRequest): Promise<void>;
 
@@ -284,6 +297,7 @@ export namespace ProtocolProxyApi {
          * Sets JavaScript breakpoint before each call to the given function.
          * If another function was created from the same source as a given one,
          * calling it will also trigger the breakpoint.
+         * @experimental
          */
         setBreakpointOnFunctionCall(params: Protocol.Debugger.SetBreakpointOnFunctionCallRequest): Promise<Protocol.Debugger.SetBreakpointOnFunctionCallResponse>;
 
@@ -300,6 +314,7 @@ export namespace ProtocolProxyApi {
 
         /**
          * Changes return value in top frame. Available only at return break position.
+         * @experimental
          */
         setReturnValue(params: Protocol.Debugger.SetReturnValueRequest): Promise<void>;
 
@@ -343,6 +358,7 @@ export namespace ProtocolProxyApi {
         /**
          * Fired when breakpoint is resolved to an actual script and location.
          * Deprecated in favor of `resolvedBreakpoints` in the `scriptParsed` event.
+         * @deprecated
          */
         on(event: 'breakpointResolved', listener: (params: Protocol.Debugger.BreakpointResolvedEvent) => void): void;
 
@@ -469,6 +485,7 @@ export namespace ProtocolProxyApi {
          * `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 immediately at a certain point in time.
+         * @experimental
          */
         on(event: 'preciseCoverageDeltaUpdate', listener: (params: Protocol.Profiler.PreciseCoverageDeltaUpdateEvent) => void): void;
 
@@ -515,12 +532,14 @@ export namespace ProtocolProxyApi {
 
         /**
          * Returns the isolate id.
+         * @experimental
          */
         getIsolateId(): Promise<Protocol.Runtime.GetIsolateIdResponse>;
 
         /**
          * Returns the JavaScript heap usage.
          * It is the total usage of the corresponding isolate not scoped to a particular Runtime.
+         * @experimental
          */
         getHeapUsage(): Promise<Protocol.Runtime.GetHeapUsageResponse>;
 
@@ -562,13 +581,20 @@ export namespace ProtocolProxyApi {
          */
         setAsyncCallStackDepth(params: Protocol.Runtime.SetAsyncCallStackDepthRequest): Promise<void>;
 
+        /**
+         * @experimental
+         */
         setCustomObjectFormatterEnabled(params: Protocol.Runtime.SetCustomObjectFormatterEnabledRequest): Promise<void>;
 
+        /**
+         * @experimental
+         */
         setMaxCallStackSizeToCapture(params: Protocol.Runtime.SetMaxCallStackSizeToCaptureRequest): Promise<void>;
 
         /**
          * Terminate current or next JavaScript execution.
          * Will cancel the termination when the outer-most script execution ends.
+         * @experimental
          */
         terminateExecution(): Promise<void>;
 
@@ -594,11 +620,13 @@ export namespace ProtocolProxyApi {
          * Note that the stackTrace portion of the resulting exceptionDetails will
          * only be populated if the Runtime domain was enabled at the time when the
          * Error was thrown.
+         * @experimental
          */
         getExceptionDetails(params: Protocol.Runtime.GetExceptionDetailsRequest): Promise<Protocol.Runtime.GetExceptionDetailsResponse>;
 
         /**
          * Notification is issued every time when binding is called.
+         * @experimental
          */
         on(event: 'bindingCalled', listener: (params: Protocol.Runtime.BindingCalledEvent) => void): void;
 
@@ -662,29 +690,34 @@ export namespace ProtocolProxyApi {
 
         /**
          * Fetches the accessibility node and partial accessibility tree for this DOM node, if it exists.
+         * @experimental
          */
         getPartialAXTree(params: Protocol.Accessibility.GetPartialAXTreeRequest): Promise<Protocol.Accessibility.GetPartialAXTreeResponse>;
 
         /**
          * Fetches the entire accessibility tree for the root Document
+         * @experimental
          */
         getFullAXTree(params: Protocol.Accessibility.GetFullAXTreeRequest): Promise<Protocol.Accessibility.GetFullAXTreeResponse>;
 
         /**
          * Fetches the root node.
          * Requires `enable()` to have been called previously.
+         * @experimental
          */
         getRootAXNode(params: Protocol.Accessibility.GetRootAXNodeRequest): Promise<Protocol.Accessibility.GetRootAXNodeResponse>;
 
         /**
          * Fetches a node and all ancestors up to and including the root.
          * Requires `enable()` to have been called previously.
+         * @experimental
          */
         getAXNodeAndAncestors(params: Protocol.Accessibility.GetAXNodeAndAncestorsRequest): Promise<Protocol.Accessibility.GetAXNodeAndAncestorsResponse>;
 
         /**
          * Fetches a particular accessibility node by AXNodeId.
          * Requires `enable()` to have been called previously.
+         * @experimental
          */
         getChildAXNodes(params: Protocol.Accessibility.GetChildAXNodesRequest): Promise<Protocol.Accessibility.GetChildAXNodesResponse>;
 
@@ -694,17 +727,20 @@ export namespace ProtocolProxyApi {
          * ignored for accessibility, and returns those that match the specified name and role. If no DOM
          * node is specified, or the DOM node does not exist, the command returns an error. If neither
          * `accessibleName` or `role` is specified, it returns all the accessibility nodes in the subtree.
+         * @experimental
          */
         queryAXTree(params: Protocol.Accessibility.QueryAXTreeRequest): Promise<Protocol.Accessibility.QueryAXTreeResponse>;
 
         /**
          * The loadComplete event mirrors the load complete event sent by the browser to assistive
          * technology when the web page has finished loading.
+         * @experimental
          */
         on(event: 'loadComplete', listener: (params: Protocol.Accessibility.LoadCompleteEvent) => void): void;
 
         /**
          * The nodesUpdated event is sent every time a previously requested node has changed the in tree.
+         * @experimental
          */
         on(event: 'nodesUpdated', listener: (params: Protocol.Accessibility.NodesUpdatedEvent) => void): void;
 
@@ -924,11 +960,13 @@ export namespace ProtocolProxyApi {
     export interface BrowserApi {
         /**
          * Set permission settings for given origin.
+         * @experimental
          */
         setPermission(params: Protocol.Browser.SetPermissionRequest): Promise<void>;
 
         /**
          * Grant specific permissions to the given origin and reject all others.
+         * @experimental
          */
         grantPermissions(params: Protocol.Browser.GrantPermissionsRequest): Promise<void>;
 
@@ -939,11 +977,13 @@ export namespace ProtocolProxyApi {
 
         /**
          * Set the behavior when downloading a file.
+         * @experimental
          */
         setDownloadBehavior(params: Protocol.Browser.SetDownloadBehaviorRequest): Promise<void>;
 
         /**
          * Cancel a download if in progress
+         * @experimental
          */
         cancelDownload(params: Protocol.Browser.CancelDownloadRequest): Promise<void>;
 
@@ -954,11 +994,13 @@ export namespace ProtocolProxyApi {
 
         /**
          * Crashes browser on the main thread.
+         * @experimental
          */
         crash(): Promise<void>;
 
         /**
          * Crashes GPU process.
+         * @experimental
          */
         crashGpuProcess(): Promise<void>;
 
@@ -970,46 +1012,55 @@ export namespace ProtocolProxyApi {
         /**
          * Returns the command line switches for the browser process if, and only if
          * --enable-automation is on the commandline.
+         * @experimental
          */
         getBrowserCommandLine(): Promise<Protocol.Browser.GetBrowserCommandLineResponse>;
 
         /**
          * Get Chrome histograms.
+         * @experimental
          */
         getHistograms(params: Protocol.Browser.GetHistogramsRequest): Promise<Protocol.Browser.GetHistogramsResponse>;
 
         /**
          * Get a Chrome histogram by name.
+         * @experimental
          */
         getHistogram(params: Protocol.Browser.GetHistogramRequest): Promise<Protocol.Browser.GetHistogramResponse>;
 
         /**
          * Get position and size of the browser window.
+         * @experimental
          */
         getWindowBounds(params: Protocol.Browser.GetWindowBoundsRequest): Promise<Protocol.Browser.GetWindowBoundsResponse>;
 
         /**
          * Get the browser window that contains the devtools target.
+         * @experimental
          */
         getWindowForTarget(params: Protocol.Browser.GetWindowForTargetRequest): Promise<Protocol.Browser.GetWindowForTargetResponse>;
 
         /**
          * Set position and/or size of the browser window.
+         * @experimental
          */
         setWindowBounds(params: Protocol.Browser.SetWindowBoundsRequest): Promise<void>;
 
         /**
          * Set size of the browser contents resizing browser window as necessary.
+         * @experimental
          */
         setContentsSize(params: Protocol.Browser.SetContentsSizeRequest): Promise<void>;
 
         /**
          * Set dock tile details, platform-specific.
+         * @experimental
          */
         setDockTile(params: Protocol.Browser.SetDockTileRequest): Promise<void>;
 
         /**
          * Invoke custom browser commands used by telemetry.
+         * @experimental
          */
         executeBrowserCommand(params: Protocol.Browser.ExecuteBrowserCommandRequest): Promise<void>;
 
@@ -1029,11 +1080,13 @@ export namespace ProtocolProxyApi {
 
         /**
          * Fired when page is about to start a download.
+         * @experimental
          */
         on(event: 'downloadWillBegin', listener: (params: Protocol.Browser.DownloadWillBeginEvent) => void): void;
 
         /**
          * Fired when download makes progress. Last call has |done| == true.
+         * @experimental
          */
         on(event: 'downloadProgress', listener: (params: Protocol.Browser.DownloadProgressEvent) => void): void;
 
@@ -1095,9 +1148,13 @@ export namespace ProtocolProxyApi {
          * to the provided property syntax, the value is parsed using combined
          * syntax as if null `propertyName` was provided. If the value cannot be
          * resolved even then, return the provided value without any changes.
+         * @experimental
          */
         resolveValues(params: Protocol.CSS.ResolveValuesRequest): Promise<Protocol.CSS.ResolveValuesResponse>;
 
+        /**
+         * @experimental
+         */
         getLonghandProperties(params: Protocol.CSS.GetLonghandPropertiesRequest): Promise<Protocol.CSS.GetLonghandPropertiesResponse>;
 
         /**
@@ -1109,6 +1166,7 @@ export namespace ProtocolProxyApi {
         /**
          * Returns the styles coming from animations & transitions
          * including the animation & transition styles coming from inheritance chain.
+         * @experimental
          */
         getAnimatedStylesForNode(params: Protocol.CSS.GetAnimatedStylesForNodeRequest): Promise<Protocol.CSS.GetAnimatedStylesForNodeResponse>;
 
@@ -1119,6 +1177,7 @@ export namespace ProtocolProxyApi {
 
         /**
          * Returns the values of the default UA-defined environment variables used in env()
+         * @experimental
          */
         getEnvironmentVariables(): Promise<Protocol.CSS.GetEnvironmentVariablesResponse>;
 
@@ -1143,12 +1202,14 @@ export namespace ProtocolProxyApi {
          * Given a DOM element identified by nodeId, getLayersForNode returns the root
          * layer for the nearest ancestor document or shadow root. The layer root contains
          * the full layer tree for the tree scope and their ordering.
+         * @experimental
          */
         getLayersForNode(params: Protocol.CSS.GetLayersForNodeRequest): Promise<Protocol.CSS.GetLayersForNodeResponse>;
 
         /**
          * Given a CSS selector text and a style sheet ID, getLocationForSelector
          * returns an array of locations of the CSS selector in the style sheet.
+         * @experimental
          */
         getLocationForSelector(params: Protocol.CSS.GetLocationForSelectorRequest): Promise<Protocol.CSS.GetLocationForSelectorResponse>;
 
@@ -1159,6 +1220,7 @@ export namespace ProtocolProxyApi {
          * There can only be 1 node tracked for computed style updates
          * so passing a new node id removes tracking from the previous node.
          * Pass `undefined` to disable tracking.
+         * @experimental
          */
         trackComputedStyleUpdatesForNode(params: Protocol.CSS.TrackComputedStyleUpdatesForNodeRequest): Promise<void>;
 
@@ -1169,11 +1231,13 @@ export namespace ProtocolProxyApi {
          * The changes to computed style properties are only tracked for nodes pushed to the front-end
          * by the DOM agent. If no changes to the tracked properties occur after the node has been pushed
          * to the front-end, no updates will be issued for the node.
+         * @experimental
          */
         trackComputedStyleUpdates(params: Protocol.CSS.TrackComputedStyleUpdatesRequest): Promise<void>;
 
         /**
          * Polls the next batch of computed style updates.
+         * @experimental
          */
         takeComputedStyleUpdates(): Promise<Protocol.CSS.TakeComputedStyleUpdatesResponse>;
 
@@ -1200,16 +1264,19 @@ export namespace ProtocolProxyApi {
 
         /**
          * Modifies the expression of a container query.
+         * @experimental
          */
         setContainerQueryText(params: Protocol.CSS.SetContainerQueryTextRequest): Promise<Protocol.CSS.SetContainerQueryTextResponse>;
 
         /**
          * Modifies the expression of a supports at-rule.
+         * @experimental
          */
         setSupportsText(params: Protocol.CSS.SetSupportsTextRequest): Promise<Protocol.CSS.SetSupportsTextResponse>;
 
         /**
          * Modifies the expression of a scope at-rule.
+         * @experimental
          */
         setScopeText(params: Protocol.CSS.SetScopeTextRequest): Promise<Protocol.CSS.SetScopeTextResponse>;
 
@@ -1247,6 +1314,7 @@ export namespace ProtocolProxyApi {
 
         /**
          * Enables/disables rendering of local CSS fonts (enabled by default).
+         * @experimental
          */
         setLocalFontsEnabled(params: Protocol.CSS.SetLocalFontsEnabledRequest): Promise<void>;
 
@@ -1277,6 +1345,9 @@ export namespace ProtocolProxyApi {
          */
         on(event: 'styleSheetRemoved', listener: (params: Protocol.CSS.StyleSheetRemovedEvent) => void): void;
 
+        /**
+         * @experimental
+         */
         on(event: 'computedStyleUpdated', listener: (params: Protocol.CSS.ComputedStyleUpdatedEvent) => void): void;
 
     }
@@ -1362,12 +1433,14 @@ export namespace ProtocolProxyApi {
     export interface DOMApi {
         /**
          * Collects class names for the node with given id and all of it's child nodes.
+         * @experimental
          */
         collectClassNamesFromSubtree(params: Protocol.DOM.CollectClassNamesFromSubtreeRequest): Promise<Protocol.DOM.CollectClassNamesFromSubtreeResponse>;
 
         /**
          * Creates a deep copy of the specified node and places it into the target container before the
          * given anchor.
+         * @experimental
          */
         copyTo(params: Protocol.DOM.CopyToRequest): Promise<Protocol.DOM.CopyToResponse>;
 
@@ -1392,6 +1465,7 @@ export namespace ProtocolProxyApi {
         /**
          * Discards search results from the session with the given id. `getSearchResults` should no longer
          * be called for that search.
+         * @experimental
          */
         discardSearchResults(params: Protocol.DOM.DiscardSearchResultsRequest): Promise<void>;
 
@@ -1418,6 +1492,7 @@ export namespace ProtocolProxyApi {
         /**
          * Returns quads that describe node position on the page. This method
          * might return multiple quads for inline nodes.
+         * @experimental
          */
         getContentQuads(params: Protocol.DOM.GetContentQuadsRequest): Promise<Protocol.DOM.GetContentQuadsResponse>;
 
@@ -1431,11 +1506,13 @@ export namespace ProtocolProxyApi {
          * Returns the root DOM node (and optionally the subtree) to the caller.
          * Deprecated, as it is not designed to work well with the rest of the DOM agent.
          * Use DOMSnapshot.captureSnapshot instead.
+         * @deprecated
          */
         getFlattenedDocument(params: Protocol.DOM.GetFlattenedDocumentRequest): Promise<Protocol.DOM.GetFlattenedDocumentResponse>;
 
         /**
          * Finds nodes with a given computed style in a subtree.
+         * @experimental
          */
         getNodesForSubtreeByStyle(params: Protocol.DOM.GetNodesForSubtreeByStyleRequest): Promise<Protocol.DOM.GetNodesForSubtreeByStyleResponse>;
 
@@ -1452,12 +1529,14 @@ export namespace ProtocolProxyApi {
 
         /**
          * Returns the id of the nearest ancestor that is a relayout boundary.
+         * @experimental
          */
         getRelayoutBoundary(params: Protocol.DOM.GetRelayoutBoundaryRequest): Promise<Protocol.DOM.GetRelayoutBoundaryResponse>;
 
         /**
          * Returns search results from given `fromIndex` to given `toIndex` from the search with the given
          * identifier.
+         * @experimental
          */
         getSearchResults(params: Protocol.DOM.GetSearchResultsRequest): Promise<Protocol.DOM.GetSearchResultsResponse>;
 
@@ -1478,6 +1557,7 @@ export namespace ProtocolProxyApi {
 
         /**
          * Marks last undoable state.
+         * @experimental
          */
         markUndoableState(): Promise<void>;
 
@@ -1489,16 +1569,19 @@ export namespace ProtocolProxyApi {
         /**
          * Searches for a given string in the DOM tree. Use `getSearchResults` to access search results or
          * `cancelSearch` to end this search session.
+         * @experimental
          */
         performSearch(params: Protocol.DOM.PerformSearchRequest): Promise<Protocol.DOM.PerformSearchResponse>;
 
         /**
          * Requests that the node is sent to the caller given its path. // FIXME, use XPath
+         * @experimental
          */
         pushNodeByPathToFrontend(params: Protocol.DOM.PushNodeByPathToFrontendRequest): Promise<Protocol.DOM.PushNodeByPathToFrontendResponse>;
 
         /**
          * Requests that a batch of nodes is sent to the caller given their backend node ids.
+         * @experimental
          */
         pushNodesByBackendIdsToFrontend(params: Protocol.DOM.PushNodesByBackendIdsToFrontendRequest): Promise<Protocol.DOM.PushNodesByBackendIdsToFrontendResponse>;
 
@@ -1516,16 +1599,19 @@ export namespace ProtocolProxyApi {
          * Returns NodeIds of current top layer elements.
          * Top layer is rendered closest to the user within a viewport, therefore its elements always
          * appear on top of all other content.
+         * @experimental
          */
         getTopLayerElements(): Promise<Protocol.DOM.GetTopLayerElementsResponse>;
 
         /**
          * Returns the NodeId of the matched element according to certain relations.
+         * @experimental
          */
         getElementByRelation(params: Protocol.DOM.GetElementByRelationRequest): Promise<Protocol.DOM.GetElementByRelationResponse>;
 
         /**
          * Re-does the last undone action.
+         * @experimental
          */
         redo(): Promise<void>;
 
@@ -1576,28 +1662,33 @@ export namespace ProtocolProxyApi {
 
         /**
          * Sets if stack traces should be captured for Nodes. See `Node.getNodeStackTraces`. Default is disabled.
+         * @experimental
          */
         setNodeStackTracesEnabled(params: Protocol.DOM.SetNodeStackTracesEnabledRequest): Promise<void>;
 
         /**
          * Gets stack traces associated with a Node. As of now, only provides stack trace for Node creation.
+         * @experimental
          */
         getNodeStackTraces(params: Protocol.DOM.GetNodeStackTracesRequest): Promise<Protocol.DOM.GetNodeStackTracesResponse>;
 
         /**
          * Returns file information for the given
          * File wrapper.
+         * @experimental
          */
         getFileInfo(params: Protocol.DOM.GetFileInfoRequest): Promise<Protocol.DOM.GetFileInfoResponse>;
 
         /**
          * Returns list of detached nodes
+         * @experimental
          */
         getDetachedDomNodes(): Promise<Protocol.DOM.GetDetachedDomNodesResponse>;
 
         /**
          * Enables console to refer to the node with given id via $x (see Command Line API for more details
          * $x functions).
+         * @experimental
          */
         setInspectedNode(params: Protocol.DOM.SetInspectedNodeRequest): Promise<void>;
 
@@ -1618,11 +1709,13 @@ export namespace ProtocolProxyApi {
 
         /**
          * Undoes the last performed action.
+         * @experimental
          */
         undo(): Promise<void>;
 
         /**
          * Returns iframe node that owns iframe with the given domain.
+         * @experimental
          */
         getFrameOwner(params: Protocol.DOM.GetFrameOwnerRequest): Promise<Protocol.DOM.GetFrameOwnerResponse>;
 
@@ -1632,24 +1725,28 @@ export namespace ProtocolProxyApi {
          * scroll-state or anchored elements. If no axes are provided and
          * queriesScrollState is false, the style container is returned, which is the
          * direct parent or the closest element with a matching container-name.
+         * @experimental
          */
         getContainerForNode(params: Protocol.DOM.GetContainerForNodeRequest): Promise<Protocol.DOM.GetContainerForNodeResponse>;
 
         /**
          * Returns the descendants of a container query container that have
          * container queries against this container.
+         * @experimental
          */
         getQueryingDescendantsForContainer(params: Protocol.DOM.GetQueryingDescendantsForContainerRequest): Promise<Protocol.DOM.GetQueryingDescendantsForContainerResponse>;
 
         /**
          * Returns the target anchor element of the given anchor query according to
          * https://www.w3.org/TR/css-anchor-position-1/#target.
+         * @experimental
          */
         getAnchorElement(params: Protocol.DOM.GetAnchorElementRequest): Promise<Protocol.DOM.GetAnchorElementResponse>;
 
         /**
          * When enabling, this API force-opens the popover identified by nodeId
          * and keeps it open until disabled.
+         * @experimental
          */
         forceShowPopover(params: Protocol.DOM.ForceShowPopoverRequest): Promise<Protocol.DOM.ForceShowPopoverResponse>;
 
@@ -1685,6 +1782,7 @@ export namespace ProtocolProxyApi {
 
         /**
          * Called when distribution is changed.
+         * @experimental
          */
         on(event: 'distributedNodesUpdated', listener: (params: Protocol.DOM.DistributedNodesUpdatedEvent) => void): void;
 
@@ -1695,26 +1793,31 @@ export namespace ProtocolProxyApi {
 
         /**
          * Fired when `Element`'s inline style is modified via a CSS property modification.
+         * @experimental
          */
         on(event: 'inlineStyleInvalidated', listener: (params: Protocol.DOM.InlineStyleInvalidatedEvent) => void): void;
 
         /**
          * Called when a pseudo element is added to an element.
+         * @experimental
          */
         on(event: 'pseudoElementAdded', listener: (params: Protocol.DOM.PseudoElementAddedEvent) => void): void;
 
         /**
          * Called when top layer elements are changed.
+         * @experimental
          */
         on(event: 'topLayerElementsUpdated', listener: () => void): void;
 
         /**
          * Fired when a node's scrollability state changes.
+         * @experimental
          */
         on(event: 'scrollableFlagUpdated', listener: (params: Protocol.DOM.ScrollableFlagUpdatedEvent) => void): void;
 
         /**
          * Called when a pseudo element is removed from an element.
+         * @experimental
          */
         on(event: 'pseudoElementRemoved', listener: (params: Protocol.DOM.PseudoElementRemovedEvent) => void): void;
 
@@ -1726,11 +1829,13 @@ export namespace ProtocolProxyApi {
 
         /**
          * Called when shadow root is popped from the element.
+         * @experimental
          */
         on(event: 'shadowRootPopped', listener: (params: Protocol.DOM.ShadowRootPoppedEvent) => void): void;
 
         /**
          * Called when shadow root is pushed into the element.
+         * @experimental
          */
         on(event: 'shadowRootPushed', listener: (params: Protocol.DOM.ShadowRootPushedEvent) => void): void;
 
@@ -1754,6 +1859,8 @@ export namespace ProtocolProxyApi {
 
         /**
          * Removes breakpoint on particular native event.
+         * @deprecated
+         * @experimental
          */
         removeInstrumentationBreakpoint(params: Protocol.DOMDebugger.RemoveInstrumentationBreakpointRequest): Promise<void>;
 
@@ -1764,6 +1871,7 @@ export namespace ProtocolProxyApi {
 
         /**
          * Sets breakpoint on particular CSP violations.
+         * @experimental
          */
         setBreakOnCSPViolation(params: Protocol.DOMDebugger.SetBreakOnCSPViolationRequest): Promise<void>;
 
@@ -1779,6 +1887,8 @@ export namespace ProtocolProxyApi {
 
         /**
          * Sets breakpoint on particular native event.
+         * @deprecated
+         * @experimental
          */
         setInstrumentationBreakpoint(params: Protocol.DOMDebugger.SetInstrumentationBreakpointRequest): Promise<void>;
 
@@ -1823,6 +1933,7 @@ export namespace ProtocolProxyApi {
          * 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.
+         * @deprecated
          */
         getSnapshot(params: Protocol.DOMSnapshot.GetSnapshotRequest): Promise<Protocol.DOMSnapshot.GetSnapshotResponse>;
 
@@ -1881,6 +1992,7 @@ export namespace ProtocolProxyApi {
     export interface EmulationApi {
         /**
          * Tells whether emulation is supported.
+         * @deprecated
          */
         canEmulate(): Promise<Protocol.Emulation.CanEmulateResponse>;
 
@@ -1896,16 +2008,19 @@ export namespace ProtocolProxyApi {
 
         /**
          * Requests that page scale factor is reset to initial values.
+         * @experimental
          */
         resetPageScaleFactor(): Promise<void>;
 
         /**
          * Enables or disables simulating a focused and active page.
+         * @experimental
          */
         setFocusEmulationEnabled(params: Protocol.Emulation.SetFocusEmulationEnabledRequest): Promise<void>;
 
         /**
          * Automatically render all web contents using a dark theme.
+         * @experimental
          */
         setAutoDarkModeOverride(params: Protocol.Emulation.SetAutoDarkModeOverrideRequest): Promise<void>;
 
@@ -1923,6 +2038,7 @@ export namespace ProtocolProxyApi {
         /**
          * Overrides the values for env(safe-area-inset-*) and env(safe-area-max-inset-*). Unset values will cause the
          * respective variables to be undefined, even if previously overridden.
+         * @experimental
          */
         setSafeAreaInsetsOverride(params: Protocol.Emulation.SetSafeAreaInsetsOverrideRequest): Promise<void>;
 
@@ -1936,6 +2052,7 @@ export namespace ProtocolProxyApi {
         /**
          * Start reporting the given posture value to the Device Posture API.
          * This override can also be set in setDeviceMetricsOverride().
+         * @experimental
          */
         setDevicePostureOverride(params: Protocol.Emulation.SetDevicePostureOverrideRequest): Promise<void>;
 
@@ -1944,12 +2061,14 @@ export namespace ProtocolProxyApi {
          * or setDevicePostureOverride() and starts using posture information from the
          * platform again.
          * Does nothing if no override is set.
+         * @experimental
          */
         clearDevicePostureOverride(): Promise<void>;
 
         /**
          * Start using the given display features to pupulate the Viewport Segments API.
          * This override can also be set in setDeviceMetricsOverride().
+         * @experimental
          */
         setDisplayFeaturesOverride(params: Protocol.Emulation.SetDisplayFeaturesOverrideRequest): Promise<void>;
 
@@ -1958,13 +2077,23 @@ export namespace ProtocolProxyApi {
          * or setDisplayFeaturesOverride() and starts using display features from the
          * platform again.
          * Does nothing if no override is set.
+         * @experimental
          */
         clearDisplayFeaturesOverride(): Promise<void>;
 
+        /**
+         * @experimental
+         */
         setScrollbarsHidden(params: Protocol.Emulation.SetScrollbarsHiddenRequest): Promise<void>;
 
+        /**
+         * @experimental
+         */
         setDocumentCookieDisabled(params: Protocol.Emulation.SetDocumentCookieDisabledRequest): Promise<void>;
 
+        /**
+         * @experimental
+         */
         setEmitTouchEventsForMouse(params: Protocol.Emulation.SetEmitTouchEventsForMouseRequest): Promise<void>;
 
         /**
@@ -1988,6 +2117,9 @@ export namespace ProtocolProxyApi {
          */
         setGeolocationOverride(params: Protocol.Emulation.SetGeolocationOverrideRequest): Promise<void>;
 
+        /**
+         * @experimental
+         */
         getOverriddenSensorInformation(params: Protocol.Emulation.GetOverriddenSensorInformationRequest): Promise<Protocol.Emulation.GetOverriddenSensorInformationResponse>;
 
         /**
@@ -1996,12 +2128,14 @@ export namespace ProtocolProxyApi {
          * data from a real hardware sensor. Otherwise, existing virtual
          * sensor-backend Sensor objects will fire an error event and new calls to
          * Sensor.start() will attempt to use a real sensor instead.
+         * @experimental
          */
         setSensorOverrideEnabled(params: Protocol.Emulation.SetSensorOverrideEnabledRequest): Promise<void>;
 
         /**
          * Updates the sensor readings reported by a sensor type previously overridden
          * by setSensorOverrideEnabled.
+         * @experimental
          */
         setSensorOverrideReadings(params: Protocol.Emulation.SetSensorOverrideReadingsRequest): Promise<void>;
 
@@ -2010,6 +2144,7 @@ export namespace ProtocolProxyApi {
          * Pressure API, so that updates to PressureObserver.observe() are provided
          * via setPressureStateOverride instead of being retrieved from
          * platform-provided telemetry data.
+         * @experimental
          */
         setPressureSourceOverrideEnabled(params: Protocol.Emulation.SetPressureSourceOverrideEnabledRequest): Promise<void>;
 
@@ -2018,6 +2153,7 @@ export namespace ProtocolProxyApi {
          * Provides a given pressure state that will be processed and eventually be
          * delivered to PressureObserver users. |source| must have been previously
          * overridden by setPressureSourceOverrideEnabled.
+         * @experimental
          */
         setPressureStateOverride(params: Protocol.Emulation.SetPressureStateOverrideRequest): Promise<void>;
 
@@ -2025,6 +2161,7 @@ export namespace ProtocolProxyApi {
          * Provides a given pressure data set that will be processed and eventually be
          * delivered to PressureObserver users. |source| must have been previously
          * overridden by setPressureSourceOverrideEnabled.
+         * @experimental
          */
         setPressureDataOverride(params: Protocol.Emulation.SetPressureDataOverrideRequest): Promise<void>;
 
@@ -2040,11 +2177,14 @@ export namespace ProtocolProxyApi {
 
         /**
          * Overrides value returned by the javascript navigator object.
+         * @deprecated
+         * @experimental
          */
         setNavigatorOverrides(params: Protocol.Emulation.SetNavigatorOverridesRequest): Promise<void>;
 
         /**
          * Sets a specified page scale factor.
+         * @experimental
          */
         setPageScaleFactor(params: Protocol.Emulation.SetPageScaleFactorRequest): Promise<void>;
 
@@ -2061,11 +2201,13 @@ export namespace ProtocolProxyApi {
         /**
          * 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.
+         * @experimental
          */
         setVirtualTimePolicy(params: Protocol.Emulation.SetVirtualTimePolicyRequest): Promise<Protocol.Emulation.SetVirtualTimePolicyResponse>;
 
         /**
          * Overrides default host system locale with the specified one.
+         * @experimental
          */
         setLocaleOverride(params: Protocol.Emulation.SetLocaleOverrideRequest): Promise<void>;
 
@@ -2078,16 +2220,25 @@ export namespace ProtocolProxyApi {
          * 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.
+         * @deprecated
+         * @experimental
          */
         setVisibleSize(params: Protocol.Emulation.SetVisibleSizeRequest): Promise<void>;
 
+        /**
+         * @experimental
+         */
         setDisabledImageTypes(params: Protocol.Emulation.SetDisabledImageTypesRequest): Promise<void>;
 
         /**
          * Override the value of navigator.connection.saveData
+         * @experimental
          */
         setDataSaverOverride(params: Protocol.Emulation.SetDataSaverOverrideRequest): Promise<void>;
 
+        /**
+         * @experimental
+         */
         setHardwareConcurrencyOverride(params: Protocol.Emulation.SetHardwareConcurrencyOverrideRequest): Promise<void>;
 
         /**
@@ -2098,17 +2249,20 @@ export namespace ProtocolProxyApi {
 
         /**
          * Allows overriding the automation flag.
+         * @experimental
          */
         setAutomationOverride(params: Protocol.Emulation.SetAutomationOverrideRequest): Promise<void>;
 
         /**
          * Allows overriding the difference between the small and large viewport sizes, which determine the
          * value of the `svh` and `lvh` unit, respectively. Only supported for top-level frames.
+         * @experimental
          */
         setSmallViewportHeightDifferenceOverride(params: Protocol.Emulation.SetSmallViewportHeightDifferenceOverrideRequest): Promise<void>;
 
         /**
          * Notification sent after the virtual time budget for the current VirtualTimePolicy has run out.
+         * @experimental
          */
         on(event: 'virtualTimeBudgetExpired', listener: () => void): void;
 
@@ -2125,11 +2279,13 @@ export namespace ProtocolProxyApi {
 
         /**
          * Disables headless events for the target.
+         * @deprecated
          */
         disable(): Promise<void>;
 
         /**
          * Enables headless events for the target.
+         * @deprecated
          */
         enable(): Promise<void>;
 
@@ -2209,6 +2365,7 @@ export namespace ProtocolProxyApi {
     export interface InputApi {
         /**
          * Dispatches a drag event into the page.
+         * @experimental
          */
         dispatchDragEvent(params: Protocol.Input.DispatchDragEventRequest): Promise<void>;
 
@@ -2220,6 +2377,7 @@ export namespace ProtocolProxyApi {
         /**
          * This method emulates inserting text that doesn't come from a key press,
          * for example an emoji keyboard or an IME.
+         * @experimental
          */
         insertText(params: Protocol.Input.InsertTextRequest): Promise<void>;
 
@@ -2227,6 +2385,7 @@ export namespace ProtocolProxyApi {
          * This method sets the current candidate text for IME.
          * Use imeCommitComposition to commit the final text.
          * Use imeSetComposition with empty string as text to cancel composition.
+         * @experimental
          */
         imeSetComposition(params: Protocol.Input.ImeSetCompositionRequest): Promise<void>;
 
@@ -2247,6 +2406,7 @@ export namespace ProtocolProxyApi {
 
         /**
          * Emulates touch event from the mouse event parameters.
+         * @experimental
          */
         emulateTouchFromMouseEvent(params: Protocol.Input.EmulateTouchFromMouseEventRequest): Promise<void>;
 
@@ -2258,27 +2418,32 @@ export namespace ProtocolProxyApi {
         /**
          * Prevents default drag and drop behavior and instead emits `Input.dragIntercepted` events.
          * Drag and drop behavior can be directly controlled via `Input.dispatchDragEvent`.
+         * @experimental
          */
         setInterceptDrags(params: Protocol.Input.SetInterceptDragsRequest): Promise<void>;
 
         /**
          * Synthesizes a pinch gesture over a time period by issuing appropriate touch events.
+         * @experimental
          */
         synthesizePinchGesture(params: Protocol.Input.SynthesizePinchGestureRequest): Promise<void>;
 
         /**
          * Synthesizes a scroll gesture over a time period by issuing appropriate touch events.
+         * @experimental
          */
         synthesizeScrollGesture(params: Protocol.Input.SynthesizeScrollGestureRequest): Promise<void>;
 
         /**
          * Synthesizes a tap gesture over a time period by issuing appropriate touch events.
+         * @experimental
          */
         synthesizeTapGesture(params: Protocol.Input.SynthesizeTapGestureRequest): Promise<void>;
 
         /**
          * Emitted only when `Input.setInterceptDrags` is enabled. Use this data with `Input.dispatchDragEvent` to
          * restore normal drag and drop behavior.
+         * @experimental
          */
         on(event: 'dragIntercepted', listener: (params: Protocol.Input.DragInterceptedEvent) => void): void;
 
@@ -2460,26 +2625,31 @@ export namespace ProtocolProxyApi {
     export interface NetworkApi {
         /**
          * Sets a list of content encodings that will be accepted. Empty list means no encoding is accepted.
+         * @experimental
          */
         setAcceptedEncodings(params: Protocol.Network.SetAcceptedEncodingsRequest): Promise<void>;
 
         /**
          * Clears accepted encodings set by setAcceptedEncodings
+         * @experimental
          */
         clearAcceptedEncodingsOverride(): Promise<void>;
 
         /**
          * Tells whether clearing browser cache is supported.
+         * @deprecated
          */
         canClearBrowserCache(): Promise<Protocol.Network.CanClearBrowserCacheResponse>;
 
         /**
          * Tells whether clearing browser cookies is supported.
+         * @deprecated
          */
         canClearBrowserCookies(): Promise<Protocol.Network.CanClearBrowserCookiesResponse>;
 
         /**
          * Tells whether emulation of network conditions is supported.
+         * @deprecated
          */
         canEmulateNetworkConditions(): Promise<Protocol.Network.CanEmulateNetworkConditionsResponse>;
 
@@ -2499,6 +2669,8 @@ export namespace ProtocolProxyApi {
          * 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.
+         * @deprecated
+         * @experimental
          */
         continueInterceptedRequest(params: Protocol.Network.ContinueInterceptedRequestRequest): Promise<void>;
 
@@ -2526,11 +2698,13 @@ export namespace ProtocolProxyApi {
          * Returns all browser cookies. Depending on the backend support, will return detailed cookie
          * information in the `cookies` field.
          * Deprecated. Use Storage.getCookies instead.
+         * @deprecated
          */
         getAllCookies(): Promise<Protocol.Network.GetAllCookiesResponse>;
 
         /**
          * Returns the DER-encoded certificate.
+         * @experimental
          */
         getCertificate(params: Protocol.Network.GetCertificateRequest): Promise<Protocol.Network.GetCertificateResponse>;
 
@@ -2552,6 +2726,7 @@ export namespace ProtocolProxyApi {
 
         /**
          * Returns content served for the given currently intercepted request.
+         * @experimental
          */
         getResponseBodyForInterception(params: Protocol.Network.GetResponseBodyForInterceptionRequest): Promise<Protocol.Network.GetResponseBodyForInterceptionResponse>;
 
@@ -2560,6 +2735,7 @@ export namespace ProtocolProxyApi {
          * 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.
+         * @experimental
          */
         takeResponseBodyForInterceptionAsStream(params: Protocol.Network.TakeResponseBodyForInterceptionAsStreamRequest): Promise<Protocol.Network.TakeResponseBodyForInterceptionAsStreamResponse>;
 
@@ -2567,16 +2743,19 @@ export namespace ProtocolProxyApi {
          * 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.
+         * @experimental
          */
         replayXHR(params: Protocol.Network.ReplayXHRRequest): Promise<void>;
 
         /**
          * Searches for given string in response content.
+         * @experimental
          */
         searchInResponseBody(params: Protocol.Network.SearchInResponseBodyRequest): Promise<Protocol.Network.SearchInResponseBodyResponse>;
 
         /**
          * Blocks URLs from loading.
+         * @experimental
          */
         setBlockedURLs(params: Protocol.Network.SetBlockedURLsRequest): Promise<void>;
 
@@ -2607,12 +2786,15 @@ export namespace ProtocolProxyApi {
 
         /**
          * Specifies whether to attach a page script stack id in requests
+         * @experimental
          */
         setAttachDebugStack(params: Protocol.Network.SetAttachDebugStackRequest): Promise<void>;
 
         /**
          * Sets the requests to intercept that match the provided patterns and optionally resource types.
          * Deprecated, please use Fetch.enable instead.
+         * @deprecated
+         * @experimental
          */
         setRequestInterception(params: Protocol.Network.SetRequestInterceptionRequest): Promise<void>;
 
@@ -2624,28 +2806,33 @@ export namespace ProtocolProxyApi {
         /**
          * Enables streaming of the response for the given requestId.
          * If enabled, the dataReceived event contains the data that was received during streaming.
+         * @experimental
          */
         streamResourceContent(params: Protocol.Network.StreamResourceContentRequest): Promise<Protocol.Network.StreamResourceContentResponse>;
 
         /**
          * Returns information about the COEP/COOP isolation status.
+         * @experimental
          */
         getSecurityIsolationStatus(params: Protocol.Network.GetSecurityIsolationStatusRequest): Promise<Protocol.Network.GetSecurityIsolationStatusResponse>;
 
         /**
          * Enables tracking for the Reporting API, events generated by the Reporting API will now be delivered to the client.
          * Enabling triggers 'reportingApiReportAdded' for all existing reports.
+         * @experimental
          */
         enableReportingApi(params: Protocol.Network.EnableReportingApiRequest): Promise<void>;
 
         /**
          * Fetches the resource and returns the content.
+         * @experimental
          */
         loadNetworkResource(params: Protocol.Network.LoadNetworkResourceRequest): Promise<Protocol.Network.LoadNetworkResourceResponse>;
 
         /**
          * Sets Controls for third-party cookie access
          * Page reload is required before the new cookie behavior will be observed
+         * @experimental
          */
         setCookieControls(params: Protocol.Network.SetCookieControlsRequest): Promise<void>;
 
@@ -2673,6 +2860,8 @@ export namespace ProtocolProxyApi {
          * Details of an intercepted HTTP request, which must be either allowed, blocked, modified or
          * mocked.
          * Deprecated, use Fetch.requestPaused instead.
+         * @deprecated
+         * @experimental
          */
         on(event: 'requestIntercepted', listener: (params: Protocol.Network.RequestInterceptedEvent) => void): void;
 
@@ -2688,11 +2877,13 @@ export namespace ProtocolProxyApi {
 
         /**
          * Fired when resource loading priority is changed
+         * @experimental
          */
         on(event: 'resourceChangedPriority', listener: (params: Protocol.Network.ResourceChangedPriorityEvent) => void): void;
 
         /**
          * Fired when a signed exchange was received over the network
+         * @experimental
          */
         on(event: 'signedExchangeReceived', listener: (params: Protocol.Network.SignedExchangeReceivedEvent) => void): void;
 
@@ -2753,61 +2944,73 @@ export namespace ProtocolProxyApi {
 
         /**
          * Fired upon direct_socket.TCPSocket creation.
+         * @experimental
          */
         on(event: 'directTCPSocketCreated', listener: (params: Protocol.Network.DirectTCPSocketCreatedEvent) => void): void;
 
         /**
          * Fired when direct_socket.TCPSocket connection is opened.
+         * @experimental
          */
         on(event: 'directTCPSocketOpened', listener: (params: Protocol.Network.DirectTCPSocketOpenedEvent) => void): void;
 
         /**
          * Fired when direct_socket.TCPSocket is aborted.
+         * @experimental
          */
         on(event: 'directTCPSocketAborted', listener: (params: Protocol.Network.DirectTCPSocketAbortedEvent) => void): void;
 
         /**
          * Fired when direct_socket.TCPSocket is closed.
+         * @experimental
          */
         on(event: 'directTCPSocketClosed', listener: (params: Protocol.Network.DirectTCPSocketClosedEvent) => void): void;
 
         /**
          * Fired when data is sent to tcp direct socket stream.
+         * @experimental
          */
         on(event: 'directTCPSocketChunkSent', listener: (params: Protocol.Network.DirectTCPSocketChunkSentEvent) => void): void;
 
         /**
          * Fired when data is received from tcp direct socket stream.
+         * @experimental
          */
         on(event: 'directTCPSocketChunkReceived', listener: (params: Protocol.Network.DirectTCPSocketChunkReceivedEvent) => void): void;
 
         /**
          * Fired upon direct_socket.UDPSocket creation.
+         * @experimental
          */
         on(event: 'directUDPSocketCreated', listener: (params: Protocol.Network.DirectUDPSocketCreatedEvent) => void): void;
 
         /**
          * Fired when direct_socket.UDPSocket connection is opened.
+         * @experimental
          */
         on(event: 'directUDPSocketOpened', listener: (params: Protocol.Network.DirectUDPSocketOpenedEvent) => void): void;
 
         /**
          * Fired when direct_socket.UDPSocket is aborted.
+         * @experimental
          */
         on(event: 'directUDPSocketAborted', listener: (params: Protocol.Network.DirectUDPSocketAbortedEvent) => void): void;
 
         /**
          * Fired when direct_socket.UDPSocket is closed.
+         * @experimental
          */
         on(event: 'directUDPSocketClosed', listener: (params: Protocol.Network.DirectUDPSocketClosedEvent) => void): void;
 
         /**
          * Fired when message is sent to udp direct socket stream.
+         * @experimental
          */
         on(event: 'directUDPSocketChunkSent', listener: (params: Protocol.Network.DirectUDPSocketChunkSentEvent) => void): void;
 
         /**
          * Fired when message is received from udp direct socket stream.
+         * @experimental
          */
         on(event: 'directUDPSocketChunkReceived', listener: (params: Protocol.Network.DirectUDPSocketChunkReceivedEvent) => void): void;
 
@@ -2816,6 +3019,7 @@ export namespace ProtocolProxyApi {
          * 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.
+         * @experimental
          */
         on(event: 'requestWillBeSentExtraInfo', listener: (params: Protocol.Network.RequestWillBeSentExtraInfoEvent) => void): void;
 
@@ -2823,6 +3027,7 @@ export namespace ProtocolProxyApi {
          * 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.
+         * @experimental
          */
         on(event: 'responseReceivedExtraInfo', listener: (params: Protocol.Network.ResponseReceivedExtraInfoEvent) => void): void;
 
@@ -2830,6 +3035,7 @@ export namespace ProtocolProxyApi {
          * Fired when 103 Early Hints headers is received in addition to the common response.
          * Not every responseReceived event will have an responseReceivedEarlyHints fired.
          * Only one responseReceivedEarlyHints may be fired for eached responseReceived event.
+         * @experimental
          */
         on(event: 'responseReceivedEarlyHints', listener: (params: Protocol.Network.ResponseReceivedEarlyHintsEvent) => void): void;
 
@@ -2838,44 +3044,57 @@ export namespace ProtocolProxyApi {
          * the type of the operation and whether the operation succeeded or
          * failed, the event is fired before the corresponding request was sent
          * or after the response was received.
+         * @experimental
          */
         on(event: 'trustTokenOperationDone', listener: (params: Protocol.Network.TrustTokenOperationDoneEvent) => void): void;
 
         /**
          * Fired once security policy has been updated.
+         * @experimental
          */
         on(event: 'policyUpdated', listener: () => void): void;
 
         /**
          * Fired once when parsing the .wbn file has succeeded.
          * The event contains the information about the web bundle contents.
+         * @experimental
          */
         on(event: 'subresourceWebBundleMetadataReceived', listener: (params: Protocol.Network.SubresourceWebBundleMetadataReceivedEvent) => void): void;
 
         /**
          * Fired once when parsing the .wbn file has failed.
+         * @experimental
          */
         on(event: 'subresourceWebBundleMetadataError', listener: (params: Protocol.Network.SubresourceWebBundleMetadataErrorEvent) => void): void;
 
         /**
          * Fired when handling requests for resources within a .wbn file.
          * Note: this will only be fired for resources that are requested by the webpage.
+         * @experimental
          */
         on(event: 'subresourceWebBundleInnerResponseParsed', listener: (params: Protocol.Network.SubresourceWebBundleInnerResponseParsedEvent) => void): void;
 
         /**
          * Fired when request for resources within a .wbn file failed.
+         * @experimental
          */
         on(event: 'subresourceWebBundleInnerResponseError', listener: (params: Protocol.Network.SubresourceWebBundleInnerResponseErrorEvent) => void): void;
 
         /**
          * Is sent whenever a new report is added.
          * And after 'enableReportingApi' for all existing reports.
+         * @experimental
          */
         on(event: 'reportingApiReportAdded', listener: (params: Protocol.Network.ReportingApiReportAddedEvent) => void): void;
 
+        /**
+         * @experimental
+         */
         on(event: 'reportingApiReportUpdated', listener: (params: Protocol.Network.ReportingApiReportUpdatedEvent) => void): void;
 
+        /**
+         * @experimental
+         */
         on(event: 'reportingApiEndpointsChangedForOrigin', listener: (params: Protocol.Network.ReportingApiEndpointsChangedForOriginEvent) => void): void;
 
     }
@@ -2916,6 +3135,7 @@ export namespace ProtocolProxyApi {
          * Deprecated: Doesn't work reliably and cannot be fixed due to process
          * separation (the owner node might be in a different process). Determine
          * the owner node in the client and use highlightNode.
+         * @deprecated
          */
         highlightFrame(params: Protocol.Overlay.HighlightFrameRequest): Promise<void>;
 
@@ -2992,11 +3212,13 @@ export namespace ProtocolProxyApi {
 
         /**
          * Deprecated, no longer has any effect.
+         * @deprecated
          */
         setShowHitTestBorders(params: Protocol.Overlay.SetShowHitTestBordersRequest): Promise<void>;
 
         /**
          * Deprecated, no longer has any effect.
+         * @deprecated
          */
         setShowWebVitals(params: Protocol.Overlay.SetShowWebVitalsRequest): Promise<void>;
 
@@ -3046,6 +3268,8 @@ export namespace ProtocolProxyApi {
     export interface PageApi {
         /**
          * Deprecated, please use addScriptToEvaluateOnNewDocument instead.
+         * @deprecated
+         * @experimental
          */
         addScriptToEvaluateOnLoad(params: Protocol.Page.AddScriptToEvaluateOnLoadRequest): Promise<Protocol.Page.AddScriptToEvaluateOnLoadResponse>;
 
@@ -3067,21 +3291,27 @@ export namespace ProtocolProxyApi {
         /**
          * Returns a snapshot of the page as a string. For MHTML format, the serialization includes
          * iframes, shadow DOM, external resources, and element-inline styles.
+         * @experimental
          */
         captureSnapshot(params: Protocol.Page.CaptureSnapshotRequest): Promise<Protocol.Page.CaptureSnapshotResponse>;
 
         /**
          * Clears the overridden device metrics.
+         * @deprecated
+         * @experimental
          */
         clearDeviceMetricsOverride(): Promise<void>;
 
         /**
          * Clears the overridden Device Orientation.
+         * @deprecated
+         * @experimental
          */
         clearDeviceOrientationOverride(): Promise<void>;
 
         /**
          * Clears the overridden Geolocation Position and Error.
+         * @deprecated
          */
         clearGeolocationOverride(): Promise<void>;
 
@@ -3092,6 +3322,8 @@ export namespace ProtocolProxyApi {
 
         /**
          * Deletes browser cookie with given name, domain and path.
+         * @deprecated
+         * @experimental
          */
         deleteCookie(params: Protocol.Page.DeleteCookieRequest): Promise<void>;
 
@@ -3114,19 +3346,28 @@ export namespace ProtocolProxyApi {
          */
         getAppManifest(params: Protocol.Page.GetAppManifestRequest): Promise<Protocol.Page.GetAppManifestResponse>;
 
+        /**
+         * @experimental
+         */
         getInstallabilityErrors(): Promise<Protocol.Page.GetInstallabilityErrorsResponse>;
 
         /**
          * Deprecated because it's not guaranteed that the returned icon is in fact the one used for PWA installation.
+         * @deprecated
+         * @experimental
          */
         getManifestIcons(): Promise<Protocol.Page.GetManifestIconsResponse>;
 
         /**
          * Returns the unique (PWA) app id.
          * Only returns values if the feature flag 'WebAppEnableManifestId' is enabled
+         * @experimental
          */
         getAppId(): Promise<Protocol.Page.GetAppIdResponse>;
 
+        /**
+         * @experimental
+         */
         getAdScriptAncestry(params: Protocol.Page.GetAdScriptAncestryRequest): Promise<Protocol.Page.GetAdScriptAncestryResponse>;
 
         /**
@@ -3151,11 +3392,13 @@ export namespace ProtocolProxyApi {
 
         /**
          * Returns content of the given resource.
+         * @experimental
          */
         getResourceContent(params: Protocol.Page.GetResourceContentRequest): Promise<Protocol.Page.GetResourceContentResponse>;
 
         /**
          * Returns present frame / resource tree structure.
+         * @experimental
          */
         getResourceTree(): Promise<Protocol.Page.GetResourceTreeResponse>;
 
@@ -3186,6 +3429,8 @@ export namespace ProtocolProxyApi {
 
         /**
          * Deprecated, please use removeScriptToEvaluateOnNewDocument instead.
+         * @deprecated
+         * @experimental
          */
         removeScriptToEvaluateOnLoad(params: Protocol.Page.RemoveScriptToEvaluateOnLoadRequest): Promise<void>;
 
@@ -3196,16 +3441,19 @@ export namespace ProtocolProxyApi {
 
         /**
          * Acknowledges that a screencast frame has been received by the frontend.
+         * @experimental
          */
         screencastFrameAck(params: Protocol.Page.ScreencastFrameAckRequest): Promise<void>;
 
         /**
          * Searches for given string in resource content.
+         * @experimental
          */
         searchInResource(params: Protocol.Page.SearchInResourceRequest): Promise<Protocol.Page.SearchInResourceResponse>;
 
         /**
          * Enable Chrome's experimental ad filter on all sites.
+         * @experimental
          */
         setAdBlockingEnabled(params: Protocol.Page.SetAdBlockingEnabledRequest): Promise<void>;
 
@@ -3216,11 +3464,13 @@ export namespace ProtocolProxyApi {
 
         /**
          * Get Permissions Policy state on given frame.
+         * @experimental
          */
         getPermissionsPolicyState(params: Protocol.Page.GetPermissionsPolicyStateRequest): Promise<Protocol.Page.GetPermissionsPolicyStateResponse>;
 
         /**
          * Get Origin Trials on given frame.
+         * @experimental
          */
         getOriginTrials(params: Protocol.Page.GetOriginTrialsRequest): Promise<Protocol.Page.GetOriginTrialsResponse>;
 
@@ -3228,21 +3478,27 @@ export namespace ProtocolProxyApi {
          * 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).
+         * @deprecated
+         * @experimental
          */
         setDeviceMetricsOverride(params: Protocol.Page.SetDeviceMetricsOverrideRequest): Promise<void>;
 
         /**
          * Overrides the Device Orientation.
+         * @deprecated
+         * @experimental
          */
         setDeviceOrientationOverride(params: Protocol.Page.SetDeviceOrientationOverrideRequest): Promise<void>;
 
         /**
          * Set generic font families.
+         * @experimental
          */
         setFontFamilies(params: Protocol.Page.SetFontFamiliesRequest): Promise<void>;
 
         /**
          * Set default font sizes.
+         * @experimental
          */
         setFontSizes(params: Protocol.Page.SetFontSizesRequest): Promise<void>;
 
@@ -3253,12 +3509,15 @@ export namespace ProtocolProxyApi {
 
         /**
          * Set the behavior when downloading a file.
+         * @deprecated
+         * @experimental
          */
         setDownloadBehavior(params: Protocol.Page.SetDownloadBehaviorRequest): Promise<void>;
 
         /**
          * Overrides the Geolocation Position or Error. Omitting any of the parameters emulates position
          * unavailable.
+         * @deprecated
          */
         setGeolocationOverride(params: Protocol.Page.SetGeolocationOverrideRequest): Promise<void>;
 
@@ -3269,11 +3528,14 @@ export namespace ProtocolProxyApi {
 
         /**
          * Toggles mouse event-based touch event emulation.
+         * @deprecated
+         * @experimental
          */
         setTouchEmulationEnabled(params: Protocol.Page.SetTouchEmulationEnabledRequest): Promise<void>;
 
         /**
          * Starts sending each frame using the `screencastFrame` event.
+         * @experimental
          */
         startScreencast(params: Protocol.Page.StartScreencastRequest): Promise<void>;
 
@@ -3284,6 +3546,7 @@ export namespace ProtocolProxyApi {
 
         /**
          * Crashes renderer on the IO thread, generates minidumps.
+         * @experimental
          */
         crash(): Promise<void>;
 
@@ -3296,11 +3559,13 @@ export namespace ProtocolProxyApi {
          * Tries to update the web lifecycle state of the page.
          * It will transition the page to the given state according to:
          * https://github.com/WICG/web-lifecycle/
+         * @experimental
          */
         setWebLifecycleState(params: Protocol.Page.SetWebLifecycleStateRequest): Promise<void>;
 
         /**
          * Stops sending each frame in the `screencastFrame`.
+         * @experimental
          */
         stopScreencast(): Promise<void>;
 
@@ -3311,39 +3576,46 @@ export namespace ProtocolProxyApi {
          * When script with a matching URL is encountered, the cache is optionally
          * produced upon backend discretion, based on internal heuristics.
          * See also: `Page.compilationCacheProduced`.
+         * @experimental
          */
         produceCompilationCache(params: Protocol.Page.ProduceCompilationCacheRequest): Promise<void>;
 
         /**
          * Seeds compilation cache for given url. Compilation cache does not survive
          * cross-process navigation.
+         * @experimental
          */
         addCompilationCache(params: Protocol.Page.AddCompilationCacheRequest): Promise<void>;
 
         /**
          * Clears seeded compilation cache.
+         * @experimental
          */
         clearCompilationCache(): Promise<void>;
 
         /**
          * Sets the Secure Payment Confirmation transaction mode.
          * https://w3c.github.io/secure-payment-confirmation/#sctn-automation-set-spc-transaction-mode
+         * @experimental
          */
         setSPCTransactionMode(params: Protocol.Page.SetSPCTransactionModeRequest): Promise<void>;
 
         /**
          * Extensions for Custom Handlers API:
          * https://html.spec.whatwg.org/multipage/system-state.html#rph-automation
+         * @experimental
          */
         setRPHRegistrationMode(params: Protocol.Page.SetRPHRegistrationModeRequest): Promise<void>;
 
         /**
          * Generates a report for testing.
+         * @experimental
          */
         generateTestReport(params: Protocol.Page.GenerateTestReportRequest): Promise<void>;
 
         /**
          * Pauses page execution. Can be resumed using generic Runtime.runIfWaitingForDebugger.
+         * @experimental
          */
         waitForDebugger(): Promise<void>;
 
@@ -3362,6 +3634,7 @@ export namespace ProtocolProxyApi {
          * for more details.
          * 
          * TODO(https://crbug.com/1440085): Remove this once Puppeteer supports tab targets.
+         * @experimental
          */
         setPrerenderingAllowed(params: Protocol.Page.SetPrerenderingAllowedRequest): Promise<void>;
 
@@ -3379,6 +3652,7 @@ export namespace ProtocolProxyApi {
 
         /**
          * Fired when frame no longer has a scheduled navigation.
+         * @deprecated
          */
         on(event: 'frameClearedScheduledNavigation', listener: (params: Protocol.Page.FrameClearedScheduledNavigationEvent) => void): void;
 
@@ -3390,6 +3664,7 @@ export namespace ProtocolProxyApi {
         /**
          * Fired before frame subtree is detached. Emitted before any frame of the
          * subtree is actually detached.
+         * @experimental
          */
         on(event: 'frameSubtreeWillBeDetached', listener: (params: Protocol.Page.FrameSubtreeWillBeDetachedEvent) => void): void;
 
@@ -3400,9 +3675,13 @@ export namespace ProtocolProxyApi {
 
         /**
          * Fired when opening document to write to.
+         * @experimental
          */
         on(event: 'documentOpened', listener: (params: Protocol.Page.DocumentOpenedEvent) => void): void;
 
+        /**
+         * @experimental
+         */
         on(event: 'frameResized', listener: () => void): void;
 
         /**
@@ -3413,39 +3692,48 @@ export namespace ProtocolProxyApi {
          * can be fired for a single navigation, for example, when a same-document
          * navigation becomes a cross-document navigation (such as in the case of a
          * frameset).
+         * @experimental
          */
         on(event: 'frameStartedNavigating', listener: (params: Protocol.Page.FrameStartedNavigatingEvent) => void): void;
 
         /**
          * Fired when a renderer-initiated navigation is requested.
          * Navigation may still be cancelled after the event is issued.
+         * @experimental
          */
         on(event: 'frameRequestedNavigation', listener: (params: Protocol.Page.FrameRequestedNavigationEvent) => void): void;
 
         /**
          * Fired when frame schedules a potential navigation.
+         * @deprecated
          */
         on(event: 'frameScheduledNavigation', listener: (params: Protocol.Page.FrameScheduledNavigationEvent) => void): void;
 
         /**
          * Fired when frame has started loading.
+         * @experimental
          */
         on(event: 'frameStartedLoading', listener: (params: Protocol.Page.FrameStartedLoadingEvent) => void): void;
 
         /**
          * Fired when frame has stopped loading.
+         * @experimental
          */
         on(event: 'frameStoppedLoading', listener: (params: Protocol.Page.FrameStoppedLoadingEvent) => void): void;
 
         /**
          * Fired when page is about to start a download.
          * Deprecated. Use Browser.downloadWillBegin instead.
+         * @deprecated
+         * @experimental
          */
         on(event: 'downloadWillBegin', listener: (params: Protocol.Page.DownloadWillBeginEvent) => void): void;
 
         /**
          * Fired when download makes progress. Last call has |done| == true.
          * Deprecated. Use Browser.downloadProgress instead.
+         * @deprecated
+         * @experimental
          */
         on(event: 'downloadProgress', listener: (params: Protocol.Page.DownloadProgressEvent) => void): void;
 
@@ -3482,6 +3770,7 @@ export namespace ProtocolProxyApi {
          * not assume any ordering with the Page.frameNavigated event. This event is fired only for
          * main-frame history navigation where the document changes (non-same-document navigations),
          * when bfcache navigation fails.
+         * @experimental
          */
         on(event: 'backForwardCacheNotUsed', listener: (params: Protocol.Page.BackForwardCacheNotUsedEvent) => void): void;
 
@@ -3489,16 +3778,19 @@ export namespace ProtocolProxyApi {
 
         /**
          * Fired when same-document navigation happens, e.g. due to history API usage or anchor navigation.
+         * @experimental
          */
         on(event: 'navigatedWithinDocument', listener: (params: Protocol.Page.NavigatedWithinDocumentEvent) => void): void;
 
         /**
          * Compressed image data requested by the `startScreencast`.
+         * @experimental
          */
         on(event: 'screencastFrame', listener: (params: Protocol.Page.ScreencastFrameEvent) => void): void;
 
         /**
          * Fired when the page with currently enabled screencast was shown or hidden `.
+         * @experimental
          */
         on(event: 'screencastVisibilityChanged', listener: (params: Protocol.Page.ScreencastVisibilityChangedEvent) => void): void;
 
@@ -3509,8 +3801,8 @@ export namespace ProtocolProxyApi {
         on(event: 'windowOpen', listener: (params: Protocol.Page.WindowOpenEvent) => void): void;
 
         /**
-         * Issued for every compilation cache generated. Is only available
-         * if Page.setGenerateCompilationCache is enabled.
+         * Issued for every compilation cache generated.
+         * @experimental
          */
         on(event: 'compilationCacheProduced', listener: (params: Protocol.Page.CompilationCacheProducedEvent) => void): void;
 
@@ -3531,6 +3823,8 @@ export namespace ProtocolProxyApi {
          * Sets time domain to use for collecting and reporting duration metrics.
          * Note that this must be called before enabling metrics collection. Calling
          * this method while metrics collection is enabled returns an error.
+         * @deprecated
+         * @experimental
          */
         setTimeDomain(params: Protocol.Performance.SetTimeDomainRequest): Promise<void>;
 
@@ -3578,12 +3872,14 @@ export namespace ProtocolProxyApi {
 
         /**
          * Handles a certificate error that fired a certificateError event.
+         * @deprecated
          */
         handleCertificateError(params: Protocol.Security.HandleCertificateErrorRequest): Promise<void>;
 
         /**
          * Enable/disable overriding certificate errors. If enabled, all certificate error events need to
          * be handled by the DevTools client and should be answered with `handleCertificateError` commands.
+         * @deprecated
          */
         setOverrideCertificateErrors(params: Protocol.Security.SetOverrideCertificateErrorsRequest): Promise<void>;
 
@@ -3592,16 +3888,19 @@ export namespace ProtocolProxyApi {
          * 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.
+         * @deprecated
          */
         on(event: 'certificateError', listener: (params: Protocol.Security.CertificateErrorEvent) => void): void;
 
         /**
          * The security state of the page changed.
+         * @experimental
          */
         on(event: 'visibleSecurityStateChanged', listener: (params: Protocol.Security.VisibleSecurityStateChangedEvent) => void): void;
 
         /**
          * The security state of the page changed. No longer being sent.
+         * @deprecated
          */
         on(event: 'securityStateChanged', listener: (params: Protocol.Security.SecurityStateChangedEvent) => void): void;
 
@@ -3678,6 +3977,7 @@ export namespace ProtocolProxyApi {
 
         /**
          * Override quota for the specified origin
+         * @experimental
          */
         overrideQuotaForOrigin(params: Protocol.Storage.OverrideQuotaForOriginRequest): Promise<void>;
 
@@ -3724,100 +4024,119 @@ export namespace ProtocolProxyApi {
         /**
          * Returns the number of stored Trust Tokens per issuer for the
          * current browsing context.
+         * @experimental
          */
         getTrustTokens(): Promise<Protocol.Storage.GetTrustTokensResponse>;
 
         /**
          * Removes all Trust Tokens issued by the provided issuerOrigin.
          * Leaves other stored data, including the issuer's Redemption Records, intact.
+         * @experimental
          */
         clearTrustTokens(params: Protocol.Storage.ClearTrustTokensRequest): Promise<Protocol.Storage.ClearTrustTokensResponse>;
 
         /**
          * Gets details for a named interest group.
+         * @experimental
          */
         getInterestGroupDetails(params: Protocol.Storage.GetInterestGroupDetailsRequest): Promise<Protocol.Storage.GetInterestGroupDetailsResponse>;
 
         /**
          * Enables/Disables issuing of interestGroupAccessed events.
+         * @experimental
          */
         setInterestGroupTracking(params: Protocol.Storage.SetInterestGroupTrackingRequest): Promise<void>;
 
         /**
          * Enables/Disables issuing of interestGroupAuctionEventOccurred and
          * interestGroupAuctionNetworkRequestCreated.
+         * @experimental
          */
         setInterestGroupAuctionTracking(params: Protocol.Storage.SetInterestGroupAuctionTrackingRequest): Promise<void>;
 
         /**
          * Gets metadata for an origin's shared storage.
+         * @experimental
          */
         getSharedStorageMetadata(params: Protocol.Storage.GetSharedStorageMetadataRequest): Promise<Protocol.Storage.GetSharedStorageMetadataResponse>;
 
         /**
          * Gets the entries in an given origin's shared storage.
+         * @experimental
          */
         getSharedStorageEntries(params: Protocol.Storage.GetSharedStorageEntriesRequest): Promise<Protocol.Storage.GetSharedStorageEntriesResponse>;
 
         /**
          * Sets entry with `key` and `value` for a given origin's shared storage.
+         * @experimental
          */
         setSharedStorageEntry(params: Protocol.Storage.SetSharedStorageEntryRequest): Promise<void>;
 
         /**
          * Deletes entry for `key` (if it exists) for a given origin's shared storage.
+         * @experimental
          */
         deleteSharedStorageEntry(params: Protocol.Storage.DeleteSharedStorageEntryRequest): Promise<void>;
 
         /**
          * Clears all entries for a given origin's shared storage.
+         * @experimental
          */
         clearSharedStorageEntries(params: Protocol.Storage.ClearSharedStorageEntriesRequest): Promise<void>;
 
         /**
          * Resets the budget for `ownerOrigin` by clearing all budget withdrawals.
+         * @experimental
          */
         resetSharedStorageBudget(params: Protocol.Storage.ResetSharedStorageBudgetRequest): Promise<void>;
 
         /**
          * Enables/disables issuing of sharedStorageAccessed events.
+         * @experimental
          */
         setSharedStorageTracking(params: Protocol.Storage.SetSharedStorageTrackingRequest): Promise<void>;
 
         /**
          * Set tracking for a storage key's buckets.
+         * @experimental
          */
         setStorageBucketTracking(params: Protocol.Storage.SetStorageBucketTrackingRequest): Promise<void>;
 
         /**
          * Deletes the Storage Bucket with the given storage key and bucket name.
+         * @experimental
          */
         deleteStorageBucket(params: Protocol.Storage.DeleteStorageBucketRequest): Promise<void>;
 
         /**
          * Deletes state for sites identified as potential bounce trackers, immediately.
+         * @experimental
          */
         runBounceTrackingMitigations(): Promise<Protocol.Storage.RunBounceTrackingMitigationsResponse>;
 
         /**
          * https://wicg.github.io/attribution-reporting-api/
+         * @experimental
          */
         setAttributionReportingLocalTestingMode(params: Protocol.Storage.SetAttributionReportingLocalTestingModeRequest): Promise<void>;
 
         /**
          * Enables/disables issuing of Attribution Reporting events.
+         * @experimental
          */
         setAttributionReportingTracking(params: Protocol.Storage.SetAttributionReportingTrackingRequest): Promise<void>;
 
         /**
          * Sends all pending Attribution Reports immediately, regardless of their
          * scheduled report time.
+         * @experimental
          */
         sendPendingAttributionReports(): Promise<Protocol.Storage.SendPendingAttributionReportsResponse>;
 
         /**
          * Returns the effective Related Website Sets in use by this profile for the browser
          * session. The effective Related Website Sets will not change during a browser session.
+         * @experimental
          */
         getRelatedWebsiteSets(): Promise<Protocol.Storage.GetRelatedWebsiteSetsResponse>;
 
@@ -3825,6 +4144,7 @@ export namespace ProtocolProxyApi {
          * Returns the list of URLs from a page and its embedded resources that match
          * existing grace period URL pattern rules.
          * https://developers.google.com/privacy-sandbox/cookies/temporary-exceptions/grace-period
+         * @experimental
          */
         getAffectedUrlsForThirdPartyCookieMetadata(params: Protocol.Storage.GetAffectedUrlsForThirdPartyCookieMetadataRequest): Promise<Protocol.Storage.GetAffectedUrlsForThirdPartyCookieMetadataResponse>;
 
@@ -3886,12 +4206,24 @@ export namespace ProtocolProxyApi {
 
         on(event: 'storageBucketDeleted', listener: (params: Protocol.Storage.StorageBucketDeletedEvent) => void): void;
 
+        /**
+         * @experimental
+         */
         on(event: 'attributionReportingSourceRegistered', listener: (params: Protocol.Storage.AttributionReportingSourceRegisteredEvent) => void): void;
 
+        /**
+         * @experimental
+         */
         on(event: 'attributionReportingTriggerRegistered', listener: (params: Protocol.Storage.AttributionReportingTriggerRegisteredEvent) => void): void;
 
+        /**
+         * @experimental
+         */
         on(event: 'attributionReportingReportSent', listener: (params: Protocol.Storage.AttributionReportingReportSentEvent) => void): void;
 
+        /**
+         * @experimental
+         */
         on(event: 'attributionReportingVerboseDebugReportSent', listener: (params: Protocol.Storage.AttributionReportingVerboseDebugReportSentEvent) => void): void;
 
     }
@@ -3927,6 +4259,7 @@ export namespace ProtocolProxyApi {
 
         /**
          * Attaches to the browser target, only uses flat sessionId mode.
+         * @experimental
          */
         attachToBrowserTarget(): Promise<Protocol.Target.AttachToBrowserTargetResponse>;
 
@@ -3944,6 +4277,7 @@ export namespace ProtocolProxyApi {
          * The object has the following API:
          * - `binding.send(json)` - a method to send messages over the remote debugging protocol
          * - `binding.onmessage = json => handleMessage(json)` - a callback that will be called for the protocol notifications and command responses.
+         * @experimental
          */
         exposeDevToolsProtocol(params: Protocol.Target.ExposeDevToolsProtocolRequest): Promise<void>;
 
@@ -3976,6 +4310,7 @@ export namespace ProtocolProxyApi {
 
         /**
          * Returns information about a target.
+         * @experimental
          */
         getTargetInfo(params: Protocol.Target.GetTargetInfoRequest): Promise<Protocol.Target.GetTargetInfoResponse>;
 
@@ -3988,6 +4323,7 @@ export namespace ProtocolProxyApi {
          * Sends protocol message over session with given id.
          * Consider using flat mode instead; see commands attachToTarget, setAutoAttach,
          * and crbug.com/991325.
+         * @deprecated
          */
         sendMessageToTarget(params: Protocol.Target.SendMessageToTargetRequest): Promise<void>;
 
@@ -4009,6 +4345,7 @@ export namespace ProtocolProxyApi {
          * through `attachedToTarget`. The specified target is also auto-attached.
          * This cancels the effect of any previous `setAutoAttach` and is also cancelled by subsequent
          * `setAutoAttach`. Only available at the Browser target.
+         * @experimental
          */
         autoAttachRelated(params: Protocol.Target.AutoAttachRelatedRequest): Promise<void>;
 
@@ -4021,17 +4358,26 @@ export namespace ProtocolProxyApi {
         /**
          * Enables target discovery for the specified locations, when `setDiscoverTargets` was set to
          * `true`.
+         * @experimental
          */
         setRemoteLocations(params: Protocol.Target.SetRemoteLocationsRequest): Promise<void>;
 
+        /**
+         * Opens a DevTools window for the target.
+         * @experimental
+         */
+        openDevTools(params: Protocol.Target.OpenDevToolsRequest): Promise<Protocol.Target.OpenDevToolsResponse>;
+
         /**
          * Issued when attached to target because of auto-attach or `attachToTarget` command.
+         * @experimental
          */
         on(event: 'attachedToTarget', listener: (params: Protocol.Target.AttachedToTargetEvent) => void): void;
 
         /**
          * 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.
+         * @experimental
          */
         on(event: 'detachedFromTarget', listener: (params: Protocol.Target.DetachedFromTargetEvent) => void): void;
 
@@ -4090,16 +4436,19 @@ export namespace ProtocolProxyApi {
 
         /**
          * Gets supported tracing categories.
+         * @experimental
          */
         getCategories(): Promise<Protocol.Tracing.GetCategoriesResponse>;
 
         /**
          * Record a clock sync marker in the trace.
+         * @experimental
          */
         recordClockSyncMarker(params: Protocol.Tracing.RecordClockSyncMarkerRequest): Promise<void>;
 
         /**
          * Request a global memory dump.
+         * @experimental
          */
         requestMemoryDump(params: Protocol.Tracing.RequestMemoryDumpRequest): Promise<Protocol.Tracing.RequestMemoryDumpResponse>;
 
@@ -4108,11 +4457,15 @@ export namespace ProtocolProxyApi {
          */
         start(params: Protocol.Tracing.StartRequest): Promise<void>;
 
+        /**
+         * @experimental
+         */
         on(event: 'bufferUsage', listener: (params: Protocol.Tracing.BufferUsageEvent) => void): void;
 
         /**
          * Contains a bucket of collected trace events. When tracing is stopped collected events will be
          * sent as a sequence of dataCollected events followed by tracingComplete event.
+         * @experimental
          */
         on(event: 'dataCollected', listener: (params: Protocol.Tracing.DataCollectedEvent) => void): void;
 
@@ -4160,6 +4513,7 @@ export namespace ProtocolProxyApi {
          * Continues loading of the paused response, optionally modifying the
          * response headers. If either responseCode or headers are modified, all of them
          * must be present.
+         * @experimental
          */
         continueResponse(params: Protocol.Fetch.ContinueResponseRequest): Promise<void>;