devtools-protocol 0.0.1279463 → 0.0.1280070

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

@@ -117,18 +117,18 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Does nothing.
          */
-        clearMessages(): Promise<void>;
+        clearMessages(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Disables console domain, prevents further console messages from being reported to the client.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables console domain, sends the messages collected so far to the client by means of the
          * `messageAdded` notification.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Issued when new console message is added.
@@ -143,36 +143,36 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Continues execution until specific location is reached.
          */
-        continueToLocation(params: Protocol.Debugger.ContinueToLocationRequest): Promise<void>;
+        continueToLocation(params: Protocol.Debugger.ContinueToLocationRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Disables debugger for given page.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables debugger for the given page. Clients should not assume that the debugging has been
          * enabled until the result for this command is received.
          */
-        enable(params: Protocol.Debugger.EnableRequest): Promise<Protocol.Debugger.EnableResponse>;
+        enable(params: Protocol.Debugger.EnableRequest): Promise<{id: number, result: Protocol.Debugger.EnableResponse, sessionId: string}>;
 
         /**
          * Evaluates expression on a given call frame.
          */
-        evaluateOnCallFrame(params: Protocol.Debugger.EvaluateOnCallFrameRequest): Promise<Protocol.Debugger.EvaluateOnCallFrameResponse>;
+        evaluateOnCallFrame(params: Protocol.Debugger.EvaluateOnCallFrameRequest): Promise<{id: number, result: Protocol.Debugger.EvaluateOnCallFrameResponse, sessionId: string}>;
 
         /**
          * Returns possible locations for breakpoint. scriptId in start and end range locations should be
          * the same.
          */
-        getPossibleBreakpoints(params: Protocol.Debugger.GetPossibleBreakpointsRequest): Promise<Protocol.Debugger.GetPossibleBreakpointsResponse>;
+        getPossibleBreakpoints(params: Protocol.Debugger.GetPossibleBreakpointsRequest): Promise<{id: number, result: Protocol.Debugger.GetPossibleBreakpointsResponse, sessionId: string}>;
 
         /**
          * Returns source for the script with given id.
          */
-        getScriptSource(params: Protocol.Debugger.GetScriptSourceRequest): Promise<Protocol.Debugger.GetScriptSourceResponse>;
+        getScriptSource(params: Protocol.Debugger.GetScriptSourceRequest): Promise<{id: number, result: Protocol.Debugger.GetScriptSourceResponse, sessionId: string}>;
 
-        disassembleWasmModule(params: Protocol.Debugger.DisassembleWasmModuleRequest): Promise<Protocol.Debugger.DisassembleWasmModuleResponse>;
+        disassembleWasmModule(params: Protocol.Debugger.DisassembleWasmModuleRequest): Promise<{id: number, result: Protocol.Debugger.DisassembleWasmModuleResponse, sessionId: string}>;
 
         /**
          * Disassemble the next chunk of lines for the module corresponding to the
@@ -180,29 +180,29 @@ export namespace ProtocolTestsProxyApi {
          * and return an empty chunk. Any subsequent calls for the now invalid stream
          * will return errors.
          */
-        nextWasmDisassemblyChunk(params: Protocol.Debugger.NextWasmDisassemblyChunkRequest): Promise<Protocol.Debugger.NextWasmDisassemblyChunkResponse>;
+        nextWasmDisassemblyChunk(params: Protocol.Debugger.NextWasmDisassemblyChunkRequest): Promise<{id: number, result: Protocol.Debugger.NextWasmDisassemblyChunkResponse, sessionId: string}>;
 
         /**
          * This command is deprecated. Use getScriptSource instead.
          */
-        getWasmBytecode(params: Protocol.Debugger.GetWasmBytecodeRequest): Promise<Protocol.Debugger.GetWasmBytecodeResponse>;
+        getWasmBytecode(params: Protocol.Debugger.GetWasmBytecodeRequest): Promise<{id: number, result: Protocol.Debugger.GetWasmBytecodeResponse, sessionId: string}>;
 
         /**
          * Returns stack trace with given `stackTraceId`.
          */
-        getStackTrace(params: Protocol.Debugger.GetStackTraceRequest): Promise<Protocol.Debugger.GetStackTraceResponse>;
+        getStackTrace(params: Protocol.Debugger.GetStackTraceRequest): Promise<{id: number, result: Protocol.Debugger.GetStackTraceResponse, sessionId: string}>;
 
         /**
          * Stops on the next JavaScript statement.
          */
-        pause(): Promise<void>;
+        pause(): Promise<{id: number, result: void, sessionId: string}>;
 
-        pauseOnAsyncCall(params: Protocol.Debugger.PauseOnAsyncCallRequest): Promise<void>;
+        pauseOnAsyncCall(params: Protocol.Debugger.PauseOnAsyncCallRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Removes JavaScript breakpoint.
          */
-        removeBreakpoint(params: Protocol.Debugger.RemoveBreakpointRequest): Promise<void>;
+        removeBreakpoint(params: Protocol.Debugger.RemoveBreakpointRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Restarts particular call frame from the beginning. The old, deprecated
@@ -219,29 +219,29 @@ export namespace ProtocolTestsProxyApi {
          * Use the call frames from the `Debugger#paused` events instead, that fires
          * once V8 pauses at the beginning of the restarted function.
          */
-        restartFrame(params: Protocol.Debugger.RestartFrameRequest): Promise<Protocol.Debugger.RestartFrameResponse>;
+        restartFrame(params: Protocol.Debugger.RestartFrameRequest): Promise<{id: number, result: Protocol.Debugger.RestartFrameResponse, sessionId: string}>;
 
         /**
          * Resumes JavaScript execution.
          */
-        resume(params: Protocol.Debugger.ResumeRequest): Promise<void>;
+        resume(params: Protocol.Debugger.ResumeRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Searches for given string in script content.
          */
-        searchInContent(params: Protocol.Debugger.SearchInContentRequest): Promise<Protocol.Debugger.SearchInContentResponse>;
+        searchInContent(params: Protocol.Debugger.SearchInContentRequest): Promise<{id: number, result: Protocol.Debugger.SearchInContentResponse, sessionId: string}>;
 
         /**
          * Enables or disables async call stacks tracking.
          */
-        setAsyncCallStackDepth(params: Protocol.Debugger.SetAsyncCallStackDepthRequest): Promise<void>;
+        setAsyncCallStackDepth(params: Protocol.Debugger.SetAsyncCallStackDepthRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * 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.
          */
-        setBlackboxPatterns(params: Protocol.Debugger.SetBlackboxPatternsRequest): Promise<void>;
+        setBlackboxPatterns(params: Protocol.Debugger.SetBlackboxPatternsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Makes backend skip steps in the script in blackboxed ranges. VM will try leave blacklisted
@@ -249,17 +249,17 @@ export namespace ProtocolTestsProxyApi {
          * Positions array contains positions where blackbox state is changed. First interval isn't
          * blackboxed. Array should be sorted.
          */
-        setBlackboxedRanges(params: Protocol.Debugger.SetBlackboxedRangesRequest): Promise<void>;
+        setBlackboxedRanges(params: Protocol.Debugger.SetBlackboxedRangesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets JavaScript breakpoint at a given location.
          */
-        setBreakpoint(params: Protocol.Debugger.SetBreakpointRequest): Promise<Protocol.Debugger.SetBreakpointResponse>;
+        setBreakpoint(params: Protocol.Debugger.SetBreakpointRequest): Promise<{id: number, result: Protocol.Debugger.SetBreakpointResponse, sessionId: string}>;
 
         /**
          * Sets instrumentation breakpoint.
          */
-        setInstrumentationBreakpoint(params: Protocol.Debugger.SetInstrumentationBreakpointRequest): Promise<Protocol.Debugger.SetInstrumentationBreakpointResponse>;
+        setInstrumentationBreakpoint(params: Protocol.Debugger.SetInstrumentationBreakpointRequest): Promise<{id: number, result: Protocol.Debugger.SetInstrumentationBreakpointResponse, sessionId: string}>;
 
         /**
          * Sets JavaScript breakpoint at given location specified either by URL or URL regex. Once this
@@ -267,30 +267,30 @@ export namespace ProtocolTestsProxyApi {
          * `locations` property. Further matching script parsing will result in subsequent
          * `breakpointResolved` events issued. This logical breakpoint will survive page reloads.
          */
-        setBreakpointByUrl(params: Protocol.Debugger.SetBreakpointByUrlRequest): Promise<Protocol.Debugger.SetBreakpointByUrlResponse>;
+        setBreakpointByUrl(params: Protocol.Debugger.SetBreakpointByUrlRequest): Promise<{id: number, result: Protocol.Debugger.SetBreakpointByUrlResponse, sessionId: string}>;
 
         /**
          * 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.
          */
-        setBreakpointOnFunctionCall(params: Protocol.Debugger.SetBreakpointOnFunctionCallRequest): Promise<Protocol.Debugger.SetBreakpointOnFunctionCallResponse>;
+        setBreakpointOnFunctionCall(params: Protocol.Debugger.SetBreakpointOnFunctionCallRequest): Promise<{id: number, result: Protocol.Debugger.SetBreakpointOnFunctionCallResponse, sessionId: string}>;
 
         /**
          * Activates / deactivates all breakpoints on the page.
          */
-        setBreakpointsActive(params: Protocol.Debugger.SetBreakpointsActiveRequest): Promise<void>;
+        setBreakpointsActive(params: Protocol.Debugger.SetBreakpointsActiveRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Defines pause on exceptions state. Can be set to stop on all exceptions, uncaught exceptions,
          * or caught exceptions, no exceptions. Initial pause on exceptions state is `none`.
          */
-        setPauseOnExceptions(params: Protocol.Debugger.SetPauseOnExceptionsRequest): Promise<void>;
+        setPauseOnExceptions(params: Protocol.Debugger.SetPauseOnExceptionsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Changes return value in top frame. Available only at return break position.
          */
-        setReturnValue(params: Protocol.Debugger.SetReturnValueRequest): Promise<void>;
+        setReturnValue(params: Protocol.Debugger.SetReturnValueRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Edits JavaScript source live.
@@ -301,33 +301,33 @@ export namespace ProtocolTestsProxyApi {
          * the live edit will be successful and a `Debugger.restartFrame` for the
          * top-most function is automatically triggered.
          */
-        setScriptSource(params: Protocol.Debugger.SetScriptSourceRequest): Promise<Protocol.Debugger.SetScriptSourceResponse>;
+        setScriptSource(params: Protocol.Debugger.SetScriptSourceRequest): Promise<{id: number, result: Protocol.Debugger.SetScriptSourceResponse, sessionId: string}>;
 
         /**
          * Makes page not interrupt on any pauses (breakpoint, exception, dom exception etc).
          */
-        setSkipAllPauses(params: Protocol.Debugger.SetSkipAllPausesRequest): Promise<void>;
+        setSkipAllPauses(params: Protocol.Debugger.SetSkipAllPausesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Changes value of variable in a callframe. Object-based scopes are not supported and must be
          * mutated manually.
          */
-        setVariableValue(params: Protocol.Debugger.SetVariableValueRequest): Promise<void>;
+        setVariableValue(params: Protocol.Debugger.SetVariableValueRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Steps into the function call.
          */
-        stepInto(params: Protocol.Debugger.StepIntoRequest): Promise<void>;
+        stepInto(params: Protocol.Debugger.StepIntoRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Steps out of the function call.
          */
-        stepOut(): Promise<void>;
+        stepOut(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Steps over the statement.
          */
-        stepOver(params: Protocol.Debugger.StepOverRequest): Promise<void>;
+        stepOver(params: Protocol.Debugger.StepOverRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Fired when breakpoint is resolved to an actual script and location.
@@ -372,29 +372,29 @@ export namespace ProtocolTestsProxyApi {
          * Enables console to refer to the node with given id via $x (see Command Line API for more details
          * $x functions).
          */
-        addInspectedHeapObject(params: Protocol.HeapProfiler.AddInspectedHeapObjectRequest): Promise<void>;
+        addInspectedHeapObject(params: Protocol.HeapProfiler.AddInspectedHeapObjectRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        collectGarbage(): Promise<void>;
+        collectGarbage(): Promise<{id: number, result: void, sessionId: string}>;
 
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
-        getHeapObjectId(params: Protocol.HeapProfiler.GetHeapObjectIdRequest): Promise<Protocol.HeapProfiler.GetHeapObjectIdResponse>;
+        getHeapObjectId(params: Protocol.HeapProfiler.GetHeapObjectIdRequest): Promise<{id: number, result: Protocol.HeapProfiler.GetHeapObjectIdResponse, sessionId: string}>;
 
-        getObjectByHeapObjectId(params: Protocol.HeapProfiler.GetObjectByHeapObjectIdRequest): Promise<Protocol.HeapProfiler.GetObjectByHeapObjectIdResponse>;
+        getObjectByHeapObjectId(params: Protocol.HeapProfiler.GetObjectByHeapObjectIdRequest): Promise<{id: number, result: Protocol.HeapProfiler.GetObjectByHeapObjectIdResponse, sessionId: string}>;
 
-        getSamplingProfile(): Promise<Protocol.HeapProfiler.GetSamplingProfileResponse>;
+        getSamplingProfile(): Promise<{id: number, result: Protocol.HeapProfiler.GetSamplingProfileResponse, sessionId: string}>;
 
-        startSampling(params: Protocol.HeapProfiler.StartSamplingRequest): Promise<void>;
+        startSampling(params: Protocol.HeapProfiler.StartSamplingRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        startTrackingHeapObjects(params: Protocol.HeapProfiler.StartTrackingHeapObjectsRequest): Promise<void>;
+        startTrackingHeapObjects(params: Protocol.HeapProfiler.StartTrackingHeapObjectsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        stopSampling(): Promise<Protocol.HeapProfiler.StopSamplingResponse>;
+        stopSampling(): Promise<{id: number, result: Protocol.HeapProfiler.StopSamplingResponse, sessionId: string}>;
 
-        stopTrackingHeapObjects(params: Protocol.HeapProfiler.StopTrackingHeapObjectsRequest): Promise<void>;
+        stopTrackingHeapObjects(params: Protocol.HeapProfiler.StopTrackingHeapObjectsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        takeHeapSnapshot(params: Protocol.HeapProfiler.TakeHeapSnapshotRequest): Promise<void>;
+        takeHeapSnapshot(params: Protocol.HeapProfiler.TakeHeapSnapshotRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         onAddHeapSnapshotChunk(listener: (event: { params: Protocol.HeapProfiler.AddHeapSnapshotChunkEvent }) => void): void;
         offAddHeapSnapshotChunk(listener: (event: { params: Protocol.HeapProfiler.AddHeapSnapshotChunkEvent }) => void): void;
@@ -427,43 +427,43 @@ export namespace ProtocolTestsProxyApi {
     }
 
     export interface ProfilerApi {
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Collect coverage data for the current isolate. The coverage data may be incomplete due to
          * garbage collection.
          */
-        getBestEffortCoverage(): Promise<Protocol.Profiler.GetBestEffortCoverageResponse>;
+        getBestEffortCoverage(): Promise<{id: number, result: Protocol.Profiler.GetBestEffortCoverageResponse, sessionId: string}>;
 
         /**
          * Changes CPU profiler sampling interval. Must be called before CPU profiles recording started.
          */
-        setSamplingInterval(params: Protocol.Profiler.SetSamplingIntervalRequest): Promise<void>;
+        setSamplingInterval(params: Protocol.Profiler.SetSamplingIntervalRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        start(): Promise<void>;
+        start(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enable precise code coverage. Coverage data for JavaScript executed before enabling precise code
          * coverage may be incomplete. Enabling prevents running optimized code and resets execution
          * counters.
          */
-        startPreciseCoverage(params: Protocol.Profiler.StartPreciseCoverageRequest): Promise<Protocol.Profiler.StartPreciseCoverageResponse>;
+        startPreciseCoverage(params: Protocol.Profiler.StartPreciseCoverageRequest): Promise<{id: number, result: Protocol.Profiler.StartPreciseCoverageResponse, sessionId: string}>;
 
-        stop(): Promise<Protocol.Profiler.StopResponse>;
+        stop(): Promise<{id: number, result: Protocol.Profiler.StopResponse, sessionId: string}>;
 
         /**
          * Disable precise code coverage. Disabling releases unnecessary execution count records and allows
          * executing optimized code.
          */
-        stopPreciseCoverage(): Promise<void>;
+        stopPreciseCoverage(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Collect coverage data for the current isolate, and resets execution counters. Precise code
          * coverage needs to have started.
          */
-        takePreciseCoverage(): Promise<Protocol.Profiler.TakePreciseCoverageResponse>;
+        takePreciseCoverage(): Promise<{id: number, result: Protocol.Profiler.TakePreciseCoverageResponse, sessionId: string}>;
 
         onConsoleProfileFinished(listener: (event: { params: Protocol.Profiler.ConsoleProfileFinishedEvent }) => void): void;
         offConsoleProfileFinished(listener: (event: { params: Protocol.Profiler.ConsoleProfileFinishedEvent }) => void): void;
@@ -492,99 +492,99 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Add handler to promise with given promise object id.
          */
-        awaitPromise(params: Protocol.Runtime.AwaitPromiseRequest): Promise<Protocol.Runtime.AwaitPromiseResponse>;
+        awaitPromise(params: Protocol.Runtime.AwaitPromiseRequest): Promise<{id: number, result: Protocol.Runtime.AwaitPromiseResponse, sessionId: string}>;
 
         /**
          * Calls function with given declaration on the given object. Object group of the result is
          * inherited from the target object.
          */
-        callFunctionOn(params: Protocol.Runtime.CallFunctionOnRequest): Promise<Protocol.Runtime.CallFunctionOnResponse>;
+        callFunctionOn(params: Protocol.Runtime.CallFunctionOnRequest): Promise<{id: number, result: Protocol.Runtime.CallFunctionOnResponse, sessionId: string}>;
 
         /**
          * Compiles expression.
          */
-        compileScript(params: Protocol.Runtime.CompileScriptRequest): Promise<Protocol.Runtime.CompileScriptResponse>;
+        compileScript(params: Protocol.Runtime.CompileScriptRequest): Promise<{id: number, result: Protocol.Runtime.CompileScriptResponse, sessionId: string}>;
 
         /**
          * Disables reporting of execution contexts creation.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Discards collected exceptions and console API calls.
          */
-        discardConsoleEntries(): Promise<void>;
+        discardConsoleEntries(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables reporting of execution contexts creation by means of `executionContextCreated` event.
          * When the reporting gets enabled the event will be sent immediately for each existing execution
          * context.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Evaluates expression on global object.
          */
-        evaluate(params: Protocol.Runtime.EvaluateRequest): Promise<Protocol.Runtime.EvaluateResponse>;
+        evaluate(params: Protocol.Runtime.EvaluateRequest): Promise<{id: number, result: Protocol.Runtime.EvaluateResponse, sessionId: string}>;
 
         /**
          * Returns the isolate id.
          */
-        getIsolateId(): Promise<Protocol.Runtime.GetIsolateIdResponse>;
+        getIsolateId(): Promise<{id: number, result: Protocol.Runtime.GetIsolateIdResponse, sessionId: string}>;
 
         /**
          * Returns the JavaScript heap usage.
          * It is the total usage of the corresponding isolate not scoped to a particular Runtime.
          */
-        getHeapUsage(): Promise<Protocol.Runtime.GetHeapUsageResponse>;
+        getHeapUsage(): Promise<{id: number, result: Protocol.Runtime.GetHeapUsageResponse, sessionId: string}>;
 
         /**
          * Returns properties of a given object. Object group of the result is inherited from the target
          * object.
          */
-        getProperties(params: Protocol.Runtime.GetPropertiesRequest): Promise<Protocol.Runtime.GetPropertiesResponse>;
+        getProperties(params: Protocol.Runtime.GetPropertiesRequest): Promise<{id: number, result: Protocol.Runtime.GetPropertiesResponse, sessionId: string}>;
 
         /**
          * Returns all let, const and class variables from global scope.
          */
-        globalLexicalScopeNames(params: Protocol.Runtime.GlobalLexicalScopeNamesRequest): Promise<Protocol.Runtime.GlobalLexicalScopeNamesResponse>;
+        globalLexicalScopeNames(params: Protocol.Runtime.GlobalLexicalScopeNamesRequest): Promise<{id: number, result: Protocol.Runtime.GlobalLexicalScopeNamesResponse, sessionId: string}>;
 
-        queryObjects(params: Protocol.Runtime.QueryObjectsRequest): Promise<Protocol.Runtime.QueryObjectsResponse>;
+        queryObjects(params: Protocol.Runtime.QueryObjectsRequest): Promise<{id: number, result: Protocol.Runtime.QueryObjectsResponse, sessionId: string}>;
 
         /**
          * Releases remote object with given id.
          */
-        releaseObject(params: Protocol.Runtime.ReleaseObjectRequest): Promise<void>;
+        releaseObject(params: Protocol.Runtime.ReleaseObjectRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Releases all remote objects that belong to a given group.
          */
-        releaseObjectGroup(params: Protocol.Runtime.ReleaseObjectGroupRequest): Promise<void>;
+        releaseObjectGroup(params: Protocol.Runtime.ReleaseObjectGroupRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Tells inspected instance to run if it was waiting for debugger to attach.
          */
-        runIfWaitingForDebugger(): Promise<void>;
+        runIfWaitingForDebugger(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Runs script with given id in a given context.
          */
-        runScript(params: Protocol.Runtime.RunScriptRequest): Promise<Protocol.Runtime.RunScriptResponse>;
+        runScript(params: Protocol.Runtime.RunScriptRequest): Promise<{id: number, result: Protocol.Runtime.RunScriptResponse, sessionId: string}>;
 
         /**
          * Enables or disables async call stacks tracking.
          */
-        setAsyncCallStackDepth(params: Protocol.Runtime.SetAsyncCallStackDepthRequest): Promise<void>;
+        setAsyncCallStackDepth(params: Protocol.Runtime.SetAsyncCallStackDepthRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        setCustomObjectFormatterEnabled(params: Protocol.Runtime.SetCustomObjectFormatterEnabledRequest): Promise<void>;
+        setCustomObjectFormatterEnabled(params: Protocol.Runtime.SetCustomObjectFormatterEnabledRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        setMaxCallStackSizeToCapture(params: Protocol.Runtime.SetMaxCallStackSizeToCaptureRequest): Promise<void>;
+        setMaxCallStackSizeToCapture(params: Protocol.Runtime.SetMaxCallStackSizeToCaptureRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Terminate current or next JavaScript execution.
          * Will cancel the termination when the outer-most script execution ends.
          */
-        terminateExecution(): Promise<void>;
+        terminateExecution(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * If executionContextId is empty, adds binding with the given name on the
@@ -594,13 +594,13 @@ export namespace ProtocolTestsProxyApi {
          * in case of any other input, function throws an exception.
          * Each binding function call produces Runtime.bindingCalled notification.
          */
-        addBinding(params: Protocol.Runtime.AddBindingRequest): Promise<void>;
+        addBinding(params: Protocol.Runtime.AddBindingRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * This method does not remove binding function from global object but
          * unsubscribes current runtime agent from Runtime.bindingCalled notifications.
          */
-        removeBinding(params: Protocol.Runtime.RemoveBindingRequest): Promise<void>;
+        removeBinding(params: Protocol.Runtime.RemoveBindingRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * This method tries to lookup and populate exception details for a
@@ -609,7 +609,7 @@ export namespace ProtocolTestsProxyApi {
          * only be populated if the Runtime domain was enabled at the time when the
          * Error was thrown.
          */
-        getExceptionDetails(params: Protocol.Runtime.GetExceptionDetailsRequest): Promise<Protocol.Runtime.GetExceptionDetailsResponse>;
+        getExceptionDetails(params: Protocol.Runtime.GetExceptionDetailsRequest): Promise<{id: number, result: Protocol.Runtime.GetExceptionDetailsResponse, sessionId: string}>;
 
         /**
          * Notification is issued every time when binding is called.
@@ -674,7 +674,7 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Returns supported domains.
          */
-        getDomains(): Promise<Protocol.Schema.GetDomainsResponse>;
+        getDomains(): Promise<{id: number, result: Protocol.Schema.GetDomainsResponse, sessionId: string}>;
 
     }
 
@@ -682,41 +682,41 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Disables the accessibility domain.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables the accessibility domain which causes `AXNodeId`s to remain consistent between method calls.
          * This turns on accessibility for the page, which can impact performance until accessibility is disabled.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Fetches the accessibility node and partial accessibility tree for this DOM node, if it exists.
          */
-        getPartialAXTree(params: Protocol.Accessibility.GetPartialAXTreeRequest): Promise<Protocol.Accessibility.GetPartialAXTreeResponse>;
+        getPartialAXTree(params: Protocol.Accessibility.GetPartialAXTreeRequest): Promise<{id: number, result: Protocol.Accessibility.GetPartialAXTreeResponse, sessionId: string}>;
 
         /**
          * Fetches the entire accessibility tree for the root Document
          */
-        getFullAXTree(params: Protocol.Accessibility.GetFullAXTreeRequest): Promise<Protocol.Accessibility.GetFullAXTreeResponse>;
+        getFullAXTree(params: Protocol.Accessibility.GetFullAXTreeRequest): Promise<{id: number, result: Protocol.Accessibility.GetFullAXTreeResponse, sessionId: string}>;
 
         /**
          * Fetches the root node.
          * Requires `enable()` to have been called previously.
          */
-        getRootAXNode(params: Protocol.Accessibility.GetRootAXNodeRequest): Promise<Protocol.Accessibility.GetRootAXNodeResponse>;
+        getRootAXNode(params: Protocol.Accessibility.GetRootAXNodeRequest): Promise<{id: number, result: Protocol.Accessibility.GetRootAXNodeResponse, sessionId: string}>;
 
         /**
          * Fetches a node and all ancestors up to and including the root.
          * Requires `enable()` to have been called previously.
          */
-        getAXNodeAndAncestors(params: Protocol.Accessibility.GetAXNodeAndAncestorsRequest): Promise<Protocol.Accessibility.GetAXNodeAndAncestorsResponse>;
+        getAXNodeAndAncestors(params: Protocol.Accessibility.GetAXNodeAndAncestorsRequest): Promise<{id: number, result: Protocol.Accessibility.GetAXNodeAndAncestorsResponse, sessionId: string}>;
 
         /**
          * Fetches a particular accessibility node by AXNodeId.
          * Requires `enable()` to have been called previously.
          */
-        getChildAXNodes(params: Protocol.Accessibility.GetChildAXNodesRequest): Promise<Protocol.Accessibility.GetChildAXNodesResponse>;
+        getChildAXNodes(params: Protocol.Accessibility.GetChildAXNodesRequest): Promise<{id: number, result: Protocol.Accessibility.GetChildAXNodesResponse, sessionId: string}>;
 
         /**
          * Query a DOM node's accessibility subtree for accessible name and role.
@@ -725,7 +725,7 @@ export namespace ProtocolTestsProxyApi {
          * 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.
          */
-        queryAXTree(params: Protocol.Accessibility.QueryAXTreeRequest): Promise<Protocol.Accessibility.QueryAXTreeResponse>;
+        queryAXTree(params: Protocol.Accessibility.QueryAXTreeRequest): Promise<{id: number, result: Protocol.Accessibility.QueryAXTreeResponse, sessionId: string}>;
 
         /**
          * The loadComplete event mirrors the load complete event sent by the browser to assistive
@@ -748,52 +748,52 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Disables animation domain notifications.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables animation domain notifications.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Returns the current time of the an animation.
          */
-        getCurrentTime(params: Protocol.Animation.GetCurrentTimeRequest): Promise<Protocol.Animation.GetCurrentTimeResponse>;
+        getCurrentTime(params: Protocol.Animation.GetCurrentTimeRequest): Promise<{id: number, result: Protocol.Animation.GetCurrentTimeResponse, sessionId: string}>;
 
         /**
          * Gets the playback rate of the document timeline.
          */
-        getPlaybackRate(): Promise<Protocol.Animation.GetPlaybackRateResponse>;
+        getPlaybackRate(): Promise<{id: number, result: Protocol.Animation.GetPlaybackRateResponse, sessionId: string}>;
 
         /**
          * Releases a set of animations to no longer be manipulated.
          */
-        releaseAnimations(params: Protocol.Animation.ReleaseAnimationsRequest): Promise<void>;
+        releaseAnimations(params: Protocol.Animation.ReleaseAnimationsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Gets the remote object of the Animation.
          */
-        resolveAnimation(params: Protocol.Animation.ResolveAnimationRequest): Promise<Protocol.Animation.ResolveAnimationResponse>;
+        resolveAnimation(params: Protocol.Animation.ResolveAnimationRequest): Promise<{id: number, result: Protocol.Animation.ResolveAnimationResponse, sessionId: string}>;
 
         /**
          * Seek a set of animations to a particular time within each animation.
          */
-        seekAnimations(params: Protocol.Animation.SeekAnimationsRequest): Promise<void>;
+        seekAnimations(params: Protocol.Animation.SeekAnimationsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets the paused state of a set of animations.
          */
-        setPaused(params: Protocol.Animation.SetPausedRequest): Promise<void>;
+        setPaused(params: Protocol.Animation.SetPausedRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets the playback rate of the document timeline.
          */
-        setPlaybackRate(params: Protocol.Animation.SetPlaybackRateRequest): Promise<void>;
+        setPlaybackRate(params: Protocol.Animation.SetPlaybackRateRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets the timing of an animation node.
          */
-        setTiming(params: Protocol.Animation.SetTimingRequest): Promise<void>;
+        setTiming(params: Protocol.Animation.SetTimingRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Event for when an animation has been cancelled.
@@ -823,30 +823,30 @@ export namespace ProtocolTestsProxyApi {
          * Returns the response body and size if it were re-encoded with the specified settings. Only
          * applies to images.
          */
-        getEncodedResponse(params: Protocol.Audits.GetEncodedResponseRequest): Promise<Protocol.Audits.GetEncodedResponseResponse>;
+        getEncodedResponse(params: Protocol.Audits.GetEncodedResponseRequest): Promise<{id: number, result: Protocol.Audits.GetEncodedResponseResponse, sessionId: string}>;
 
         /**
          * Disables issues domain, prevents further issues from being reported to the client.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables issues domain, sends the issues collected so far to the client by means of the
          * `issueAdded` event.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Runs the contrast check for the target page. Found issues are reported
          * using Audits.issueAdded event.
          */
-        checkContrast(params: Protocol.Audits.CheckContrastRequest): Promise<void>;
+        checkContrast(params: Protocol.Audits.CheckContrastRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Runs the form issues check for the target page. Found issues are reported
          * using Audits.issueAdded event.
          */
-        checkFormsIssues(): Promise<Protocol.Audits.CheckFormsIssuesResponse>;
+        checkFormsIssues(): Promise<{id: number, result: Protocol.Audits.CheckFormsIssuesResponse, sessionId: string}>;
 
         onIssueAdded(listener: (event: { params: Protocol.Audits.IssueAddedEvent }) => void): void;
         offIssueAdded(listener: (event: { params: Protocol.Audits.IssueAddedEvent }) => void): void;
@@ -859,22 +859,22 @@ export namespace ProtocolTestsProxyApi {
          * Trigger autofill on a form identified by the fieldId.
          * If the field and related form cannot be autofilled, returns an error.
          */
-        trigger(params: Protocol.Autofill.TriggerRequest): Promise<void>;
+        trigger(params: Protocol.Autofill.TriggerRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Set addresses so that developers can verify their forms implementation.
          */
-        setAddresses(params: Protocol.Autofill.SetAddressesRequest): Promise<void>;
+        setAddresses(params: Protocol.Autofill.SetAddressesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Disables autofill domain notifications.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables autofill domain notifications.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Emitted when an address form is filled.
@@ -889,22 +889,22 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Enables event updates for the service.
          */
-        startObserving(params: Protocol.BackgroundService.StartObservingRequest): Promise<void>;
+        startObserving(params: Protocol.BackgroundService.StartObservingRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Disables event updates for the service.
          */
-        stopObserving(params: Protocol.BackgroundService.StopObservingRequest): Promise<void>;
+        stopObserving(params: Protocol.BackgroundService.StopObservingRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Set the recording state for the service.
          */
-        setRecording(params: Protocol.BackgroundService.SetRecordingRequest): Promise<void>;
+        setRecording(params: Protocol.BackgroundService.SetRecordingRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Clears all stored data for the service.
          */
-        clearEvents(params: Protocol.BackgroundService.ClearEventsRequest): Promise<void>;
+        clearEvents(params: Protocol.BackgroundService.ClearEventsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Called when the recording state for the service has been updated.
@@ -927,94 +927,94 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Set permission settings for given origin.
          */
-        setPermission(params: Protocol.Browser.SetPermissionRequest): Promise<void>;
+        setPermission(params: Protocol.Browser.SetPermissionRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Grant specific permissions to the given origin and reject all others.
          */
-        grantPermissions(params: Protocol.Browser.GrantPermissionsRequest): Promise<void>;
+        grantPermissions(params: Protocol.Browser.GrantPermissionsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Reset all permission management for all origins.
          */
-        resetPermissions(params: Protocol.Browser.ResetPermissionsRequest): Promise<void>;
+        resetPermissions(params: Protocol.Browser.ResetPermissionsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Set the behavior when downloading a file.
          */
-        setDownloadBehavior(params: Protocol.Browser.SetDownloadBehaviorRequest): Promise<void>;
+        setDownloadBehavior(params: Protocol.Browser.SetDownloadBehaviorRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Cancel a download if in progress
          */
-        cancelDownload(params: Protocol.Browser.CancelDownloadRequest): Promise<void>;
+        cancelDownload(params: Protocol.Browser.CancelDownloadRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Close browser gracefully.
          */
-        close(): Promise<void>;
+        close(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Crashes browser on the main thread.
          */
-        crash(): Promise<void>;
+        crash(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Crashes GPU process.
          */
-        crashGpuProcess(): Promise<void>;
+        crashGpuProcess(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Returns version information.
          */
-        getVersion(): Promise<Protocol.Browser.GetVersionResponse>;
+        getVersion(): Promise<{id: number, result: Protocol.Browser.GetVersionResponse, sessionId: string}>;
 
         /**
          * Returns the command line switches for the browser process if, and only if
          * --enable-automation is on the commandline.
          */
-        getBrowserCommandLine(): Promise<Protocol.Browser.GetBrowserCommandLineResponse>;
+        getBrowserCommandLine(): Promise<{id: number, result: Protocol.Browser.GetBrowserCommandLineResponse, sessionId: string}>;
 
         /**
          * Get Chrome histograms.
          */
-        getHistograms(params: Protocol.Browser.GetHistogramsRequest): Promise<Protocol.Browser.GetHistogramsResponse>;
+        getHistograms(params: Protocol.Browser.GetHistogramsRequest): Promise<{id: number, result: Protocol.Browser.GetHistogramsResponse, sessionId: string}>;
 
         /**
          * Get a Chrome histogram by name.
          */
-        getHistogram(params: Protocol.Browser.GetHistogramRequest): Promise<Protocol.Browser.GetHistogramResponse>;
+        getHistogram(params: Protocol.Browser.GetHistogramRequest): Promise<{id: number, result: Protocol.Browser.GetHistogramResponse, sessionId: string}>;
 
         /**
          * Get position and size of the browser window.
          */
-        getWindowBounds(params: Protocol.Browser.GetWindowBoundsRequest): Promise<Protocol.Browser.GetWindowBoundsResponse>;
+        getWindowBounds(params: Protocol.Browser.GetWindowBoundsRequest): Promise<{id: number, result: Protocol.Browser.GetWindowBoundsResponse, sessionId: string}>;
 
         /**
          * Get the browser window that contains the devtools target.
          */
-        getWindowForTarget(params: Protocol.Browser.GetWindowForTargetRequest): Promise<Protocol.Browser.GetWindowForTargetResponse>;
+        getWindowForTarget(params: Protocol.Browser.GetWindowForTargetRequest): Promise<{id: number, result: Protocol.Browser.GetWindowForTargetResponse, sessionId: string}>;
 
         /**
          * Set position and/or size of the browser window.
          */
-        setWindowBounds(params: Protocol.Browser.SetWindowBoundsRequest): Promise<void>;
+        setWindowBounds(params: Protocol.Browser.SetWindowBoundsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Set dock tile details, platform-specific.
          */
-        setDockTile(params: Protocol.Browser.SetDockTileRequest): Promise<void>;
+        setDockTile(params: Protocol.Browser.SetDockTileRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Invoke custom browser commands used by telemetry.
          */
-        executeBrowserCommand(params: Protocol.Browser.ExecuteBrowserCommandRequest): Promise<void>;
+        executeBrowserCommand(params: Protocol.Browser.ExecuteBrowserCommandRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Allows a site to use privacy sandbox features that require enrollment
          * without the site actually being enrolled. Only supported on page targets.
          */
-        addPrivacySandboxEnrollmentOverride(params: Protocol.Browser.AddPrivacySandboxEnrollmentOverrideRequest): Promise<void>;
+        addPrivacySandboxEnrollmentOverride(params: Protocol.Browser.AddPrivacySandboxEnrollmentOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Fired when page is about to start a download.
@@ -1037,68 +1037,68 @@ export namespace ProtocolTestsProxyApi {
          * Inserts a new rule with the given `ruleText` in a stylesheet with given `styleSheetId`, at the
          * position specified by `location`.
          */
-        addRule(params: Protocol.CSS.AddRuleRequest): Promise<Protocol.CSS.AddRuleResponse>;
+        addRule(params: Protocol.CSS.AddRuleRequest): Promise<{id: number, result: Protocol.CSS.AddRuleResponse, sessionId: string}>;
 
         /**
          * Returns all class names from specified stylesheet.
          */
-        collectClassNames(params: Protocol.CSS.CollectClassNamesRequest): Promise<Protocol.CSS.CollectClassNamesResponse>;
+        collectClassNames(params: Protocol.CSS.CollectClassNamesRequest): Promise<{id: number, result: Protocol.CSS.CollectClassNamesResponse, sessionId: string}>;
 
         /**
          * Creates a new special "via-inspector" stylesheet in the frame with given `frameId`.
          */
-        createStyleSheet(params: Protocol.CSS.CreateStyleSheetRequest): Promise<Protocol.CSS.CreateStyleSheetResponse>;
+        createStyleSheet(params: Protocol.CSS.CreateStyleSheetRequest): Promise<{id: number, result: Protocol.CSS.CreateStyleSheetResponse, sessionId: string}>;
 
         /**
          * Disables the CSS agent for the given page.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables the CSS agent for the given page. Clients should not assume that the CSS agent has been
          * enabled until the result of this command is received.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Ensures that the given node will have specified pseudo-classes whenever its style is computed by
          * the browser.
          */
-        forcePseudoState(params: Protocol.CSS.ForcePseudoStateRequest): Promise<void>;
+        forcePseudoState(params: Protocol.CSS.ForcePseudoStateRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        getBackgroundColors(params: Protocol.CSS.GetBackgroundColorsRequest): Promise<Protocol.CSS.GetBackgroundColorsResponse>;
+        getBackgroundColors(params: Protocol.CSS.GetBackgroundColorsRequest): Promise<{id: number, result: Protocol.CSS.GetBackgroundColorsResponse, sessionId: string}>;
 
         /**
          * Returns the computed style for a DOM node identified by `nodeId`.
          */
-        getComputedStyleForNode(params: Protocol.CSS.GetComputedStyleForNodeRequest): Promise<Protocol.CSS.GetComputedStyleForNodeResponse>;
+        getComputedStyleForNode(params: Protocol.CSS.GetComputedStyleForNodeRequest): Promise<{id: number, result: Protocol.CSS.GetComputedStyleForNodeResponse, sessionId: string}>;
 
         /**
          * Returns the styles defined inline (explicitly in the "style" attribute and implicitly, using DOM
          * attributes) for a DOM node identified by `nodeId`.
          */
-        getInlineStylesForNode(params: Protocol.CSS.GetInlineStylesForNodeRequest): Promise<Protocol.CSS.GetInlineStylesForNodeResponse>;
+        getInlineStylesForNode(params: Protocol.CSS.GetInlineStylesForNodeRequest): Promise<{id: number, result: Protocol.CSS.GetInlineStylesForNodeResponse, sessionId: string}>;
 
         /**
          * Returns requested styles for a DOM node identified by `nodeId`.
          */
-        getMatchedStylesForNode(params: Protocol.CSS.GetMatchedStylesForNodeRequest): Promise<Protocol.CSS.GetMatchedStylesForNodeResponse>;
+        getMatchedStylesForNode(params: Protocol.CSS.GetMatchedStylesForNodeRequest): Promise<{id: number, result: Protocol.CSS.GetMatchedStylesForNodeResponse, sessionId: string}>;
 
         /**
          * Returns all media queries parsed by the rendering engine.
          */
-        getMediaQueries(): Promise<Protocol.CSS.GetMediaQueriesResponse>;
+        getMediaQueries(): Promise<{id: number, result: Protocol.CSS.GetMediaQueriesResponse, sessionId: string}>;
 
         /**
          * Requests information about platform fonts which we used to render child TextNodes in the given
          * node.
          */
-        getPlatformFontsForNode(params: Protocol.CSS.GetPlatformFontsForNodeRequest): Promise<Protocol.CSS.GetPlatformFontsForNodeResponse>;
+        getPlatformFontsForNode(params: Protocol.CSS.GetPlatformFontsForNodeRequest): Promise<{id: number, result: Protocol.CSS.GetPlatformFontsForNodeResponse, sessionId: string}>;
 
         /**
          * Returns the current textual content for a stylesheet.
          */
-        getStyleSheetText(params: Protocol.CSS.GetStyleSheetTextRequest): Promise<Protocol.CSS.GetStyleSheetTextResponse>;
+        getStyleSheetText(params: Protocol.CSS.GetStyleSheetTextRequest): Promise<{id: number, result: Protocol.CSS.GetStyleSheetTextResponse, sessionId: string}>;
 
         /**
          * Returns all layers parsed by the rendering engine for the tree scope of a node.
@@ -1106,13 +1106,13 @@ export namespace ProtocolTestsProxyApi {
          * layer for the nearest ancestor document or shadow root. The layer root contains
          * the full layer tree for the tree scope and their ordering.
          */
-        getLayersForNode(params: Protocol.CSS.GetLayersForNodeRequest): Promise<Protocol.CSS.GetLayersForNodeResponse>;
+        getLayersForNode(params: Protocol.CSS.GetLayersForNodeRequest): Promise<{id: number, result: Protocol.CSS.GetLayersForNodeResponse, sessionId: string}>;
 
         /**
          * Given a CSS selector text and a style sheet ID, getLocationForSelector
          * returns an array of locations of the CSS selector in the style sheet.
          */
-        getLocationForSelector(params: Protocol.CSS.GetLocationForSelectorRequest): Promise<Protocol.CSS.GetLocationForSelectorResponse>;
+        getLocationForSelector(params: Protocol.CSS.GetLocationForSelectorRequest): Promise<{id: number, result: Protocol.CSS.GetLocationForSelectorResponse, sessionId: string}>;
 
         /**
          * Starts tracking the given computed styles for updates. The specified array of properties
@@ -1122,85 +1122,85 @@ export namespace ProtocolTestsProxyApi {
          * 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.
          */
-        trackComputedStyleUpdates(params: Protocol.CSS.TrackComputedStyleUpdatesRequest): Promise<void>;
+        trackComputedStyleUpdates(params: Protocol.CSS.TrackComputedStyleUpdatesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Polls the next batch of computed style updates.
          */
-        takeComputedStyleUpdates(): Promise<Protocol.CSS.TakeComputedStyleUpdatesResponse>;
+        takeComputedStyleUpdates(): Promise<{id: number, result: Protocol.CSS.TakeComputedStyleUpdatesResponse, sessionId: string}>;
 
         /**
          * Find a rule with the given active property for the given node and set the new value for this
          * property
          */
-        setEffectivePropertyValueForNode(params: Protocol.CSS.SetEffectivePropertyValueForNodeRequest): Promise<void>;
+        setEffectivePropertyValueForNode(params: Protocol.CSS.SetEffectivePropertyValueForNodeRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Modifies the property rule property name.
          */
-        setPropertyRulePropertyName(params: Protocol.CSS.SetPropertyRulePropertyNameRequest): Promise<Protocol.CSS.SetPropertyRulePropertyNameResponse>;
+        setPropertyRulePropertyName(params: Protocol.CSS.SetPropertyRulePropertyNameRequest): Promise<{id: number, result: Protocol.CSS.SetPropertyRulePropertyNameResponse, sessionId: string}>;
 
         /**
          * Modifies the keyframe rule key text.
          */
-        setKeyframeKey(params: Protocol.CSS.SetKeyframeKeyRequest): Promise<Protocol.CSS.SetKeyframeKeyResponse>;
+        setKeyframeKey(params: Protocol.CSS.SetKeyframeKeyRequest): Promise<{id: number, result: Protocol.CSS.SetKeyframeKeyResponse, sessionId: string}>;
 
         /**
          * Modifies the rule selector.
          */
-        setMediaText(params: Protocol.CSS.SetMediaTextRequest): Promise<Protocol.CSS.SetMediaTextResponse>;
+        setMediaText(params: Protocol.CSS.SetMediaTextRequest): Promise<{id: number, result: Protocol.CSS.SetMediaTextResponse, sessionId: string}>;
 
         /**
          * Modifies the expression of a container query.
          */
-        setContainerQueryText(params: Protocol.CSS.SetContainerQueryTextRequest): Promise<Protocol.CSS.SetContainerQueryTextResponse>;
+        setContainerQueryText(params: Protocol.CSS.SetContainerQueryTextRequest): Promise<{id: number, result: Protocol.CSS.SetContainerQueryTextResponse, sessionId: string}>;
 
         /**
          * Modifies the expression of a supports at-rule.
          */
-        setSupportsText(params: Protocol.CSS.SetSupportsTextRequest): Promise<Protocol.CSS.SetSupportsTextResponse>;
+        setSupportsText(params: Protocol.CSS.SetSupportsTextRequest): Promise<{id: number, result: Protocol.CSS.SetSupportsTextResponse, sessionId: string}>;
 
         /**
          * Modifies the expression of a scope at-rule.
          */
-        setScopeText(params: Protocol.CSS.SetScopeTextRequest): Promise<Protocol.CSS.SetScopeTextResponse>;
+        setScopeText(params: Protocol.CSS.SetScopeTextRequest): Promise<{id: number, result: Protocol.CSS.SetScopeTextResponse, sessionId: string}>;
 
         /**
          * Modifies the rule selector.
          */
-        setRuleSelector(params: Protocol.CSS.SetRuleSelectorRequest): Promise<Protocol.CSS.SetRuleSelectorResponse>;
+        setRuleSelector(params: Protocol.CSS.SetRuleSelectorRequest): Promise<{id: number, result: Protocol.CSS.SetRuleSelectorResponse, sessionId: string}>;
 
         /**
          * Sets the new stylesheet text.
          */
-        setStyleSheetText(params: Protocol.CSS.SetStyleSheetTextRequest): Promise<Protocol.CSS.SetStyleSheetTextResponse>;
+        setStyleSheetText(params: Protocol.CSS.SetStyleSheetTextRequest): Promise<{id: number, result: Protocol.CSS.SetStyleSheetTextResponse, sessionId: string}>;
 
         /**
          * Applies specified style edits one after another in the given order.
          */
-        setStyleTexts(params: Protocol.CSS.SetStyleTextsRequest): Promise<Protocol.CSS.SetStyleTextsResponse>;
+        setStyleTexts(params: Protocol.CSS.SetStyleTextsRequest): Promise<{id: number, result: Protocol.CSS.SetStyleTextsResponse, sessionId: string}>;
 
         /**
          * Enables the selector recording.
          */
-        startRuleUsageTracking(): Promise<void>;
+        startRuleUsageTracking(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Stop tracking rule usage and return the list of rules that were used since last call to
          * `takeCoverageDelta` (or since start of coverage instrumentation).
          */
-        stopRuleUsageTracking(): Promise<Protocol.CSS.StopRuleUsageTrackingResponse>;
+        stopRuleUsageTracking(): Promise<{id: number, result: Protocol.CSS.StopRuleUsageTrackingResponse, sessionId: string}>;
 
         /**
          * Obtain list of rules that became used since last call to this method (or since start of coverage
          * instrumentation).
          */
-        takeCoverageDelta(): Promise<Protocol.CSS.TakeCoverageDeltaResponse>;
+        takeCoverageDelta(): Promise<{id: number, result: Protocol.CSS.TakeCoverageDeltaResponse, sessionId: string}>;
 
         /**
          * Enables/disables rendering of local CSS fonts (enabled by default).
          */
-        setLocalFontsEnabled(params: Protocol.CSS.SetLocalFontsEnabledRequest): Promise<void>;
+        setLocalFontsEnabled(params: Protocol.CSS.SetLocalFontsEnabledRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Fires whenever a web font is updated.  A non-empty font parameter indicates a successfully loaded
@@ -1245,27 +1245,27 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Deletes a cache.
          */
-        deleteCache(params: Protocol.CacheStorage.DeleteCacheRequest): Promise<void>;
+        deleteCache(params: Protocol.CacheStorage.DeleteCacheRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Deletes a cache entry.
          */
-        deleteEntry(params: Protocol.CacheStorage.DeleteEntryRequest): Promise<void>;
+        deleteEntry(params: Protocol.CacheStorage.DeleteEntryRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Requests cache names.
          */
-        requestCacheNames(params: Protocol.CacheStorage.RequestCacheNamesRequest): Promise<Protocol.CacheStorage.RequestCacheNamesResponse>;
+        requestCacheNames(params: Protocol.CacheStorage.RequestCacheNamesRequest): Promise<{id: number, result: Protocol.CacheStorage.RequestCacheNamesResponse, sessionId: string}>;
 
         /**
          * Fetches cache entry.
          */
-        requestCachedResponse(params: Protocol.CacheStorage.RequestCachedResponseRequest): Promise<Protocol.CacheStorage.RequestCachedResponseResponse>;
+        requestCachedResponse(params: Protocol.CacheStorage.RequestCachedResponseRequest): Promise<{id: number, result: Protocol.CacheStorage.RequestCachedResponseResponse, sessionId: string}>;
 
         /**
          * Requests data from cache.
          */
-        requestEntries(params: Protocol.CacheStorage.RequestEntriesRequest): Promise<Protocol.CacheStorage.RequestEntriesResponse>;
+        requestEntries(params: Protocol.CacheStorage.RequestEntriesRequest): Promise<{id: number, result: Protocol.CacheStorage.RequestEntriesResponse, sessionId: string}>;
 
     }
 
@@ -1277,33 +1277,33 @@ export namespace ProtocolTestsProxyApi {
          * Also starts observing for issue messages. When an issue is added or removed,
          * an |issueUpdated| event is fired.
          */
-        enable(params: Protocol.Cast.EnableRequest): Promise<void>;
+        enable(params: Protocol.Cast.EnableRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Stops observing for sinks and issues.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets a sink to be used when the web page requests the browser to choose a
          * sink via Presentation API, Remote Playback API, or Cast SDK.
          */
-        setSinkToUse(params: Protocol.Cast.SetSinkToUseRequest): Promise<void>;
+        setSinkToUse(params: Protocol.Cast.SetSinkToUseRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Starts mirroring the desktop to the sink.
          */
-        startDesktopMirroring(params: Protocol.Cast.StartDesktopMirroringRequest): Promise<void>;
+        startDesktopMirroring(params: Protocol.Cast.StartDesktopMirroringRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Starts mirroring the tab to the sink.
          */
-        startTabMirroring(params: Protocol.Cast.StartTabMirroringRequest): Promise<void>;
+        startTabMirroring(params: Protocol.Cast.StartTabMirroringRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Stops the active Cast session on the sink.
          */
-        stopCasting(params: Protocol.Cast.StopCastingRequest): Promise<void>;
+        stopCasting(params: Protocol.Cast.StopCastingRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * This is fired whenever the list of available sinks changes. A sink is a
@@ -1327,258 +1327,258 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Collects class names for the node with given id and all of it's child nodes.
          */
-        collectClassNamesFromSubtree(params: Protocol.DOM.CollectClassNamesFromSubtreeRequest): Promise<Protocol.DOM.CollectClassNamesFromSubtreeResponse>;
+        collectClassNamesFromSubtree(params: Protocol.DOM.CollectClassNamesFromSubtreeRequest): Promise<{id: number, result: Protocol.DOM.CollectClassNamesFromSubtreeResponse, sessionId: string}>;
 
         /**
          * Creates a deep copy of the specified node and places it into the target container before the
          * given anchor.
          */
-        copyTo(params: Protocol.DOM.CopyToRequest): Promise<Protocol.DOM.CopyToResponse>;
+        copyTo(params: Protocol.DOM.CopyToRequest): Promise<{id: number, result: Protocol.DOM.CopyToResponse, sessionId: string}>;
 
         /**
          * Describes node given its id, does not require domain to be enabled. Does not start tracking any
          * objects, can be used for automation.
          */
-        describeNode(params: Protocol.DOM.DescribeNodeRequest): Promise<Protocol.DOM.DescribeNodeResponse>;
+        describeNode(params: Protocol.DOM.DescribeNodeRequest): Promise<{id: number, result: Protocol.DOM.DescribeNodeResponse, sessionId: string}>;
 
         /**
          * Scrolls the specified rect of the given node into view if not already visible.
          * Note: exactly one between nodeId, backendNodeId and objectId should be passed
          * to identify the node.
          */
-        scrollIntoViewIfNeeded(params: Protocol.DOM.ScrollIntoViewIfNeededRequest): Promise<void>;
+        scrollIntoViewIfNeeded(params: Protocol.DOM.ScrollIntoViewIfNeededRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Disables DOM agent for the given page.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Discards search results from the session with the given id. `getSearchResults` should no longer
          * be called for that search.
          */
-        discardSearchResults(params: Protocol.DOM.DiscardSearchResultsRequest): Promise<void>;
+        discardSearchResults(params: Protocol.DOM.DiscardSearchResultsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables DOM agent for the given page.
          */
-        enable(params: Protocol.DOM.EnableRequest): Promise<void>;
+        enable(params: Protocol.DOM.EnableRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Focuses the given element.
          */
-        focus(params: Protocol.DOM.FocusRequest): Promise<void>;
+        focus(params: Protocol.DOM.FocusRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Returns attributes for the specified node.
          */
-        getAttributes(params: Protocol.DOM.GetAttributesRequest): Promise<Protocol.DOM.GetAttributesResponse>;
+        getAttributes(params: Protocol.DOM.GetAttributesRequest): Promise<{id: number, result: Protocol.DOM.GetAttributesResponse, sessionId: string}>;
 
         /**
          * Returns boxes for the given node.
          */
-        getBoxModel(params: Protocol.DOM.GetBoxModelRequest): Promise<Protocol.DOM.GetBoxModelResponse>;
+        getBoxModel(params: Protocol.DOM.GetBoxModelRequest): Promise<{id: number, result: Protocol.DOM.GetBoxModelResponse, sessionId: string}>;
 
         /**
          * Returns quads that describe node position on the page. This method
          * might return multiple quads for inline nodes.
          */
-        getContentQuads(params: Protocol.DOM.GetContentQuadsRequest): Promise<Protocol.DOM.GetContentQuadsResponse>;
+        getContentQuads(params: Protocol.DOM.GetContentQuadsRequest): Promise<{id: number, result: Protocol.DOM.GetContentQuadsResponse, sessionId: string}>;
 
         /**
          * Returns the root DOM node (and optionally the subtree) to the caller.
          * Implicitly enables the DOM domain events for the current target.
          */
-        getDocument(params: Protocol.DOM.GetDocumentRequest): Promise<Protocol.DOM.GetDocumentResponse>;
+        getDocument(params: Protocol.DOM.GetDocumentRequest): Promise<{id: number, result: Protocol.DOM.GetDocumentResponse, sessionId: string}>;
 
         /**
          * 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.
          */
-        getFlattenedDocument(params: Protocol.DOM.GetFlattenedDocumentRequest): Promise<Protocol.DOM.GetFlattenedDocumentResponse>;
+        getFlattenedDocument(params: Protocol.DOM.GetFlattenedDocumentRequest): Promise<{id: number, result: Protocol.DOM.GetFlattenedDocumentResponse, sessionId: string}>;
 
         /**
          * Finds nodes with a given computed style in a subtree.
          */
-        getNodesForSubtreeByStyle(params: Protocol.DOM.GetNodesForSubtreeByStyleRequest): Promise<Protocol.DOM.GetNodesForSubtreeByStyleResponse>;
+        getNodesForSubtreeByStyle(params: Protocol.DOM.GetNodesForSubtreeByStyleRequest): Promise<{id: number, result: Protocol.DOM.GetNodesForSubtreeByStyleResponse, sessionId: string}>;
 
         /**
          * Returns node id at given location. Depending on whether DOM domain is enabled, nodeId is
          * either returned or not.
          */
-        getNodeForLocation(params: Protocol.DOM.GetNodeForLocationRequest): Promise<Protocol.DOM.GetNodeForLocationResponse>;
+        getNodeForLocation(params: Protocol.DOM.GetNodeForLocationRequest): Promise<{id: number, result: Protocol.DOM.GetNodeForLocationResponse, sessionId: string}>;
 
         /**
          * Returns node's HTML markup.
          */
-        getOuterHTML(params: Protocol.DOM.GetOuterHTMLRequest): Promise<Protocol.DOM.GetOuterHTMLResponse>;
+        getOuterHTML(params: Protocol.DOM.GetOuterHTMLRequest): Promise<{id: number, result: Protocol.DOM.GetOuterHTMLResponse, sessionId: string}>;
 
         /**
          * Returns the id of the nearest ancestor that is a relayout boundary.
          */
-        getRelayoutBoundary(params: Protocol.DOM.GetRelayoutBoundaryRequest): Promise<Protocol.DOM.GetRelayoutBoundaryResponse>;
+        getRelayoutBoundary(params: Protocol.DOM.GetRelayoutBoundaryRequest): Promise<{id: number, result: Protocol.DOM.GetRelayoutBoundaryResponse, sessionId: string}>;
 
         /**
          * Returns search results from given `fromIndex` to given `toIndex` from the search with the given
          * identifier.
          */
-        getSearchResults(params: Protocol.DOM.GetSearchResultsRequest): Promise<Protocol.DOM.GetSearchResultsResponse>;
+        getSearchResults(params: Protocol.DOM.GetSearchResultsRequest): Promise<{id: number, result: Protocol.DOM.GetSearchResultsResponse, sessionId: string}>;
 
         /**
          * Hides any highlight.
          */
-        hideHighlight(): Promise<void>;
+        hideHighlight(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Highlights DOM node.
          */
-        highlightNode(): Promise<void>;
+        highlightNode(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Highlights given rectangle.
          */
-        highlightRect(): Promise<void>;
+        highlightRect(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Marks last undoable state.
          */
-        markUndoableState(): Promise<void>;
+        markUndoableState(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Moves node into the new container, places it before the given anchor.
          */
-        moveTo(params: Protocol.DOM.MoveToRequest): Promise<Protocol.DOM.MoveToResponse>;
+        moveTo(params: Protocol.DOM.MoveToRequest): Promise<{id: number, result: Protocol.DOM.MoveToResponse, sessionId: string}>;
 
         /**
          * Searches for a given string in the DOM tree. Use `getSearchResults` to access search results or
          * `cancelSearch` to end this search session.
          */
-        performSearch(params: Protocol.DOM.PerformSearchRequest): Promise<Protocol.DOM.PerformSearchResponse>;
+        performSearch(params: Protocol.DOM.PerformSearchRequest): Promise<{id: number, result: Protocol.DOM.PerformSearchResponse, sessionId: string}>;
 
         /**
          * Requests that the node is sent to the caller given its path. // FIXME, use XPath
          */
-        pushNodeByPathToFrontend(params: Protocol.DOM.PushNodeByPathToFrontendRequest): Promise<Protocol.DOM.PushNodeByPathToFrontendResponse>;
+        pushNodeByPathToFrontend(params: Protocol.DOM.PushNodeByPathToFrontendRequest): Promise<{id: number, result: Protocol.DOM.PushNodeByPathToFrontendResponse, sessionId: string}>;
 
         /**
          * Requests that a batch of nodes is sent to the caller given their backend node ids.
          */
-        pushNodesByBackendIdsToFrontend(params: Protocol.DOM.PushNodesByBackendIdsToFrontendRequest): Promise<Protocol.DOM.PushNodesByBackendIdsToFrontendResponse>;
+        pushNodesByBackendIdsToFrontend(params: Protocol.DOM.PushNodesByBackendIdsToFrontendRequest): Promise<{id: number, result: Protocol.DOM.PushNodesByBackendIdsToFrontendResponse, sessionId: string}>;
 
         /**
          * Executes `querySelector` on a given node.
          */
-        querySelector(params: Protocol.DOM.QuerySelectorRequest): Promise<Protocol.DOM.QuerySelectorResponse>;
+        querySelector(params: Protocol.DOM.QuerySelectorRequest): Promise<{id: number, result: Protocol.DOM.QuerySelectorResponse, sessionId: string}>;
 
         /**
          * Executes `querySelectorAll` on a given node.
          */
-        querySelectorAll(params: Protocol.DOM.QuerySelectorAllRequest): Promise<Protocol.DOM.QuerySelectorAllResponse>;
+        querySelectorAll(params: Protocol.DOM.QuerySelectorAllRequest): Promise<{id: number, result: Protocol.DOM.QuerySelectorAllResponse, sessionId: string}>;
 
         /**
          * 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.
          */
-        getTopLayerElements(): Promise<Protocol.DOM.GetTopLayerElementsResponse>;
+        getTopLayerElements(): Promise<{id: number, result: Protocol.DOM.GetTopLayerElementsResponse, sessionId: string}>;
 
         /**
          * Re-does the last undone action.
          */
-        redo(): Promise<void>;
+        redo(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Removes attribute with given name from an element with given id.
          */
-        removeAttribute(params: Protocol.DOM.RemoveAttributeRequest): Promise<void>;
+        removeAttribute(params: Protocol.DOM.RemoveAttributeRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Removes node with given id.
          */
-        removeNode(params: Protocol.DOM.RemoveNodeRequest): Promise<void>;
+        removeNode(params: Protocol.DOM.RemoveNodeRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Requests that children of the node with given id are returned to the caller in form of
          * `setChildNodes` events where not only immediate children are retrieved, but all children down to
          * the specified depth.
          */
-        requestChildNodes(params: Protocol.DOM.RequestChildNodesRequest): Promise<void>;
+        requestChildNodes(params: Protocol.DOM.RequestChildNodesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Requests that the node is sent to the caller given the JavaScript node object reference. All
          * nodes that form the path from the node to the root are also sent to the client as a series of
          * `setChildNodes` notifications.
          */
-        requestNode(params: Protocol.DOM.RequestNodeRequest): Promise<Protocol.DOM.RequestNodeResponse>;
+        requestNode(params: Protocol.DOM.RequestNodeRequest): Promise<{id: number, result: Protocol.DOM.RequestNodeResponse, sessionId: string}>;
 
         /**
          * Resolves the JavaScript node object for a given NodeId or BackendNodeId.
          */
-        resolveNode(params: Protocol.DOM.ResolveNodeRequest): Promise<Protocol.DOM.ResolveNodeResponse>;
+        resolveNode(params: Protocol.DOM.ResolveNodeRequest): Promise<{id: number, result: Protocol.DOM.ResolveNodeResponse, sessionId: string}>;
 
         /**
          * Sets attribute for an element with given id.
          */
-        setAttributeValue(params: Protocol.DOM.SetAttributeValueRequest): Promise<void>;
+        setAttributeValue(params: Protocol.DOM.SetAttributeValueRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets attributes on element with given id. This method is useful when user edits some existing
          * attribute value and types in several attribute name/value pairs.
          */
-        setAttributesAsText(params: Protocol.DOM.SetAttributesAsTextRequest): Promise<void>;
+        setAttributesAsText(params: Protocol.DOM.SetAttributesAsTextRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets files for the given file input element.
          */
-        setFileInputFiles(params: Protocol.DOM.SetFileInputFilesRequest): Promise<void>;
+        setFileInputFiles(params: Protocol.DOM.SetFileInputFilesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets if stack traces should be captured for Nodes. See `Node.getNodeStackTraces`. Default is disabled.
          */
-        setNodeStackTracesEnabled(params: Protocol.DOM.SetNodeStackTracesEnabledRequest): Promise<void>;
+        setNodeStackTracesEnabled(params: Protocol.DOM.SetNodeStackTracesEnabledRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Gets stack traces associated with a Node. As of now, only provides stack trace for Node creation.
          */
-        getNodeStackTraces(params: Protocol.DOM.GetNodeStackTracesRequest): Promise<Protocol.DOM.GetNodeStackTracesResponse>;
+        getNodeStackTraces(params: Protocol.DOM.GetNodeStackTracesRequest): Promise<{id: number, result: Protocol.DOM.GetNodeStackTracesResponse, sessionId: string}>;
 
         /**
          * Returns file information for the given
          * File wrapper.
          */
-        getFileInfo(params: Protocol.DOM.GetFileInfoRequest): Promise<Protocol.DOM.GetFileInfoResponse>;
+        getFileInfo(params: Protocol.DOM.GetFileInfoRequest): Promise<{id: number, result: Protocol.DOM.GetFileInfoResponse, sessionId: string}>;
 
         /**
          * Enables console to refer to the node with given id via $x (see Command Line API for more details
          * $x functions).
          */
-        setInspectedNode(params: Protocol.DOM.SetInspectedNodeRequest): Promise<void>;
+        setInspectedNode(params: Protocol.DOM.SetInspectedNodeRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets node name for a node with given id.
          */
-        setNodeName(params: Protocol.DOM.SetNodeNameRequest): Promise<Protocol.DOM.SetNodeNameResponse>;
+        setNodeName(params: Protocol.DOM.SetNodeNameRequest): Promise<{id: number, result: Protocol.DOM.SetNodeNameResponse, sessionId: string}>;
 
         /**
          * Sets node value for a node with given id.
          */
-        setNodeValue(params: Protocol.DOM.SetNodeValueRequest): Promise<void>;
+        setNodeValue(params: Protocol.DOM.SetNodeValueRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets node HTML markup, returns new node id.
          */
-        setOuterHTML(params: Protocol.DOM.SetOuterHTMLRequest): Promise<void>;
+        setOuterHTML(params: Protocol.DOM.SetOuterHTMLRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Undoes the last performed action.
          */
-        undo(): Promise<void>;
+        undo(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Returns iframe node that owns iframe with the given domain.
          */
-        getFrameOwner(params: Protocol.DOM.GetFrameOwnerRequest): Promise<Protocol.DOM.GetFrameOwnerResponse>;
+        getFrameOwner(params: Protocol.DOM.GetFrameOwnerRequest): Promise<{id: number, result: Protocol.DOM.GetFrameOwnerResponse, sessionId: string}>;
 
         /**
          * Returns the query container of the given node based on container query
@@ -1586,13 +1586,13 @@ export namespace ProtocolTestsProxyApi {
          * provided, the style container is returned, which is the direct parent or the
          * closest element with a matching container-name.
          */
-        getContainerForNode(params: Protocol.DOM.GetContainerForNodeRequest): Promise<Protocol.DOM.GetContainerForNodeResponse>;
+        getContainerForNode(params: Protocol.DOM.GetContainerForNodeRequest): Promise<{id: number, result: Protocol.DOM.GetContainerForNodeResponse, sessionId: string}>;
 
         /**
          * Returns the descendants of a container query container that have
          * container queries against this container.
          */
-        getQueryingDescendantsForContainer(params: Protocol.DOM.GetQueryingDescendantsForContainerRequest): Promise<Protocol.DOM.GetQueryingDescendantsForContainerResponse>;
+        getQueryingDescendantsForContainer(params: Protocol.DOM.GetQueryingDescendantsForContainerRequest): Promise<{id: number, result: Protocol.DOM.GetQueryingDescendantsForContainerResponse, sessionId: string}>;
 
         /**
          * Fired when `Element`'s attribute is modified.
@@ -1706,52 +1706,52 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Returns event listeners of the given object.
          */
-        getEventListeners(params: Protocol.DOMDebugger.GetEventListenersRequest): Promise<Protocol.DOMDebugger.GetEventListenersResponse>;
+        getEventListeners(params: Protocol.DOMDebugger.GetEventListenersRequest): Promise<{id: number, result: Protocol.DOMDebugger.GetEventListenersResponse, sessionId: string}>;
 
         /**
          * Removes DOM breakpoint that was set using `setDOMBreakpoint`.
          */
-        removeDOMBreakpoint(params: Protocol.DOMDebugger.RemoveDOMBreakpointRequest): Promise<void>;
+        removeDOMBreakpoint(params: Protocol.DOMDebugger.RemoveDOMBreakpointRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Removes breakpoint on particular DOM event.
          */
-        removeEventListenerBreakpoint(params: Protocol.DOMDebugger.RemoveEventListenerBreakpointRequest): Promise<void>;
+        removeEventListenerBreakpoint(params: Protocol.DOMDebugger.RemoveEventListenerBreakpointRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Removes breakpoint on particular native event.
          */
-        removeInstrumentationBreakpoint(params: Protocol.DOMDebugger.RemoveInstrumentationBreakpointRequest): Promise<void>;
+        removeInstrumentationBreakpoint(params: Protocol.DOMDebugger.RemoveInstrumentationBreakpointRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Removes breakpoint from XMLHttpRequest.
          */
-        removeXHRBreakpoint(params: Protocol.DOMDebugger.RemoveXHRBreakpointRequest): Promise<void>;
+        removeXHRBreakpoint(params: Protocol.DOMDebugger.RemoveXHRBreakpointRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets breakpoint on particular CSP violations.
          */
-        setBreakOnCSPViolation(params: Protocol.DOMDebugger.SetBreakOnCSPViolationRequest): Promise<void>;
+        setBreakOnCSPViolation(params: Protocol.DOMDebugger.SetBreakOnCSPViolationRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets breakpoint on particular operation with DOM.
          */
-        setDOMBreakpoint(params: Protocol.DOMDebugger.SetDOMBreakpointRequest): Promise<void>;
+        setDOMBreakpoint(params: Protocol.DOMDebugger.SetDOMBreakpointRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets breakpoint on particular DOM event.
          */
-        setEventListenerBreakpoint(params: Protocol.DOMDebugger.SetEventListenerBreakpointRequest): Promise<void>;
+        setEventListenerBreakpoint(params: Protocol.DOMDebugger.SetEventListenerBreakpointRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets breakpoint on particular native event.
          */
-        setInstrumentationBreakpoint(params: Protocol.DOMDebugger.SetInstrumentationBreakpointRequest): Promise<void>;
+        setInstrumentationBreakpoint(params: Protocol.DOMDebugger.SetInstrumentationBreakpointRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets breakpoint on XMLHttpRequest.
          */
-        setXHRBreakpoint(params: Protocol.DOMDebugger.SetXHRBreakpointRequest): Promise<void>;
+        setXHRBreakpoint(params: Protocol.DOMDebugger.SetXHRBreakpointRequest): Promise<{id: number, result: void, sessionId: string}>;
 
     }
 
@@ -1759,17 +1759,17 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Sets breakpoint on particular native event.
          */
-        setInstrumentationBreakpoint(params: Protocol.EventBreakpoints.SetInstrumentationBreakpointRequest): Promise<void>;
+        setInstrumentationBreakpoint(params: Protocol.EventBreakpoints.SetInstrumentationBreakpointRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Removes breakpoint on particular native event.
          */
-        removeInstrumentationBreakpoint(params: Protocol.EventBreakpoints.RemoveInstrumentationBreakpointRequest): Promise<void>;
+        removeInstrumentationBreakpoint(params: Protocol.EventBreakpoints.RemoveInstrumentationBreakpointRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Removes all breakpoints
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
     }
 
@@ -1777,12 +1777,12 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Disables DOM snapshot agent for the given page.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables DOM snapshot agent for the given page.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Returns a document snapshot, including the full DOM tree of the root node (including iframes,
@@ -1790,7 +1790,7 @@ export namespace ProtocolTestsProxyApi {
          * white-listed computed style information for the nodes. Shadow DOM in the returned DOM tree is
          * flattened.
          */
-        getSnapshot(params: Protocol.DOMSnapshot.GetSnapshotRequest): Promise<Protocol.DOMSnapshot.GetSnapshotResponse>;
+        getSnapshot(params: Protocol.DOMSnapshot.GetSnapshotRequest): Promise<{id: number, result: Protocol.DOMSnapshot.GetSnapshotResponse, sessionId: string}>;
 
         /**
          * Returns a document snapshot, including the full DOM tree of the root node (including iframes,
@@ -1798,28 +1798,28 @@ export namespace ProtocolTestsProxyApi {
          * white-listed computed style information for the nodes. Shadow DOM in the returned DOM tree is
          * flattened.
          */
-        captureSnapshot(params: Protocol.DOMSnapshot.CaptureSnapshotRequest): Promise<Protocol.DOMSnapshot.CaptureSnapshotResponse>;
+        captureSnapshot(params: Protocol.DOMSnapshot.CaptureSnapshotRequest): Promise<{id: number, result: Protocol.DOMSnapshot.CaptureSnapshotResponse, sessionId: string}>;
 
     }
 
     export interface DOMStorageApi {
-        clear(params: Protocol.DOMStorage.ClearRequest): Promise<void>;
+        clear(params: Protocol.DOMStorage.ClearRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Disables storage tracking, prevents storage events from being sent to the client.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables storage tracking, storage events will now be delivered to the client.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
-        getDOMStorageItems(params: Protocol.DOMStorage.GetDOMStorageItemsRequest): Promise<Protocol.DOMStorage.GetDOMStorageItemsResponse>;
+        getDOMStorageItems(params: Protocol.DOMStorage.GetDOMStorageItemsRequest): Promise<{id: number, result: Protocol.DOMStorage.GetDOMStorageItemsResponse, sessionId: string}>;
 
-        removeDOMStorageItem(params: Protocol.DOMStorage.RemoveDOMStorageItemRequest): Promise<void>;
+        removeDOMStorageItem(params: Protocol.DOMStorage.RemoveDOMStorageItemRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        setDOMStorageItem(params: Protocol.DOMStorage.SetDOMStorageItemRequest): Promise<void>;
+        setDOMStorageItem(params: Protocol.DOMStorage.SetDOMStorageItemRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         onDomStorageItemAdded(listener: (event: { params: Protocol.DOMStorage.DomStorageItemAddedEvent }) => void): void;
         offDomStorageItemAdded(listener: (event: { params: Protocol.DOMStorage.DomStorageItemAddedEvent }) => void): void;
@@ -1843,16 +1843,16 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Disables database tracking, prevents database events from being sent to the client.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables database tracking, database events will now be delivered to the client.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
-        executeSQL(params: Protocol.Database.ExecuteSQLRequest): Promise<Protocol.Database.ExecuteSQLResponse>;
+        executeSQL(params: Protocol.Database.ExecuteSQLRequest): Promise<{id: number, result: Protocol.Database.ExecuteSQLResponse, sessionId: string}>;
 
-        getDatabaseTableNames(params: Protocol.Database.GetDatabaseTableNamesRequest): Promise<Protocol.Database.GetDatabaseTableNamesResponse>;
+        getDatabaseTableNames(params: Protocol.Database.GetDatabaseTableNamesRequest): Promise<{id: number, result: Protocol.Database.GetDatabaseTableNamesResponse, sessionId: string}>;
 
         onAddDatabase(listener: (event: { params: Protocol.Database.AddDatabaseEvent }) => void): void;
         offAddDatabase(listener: (event: { params: Protocol.Database.AddDatabaseEvent }) => void): void;
@@ -1864,12 +1864,12 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Clears the overridden Device Orientation.
          */
-        clearDeviceOrientationOverride(): Promise<void>;
+        clearDeviceOrientationOverride(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Overrides the Device Orientation.
          */
-        setDeviceOrientationOverride(params: Protocol.DeviceOrientation.SetDeviceOrientationOverrideRequest): Promise<void>;
+        setDeviceOrientationOverride(params: Protocol.DeviceOrientation.SetDeviceOrientationOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
     }
 
@@ -1877,74 +1877,88 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Tells whether emulation is supported.
          */
-        canEmulate(): Promise<Protocol.Emulation.CanEmulateResponse>;
+        canEmulate(): Promise<{id: number, result: Protocol.Emulation.CanEmulateResponse, sessionId: string}>;
 
         /**
          * Clears the overridden device metrics.
          */
-        clearDeviceMetricsOverride(): Promise<void>;
+        clearDeviceMetricsOverride(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Clears the overridden Geolocation Position and Error.
          */
-        clearGeolocationOverride(): Promise<void>;
+        clearGeolocationOverride(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Requests that page scale factor is reset to initial values.
          */
-        resetPageScaleFactor(): Promise<void>;
+        resetPageScaleFactor(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables or disables simulating a focused and active page.
          */
-        setFocusEmulationEnabled(params: Protocol.Emulation.SetFocusEmulationEnabledRequest): Promise<void>;
+        setFocusEmulationEnabled(params: Protocol.Emulation.SetFocusEmulationEnabledRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Automatically render all web contents using a dark theme.
          */
-        setAutoDarkModeOverride(params: Protocol.Emulation.SetAutoDarkModeOverrideRequest): Promise<void>;
+        setAutoDarkModeOverride(params: Protocol.Emulation.SetAutoDarkModeOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables CPU throttling to emulate slow CPUs.
          */
-        setCPUThrottlingRate(params: Protocol.Emulation.SetCPUThrottlingRateRequest): Promise<void>;
+        setCPUThrottlingRate(params: Protocol.Emulation.SetCPUThrottlingRateRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets or clears an override of the default background color of the frame. This override is used
          * if the content does not specify one.
          */
-        setDefaultBackgroundColorOverride(params: Protocol.Emulation.SetDefaultBackgroundColorOverrideRequest): Promise<void>;
+        setDefaultBackgroundColorOverride(params: Protocol.Emulation.SetDefaultBackgroundColorOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Overrides the values of device screen dimensions (window.screen.width, window.screen.height,
          * window.innerWidth, window.innerHeight, and "device-width"/"device-height"-related CSS media
          * query results).
          */
-        setDeviceMetricsOverride(params: Protocol.Emulation.SetDeviceMetricsOverrideRequest): Promise<void>;
+        setDeviceMetricsOverride(params: Protocol.Emulation.SetDeviceMetricsOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        setScrollbarsHidden(params: Protocol.Emulation.SetScrollbarsHiddenRequest): Promise<void>;
+        /**
+         * Start reporting the given posture value to the Device Posture API.
+         * This override can also be set in setDeviceMetricsOverride().
+         */
+        setDevicePostureOverride(params: Protocol.Emulation.SetDevicePostureOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
+
+        /**
+         * Clears a device posture override set with either setDeviceMetricsOverride()
+         * or setDevicePostureOverride() and starts using posture information from the
+         * platform again.
+         * Does nothing if no override is set.
+         */
+        clearDevicePostureOverride(): Promise<{id: number, result: void, sessionId: string}>;
+
+        setScrollbarsHidden(params: Protocol.Emulation.SetScrollbarsHiddenRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        setDocumentCookieDisabled(params: Protocol.Emulation.SetDocumentCookieDisabledRequest): Promise<void>;
+        setDocumentCookieDisabled(params: Protocol.Emulation.SetDocumentCookieDisabledRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        setEmitTouchEventsForMouse(params: Protocol.Emulation.SetEmitTouchEventsForMouseRequest): Promise<void>;
+        setEmitTouchEventsForMouse(params: Protocol.Emulation.SetEmitTouchEventsForMouseRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Emulates the given media type or media feature for CSS media queries.
          */
-        setEmulatedMedia(params: Protocol.Emulation.SetEmulatedMediaRequest): Promise<void>;
+        setEmulatedMedia(params: Protocol.Emulation.SetEmulatedMediaRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Emulates the given vision deficiency.
          */
-        setEmulatedVisionDeficiency(params: Protocol.Emulation.SetEmulatedVisionDeficiencyRequest): Promise<void>;
+        setEmulatedVisionDeficiency(params: Protocol.Emulation.SetEmulatedVisionDeficiencyRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Overrides the Geolocation Position or Error. Omitting any of the parameters emulates position
          * unavailable.
          */
-        setGeolocationOverride(params: Protocol.Emulation.SetGeolocationOverrideRequest): Promise<void>;
+        setGeolocationOverride(params: Protocol.Emulation.SetGeolocationOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        getOverriddenSensorInformation(params: Protocol.Emulation.GetOverriddenSensorInformationRequest): Promise<Protocol.Emulation.GetOverriddenSensorInformationResponse>;
+        getOverriddenSensorInformation(params: Protocol.Emulation.GetOverriddenSensorInformationRequest): Promise<{id: number, result: Protocol.Emulation.GetOverriddenSensorInformationResponse, sessionId: string}>;
 
         /**
          * Overrides a platform sensor of a given type. If |enabled| is true, calls to
@@ -1953,81 +1967,81 @@ export namespace ProtocolTestsProxyApi {
          * sensor-backend Sensor objects will fire an error event and new calls to
          * Sensor.start() will attempt to use a real sensor instead.
          */
-        setSensorOverrideEnabled(params: Protocol.Emulation.SetSensorOverrideEnabledRequest): Promise<void>;
+        setSensorOverrideEnabled(params: Protocol.Emulation.SetSensorOverrideEnabledRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Updates the sensor readings reported by a sensor type previously overridden
          * by setSensorOverrideEnabled.
          */
-        setSensorOverrideReadings(params: Protocol.Emulation.SetSensorOverrideReadingsRequest): Promise<void>;
+        setSensorOverrideReadings(params: Protocol.Emulation.SetSensorOverrideReadingsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Overrides the Idle state.
          */
-        setIdleOverride(params: Protocol.Emulation.SetIdleOverrideRequest): Promise<void>;
+        setIdleOverride(params: Protocol.Emulation.SetIdleOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Clears Idle state overrides.
          */
-        clearIdleOverride(): Promise<void>;
+        clearIdleOverride(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Overrides value returned by the javascript navigator object.
          */
-        setNavigatorOverrides(params: Protocol.Emulation.SetNavigatorOverridesRequest): Promise<void>;
+        setNavigatorOverrides(params: Protocol.Emulation.SetNavigatorOverridesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets a specified page scale factor.
          */
-        setPageScaleFactor(params: Protocol.Emulation.SetPageScaleFactorRequest): Promise<void>;
+        setPageScaleFactor(params: Protocol.Emulation.SetPageScaleFactorRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Switches script execution in the page.
          */
-        setScriptExecutionDisabled(params: Protocol.Emulation.SetScriptExecutionDisabledRequest): Promise<void>;
+        setScriptExecutionDisabled(params: Protocol.Emulation.SetScriptExecutionDisabledRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables touch on platforms which do not support them.
          */
-        setTouchEmulationEnabled(params: Protocol.Emulation.SetTouchEmulationEnabledRequest): Promise<void>;
+        setTouchEmulationEnabled(params: Protocol.Emulation.SetTouchEmulationEnabledRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Turns on virtual time for all frames (replacing real-time with a synthetic time source) and sets
          * the current virtual time policy.  Note this supersedes any previous time budget.
          */
-        setVirtualTimePolicy(params: Protocol.Emulation.SetVirtualTimePolicyRequest): Promise<Protocol.Emulation.SetVirtualTimePolicyResponse>;
+        setVirtualTimePolicy(params: Protocol.Emulation.SetVirtualTimePolicyRequest): Promise<{id: number, result: Protocol.Emulation.SetVirtualTimePolicyResponse, sessionId: string}>;
 
         /**
          * Overrides default host system locale with the specified one.
          */
-        setLocaleOverride(params: Protocol.Emulation.SetLocaleOverrideRequest): Promise<void>;
+        setLocaleOverride(params: Protocol.Emulation.SetLocaleOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Overrides default host system timezone with the specified one.
          */
-        setTimezoneOverride(params: Protocol.Emulation.SetTimezoneOverrideRequest): Promise<void>;
+        setTimezoneOverride(params: Protocol.Emulation.SetTimezoneOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Resizes the frame/viewport of the page. Note that this does not affect the frame's container
          * (e.g. browser window). Can be used to produce screenshots of the specified size. Not supported
          * on Android.
          */
-        setVisibleSize(params: Protocol.Emulation.SetVisibleSizeRequest): Promise<void>;
+        setVisibleSize(params: Protocol.Emulation.SetVisibleSizeRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        setDisabledImageTypes(params: Protocol.Emulation.SetDisabledImageTypesRequest): Promise<void>;
+        setDisabledImageTypes(params: Protocol.Emulation.SetDisabledImageTypesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        setHardwareConcurrencyOverride(params: Protocol.Emulation.SetHardwareConcurrencyOverrideRequest): Promise<void>;
+        setHardwareConcurrencyOverride(params: Protocol.Emulation.SetHardwareConcurrencyOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Allows overriding user agent with the given string.
          * `userAgentMetadata` must be set for Client Hint headers to be sent.
          */
-        setUserAgentOverride(params: Protocol.Emulation.SetUserAgentOverrideRequest): Promise<void>;
+        setUserAgentOverride(params: Protocol.Emulation.SetUserAgentOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Allows overriding the automation flag.
          */
-        setAutomationOverride(params: Protocol.Emulation.SetAutomationOverrideRequest): Promise<void>;
+        setAutomationOverride(params: Protocol.Emulation.SetAutomationOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Notification sent after the virtual time budget for the current VirtualTimePolicy has run out.
@@ -2045,17 +2059,17 @@ export namespace ProtocolTestsProxyApi {
          * BeginFrameControl. Designed for use with --run-all-compositor-stages-before-draw, see also
          * https://goo.gle/chrome-headless-rendering for more background.
          */
-        beginFrame(params: Protocol.HeadlessExperimental.BeginFrameRequest): Promise<Protocol.HeadlessExperimental.BeginFrameResponse>;
+        beginFrame(params: Protocol.HeadlessExperimental.BeginFrameRequest): Promise<{id: number, result: Protocol.HeadlessExperimental.BeginFrameResponse, sessionId: string}>;
 
         /**
          * Disables headless events for the target.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables headless events for the target.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
     }
 
@@ -2063,17 +2077,17 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Close the stream, discard any temporary backing storage.
          */
-        close(params: Protocol.IO.CloseRequest): Promise<void>;
+        close(params: Protocol.IO.CloseRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Read a chunk of the stream
          */
-        read(params: Protocol.IO.ReadRequest): Promise<Protocol.IO.ReadResponse>;
+        read(params: Protocol.IO.ReadRequest): Promise<{id: number, result: Protocol.IO.ReadResponse, sessionId: string}>;
 
         /**
          * Return UUID of Blob object specified by a remote object id.
          */
-        resolveBlob(params: Protocol.IO.ResolveBlobRequest): Promise<Protocol.IO.ResolveBlobResponse>;
+        resolveBlob(params: Protocol.IO.ResolveBlobRequest): Promise<{id: number, result: Protocol.IO.ResolveBlobResponse, sessionId: string}>;
 
     }
 
@@ -2081,47 +2095,47 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Clears all entries from an object store.
          */
-        clearObjectStore(params: Protocol.IndexedDB.ClearObjectStoreRequest): Promise<void>;
+        clearObjectStore(params: Protocol.IndexedDB.ClearObjectStoreRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Deletes a database.
          */
-        deleteDatabase(params: Protocol.IndexedDB.DeleteDatabaseRequest): Promise<void>;
+        deleteDatabase(params: Protocol.IndexedDB.DeleteDatabaseRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Delete a range of entries from an object store
          */
-        deleteObjectStoreEntries(params: Protocol.IndexedDB.DeleteObjectStoreEntriesRequest): Promise<void>;
+        deleteObjectStoreEntries(params: Protocol.IndexedDB.DeleteObjectStoreEntriesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Disables events from backend.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables events from backend.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Requests data from object store or index.
          */
-        requestData(params: Protocol.IndexedDB.RequestDataRequest): Promise<Protocol.IndexedDB.RequestDataResponse>;
+        requestData(params: Protocol.IndexedDB.RequestDataRequest): Promise<{id: number, result: Protocol.IndexedDB.RequestDataResponse, sessionId: string}>;
 
         /**
          * Gets metadata of an object store.
          */
-        getMetadata(params: Protocol.IndexedDB.GetMetadataRequest): Promise<Protocol.IndexedDB.GetMetadataResponse>;
+        getMetadata(params: Protocol.IndexedDB.GetMetadataRequest): Promise<{id: number, result: Protocol.IndexedDB.GetMetadataResponse, sessionId: string}>;
 
         /**
          * Requests database with given name in given frame.
          */
-        requestDatabase(params: Protocol.IndexedDB.RequestDatabaseRequest): Promise<Protocol.IndexedDB.RequestDatabaseResponse>;
+        requestDatabase(params: Protocol.IndexedDB.RequestDatabaseRequest): Promise<{id: number, result: Protocol.IndexedDB.RequestDatabaseResponse, sessionId: string}>;
 
         /**
          * Requests database names for given security origin.
          */
-        requestDatabaseNames(params: Protocol.IndexedDB.RequestDatabaseNamesRequest): Promise<Protocol.IndexedDB.RequestDatabaseNamesResponse>;
+        requestDatabaseNames(params: Protocol.IndexedDB.RequestDatabaseNamesRequest): Promise<{id: number, result: Protocol.IndexedDB.RequestDatabaseNamesResponse, sessionId: string}>;
 
     }
 
@@ -2129,71 +2143,71 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Dispatches a drag event into the page.
          */
-        dispatchDragEvent(params: Protocol.Input.DispatchDragEventRequest): Promise<void>;
+        dispatchDragEvent(params: Protocol.Input.DispatchDragEventRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Dispatches a key event to the page.
          */
-        dispatchKeyEvent(params: Protocol.Input.DispatchKeyEventRequest): Promise<void>;
+        dispatchKeyEvent(params: Protocol.Input.DispatchKeyEventRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * This method emulates inserting text that doesn't come from a key press,
          * for example an emoji keyboard or an IME.
          */
-        insertText(params: Protocol.Input.InsertTextRequest): Promise<void>;
+        insertText(params: Protocol.Input.InsertTextRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * 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.
          */
-        imeSetComposition(params: Protocol.Input.ImeSetCompositionRequest): Promise<void>;
+        imeSetComposition(params: Protocol.Input.ImeSetCompositionRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Dispatches a mouse event to the page.
          */
-        dispatchMouseEvent(params: Protocol.Input.DispatchMouseEventRequest): Promise<void>;
+        dispatchMouseEvent(params: Protocol.Input.DispatchMouseEventRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Dispatches a touch event to the page.
          */
-        dispatchTouchEvent(params: Protocol.Input.DispatchTouchEventRequest): Promise<void>;
+        dispatchTouchEvent(params: Protocol.Input.DispatchTouchEventRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Cancels any active dragging in the page.
          */
-        cancelDragging(): Promise<void>;
+        cancelDragging(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Emulates touch event from the mouse event parameters.
          */
-        emulateTouchFromMouseEvent(params: Protocol.Input.EmulateTouchFromMouseEventRequest): Promise<void>;
+        emulateTouchFromMouseEvent(params: Protocol.Input.EmulateTouchFromMouseEventRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Ignores input events (useful while auditing page).
          */
-        setIgnoreInputEvents(params: Protocol.Input.SetIgnoreInputEventsRequest): Promise<void>;
+        setIgnoreInputEvents(params: Protocol.Input.SetIgnoreInputEventsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Prevents default drag and drop behavior and instead emits `Input.dragIntercepted` events.
          * Drag and drop behavior can be directly controlled via `Input.dispatchDragEvent`.
          */
-        setInterceptDrags(params: Protocol.Input.SetInterceptDragsRequest): Promise<void>;
+        setInterceptDrags(params: Protocol.Input.SetInterceptDragsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Synthesizes a pinch gesture over a time period by issuing appropriate touch events.
          */
-        synthesizePinchGesture(params: Protocol.Input.SynthesizePinchGestureRequest): Promise<void>;
+        synthesizePinchGesture(params: Protocol.Input.SynthesizePinchGestureRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Synthesizes a scroll gesture over a time period by issuing appropriate touch events.
          */
-        synthesizeScrollGesture(params: Protocol.Input.SynthesizeScrollGestureRequest): Promise<void>;
+        synthesizeScrollGesture(params: Protocol.Input.SynthesizeScrollGestureRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Synthesizes a tap gesture over a time period by issuing appropriate touch events.
          */
-        synthesizeTapGesture(params: Protocol.Input.SynthesizeTapGestureRequest): Promise<void>;
+        synthesizeTapGesture(params: Protocol.Input.SynthesizeTapGestureRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Emitted only when `Input.setInterceptDrags` is enabled. Use this data with `Input.dispatchDragEvent` to
@@ -2209,12 +2223,12 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Disables inspector domain notifications.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables inspector domain notifications.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Fired when remote debugging connection is about to be terminated. Contains detach reason.
@@ -2243,44 +2257,44 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Provides the reasons why the given layer was composited.
          */
-        compositingReasons(params: Protocol.LayerTree.CompositingReasonsRequest): Promise<Protocol.LayerTree.CompositingReasonsResponse>;
+        compositingReasons(params: Protocol.LayerTree.CompositingReasonsRequest): Promise<{id: number, result: Protocol.LayerTree.CompositingReasonsResponse, sessionId: string}>;
 
         /**
          * Disables compositing tree inspection.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables compositing tree inspection.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Returns the snapshot identifier.
          */
-        loadSnapshot(params: Protocol.LayerTree.LoadSnapshotRequest): Promise<Protocol.LayerTree.LoadSnapshotResponse>;
+        loadSnapshot(params: Protocol.LayerTree.LoadSnapshotRequest): Promise<{id: number, result: Protocol.LayerTree.LoadSnapshotResponse, sessionId: string}>;
 
         /**
          * Returns the layer snapshot identifier.
          */
-        makeSnapshot(params: Protocol.LayerTree.MakeSnapshotRequest): Promise<Protocol.LayerTree.MakeSnapshotResponse>;
+        makeSnapshot(params: Protocol.LayerTree.MakeSnapshotRequest): Promise<{id: number, result: Protocol.LayerTree.MakeSnapshotResponse, sessionId: string}>;
 
-        profileSnapshot(params: Protocol.LayerTree.ProfileSnapshotRequest): Promise<Protocol.LayerTree.ProfileSnapshotResponse>;
+        profileSnapshot(params: Protocol.LayerTree.ProfileSnapshotRequest): Promise<{id: number, result: Protocol.LayerTree.ProfileSnapshotResponse, sessionId: string}>;
 
         /**
          * Releases layer snapshot captured by the back-end.
          */
-        releaseSnapshot(params: Protocol.LayerTree.ReleaseSnapshotRequest): Promise<void>;
+        releaseSnapshot(params: Protocol.LayerTree.ReleaseSnapshotRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Replays the layer snapshot and returns the resulting bitmap.
          */
-        replaySnapshot(params: Protocol.LayerTree.ReplaySnapshotRequest): Promise<Protocol.LayerTree.ReplaySnapshotResponse>;
+        replaySnapshot(params: Protocol.LayerTree.ReplaySnapshotRequest): Promise<{id: number, result: Protocol.LayerTree.ReplaySnapshotResponse, sessionId: string}>;
 
         /**
          * Replays the layer snapshot and returns canvas log.
          */
-        snapshotCommandLog(params: Protocol.LayerTree.SnapshotCommandLogRequest): Promise<Protocol.LayerTree.SnapshotCommandLogResponse>;
+        snapshotCommandLog(params: Protocol.LayerTree.SnapshotCommandLogRequest): Promise<{id: number, result: Protocol.LayerTree.SnapshotCommandLogResponse, sessionId: string}>;
 
         onLayerPainted(listener: (event: { params: Protocol.LayerTree.LayerPaintedEvent }) => void): void;
         offLayerPainted(listener: (event: { params: Protocol.LayerTree.LayerPaintedEvent }) => void): void;
@@ -2296,28 +2310,28 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Clears the log.
          */
-        clear(): Promise<void>;
+        clear(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Disables log domain, prevents further log entries from being reported to the client.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables log domain, sends the entries collected so far to the client by means of the
          * `entryAdded` notification.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * start violation reporting.
          */
-        startViolationsReport(params: Protocol.Log.StartViolationsReportRequest): Promise<void>;
+        startViolationsReport(params: Protocol.Log.StartViolationsReportRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Stop violation reporting.
          */
-        stopViolationsReport(): Promise<void>;
+        stopViolationsReport(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Issued when new message was logged.
@@ -2329,52 +2343,52 @@ export namespace ProtocolTestsProxyApi {
     }
 
     export interface MemoryApi {
-        getDOMCounters(): Promise<Protocol.Memory.GetDOMCountersResponse>;
+        getDOMCounters(): Promise<{id: number, result: Protocol.Memory.GetDOMCountersResponse, sessionId: string}>;
 
-        prepareForLeakDetection(): Promise<void>;
+        prepareForLeakDetection(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Simulate OomIntervention by purging V8 memory.
          */
-        forciblyPurgeJavaScriptMemory(): Promise<void>;
+        forciblyPurgeJavaScriptMemory(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enable/disable suppressing memory pressure notifications in all processes.
          */
-        setPressureNotificationsSuppressed(params: Protocol.Memory.SetPressureNotificationsSuppressedRequest): Promise<void>;
+        setPressureNotificationsSuppressed(params: Protocol.Memory.SetPressureNotificationsSuppressedRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Simulate a memory pressure notification in all processes.
          */
-        simulatePressureNotification(params: Protocol.Memory.SimulatePressureNotificationRequest): Promise<void>;
+        simulatePressureNotification(params: Protocol.Memory.SimulatePressureNotificationRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Start collecting native memory profile.
          */
-        startSampling(params: Protocol.Memory.StartSamplingRequest): Promise<void>;
+        startSampling(params: Protocol.Memory.StartSamplingRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Stop collecting native memory profile.
          */
-        stopSampling(): Promise<void>;
+        stopSampling(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Retrieve native memory allocations profile
          * collected since renderer process startup.
          */
-        getAllTimeSamplingProfile(): Promise<Protocol.Memory.GetAllTimeSamplingProfileResponse>;
+        getAllTimeSamplingProfile(): Promise<{id: number, result: Protocol.Memory.GetAllTimeSamplingProfileResponse, sessionId: string}>;
 
         /**
          * Retrieve native memory allocations profile
          * collected since browser process startup.
          */
-        getBrowserSamplingProfile(): Promise<Protocol.Memory.GetBrowserSamplingProfileResponse>;
+        getBrowserSamplingProfile(): Promise<{id: number, result: Protocol.Memory.GetBrowserSamplingProfileResponse, sessionId: string}>;
 
         /**
          * Retrieve native memory allocations profile collected since last
          * `startSampling` call.
          */
-        getSamplingProfile(): Promise<Protocol.Memory.GetSamplingProfileResponse>;
+        getSamplingProfile(): Promise<{id: number, result: Protocol.Memory.GetSamplingProfileResponse, sessionId: string}>;
 
     }
 
@@ -2382,37 +2396,37 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Sets a list of content encodings that will be accepted. Empty list means no encoding is accepted.
          */
-        setAcceptedEncodings(params: Protocol.Network.SetAcceptedEncodingsRequest): Promise<void>;
+        setAcceptedEncodings(params: Protocol.Network.SetAcceptedEncodingsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Clears accepted encodings set by setAcceptedEncodings
          */
-        clearAcceptedEncodingsOverride(): Promise<void>;
+        clearAcceptedEncodingsOverride(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Tells whether clearing browser cache is supported.
          */
-        canClearBrowserCache(): Promise<Protocol.Network.CanClearBrowserCacheResponse>;
+        canClearBrowserCache(): Promise<{id: number, result: Protocol.Network.CanClearBrowserCacheResponse, sessionId: string}>;
 
         /**
          * Tells whether clearing browser cookies is supported.
          */
-        canClearBrowserCookies(): Promise<Protocol.Network.CanClearBrowserCookiesResponse>;
+        canClearBrowserCookies(): Promise<{id: number, result: Protocol.Network.CanClearBrowserCookiesResponse, sessionId: string}>;
 
         /**
          * Tells whether emulation of network conditions is supported.
          */
-        canEmulateNetworkConditions(): Promise<Protocol.Network.CanEmulateNetworkConditionsResponse>;
+        canEmulateNetworkConditions(): Promise<{id: number, result: Protocol.Network.CanEmulateNetworkConditionsResponse, sessionId: string}>;
 
         /**
          * Clears browser cache.
          */
-        clearBrowserCache(): Promise<void>;
+        clearBrowserCache(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Clears browser cookies.
          */
-        clearBrowserCookies(): Promise<void>;
+        clearBrowserCookies(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Response to Network.requestIntercepted which either modifies the request to continue with any
@@ -2421,60 +2435,60 @@ export namespace ProtocolTestsProxyApi {
          * event will be sent with the same InterceptionId.
          * Deprecated, use Fetch.continueRequest, Fetch.fulfillRequest and Fetch.failRequest instead.
          */
-        continueInterceptedRequest(params: Protocol.Network.ContinueInterceptedRequestRequest): Promise<void>;
+        continueInterceptedRequest(params: Protocol.Network.ContinueInterceptedRequestRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Deletes browser cookies with matching name and url or domain/path/partitionKey pair.
          */
-        deleteCookies(params: Protocol.Network.DeleteCookiesRequest): Promise<void>;
+        deleteCookies(params: Protocol.Network.DeleteCookiesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Disables network tracking, prevents network events from being sent to the client.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Activates emulation of network conditions.
          */
-        emulateNetworkConditions(params: Protocol.Network.EmulateNetworkConditionsRequest): Promise<void>;
+        emulateNetworkConditions(params: Protocol.Network.EmulateNetworkConditionsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables network tracking, network events will now be delivered to the client.
          */
-        enable(params: Protocol.Network.EnableRequest): Promise<void>;
+        enable(params: Protocol.Network.EnableRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Returns all browser cookies. Depending on the backend support, will return detailed cookie
          * information in the `cookies` field.
          * Deprecated. Use Storage.getCookies instead.
          */
-        getAllCookies(): Promise<Protocol.Network.GetAllCookiesResponse>;
+        getAllCookies(): Promise<{id: number, result: Protocol.Network.GetAllCookiesResponse, sessionId: string}>;
 
         /**
          * Returns the DER-encoded certificate.
          */
-        getCertificate(params: Protocol.Network.GetCertificateRequest): Promise<Protocol.Network.GetCertificateResponse>;
+        getCertificate(params: Protocol.Network.GetCertificateRequest): Promise<{id: number, result: Protocol.Network.GetCertificateResponse, sessionId: string}>;
 
         /**
          * Returns all browser cookies for the current URL. Depending on the backend support, will return
          * detailed cookie information in the `cookies` field.
          */
-        getCookies(params: Protocol.Network.GetCookiesRequest): Promise<Protocol.Network.GetCookiesResponse>;
+        getCookies(params: Protocol.Network.GetCookiesRequest): Promise<{id: number, result: Protocol.Network.GetCookiesResponse, sessionId: string}>;
 
         /**
          * Returns content served for the given request.
          */
-        getResponseBody(params: Protocol.Network.GetResponseBodyRequest): Promise<Protocol.Network.GetResponseBodyResponse>;
+        getResponseBody(params: Protocol.Network.GetResponseBodyRequest): Promise<{id: number, result: Protocol.Network.GetResponseBodyResponse, sessionId: string}>;
 
         /**
          * Returns post data sent with the request. Returns an error when no data was sent with the request.
          */
-        getRequestPostData(params: Protocol.Network.GetRequestPostDataRequest): Promise<Protocol.Network.GetRequestPostDataResponse>;
+        getRequestPostData(params: Protocol.Network.GetRequestPostDataRequest): Promise<{id: number, result: Protocol.Network.GetRequestPostDataResponse, sessionId: string}>;
 
         /**
          * Returns content served for the given currently intercepted request.
          */
-        getResponseBodyForInterception(params: Protocol.Network.GetResponseBodyForInterceptionRequest): Promise<Protocol.Network.GetResponseBodyForInterceptionResponse>;
+        getResponseBodyForInterception(params: Protocol.Network.GetResponseBodyForInterceptionRequest): Promise<{id: number, result: Protocol.Network.GetResponseBodyForInterceptionResponse, sessionId: string}>;
 
         /**
          * Returns a handle to the stream representing the response body. Note that after this command,
@@ -2482,87 +2496,87 @@ export namespace ProtocolTestsProxyApi {
          * the response body. The stream only supports sequential read, IO.read will fail if the position
          * is specified.
          */
-        takeResponseBodyForInterceptionAsStream(params: Protocol.Network.TakeResponseBodyForInterceptionAsStreamRequest): Promise<Protocol.Network.TakeResponseBodyForInterceptionAsStreamResponse>;
+        takeResponseBodyForInterceptionAsStream(params: Protocol.Network.TakeResponseBodyForInterceptionAsStreamRequest): Promise<{id: number, result: Protocol.Network.TakeResponseBodyForInterceptionAsStreamResponse, sessionId: string}>;
 
         /**
          * This method sends a new XMLHttpRequest which is identical to the original one. The following
          * parameters should be identical: method, url, async, request body, extra headers, withCredentials
          * attribute, user, password.
          */
-        replayXHR(params: Protocol.Network.ReplayXHRRequest): Promise<void>;
+        replayXHR(params: Protocol.Network.ReplayXHRRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Searches for given string in response content.
          */
-        searchInResponseBody(params: Protocol.Network.SearchInResponseBodyRequest): Promise<Protocol.Network.SearchInResponseBodyResponse>;
+        searchInResponseBody(params: Protocol.Network.SearchInResponseBodyRequest): Promise<{id: number, result: Protocol.Network.SearchInResponseBodyResponse, sessionId: string}>;
 
         /**
          * Blocks URLs from loading.
          */
-        setBlockedURLs(params: Protocol.Network.SetBlockedURLsRequest): Promise<void>;
+        setBlockedURLs(params: Protocol.Network.SetBlockedURLsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Toggles ignoring of service worker for each request.
          */
-        setBypassServiceWorker(params: Protocol.Network.SetBypassServiceWorkerRequest): Promise<void>;
+        setBypassServiceWorker(params: Protocol.Network.SetBypassServiceWorkerRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Toggles ignoring cache for each request. If `true`, cache will not be used.
          */
-        setCacheDisabled(params: Protocol.Network.SetCacheDisabledRequest): Promise<void>;
+        setCacheDisabled(params: Protocol.Network.SetCacheDisabledRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets a cookie with the given cookie data; may overwrite equivalent cookies if they exist.
          */
-        setCookie(params: Protocol.Network.SetCookieRequest): Promise<Protocol.Network.SetCookieResponse>;
+        setCookie(params: Protocol.Network.SetCookieRequest): Promise<{id: number, result: Protocol.Network.SetCookieResponse, sessionId: string}>;
 
         /**
          * Sets given cookies.
          */
-        setCookies(params: Protocol.Network.SetCookiesRequest): Promise<void>;
+        setCookies(params: Protocol.Network.SetCookiesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Specifies whether to always send extra HTTP headers with the requests from this page.
          */
-        setExtraHTTPHeaders(params: Protocol.Network.SetExtraHTTPHeadersRequest): Promise<void>;
+        setExtraHTTPHeaders(params: Protocol.Network.SetExtraHTTPHeadersRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Specifies whether to attach a page script stack id in requests
          */
-        setAttachDebugStack(params: Protocol.Network.SetAttachDebugStackRequest): Promise<void>;
+        setAttachDebugStack(params: Protocol.Network.SetAttachDebugStackRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets the requests to intercept that match the provided patterns and optionally resource types.
          * Deprecated, please use Fetch.enable instead.
          */
-        setRequestInterception(params: Protocol.Network.SetRequestInterceptionRequest): Promise<void>;
+        setRequestInterception(params: Protocol.Network.SetRequestInterceptionRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Allows overriding user agent with the given string.
          */
-        setUserAgentOverride(params: Protocol.Network.SetUserAgentOverrideRequest): Promise<void>;
+        setUserAgentOverride(params: Protocol.Network.SetUserAgentOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables streaming of the response for the given requestId.
          * If enabled, the dataReceived event contains the data that was received during streaming.
          */
-        streamResourceContent(params: Protocol.Network.StreamResourceContentRequest): Promise<Protocol.Network.StreamResourceContentResponse>;
+        streamResourceContent(params: Protocol.Network.StreamResourceContentRequest): Promise<{id: number, result: Protocol.Network.StreamResourceContentResponse, sessionId: string}>;
 
         /**
          * Returns information about the COEP/COOP isolation status.
          */
-        getSecurityIsolationStatus(params: Protocol.Network.GetSecurityIsolationStatusRequest): Promise<Protocol.Network.GetSecurityIsolationStatusResponse>;
+        getSecurityIsolationStatus(params: Protocol.Network.GetSecurityIsolationStatusRequest): Promise<{id: number, result: Protocol.Network.GetSecurityIsolationStatusResponse, sessionId: string}>;
 
         /**
          * 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.
          */
-        enableReportingApi(params: Protocol.Network.EnableReportingApiRequest): Promise<void>;
+        enableReportingApi(params: Protocol.Network.EnableReportingApiRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Fetches the resource and returns the content.
          */
-        loadNetworkResource(params: Protocol.Network.LoadNetworkResourceRequest): Promise<Protocol.Network.LoadNetworkResourceResponse>;
+        loadNetworkResource(params: Protocol.Network.LoadNetworkResourceRequest): Promise<{id: number, result: Protocol.Network.LoadNetworkResourceResponse, sessionId: string}>;
 
         /**
          * Fired when data chunk was received over the network.
@@ -2787,32 +2801,32 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Disables domain notifications.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables domain notifications.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * For testing.
          */
-        getHighlightObjectForTest(params: Protocol.Overlay.GetHighlightObjectForTestRequest): Promise<Protocol.Overlay.GetHighlightObjectForTestResponse>;
+        getHighlightObjectForTest(params: Protocol.Overlay.GetHighlightObjectForTestRequest): Promise<{id: number, result: Protocol.Overlay.GetHighlightObjectForTestResponse, sessionId: string}>;
 
         /**
          * For Persistent Grid testing.
          */
-        getGridHighlightObjectsForTest(params: Protocol.Overlay.GetGridHighlightObjectsForTestRequest): Promise<Protocol.Overlay.GetGridHighlightObjectsForTestResponse>;
+        getGridHighlightObjectsForTest(params: Protocol.Overlay.GetGridHighlightObjectsForTestRequest): Promise<{id: number, result: Protocol.Overlay.GetGridHighlightObjectsForTestResponse, sessionId: string}>;
 
         /**
          * For Source Order Viewer testing.
          */
-        getSourceOrderHighlightObjectForTest(params: Protocol.Overlay.GetSourceOrderHighlightObjectForTestRequest): Promise<Protocol.Overlay.GetSourceOrderHighlightObjectForTestResponse>;
+        getSourceOrderHighlightObjectForTest(params: Protocol.Overlay.GetSourceOrderHighlightObjectForTestRequest): Promise<{id: number, result: Protocol.Overlay.GetSourceOrderHighlightObjectForTestResponse, sessionId: string}>;
 
         /**
          * Hides any highlight.
          */
-        hideHighlight(): Promise<void>;
+        hideHighlight(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Highlights owner element of the frame with given id.
@@ -2820,108 +2834,108 @@ export namespace ProtocolTestsProxyApi {
          * separation (the owner node might be in a different process). Determine
          * the owner node in the client and use highlightNode.
          */
-        highlightFrame(params: Protocol.Overlay.HighlightFrameRequest): Promise<void>;
+        highlightFrame(params: Protocol.Overlay.HighlightFrameRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Highlights DOM node with given id or with the given JavaScript object wrapper. Either nodeId or
          * objectId must be specified.
          */
-        highlightNode(params: Protocol.Overlay.HighlightNodeRequest): Promise<void>;
+        highlightNode(params: Protocol.Overlay.HighlightNodeRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Highlights given quad. Coordinates are absolute with respect to the main frame viewport.
          */
-        highlightQuad(params: Protocol.Overlay.HighlightQuadRequest): Promise<void>;
+        highlightQuad(params: Protocol.Overlay.HighlightQuadRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Highlights given rectangle. Coordinates are absolute with respect to the main frame viewport.
          */
-        highlightRect(params: Protocol.Overlay.HighlightRectRequest): Promise<void>;
+        highlightRect(params: Protocol.Overlay.HighlightRectRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Highlights the source order of the children of the DOM node with given id or with the given
          * JavaScript object wrapper. Either nodeId or objectId must be specified.
          */
-        highlightSourceOrder(params: Protocol.Overlay.HighlightSourceOrderRequest): Promise<void>;
+        highlightSourceOrder(params: Protocol.Overlay.HighlightSourceOrderRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enters the 'inspect' mode. In this mode, elements that user is hovering over are highlighted.
          * Backend then generates 'inspectNodeRequested' event upon element selection.
          */
-        setInspectMode(params: Protocol.Overlay.SetInspectModeRequest): Promise<void>;
+        setInspectMode(params: Protocol.Overlay.SetInspectModeRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Highlights owner element of all frames detected to be ads.
          */
-        setShowAdHighlights(params: Protocol.Overlay.SetShowAdHighlightsRequest): Promise<void>;
+        setShowAdHighlights(params: Protocol.Overlay.SetShowAdHighlightsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        setPausedInDebuggerMessage(params: Protocol.Overlay.SetPausedInDebuggerMessageRequest): Promise<void>;
+        setPausedInDebuggerMessage(params: Protocol.Overlay.SetPausedInDebuggerMessageRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Requests that backend shows debug borders on layers
          */
-        setShowDebugBorders(params: Protocol.Overlay.SetShowDebugBordersRequest): Promise<void>;
+        setShowDebugBorders(params: Protocol.Overlay.SetShowDebugBordersRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Requests that backend shows the FPS counter
          */
-        setShowFPSCounter(params: Protocol.Overlay.SetShowFPSCounterRequest): Promise<void>;
+        setShowFPSCounter(params: Protocol.Overlay.SetShowFPSCounterRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Highlight multiple elements with the CSS Grid overlay.
          */
-        setShowGridOverlays(params: Protocol.Overlay.SetShowGridOverlaysRequest): Promise<void>;
+        setShowGridOverlays(params: Protocol.Overlay.SetShowGridOverlaysRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        setShowFlexOverlays(params: Protocol.Overlay.SetShowFlexOverlaysRequest): Promise<void>;
+        setShowFlexOverlays(params: Protocol.Overlay.SetShowFlexOverlaysRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        setShowScrollSnapOverlays(params: Protocol.Overlay.SetShowScrollSnapOverlaysRequest): Promise<void>;
+        setShowScrollSnapOverlays(params: Protocol.Overlay.SetShowScrollSnapOverlaysRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        setShowContainerQueryOverlays(params: Protocol.Overlay.SetShowContainerQueryOverlaysRequest): Promise<void>;
+        setShowContainerQueryOverlays(params: Protocol.Overlay.SetShowContainerQueryOverlaysRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Requests that backend shows paint rectangles
          */
-        setShowPaintRects(params: Protocol.Overlay.SetShowPaintRectsRequest): Promise<void>;
+        setShowPaintRects(params: Protocol.Overlay.SetShowPaintRectsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Requests that backend shows layout shift regions
          */
-        setShowLayoutShiftRegions(params: Protocol.Overlay.SetShowLayoutShiftRegionsRequest): Promise<void>;
+        setShowLayoutShiftRegions(params: Protocol.Overlay.SetShowLayoutShiftRegionsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Requests that backend shows scroll bottleneck rects
          */
-        setShowScrollBottleneckRects(params: Protocol.Overlay.SetShowScrollBottleneckRectsRequest): Promise<void>;
+        setShowScrollBottleneckRects(params: Protocol.Overlay.SetShowScrollBottleneckRectsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Deprecated, no longer has any effect.
          */
-        setShowHitTestBorders(params: Protocol.Overlay.SetShowHitTestBordersRequest): Promise<void>;
+        setShowHitTestBorders(params: Protocol.Overlay.SetShowHitTestBordersRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Request that backend shows an overlay with web vital metrics.
          */
-        setShowWebVitals(params: Protocol.Overlay.SetShowWebVitalsRequest): Promise<void>;
+        setShowWebVitals(params: Protocol.Overlay.SetShowWebVitalsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Paints viewport size upon main frame resize.
          */
-        setShowViewportSizeOnResize(params: Protocol.Overlay.SetShowViewportSizeOnResizeRequest): Promise<void>;
+        setShowViewportSizeOnResize(params: Protocol.Overlay.SetShowViewportSizeOnResizeRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Add a dual screen device hinge
          */
-        setShowHinge(params: Protocol.Overlay.SetShowHingeRequest): Promise<void>;
+        setShowHinge(params: Protocol.Overlay.SetShowHingeRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Show elements in isolation mode with overlays.
          */
-        setShowIsolatedElements(params: Protocol.Overlay.SetShowIsolatedElementsRequest): Promise<void>;
+        setShowIsolatedElements(params: Protocol.Overlay.SetShowIsolatedElementsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Show Window Controls Overlay for PWA
          */
-        setShowWindowControlsOverlay(params: Protocol.Overlay.SetShowWindowControlsOverlayRequest): Promise<void>;
+        setShowWindowControlsOverlay(params: Protocol.Overlay.SetShowWindowControlsOverlayRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Fired when the node should be inspected. This happens after call to `setInspectMode` or when
@@ -2958,255 +2972,255 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Deprecated, please use addScriptToEvaluateOnNewDocument instead.
          */
-        addScriptToEvaluateOnLoad(params: Protocol.Page.AddScriptToEvaluateOnLoadRequest): Promise<Protocol.Page.AddScriptToEvaluateOnLoadResponse>;
+        addScriptToEvaluateOnLoad(params: Protocol.Page.AddScriptToEvaluateOnLoadRequest): Promise<{id: number, result: Protocol.Page.AddScriptToEvaluateOnLoadResponse, sessionId: string}>;
 
         /**
          * Evaluates given script in every frame upon creation (before loading frame's scripts).
          */
-        addScriptToEvaluateOnNewDocument(params: Protocol.Page.AddScriptToEvaluateOnNewDocumentRequest): Promise<Protocol.Page.AddScriptToEvaluateOnNewDocumentResponse>;
+        addScriptToEvaluateOnNewDocument(params: Protocol.Page.AddScriptToEvaluateOnNewDocumentRequest): Promise<{id: number, result: Protocol.Page.AddScriptToEvaluateOnNewDocumentResponse, sessionId: string}>;
 
         /**
          * Brings page to front (activates tab).
          */
-        bringToFront(): Promise<void>;
+        bringToFront(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Capture page screenshot.
          */
-        captureScreenshot(params: Protocol.Page.CaptureScreenshotRequest): Promise<Protocol.Page.CaptureScreenshotResponse>;
+        captureScreenshot(params: Protocol.Page.CaptureScreenshotRequest): Promise<{id: number, result: Protocol.Page.CaptureScreenshotResponse, sessionId: string}>;
 
         /**
          * Returns a snapshot of the page as a string. For MHTML format, the serialization includes
          * iframes, shadow DOM, external resources, and element-inline styles.
          */
-        captureSnapshot(params: Protocol.Page.CaptureSnapshotRequest): Promise<Protocol.Page.CaptureSnapshotResponse>;
+        captureSnapshot(params: Protocol.Page.CaptureSnapshotRequest): Promise<{id: number, result: Protocol.Page.CaptureSnapshotResponse, sessionId: string}>;
 
         /**
          * Clears the overridden device metrics.
          */
-        clearDeviceMetricsOverride(): Promise<void>;
+        clearDeviceMetricsOverride(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Clears the overridden Device Orientation.
          */
-        clearDeviceOrientationOverride(): Promise<void>;
+        clearDeviceOrientationOverride(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Clears the overridden Geolocation Position and Error.
          */
-        clearGeolocationOverride(): Promise<void>;
+        clearGeolocationOverride(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Creates an isolated world for the given frame.
          */
-        createIsolatedWorld(params: Protocol.Page.CreateIsolatedWorldRequest): Promise<Protocol.Page.CreateIsolatedWorldResponse>;
+        createIsolatedWorld(params: Protocol.Page.CreateIsolatedWorldRequest): Promise<{id: number, result: Protocol.Page.CreateIsolatedWorldResponse, sessionId: string}>;
 
         /**
          * Deletes browser cookie with given name, domain and path.
          */
-        deleteCookie(params: Protocol.Page.DeleteCookieRequest): Promise<void>;
+        deleteCookie(params: Protocol.Page.DeleteCookieRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Disables page domain notifications.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables page domain notifications.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
-        getAppManifest(): Promise<Protocol.Page.GetAppManifestResponse>;
+        getAppManifest(): Promise<{id: number, result: Protocol.Page.GetAppManifestResponse, sessionId: string}>;
 
-        getInstallabilityErrors(): Promise<Protocol.Page.GetInstallabilityErrorsResponse>;
+        getInstallabilityErrors(): Promise<{id: number, result: Protocol.Page.GetInstallabilityErrorsResponse, sessionId: string}>;
 
         /**
          * Deprecated because it's not guaranteed that the returned icon is in fact the one used for PWA installation.
          */
-        getManifestIcons(): Promise<Protocol.Page.GetManifestIconsResponse>;
+        getManifestIcons(): Promise<{id: number, result: Protocol.Page.GetManifestIconsResponse, sessionId: string}>;
 
         /**
          * Returns the unique (PWA) app id.
          * Only returns values if the feature flag 'WebAppEnableManifestId' is enabled
          */
-        getAppId(): Promise<Protocol.Page.GetAppIdResponse>;
+        getAppId(): Promise<{id: number, result: Protocol.Page.GetAppIdResponse, sessionId: string}>;
 
-        getAdScriptId(params: Protocol.Page.GetAdScriptIdRequest): Promise<Protocol.Page.GetAdScriptIdResponse>;
+        getAdScriptId(params: Protocol.Page.GetAdScriptIdRequest): Promise<{id: number, result: Protocol.Page.GetAdScriptIdResponse, sessionId: string}>;
 
         /**
          * Returns present frame tree structure.
          */
-        getFrameTree(): Promise<Protocol.Page.GetFrameTreeResponse>;
+        getFrameTree(): Promise<{id: number, result: Protocol.Page.GetFrameTreeResponse, sessionId: string}>;
 
         /**
          * Returns metrics relating to the layouting of the page, such as viewport bounds/scale.
          */
-        getLayoutMetrics(): Promise<Protocol.Page.GetLayoutMetricsResponse>;
+        getLayoutMetrics(): Promise<{id: number, result: Protocol.Page.GetLayoutMetricsResponse, sessionId: string}>;
 
         /**
          * Returns navigation history for the current page.
          */
-        getNavigationHistory(): Promise<Protocol.Page.GetNavigationHistoryResponse>;
+        getNavigationHistory(): Promise<{id: number, result: Protocol.Page.GetNavigationHistoryResponse, sessionId: string}>;
 
         /**
          * Resets navigation history for the current page.
          */
-        resetNavigationHistory(): Promise<void>;
+        resetNavigationHistory(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Returns content of the given resource.
          */
-        getResourceContent(params: Protocol.Page.GetResourceContentRequest): Promise<Protocol.Page.GetResourceContentResponse>;
+        getResourceContent(params: Protocol.Page.GetResourceContentRequest): Promise<{id: number, result: Protocol.Page.GetResourceContentResponse, sessionId: string}>;
 
         /**
          * Returns present frame / resource tree structure.
          */
-        getResourceTree(): Promise<Protocol.Page.GetResourceTreeResponse>;
+        getResourceTree(): Promise<{id: number, result: Protocol.Page.GetResourceTreeResponse, sessionId: string}>;
 
         /**
          * Accepts or dismisses a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload).
          */
-        handleJavaScriptDialog(params: Protocol.Page.HandleJavaScriptDialogRequest): Promise<void>;
+        handleJavaScriptDialog(params: Protocol.Page.HandleJavaScriptDialogRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Navigates current page to the given URL.
          */
-        navigate(params: Protocol.Page.NavigateRequest): Promise<Protocol.Page.NavigateResponse>;
+        navigate(params: Protocol.Page.NavigateRequest): Promise<{id: number, result: Protocol.Page.NavigateResponse, sessionId: string}>;
 
         /**
          * Navigates current page to the given history entry.
          */
-        navigateToHistoryEntry(params: Protocol.Page.NavigateToHistoryEntryRequest): Promise<void>;
+        navigateToHistoryEntry(params: Protocol.Page.NavigateToHistoryEntryRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Print page as PDF.
          */
-        printToPDF(params: Protocol.Page.PrintToPDFRequest): Promise<Protocol.Page.PrintToPDFResponse>;
+        printToPDF(params: Protocol.Page.PrintToPDFRequest): Promise<{id: number, result: Protocol.Page.PrintToPDFResponse, sessionId: string}>;
 
         /**
          * Reloads given page optionally ignoring the cache.
          */
-        reload(params: Protocol.Page.ReloadRequest): Promise<void>;
+        reload(params: Protocol.Page.ReloadRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Deprecated, please use removeScriptToEvaluateOnNewDocument instead.
          */
-        removeScriptToEvaluateOnLoad(params: Protocol.Page.RemoveScriptToEvaluateOnLoadRequest): Promise<void>;
+        removeScriptToEvaluateOnLoad(params: Protocol.Page.RemoveScriptToEvaluateOnLoadRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Removes given script from the list.
          */
-        removeScriptToEvaluateOnNewDocument(params: Protocol.Page.RemoveScriptToEvaluateOnNewDocumentRequest): Promise<void>;
+        removeScriptToEvaluateOnNewDocument(params: Protocol.Page.RemoveScriptToEvaluateOnNewDocumentRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Acknowledges that a screencast frame has been received by the frontend.
          */
-        screencastFrameAck(params: Protocol.Page.ScreencastFrameAckRequest): Promise<void>;
+        screencastFrameAck(params: Protocol.Page.ScreencastFrameAckRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Searches for given string in resource content.
          */
-        searchInResource(params: Protocol.Page.SearchInResourceRequest): Promise<Protocol.Page.SearchInResourceResponse>;
+        searchInResource(params: Protocol.Page.SearchInResourceRequest): Promise<{id: number, result: Protocol.Page.SearchInResourceResponse, sessionId: string}>;
 
         /**
          * Enable Chrome's experimental ad filter on all sites.
          */
-        setAdBlockingEnabled(params: Protocol.Page.SetAdBlockingEnabledRequest): Promise<void>;
+        setAdBlockingEnabled(params: Protocol.Page.SetAdBlockingEnabledRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enable page Content Security Policy by-passing.
          */
-        setBypassCSP(params: Protocol.Page.SetBypassCSPRequest): Promise<void>;
+        setBypassCSP(params: Protocol.Page.SetBypassCSPRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Get Permissions Policy state on given frame.
          */
-        getPermissionsPolicyState(params: Protocol.Page.GetPermissionsPolicyStateRequest): Promise<Protocol.Page.GetPermissionsPolicyStateResponse>;
+        getPermissionsPolicyState(params: Protocol.Page.GetPermissionsPolicyStateRequest): Promise<{id: number, result: Protocol.Page.GetPermissionsPolicyStateResponse, sessionId: string}>;
 
         /**
          * Get Origin Trials on given frame.
          */
-        getOriginTrials(params: Protocol.Page.GetOriginTrialsRequest): Promise<Protocol.Page.GetOriginTrialsResponse>;
+        getOriginTrials(params: Protocol.Page.GetOriginTrialsRequest): Promise<{id: number, result: Protocol.Page.GetOriginTrialsResponse, sessionId: string}>;
 
         /**
          * Overrides the values of device screen dimensions (window.screen.width, window.screen.height,
          * window.innerWidth, window.innerHeight, and "device-width"/"device-height"-related CSS media
          * query results).
          */
-        setDeviceMetricsOverride(params: Protocol.Page.SetDeviceMetricsOverrideRequest): Promise<void>;
+        setDeviceMetricsOverride(params: Protocol.Page.SetDeviceMetricsOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Overrides the Device Orientation.
          */
-        setDeviceOrientationOverride(params: Protocol.Page.SetDeviceOrientationOverrideRequest): Promise<void>;
+        setDeviceOrientationOverride(params: Protocol.Page.SetDeviceOrientationOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Set generic font families.
          */
-        setFontFamilies(params: Protocol.Page.SetFontFamiliesRequest): Promise<void>;
+        setFontFamilies(params: Protocol.Page.SetFontFamiliesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Set default font sizes.
          */
-        setFontSizes(params: Protocol.Page.SetFontSizesRequest): Promise<void>;
+        setFontSizes(params: Protocol.Page.SetFontSizesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets given markup as the document's HTML.
          */
-        setDocumentContent(params: Protocol.Page.SetDocumentContentRequest): Promise<void>;
+        setDocumentContent(params: Protocol.Page.SetDocumentContentRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Set the behavior when downloading a file.
          */
-        setDownloadBehavior(params: Protocol.Page.SetDownloadBehaviorRequest): Promise<void>;
+        setDownloadBehavior(params: Protocol.Page.SetDownloadBehaviorRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Overrides the Geolocation Position or Error. Omitting any of the parameters emulates position
          * unavailable.
          */
-        setGeolocationOverride(params: Protocol.Page.SetGeolocationOverrideRequest): Promise<void>;
+        setGeolocationOverride(params: Protocol.Page.SetGeolocationOverrideRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Controls whether page will emit lifecycle events.
          */
-        setLifecycleEventsEnabled(params: Protocol.Page.SetLifecycleEventsEnabledRequest): Promise<void>;
+        setLifecycleEventsEnabled(params: Protocol.Page.SetLifecycleEventsEnabledRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Toggles mouse event-based touch event emulation.
          */
-        setTouchEmulationEnabled(params: Protocol.Page.SetTouchEmulationEnabledRequest): Promise<void>;
+        setTouchEmulationEnabled(params: Protocol.Page.SetTouchEmulationEnabledRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Starts sending each frame using the `screencastFrame` event.
          */
-        startScreencast(params: Protocol.Page.StartScreencastRequest): Promise<void>;
+        startScreencast(params: Protocol.Page.StartScreencastRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Force the page stop all navigations and pending resource fetches.
          */
-        stopLoading(): Promise<void>;
+        stopLoading(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Crashes renderer on the IO thread, generates minidumps.
          */
-        crash(): Promise<void>;
+        crash(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Tries to close page, running its beforeunload hooks, if any.
          */
-        close(): Promise<void>;
+        close(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * 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/
          */
-        setWebLifecycleState(params: Protocol.Page.SetWebLifecycleStateRequest): Promise<void>;
+        setWebLifecycleState(params: Protocol.Page.SetWebLifecycleStateRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Stops sending each frame in the `screencastFrame`.
          */
-        stopScreencast(): Promise<void>;
+        stopScreencast(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Requests backend to produce compilation cache for the specified scripts.
@@ -3216,47 +3230,47 @@ export namespace ProtocolTestsProxyApi {
          * produced upon backend discretion, based on internal heuristics.
          * See also: `Page.compilationCacheProduced`.
          */
-        produceCompilationCache(params: Protocol.Page.ProduceCompilationCacheRequest): Promise<void>;
+        produceCompilationCache(params: Protocol.Page.ProduceCompilationCacheRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Seeds compilation cache for given url. Compilation cache does not survive
          * cross-process navigation.
          */
-        addCompilationCache(params: Protocol.Page.AddCompilationCacheRequest): Promise<void>;
+        addCompilationCache(params: Protocol.Page.AddCompilationCacheRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Clears seeded compilation cache.
          */
-        clearCompilationCache(): Promise<void>;
+        clearCompilationCache(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets the Secure Payment Confirmation transaction mode.
          * https://w3c.github.io/secure-payment-confirmation/#sctn-automation-set-spc-transaction-mode
          */
-        setSPCTransactionMode(params: Protocol.Page.SetSPCTransactionModeRequest): Promise<void>;
+        setSPCTransactionMode(params: Protocol.Page.SetSPCTransactionModeRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Extensions for Custom Handlers API:
          * https://html.spec.whatwg.org/multipage/system-state.html#rph-automation
          */
-        setRPHRegistrationMode(params: Protocol.Page.SetRPHRegistrationModeRequest): Promise<void>;
+        setRPHRegistrationMode(params: Protocol.Page.SetRPHRegistrationModeRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Generates a report for testing.
          */
-        generateTestReport(params: Protocol.Page.GenerateTestReportRequest): Promise<void>;
+        generateTestReport(params: Protocol.Page.GenerateTestReportRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Pauses page execution. Can be resumed using generic Runtime.runIfWaitingForDebugger.
          */
-        waitForDebugger(): Promise<void>;
+        waitForDebugger(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Intercept file chooser requests and transfer control to protocol clients.
          * When file chooser interception is enabled, native file chooser dialog is not shown.
          * Instead, a protocol event `Page.fileChooserOpened` is emitted.
          */
-        setInterceptFileChooserDialog(params: Protocol.Page.SetInterceptFileChooserDialogRequest): Promise<void>;
+        setInterceptFileChooserDialog(params: Protocol.Page.SetInterceptFileChooserDialogRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enable/disable prerendering manually.
@@ -3267,7 +3281,7 @@ export namespace ProtocolTestsProxyApi {
          * 
          * TODO(https://crbug.com/1440085): Remove this once Puppeteer supports tab targets.
          */
-        setPrerenderingAllowed(params: Protocol.Page.SetPrerenderingAllowedRequest): Promise<void>;
+        setPrerenderingAllowed(params: Protocol.Page.SetPrerenderingAllowedRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         onDomContentEventFired(listener: (event: { params: Protocol.Page.DomContentEventFiredEvent }) => void): void;
         offDomContentEventFired(listener: (event: { params: Protocol.Page.DomContentEventFiredEvent }) => void): void;
@@ -3458,24 +3472,24 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Disable collecting and reporting metrics.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enable collecting and reporting metrics.
          */
-        enable(params: Protocol.Performance.EnableRequest): Promise<void>;
+        enable(params: Protocol.Performance.EnableRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * 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.
          */
-        setTimeDomain(params: Protocol.Performance.SetTimeDomainRequest): Promise<void>;
+        setTimeDomain(params: Protocol.Performance.SetTimeDomainRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Retrieve current values of run-time metrics.
          */
-        getMetrics(): Promise<Protocol.Performance.GetMetricsResponse>;
+        getMetrics(): Promise<{id: number, result: Protocol.Performance.GetMetricsResponse, sessionId: string}>;
 
         /**
          * Current values of the metrics.
@@ -3491,7 +3505,7 @@ export namespace ProtocolTestsProxyApi {
          * Previously buffered events would be reported before method returns.
          * See also: timelineEventAdded
          */
-        enable(params: Protocol.PerformanceTimeline.EnableRequest): Promise<void>;
+        enable(params: Protocol.PerformanceTimeline.EnableRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sent when a performance timeline event is added. See reportPerformanceTimeline method.
@@ -3506,28 +3520,28 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Disables tracking security state changes.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables tracking security state changes.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enable/disable whether all certificate errors should be ignored.
          */
-        setIgnoreCertificateErrors(params: Protocol.Security.SetIgnoreCertificateErrorsRequest): Promise<void>;
+        setIgnoreCertificateErrors(params: Protocol.Security.SetIgnoreCertificateErrorsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Handles a certificate error that fired a certificateError event.
          */
-        handleCertificateError(params: Protocol.Security.HandleCertificateErrorRequest): Promise<void>;
+        handleCertificateError(params: Protocol.Security.HandleCertificateErrorRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * 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.
          */
-        setOverrideCertificateErrors(params: Protocol.Security.SetOverrideCertificateErrorsRequest): Promise<void>;
+        setOverrideCertificateErrors(params: Protocol.Security.SetOverrideCertificateErrorsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * There is a certificate error. If overriding certificate errors is enabled, then it should be
@@ -3556,31 +3570,31 @@ export namespace ProtocolTestsProxyApi {
     }
 
     export interface ServiceWorkerApi {
-        deliverPushMessage(params: Protocol.ServiceWorker.DeliverPushMessageRequest): Promise<void>;
+        deliverPushMessage(params: Protocol.ServiceWorker.DeliverPushMessageRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
-        dispatchSyncEvent(params: Protocol.ServiceWorker.DispatchSyncEventRequest): Promise<void>;
+        dispatchSyncEvent(params: Protocol.ServiceWorker.DispatchSyncEventRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        dispatchPeriodicSyncEvent(params: Protocol.ServiceWorker.DispatchPeriodicSyncEventRequest): Promise<void>;
+        dispatchPeriodicSyncEvent(params: Protocol.ServiceWorker.DispatchPeriodicSyncEventRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
-        inspectWorker(params: Protocol.ServiceWorker.InspectWorkerRequest): Promise<void>;
+        inspectWorker(params: Protocol.ServiceWorker.InspectWorkerRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        setForceUpdateOnPageLoad(params: Protocol.ServiceWorker.SetForceUpdateOnPageLoadRequest): Promise<void>;
+        setForceUpdateOnPageLoad(params: Protocol.ServiceWorker.SetForceUpdateOnPageLoadRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        skipWaiting(params: Protocol.ServiceWorker.SkipWaitingRequest): Promise<void>;
+        skipWaiting(params: Protocol.ServiceWorker.SkipWaitingRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        startWorker(params: Protocol.ServiceWorker.StartWorkerRequest): Promise<void>;
+        startWorker(params: Protocol.ServiceWorker.StartWorkerRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        stopAllWorkers(): Promise<void>;
+        stopAllWorkers(): Promise<{id: number, result: void, sessionId: string}>;
 
-        stopWorker(params: Protocol.ServiceWorker.StopWorkerRequest): Promise<void>;
+        stopWorker(params: Protocol.ServiceWorker.StopWorkerRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        unregister(params: Protocol.ServiceWorker.UnregisterRequest): Promise<void>;
+        unregister(params: Protocol.ServiceWorker.UnregisterRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        updateRegistration(params: Protocol.ServiceWorker.UpdateRegistrationRequest): Promise<void>;
+        updateRegistration(params: Protocol.ServiceWorker.UpdateRegistrationRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         onWorkerErrorReported(listener: (event: { params: Protocol.ServiceWorker.WorkerErrorReportedEvent }) => void): void;
         offWorkerErrorReported(listener: (event: { params: Protocol.ServiceWorker.WorkerErrorReportedEvent }) => void): void;
@@ -3600,182 +3614,182 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Returns a storage key given a frame id.
          */
-        getStorageKeyForFrame(params: Protocol.Storage.GetStorageKeyForFrameRequest): Promise<Protocol.Storage.GetStorageKeyForFrameResponse>;
+        getStorageKeyForFrame(params: Protocol.Storage.GetStorageKeyForFrameRequest): Promise<{id: number, result: Protocol.Storage.GetStorageKeyForFrameResponse, sessionId: string}>;
 
         /**
          * Clears storage for origin.
          */
-        clearDataForOrigin(params: Protocol.Storage.ClearDataForOriginRequest): Promise<void>;
+        clearDataForOrigin(params: Protocol.Storage.ClearDataForOriginRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Clears storage for storage key.
          */
-        clearDataForStorageKey(params: Protocol.Storage.ClearDataForStorageKeyRequest): Promise<void>;
+        clearDataForStorageKey(params: Protocol.Storage.ClearDataForStorageKeyRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Returns all browser cookies.
          */
-        getCookies(params: Protocol.Storage.GetCookiesRequest): Promise<Protocol.Storage.GetCookiesResponse>;
+        getCookies(params: Protocol.Storage.GetCookiesRequest): Promise<{id: number, result: Protocol.Storage.GetCookiesResponse, sessionId: string}>;
 
         /**
          * Sets given cookies.
          */
-        setCookies(params: Protocol.Storage.SetCookiesRequest): Promise<void>;
+        setCookies(params: Protocol.Storage.SetCookiesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Clears cookies.
          */
-        clearCookies(params: Protocol.Storage.ClearCookiesRequest): Promise<void>;
+        clearCookies(params: Protocol.Storage.ClearCookiesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Returns usage and quota in bytes.
          */
-        getUsageAndQuota(params: Protocol.Storage.GetUsageAndQuotaRequest): Promise<Protocol.Storage.GetUsageAndQuotaResponse>;
+        getUsageAndQuota(params: Protocol.Storage.GetUsageAndQuotaRequest): Promise<{id: number, result: Protocol.Storage.GetUsageAndQuotaResponse, sessionId: string}>;
 
         /**
          * Override quota for the specified origin
          */
-        overrideQuotaForOrigin(params: Protocol.Storage.OverrideQuotaForOriginRequest): Promise<void>;
+        overrideQuotaForOrigin(params: Protocol.Storage.OverrideQuotaForOriginRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Registers origin to be notified when an update occurs to its cache storage list.
          */
-        trackCacheStorageForOrigin(params: Protocol.Storage.TrackCacheStorageForOriginRequest): Promise<void>;
+        trackCacheStorageForOrigin(params: Protocol.Storage.TrackCacheStorageForOriginRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Registers storage key to be notified when an update occurs to its cache storage list.
          */
-        trackCacheStorageForStorageKey(params: Protocol.Storage.TrackCacheStorageForStorageKeyRequest): Promise<void>;
+        trackCacheStorageForStorageKey(params: Protocol.Storage.TrackCacheStorageForStorageKeyRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Registers origin to be notified when an update occurs to its IndexedDB.
          */
-        trackIndexedDBForOrigin(params: Protocol.Storage.TrackIndexedDBForOriginRequest): Promise<void>;
+        trackIndexedDBForOrigin(params: Protocol.Storage.TrackIndexedDBForOriginRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Registers storage key to be notified when an update occurs to its IndexedDB.
          */
-        trackIndexedDBForStorageKey(params: Protocol.Storage.TrackIndexedDBForStorageKeyRequest): Promise<void>;
+        trackIndexedDBForStorageKey(params: Protocol.Storage.TrackIndexedDBForStorageKeyRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Unregisters origin from receiving notifications for cache storage.
          */
-        untrackCacheStorageForOrigin(params: Protocol.Storage.UntrackCacheStorageForOriginRequest): Promise<void>;
+        untrackCacheStorageForOrigin(params: Protocol.Storage.UntrackCacheStorageForOriginRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Unregisters storage key from receiving notifications for cache storage.
          */
-        untrackCacheStorageForStorageKey(params: Protocol.Storage.UntrackCacheStorageForStorageKeyRequest): Promise<void>;
+        untrackCacheStorageForStorageKey(params: Protocol.Storage.UntrackCacheStorageForStorageKeyRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Unregisters origin from receiving notifications for IndexedDB.
          */
-        untrackIndexedDBForOrigin(params: Protocol.Storage.UntrackIndexedDBForOriginRequest): Promise<void>;
+        untrackIndexedDBForOrigin(params: Protocol.Storage.UntrackIndexedDBForOriginRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Unregisters storage key from receiving notifications for IndexedDB.
          */
-        untrackIndexedDBForStorageKey(params: Protocol.Storage.UntrackIndexedDBForStorageKeyRequest): Promise<void>;
+        untrackIndexedDBForStorageKey(params: Protocol.Storage.UntrackIndexedDBForStorageKeyRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Returns the number of stored Trust Tokens per issuer for the
          * current browsing context.
          */
-        getTrustTokens(): Promise<Protocol.Storage.GetTrustTokensResponse>;
+        getTrustTokens(): Promise<{id: number, result: Protocol.Storage.GetTrustTokensResponse, sessionId: string}>;
 
         /**
          * Removes all Trust Tokens issued by the provided issuerOrigin.
          * Leaves other stored data, including the issuer's Redemption Records, intact.
          */
-        clearTrustTokens(params: Protocol.Storage.ClearTrustTokensRequest): Promise<Protocol.Storage.ClearTrustTokensResponse>;
+        clearTrustTokens(params: Protocol.Storage.ClearTrustTokensRequest): Promise<{id: number, result: Protocol.Storage.ClearTrustTokensResponse, sessionId: string}>;
 
         /**
          * Gets details for a named interest group.
          */
-        getInterestGroupDetails(params: Protocol.Storage.GetInterestGroupDetailsRequest): Promise<Protocol.Storage.GetInterestGroupDetailsResponse>;
+        getInterestGroupDetails(params: Protocol.Storage.GetInterestGroupDetailsRequest): Promise<{id: number, result: Protocol.Storage.GetInterestGroupDetailsResponse, sessionId: string}>;
 
         /**
          * Enables/Disables issuing of interestGroupAccessed events.
          */
-        setInterestGroupTracking(params: Protocol.Storage.SetInterestGroupTrackingRequest): Promise<void>;
+        setInterestGroupTracking(params: Protocol.Storage.SetInterestGroupTrackingRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables/Disables issuing of interestGroupAuctionEventOccurred and
          * interestGroupAuctionNetworkRequestCreated.
          */
-        setInterestGroupAuctionTracking(params: Protocol.Storage.SetInterestGroupAuctionTrackingRequest): Promise<void>;
+        setInterestGroupAuctionTracking(params: Protocol.Storage.SetInterestGroupAuctionTrackingRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Gets metadata for an origin's shared storage.
          */
-        getSharedStorageMetadata(params: Protocol.Storage.GetSharedStorageMetadataRequest): Promise<Protocol.Storage.GetSharedStorageMetadataResponse>;
+        getSharedStorageMetadata(params: Protocol.Storage.GetSharedStorageMetadataRequest): Promise<{id: number, result: Protocol.Storage.GetSharedStorageMetadataResponse, sessionId: string}>;
 
         /**
          * Gets the entries in an given origin's shared storage.
          */
-        getSharedStorageEntries(params: Protocol.Storage.GetSharedStorageEntriesRequest): Promise<Protocol.Storage.GetSharedStorageEntriesResponse>;
+        getSharedStorageEntries(params: Protocol.Storage.GetSharedStorageEntriesRequest): Promise<{id: number, result: Protocol.Storage.GetSharedStorageEntriesResponse, sessionId: string}>;
 
         /**
          * Sets entry with `key` and `value` for a given origin's shared storage.
          */
-        setSharedStorageEntry(params: Protocol.Storage.SetSharedStorageEntryRequest): Promise<void>;
+        setSharedStorageEntry(params: Protocol.Storage.SetSharedStorageEntryRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Deletes entry for `key` (if it exists) for a given origin's shared storage.
          */
-        deleteSharedStorageEntry(params: Protocol.Storage.DeleteSharedStorageEntryRequest): Promise<void>;
+        deleteSharedStorageEntry(params: Protocol.Storage.DeleteSharedStorageEntryRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Clears all entries for a given origin's shared storage.
          */
-        clearSharedStorageEntries(params: Protocol.Storage.ClearSharedStorageEntriesRequest): Promise<void>;
+        clearSharedStorageEntries(params: Protocol.Storage.ClearSharedStorageEntriesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Resets the budget for `ownerOrigin` by clearing all budget withdrawals.
          */
-        resetSharedStorageBudget(params: Protocol.Storage.ResetSharedStorageBudgetRequest): Promise<void>;
+        resetSharedStorageBudget(params: Protocol.Storage.ResetSharedStorageBudgetRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables/disables issuing of sharedStorageAccessed events.
          */
-        setSharedStorageTracking(params: Protocol.Storage.SetSharedStorageTrackingRequest): Promise<void>;
+        setSharedStorageTracking(params: Protocol.Storage.SetSharedStorageTrackingRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Set tracking for a storage key's buckets.
          */
-        setStorageBucketTracking(params: Protocol.Storage.SetStorageBucketTrackingRequest): Promise<void>;
+        setStorageBucketTracking(params: Protocol.Storage.SetStorageBucketTrackingRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Deletes the Storage Bucket with the given storage key and bucket name.
          */
-        deleteStorageBucket(params: Protocol.Storage.DeleteStorageBucketRequest): Promise<void>;
+        deleteStorageBucket(params: Protocol.Storage.DeleteStorageBucketRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Deletes state for sites identified as potential bounce trackers, immediately.
          */
-        runBounceTrackingMitigations(): Promise<Protocol.Storage.RunBounceTrackingMitigationsResponse>;
+        runBounceTrackingMitigations(): Promise<{id: number, result: Protocol.Storage.RunBounceTrackingMitigationsResponse, sessionId: string}>;
 
         /**
          * https://wicg.github.io/attribution-reporting-api/
          */
-        setAttributionReportingLocalTestingMode(params: Protocol.Storage.SetAttributionReportingLocalTestingModeRequest): Promise<void>;
+        setAttributionReportingLocalTestingMode(params: Protocol.Storage.SetAttributionReportingLocalTestingModeRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables/disables issuing of Attribution Reporting events.
          */
-        setAttributionReportingTracking(params: Protocol.Storage.SetAttributionReportingTrackingRequest): Promise<void>;
+        setAttributionReportingTracking(params: Protocol.Storage.SetAttributionReportingTrackingRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sends all pending Attribution Reports immediately, regardless of their
          * scheduled report time.
          */
-        sendPendingAttributionReports(): Promise<Protocol.Storage.SendPendingAttributionReportsResponse>;
+        sendPendingAttributionReports(): Promise<{id: number, result: Protocol.Storage.SendPendingAttributionReportsResponse, sessionId: string}>;
 
         /**
          * 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.
          */
-        getRelatedWebsiteSets(): Promise<Protocol.Storage.GetRelatedWebsiteSetsResponse>;
+        getRelatedWebsiteSets(): Promise<{id: number, result: Protocol.Storage.GetRelatedWebsiteSetsResponse, sessionId: string}>;
 
         /**
          * A cache's contents have been modified.
@@ -3861,17 +3875,17 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Returns information about the system.
          */
-        getInfo(): Promise<Protocol.SystemInfo.GetInfoResponse>;
+        getInfo(): Promise<{id: number, result: Protocol.SystemInfo.GetInfoResponse, sessionId: string}>;
 
         /**
          * Returns information about the feature state.
          */
-        getFeatureState(params: Protocol.SystemInfo.GetFeatureStateRequest): Promise<Protocol.SystemInfo.GetFeatureStateResponse>;
+        getFeatureState(params: Protocol.SystemInfo.GetFeatureStateRequest): Promise<{id: number, result: Protocol.SystemInfo.GetFeatureStateResponse, sessionId: string}>;
 
         /**
          * Returns information about all running processes.
          */
-        getProcessInfo(): Promise<Protocol.SystemInfo.GetProcessInfoResponse>;
+        getProcessInfo(): Promise<{id: number, result: Protocol.SystemInfo.GetProcessInfoResponse, sessionId: string}>;
 
     }
 
@@ -3879,22 +3893,22 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Activates (focuses) the target.
          */
-        activateTarget(params: Protocol.Target.ActivateTargetRequest): Promise<void>;
+        activateTarget(params: Protocol.Target.ActivateTargetRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Attaches to the target with given id.
          */
-        attachToTarget(params: Protocol.Target.AttachToTargetRequest): Promise<Protocol.Target.AttachToTargetResponse>;
+        attachToTarget(params: Protocol.Target.AttachToTargetRequest): Promise<{id: number, result: Protocol.Target.AttachToTargetResponse, sessionId: string}>;
 
         /**
          * Attaches to the browser target, only uses flat sessionId mode.
          */
-        attachToBrowserTarget(): Promise<Protocol.Target.AttachToBrowserTargetResponse>;
+        attachToBrowserTarget(): Promise<{id: number, result: Protocol.Target.AttachToBrowserTargetResponse, sessionId: string}>;
 
         /**
          * Closes the target. If the target is a page that gets closed too.
          */
-        closeTarget(params: Protocol.Target.CloseTargetRequest): Promise<Protocol.Target.CloseTargetResponse>;
+        closeTarget(params: Protocol.Target.CloseTargetRequest): Promise<{id: number, result: Protocol.Target.CloseTargetResponse, sessionId: string}>;
 
         /**
          * Inject object to the target's main frame that provides a communication
@@ -3906,51 +3920,51 @@ export namespace ProtocolTestsProxyApi {
          * - `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.
          */
-        exposeDevToolsProtocol(params: Protocol.Target.ExposeDevToolsProtocolRequest): Promise<void>;
+        exposeDevToolsProtocol(params: Protocol.Target.ExposeDevToolsProtocolRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Creates a new empty BrowserContext. Similar to an incognito profile but you can have more than
          * one.
          */
-        createBrowserContext(params: Protocol.Target.CreateBrowserContextRequest): Promise<Protocol.Target.CreateBrowserContextResponse>;
+        createBrowserContext(params: Protocol.Target.CreateBrowserContextRequest): Promise<{id: number, result: Protocol.Target.CreateBrowserContextResponse, sessionId: string}>;
 
         /**
          * Returns all browser contexts created with `Target.createBrowserContext` method.
          */
-        getBrowserContexts(): Promise<Protocol.Target.GetBrowserContextsResponse>;
+        getBrowserContexts(): Promise<{id: number, result: Protocol.Target.GetBrowserContextsResponse, sessionId: string}>;
 
         /**
          * Creates a new page.
          */
-        createTarget(params: Protocol.Target.CreateTargetRequest): Promise<Protocol.Target.CreateTargetResponse>;
+        createTarget(params: Protocol.Target.CreateTargetRequest): Promise<{id: number, result: Protocol.Target.CreateTargetResponse, sessionId: string}>;
 
         /**
          * Detaches session with given id.
          */
-        detachFromTarget(params: Protocol.Target.DetachFromTargetRequest): Promise<void>;
+        detachFromTarget(params: Protocol.Target.DetachFromTargetRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Deletes a BrowserContext. All the belonging pages will be closed without calling their
          * beforeunload hooks.
          */
-        disposeBrowserContext(params: Protocol.Target.DisposeBrowserContextRequest): Promise<void>;
+        disposeBrowserContext(params: Protocol.Target.DisposeBrowserContextRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Returns information about a target.
          */
-        getTargetInfo(params: Protocol.Target.GetTargetInfoRequest): Promise<Protocol.Target.GetTargetInfoResponse>;
+        getTargetInfo(params: Protocol.Target.GetTargetInfoRequest): Promise<{id: number, result: Protocol.Target.GetTargetInfoResponse, sessionId: string}>;
 
         /**
          * Retrieves a list of available targets.
          */
-        getTargets(params: Protocol.Target.GetTargetsRequest): Promise<Protocol.Target.GetTargetsResponse>;
+        getTargets(params: Protocol.Target.GetTargetsRequest): Promise<{id: number, result: Protocol.Target.GetTargetsResponse, sessionId: string}>;
 
         /**
          * Sends protocol message over session with given id.
          * Consider using flat mode instead; see commands attachToTarget, setAutoAttach,
          * and crbug.com/991325.
          */
-        sendMessageToTarget(params: Protocol.Target.SendMessageToTargetRequest): Promise<void>;
+        sendMessageToTarget(params: Protocol.Target.SendMessageToTargetRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Controls whether to automatically attach to new targets which are considered to be related to
@@ -3959,7 +3973,7 @@ export namespace ProtocolTestsProxyApi {
          * This also clears all targets added by `autoAttachRelated` from the list of targets to watch
          * for creation of related targets.
          */
-        setAutoAttach(params: Protocol.Target.SetAutoAttachRequest): Promise<void>;
+        setAutoAttach(params: Protocol.Target.SetAutoAttachRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Adds the specified target to the list of targets that will be monitored for any related target
@@ -3968,19 +3982,19 @@ export namespace ProtocolTestsProxyApi {
          * This cancels the effect of any previous `setAutoAttach` and is also cancelled by subsequent
          * `setAutoAttach`. Only available at the Browser target.
          */
-        autoAttachRelated(params: Protocol.Target.AutoAttachRelatedRequest): Promise<void>;
+        autoAttachRelated(params: Protocol.Target.AutoAttachRelatedRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Controls whether to discover available targets and notify via
          * `targetCreated/targetInfoChanged/targetDestroyed` events.
          */
-        setDiscoverTargets(params: Protocol.Target.SetDiscoverTargetsRequest): Promise<void>;
+        setDiscoverTargets(params: Protocol.Target.SetDiscoverTargetsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables target discovery for the specified locations, when `setDiscoverTargets` was set to
          * `true`.
          */
-        setRemoteLocations(params: Protocol.Target.SetRemoteLocationsRequest): Promise<void>;
+        setRemoteLocations(params: Protocol.Target.SetRemoteLocationsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Issued when attached to target because of auto-attach or `attachToTarget` command.
@@ -4040,12 +4054,12 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Request browser port binding.
          */
-        bind(params: Protocol.Tethering.BindRequest): Promise<void>;
+        bind(params: Protocol.Tethering.BindRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Request browser port unbinding.
          */
-        unbind(params: Protocol.Tethering.UnbindRequest): Promise<void>;
+        unbind(params: Protocol.Tethering.UnbindRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Informs that port was successfully bound and got a specified connection id.
@@ -4060,27 +4074,27 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Stop trace events collection.
          */
-        end(): Promise<void>;
+        end(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Gets supported tracing categories.
          */
-        getCategories(): Promise<Protocol.Tracing.GetCategoriesResponse>;
+        getCategories(): Promise<{id: number, result: Protocol.Tracing.GetCategoriesResponse, sessionId: string}>;
 
         /**
          * Record a clock sync marker in the trace.
          */
-        recordClockSyncMarker(params: Protocol.Tracing.RecordClockSyncMarkerRequest): Promise<void>;
+        recordClockSyncMarker(params: Protocol.Tracing.RecordClockSyncMarkerRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Request a global memory dump.
          */
-        requestMemoryDump(params: Protocol.Tracing.RequestMemoryDumpRequest): Promise<Protocol.Tracing.RequestMemoryDumpResponse>;
+        requestMemoryDump(params: Protocol.Tracing.RequestMemoryDumpRequest): Promise<{id: number, result: Protocol.Tracing.RequestMemoryDumpResponse, sessionId: string}>;
 
         /**
          * Start trace events collection.
          */
-        start(params: Protocol.Tracing.StartRequest): Promise<void>;
+        start(params: Protocol.Tracing.StartRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         onBufferUsage(listener: (event: { params: Protocol.Tracing.BufferUsageEvent }) => void): void;
         offBufferUsage(listener: (event: { params: Protocol.Tracing.BufferUsageEvent }) => void): void;
@@ -4108,40 +4122,40 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Disables the fetch domain.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Enables issuing of requestPaused events. A request will be paused until client
          * calls one of failRequest, fulfillRequest or continueRequest/continueWithAuth.
          */
-        enable(params: Protocol.Fetch.EnableRequest): Promise<void>;
+        enable(params: Protocol.Fetch.EnableRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Causes the request to fail with specified reason.
          */
-        failRequest(params: Protocol.Fetch.FailRequestRequest): Promise<void>;
+        failRequest(params: Protocol.Fetch.FailRequestRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Provides response to the request.
          */
-        fulfillRequest(params: Protocol.Fetch.FulfillRequestRequest): Promise<void>;
+        fulfillRequest(params: Protocol.Fetch.FulfillRequestRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Continues the request, optionally modifying some of its parameters.
          */
-        continueRequest(params: Protocol.Fetch.ContinueRequestRequest): Promise<void>;
+        continueRequest(params: Protocol.Fetch.ContinueRequestRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Continues a request supplying authChallengeResponse following authRequired event.
          */
-        continueWithAuth(params: Protocol.Fetch.ContinueWithAuthRequest): Promise<void>;
+        continueWithAuth(params: Protocol.Fetch.ContinueWithAuthRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Continues loading of the paused response, optionally modifying the
          * response headers. If either responseCode or headers are modified, all of them
          * must be present.
          */
-        continueResponse(params: Protocol.Fetch.ContinueResponseRequest): Promise<void>;
+        continueResponse(params: Protocol.Fetch.ContinueResponseRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Causes the body of the response to be received from the server and
@@ -4155,7 +4169,7 @@ export namespace ProtocolTestsProxyApi {
          * `responseCode` and presence of `location` response header, see
          * comments to `requestPaused` for details.
          */
-        getResponseBody(params: Protocol.Fetch.GetResponseBodyRequest): Promise<Protocol.Fetch.GetResponseBodyResponse>;
+        getResponseBody(params: Protocol.Fetch.GetResponseBodyRequest): Promise<{id: number, result: Protocol.Fetch.GetResponseBodyResponse, sessionId: string}>;
 
         /**
          * Returns a handle to the stream representing the response body.
@@ -4169,7 +4183,7 @@ export namespace ProtocolTestsProxyApi {
          * Calling other methods that affect the request or disabling fetch
          * domain before body is received results in an undefined behavior.
          */
-        takeResponseBodyAsStream(params: Protocol.Fetch.TakeResponseBodyAsStreamRequest): Promise<Protocol.Fetch.TakeResponseBodyAsStreamResponse>;
+        takeResponseBodyAsStream(params: Protocol.Fetch.TakeResponseBodyAsStreamRequest): Promise<{id: number, result: Protocol.Fetch.TakeResponseBodyAsStreamResponse, sessionId: string}>;
 
         /**
          * Issued when the domain is enabled and the request URL matches the
@@ -4202,17 +4216,17 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Enables the WebAudio domain and starts sending context lifetime events.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Disables the WebAudio domain.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Fetch the realtime data from the registered contexts.
          */
-        getRealtimeData(params: Protocol.WebAudio.GetRealtimeDataRequest): Promise<Protocol.WebAudio.GetRealtimeDataResponse>;
+        getRealtimeData(params: Protocol.WebAudio.GetRealtimeDataRequest): Promise<{id: number, result: Protocol.WebAudio.GetRealtimeDataResponse, sessionId: string}>;
 
         /**
          * Notifies that a new BaseAudioContext has been created.
@@ -4312,71 +4326,71 @@ export namespace ProtocolTestsProxyApi {
          * Enable the WebAuthn domain and start intercepting credential storage and
          * retrieval with a virtual authenticator.
          */
-        enable(params: Protocol.WebAuthn.EnableRequest): Promise<void>;
+        enable(params: Protocol.WebAuthn.EnableRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Disable the WebAuthn domain.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Creates and adds a virtual authenticator.
          */
-        addVirtualAuthenticator(params: Protocol.WebAuthn.AddVirtualAuthenticatorRequest): Promise<Protocol.WebAuthn.AddVirtualAuthenticatorResponse>;
+        addVirtualAuthenticator(params: Protocol.WebAuthn.AddVirtualAuthenticatorRequest): Promise<{id: number, result: Protocol.WebAuthn.AddVirtualAuthenticatorResponse, sessionId: string}>;
 
         /**
          * Resets parameters isBogusSignature, isBadUV, isBadUP to false if they are not present.
          */
-        setResponseOverrideBits(params: Protocol.WebAuthn.SetResponseOverrideBitsRequest): Promise<void>;
+        setResponseOverrideBits(params: Protocol.WebAuthn.SetResponseOverrideBitsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Removes the given authenticator.
          */
-        removeVirtualAuthenticator(params: Protocol.WebAuthn.RemoveVirtualAuthenticatorRequest): Promise<void>;
+        removeVirtualAuthenticator(params: Protocol.WebAuthn.RemoveVirtualAuthenticatorRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Adds the credential to the specified authenticator.
          */
-        addCredential(params: Protocol.WebAuthn.AddCredentialRequest): Promise<void>;
+        addCredential(params: Protocol.WebAuthn.AddCredentialRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Returns a single credential stored in the given virtual authenticator that
          * matches the credential ID.
          */
-        getCredential(params: Protocol.WebAuthn.GetCredentialRequest): Promise<Protocol.WebAuthn.GetCredentialResponse>;
+        getCredential(params: Protocol.WebAuthn.GetCredentialRequest): Promise<{id: number, result: Protocol.WebAuthn.GetCredentialResponse, sessionId: string}>;
 
         /**
          * Returns all the credentials stored in the given virtual authenticator.
          */
-        getCredentials(params: Protocol.WebAuthn.GetCredentialsRequest): Promise<Protocol.WebAuthn.GetCredentialsResponse>;
+        getCredentials(params: Protocol.WebAuthn.GetCredentialsRequest): Promise<{id: number, result: Protocol.WebAuthn.GetCredentialsResponse, sessionId: string}>;
 
         /**
          * Removes a credential from the authenticator.
          */
-        removeCredential(params: Protocol.WebAuthn.RemoveCredentialRequest): Promise<void>;
+        removeCredential(params: Protocol.WebAuthn.RemoveCredentialRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Clears all the credentials from the specified device.
          */
-        clearCredentials(params: Protocol.WebAuthn.ClearCredentialsRequest): Promise<void>;
+        clearCredentials(params: Protocol.WebAuthn.ClearCredentialsRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets whether User Verification succeeds or fails for an authenticator.
          * The default is true.
          */
-        setUserVerified(params: Protocol.WebAuthn.SetUserVerifiedRequest): Promise<void>;
+        setUserVerified(params: Protocol.WebAuthn.SetUserVerifiedRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Sets whether tests of user presence will succeed immediately (if true) or fail to resolve (if false) for an authenticator.
          * The default is true.
          */
-        setAutomaticPresenceSimulation(params: Protocol.WebAuthn.SetAutomaticPresenceSimulationRequest): Promise<void>;
+        setAutomaticPresenceSimulation(params: Protocol.WebAuthn.SetAutomaticPresenceSimulationRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Allows setting credential properties.
          * https://w3c.github.io/webauthn/#sctn-automation-set-credential-properties
          */
-        setCredentialProperties(params: Protocol.WebAuthn.SetCredentialPropertiesRequest): Promise<void>;
+        setCredentialProperties(params: Protocol.WebAuthn.SetCredentialPropertiesRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Triggered when a credential is added to an authenticator.
@@ -4398,12 +4412,12 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Enables the Media domain
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Disables the Media domain.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * This can be called multiple times, and can be used to set / override /
@@ -4450,22 +4464,22 @@ export namespace ProtocolTestsProxyApi {
         /**
          * Enable events in this domain.
          */
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Disable events in this domain.
          */
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Select a device in response to a DeviceAccess.deviceRequestPrompted event.
          */
-        selectPrompt(params: Protocol.DeviceAccess.SelectPromptRequest): Promise<void>;
+        selectPrompt(params: Protocol.DeviceAccess.SelectPromptRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Cancel a prompt in response to a DeviceAccess.deviceRequestPrompted event.
          */
-        cancelPrompt(params: Protocol.DeviceAccess.CancelPromptRequest): Promise<void>;
+        cancelPrompt(params: Protocol.DeviceAccess.CancelPromptRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * A device request opened a user prompt to select a device. Respond with the
@@ -4478,9 +4492,9 @@ export namespace ProtocolTestsProxyApi {
     }
 
     export interface PreloadApi {
-        enable(): Promise<void>;
+        enable(): Promise<{id: number, result: void, sessionId: string}>;
 
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Upsert. Currently, it is only emitted when a rule set added.
@@ -4524,23 +4538,23 @@ export namespace ProtocolTestsProxyApi {
     }
 
     export interface FedCmApi {
-        enable(params: Protocol.FedCm.EnableRequest): Promise<void>;
+        enable(params: Protocol.FedCm.EnableRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        disable(): Promise<void>;
+        disable(): Promise<{id: number, result: void, sessionId: string}>;
 
-        selectAccount(params: Protocol.FedCm.SelectAccountRequest): Promise<void>;
+        selectAccount(params: Protocol.FedCm.SelectAccountRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        clickDialogButton(params: Protocol.FedCm.ClickDialogButtonRequest): Promise<void>;
+        clickDialogButton(params: Protocol.FedCm.ClickDialogButtonRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        openUrl(params: Protocol.FedCm.OpenUrlRequest): Promise<void>;
+        openUrl(params: Protocol.FedCm.OpenUrlRequest): Promise<{id: number, result: void, sessionId: string}>;
 
-        dismissDialog(params: Protocol.FedCm.DismissDialogRequest): Promise<void>;
+        dismissDialog(params: Protocol.FedCm.DismissDialogRequest): Promise<{id: number, result: void, sessionId: string}>;
 
         /**
          * Resets the cooldown time, if any, to allow the next FedCM call to show
          * a dialog even if one was recently dismissed by the user.
          */
-        resetCooldown(): Promise<void>;
+        resetCooldown(): Promise<{id: number, result: void, sessionId: string}>;
 
         onDialogShown(listener: (event: { params: Protocol.FedCm.DialogShownEvent }) => void): void;
         offDialogShown(listener: (event: { params: Protocol.FedCm.DialogShownEvent }) => void): void;