@types/node 10.9.0 → 10.9.4

node/inspector.d.ts

@@ -15,1635 +15,1864 @@ declare module "inspector" {
         params: T;
     }
 
-    export namespace Schema {
+    export namespace Console {
         /**
-         * Description of the protocol domain.
+         * Console message.
          */
-        export interface Domain {
+        export interface ConsoleMessage {
             /**
-             * Domain name.
+             * Message source.
              */
-            name: string;
+            source: string;
             /**
-             * Domain version.
+             * Message severity.
              */
-            version: string;
+            level: string;
+            /**
+             * Message text.
+             */
+            text: string;
+            /**
+             * URL of the message origin.
+             */
+            url?: string;
+            /**
+             * Line number in the resource that generated this message (1-based).
+             */
+            line?: number;
+            /**
+             * Column number in the resource that generated this message (1-based).
+             */
+            column?: number;
         }
 
-        export interface GetDomainsReturnType {
+        export interface MessageAddedEventDataType {
             /**
-             * List of supported domains.
+             * Console message that has been added.
              */
-            domains: Schema.Domain[];
+            message: Console.ConsoleMessage;
         }
     }
 
-    export namespace Runtime {
-        /**
-         * Unique script identifier.
-         */
-        export type ScriptId = string;
-
+    export namespace Debugger {
         /**
-         * Unique object identifier.
+         * Breakpoint identifier.
          */
-        export type RemoteObjectId = string;
+        export type BreakpointId = string;
 
         /**
-         * Primitive value which cannot be JSON-stringified.
+         * Call frame identifier.
          */
-        export type UnserializableValue = string;
+        export type CallFrameId = string;
 
         /**
-         * Mirror object referencing original JavaScript object.
+         * Location in the source code.
          */
-        export interface RemoteObject {
-            /**
-             * Object type.
-             */
-            type: string;
-            /**
-             * Object subtype hint. Specified for <code>object</code> type values only.
-             */
-            subtype?: string;
-            /**
-             * Object class (constructor) name. Specified for <code>object</code> type values only.
-             */
-            className?: string;
-            /**
-             * Remote object value in case of primitive values or JSON values (if it was requested).
-             */
-            value?: any;
-            /**
-             * Primitive value which can not be JSON-stringified does not have <code>value</code>, but gets this property.
-             */
-            unserializableValue?: Runtime.UnserializableValue;
-            /**
-             * String representation of the object.
-             */
-            description?: string;
+        export interface Location {
             /**
-             * Unique object identifier (for non-primitive values).
+             * Script identifier as reported in the `Debugger.scriptParsed`.
              */
-            objectId?: Runtime.RemoteObjectId;
+            scriptId: Runtime.ScriptId;
             /**
-             * Preview containing abbreviated property values. Specified for <code>object</code> type values only.
-             * @experimental
+             * Line number in the script (0-based).
              */
-            preview?: Runtime.ObjectPreview;
+            lineNumber: number;
             /**
-             * @experimental
+             * Column number in the script (0-based).
              */
-            customPreview?: Runtime.CustomPreview;
+            columnNumber?: number;
         }
 
         /**
+         * Location in the source code.
          * @experimental
          */
-        export interface CustomPreview {
-            header: string;
-            hasBody: boolean;
-            formatterObjectId: Runtime.RemoteObjectId;
-            bindRemoteObjectFunctionId: Runtime.RemoteObjectId;
-            configObjectId?: Runtime.RemoteObjectId;
+        export interface ScriptPosition {
+            lineNumber: number;
+            columnNumber: number;
         }
 
         /**
-         * Object containing abbreviated remote object value.
-         * @experimental
+         * JavaScript call frame. Array of call frames form the call stack.
          */
-        export interface ObjectPreview {
+        export interface CallFrame {
             /**
-             * Object type.
+             * Call frame identifier. This identifier is only valid while the virtual machine is paused.
              */
-            type: string;
+            callFrameId: Debugger.CallFrameId;
             /**
-             * Object subtype hint. Specified for <code>object</code> type values only.
+             * Name of the JavaScript function called on this call frame.
              */
-            subtype?: string;
+            functionName: string;
             /**
-             * String representation of the object.
+             * Location in the source code.
              */
-            description?: string;
+            functionLocation?: Debugger.Location;
             /**
-             * True iff some of the properties or entries of the original object did not fit.
+             * Location in the source code.
              */
-            overflow: boolean;
+            location: Debugger.Location;
             /**
-             * List of the properties.
+             * JavaScript script name or url.
              */
-            properties: Runtime.PropertyPreview[];
+            url: string;
             /**
-             * List of the entries. Specified for <code>map</code> and <code>set</code> subtype values only.
+             * Scope chain for this call frame.
              */
-            entries?: Runtime.EntryPreview[];
+            scopeChain: Debugger.Scope[];
+            /**
+             * `this` object for this call frame.
+             */
+            this: Runtime.RemoteObject;
+            /**
+             * The value being returned, if the function is at return point.
+             */
+            returnValue?: Runtime.RemoteObject;
         }
 
         /**
-         * @experimental
+         * Scope description.
          */
-        export interface PropertyPreview {
-            /**
-             * Property name.
-             */
-            name: string;
+        export interface Scope {
             /**
-             * Object type. Accessor means that the property itself is an accessor property.
+             * Scope type.
              */
             type: string;
             /**
-             * User-friendly property value string.
+             * Object representing the scope. For `global` and `with` scopes it represents the actual
+object; for the rest of the scopes, it is artificial transient object enumerating scope
+variables as its properties.
              */
-            value?: string;
+            object: Runtime.RemoteObject;
+            name?: string;
             /**
-             * Nested value preview.
+             * Location in the source code where scope starts
              */
-            valuePreview?: Runtime.ObjectPreview;
+            startLocation?: Debugger.Location;
             /**
-             * Object subtype hint. Specified for <code>object</code> type values only.
+             * Location in the source code where scope ends
              */
-            subtype?: string;
+            endLocation?: Debugger.Location;
         }
 
         /**
-         * @experimental
+         * Search match for resource.
          */
-        export interface EntryPreview {
+        export interface SearchMatch {
             /**
-             * Preview of the key. Specified for map-like collection entries.
+             * Line number in resource content.
              */
-            key?: Runtime.ObjectPreview;
+            lineNumber: number;
             /**
-             * Preview of the value.
+             * Line with match content.
              */
-            value: Runtime.ObjectPreview;
+            lineContent: string;
         }
 
-        /**
-         * Object property descriptor.
-         */
-        export interface PropertyDescriptor {
+        export interface BreakLocation {
             /**
-             * Property name or symbol description.
+             * Script identifier as reported in the `Debugger.scriptParsed`.
              */
-            name: string;
+            scriptId: Runtime.ScriptId;
             /**
-             * The value associated with the property.
+             * Line number in the script (0-based).
              */
-            value?: Runtime.RemoteObject;
+            lineNumber: number;
             /**
-             * True if the value associated with the property may be changed (data descriptors only).
+             * Column number in the script (0-based).
              */
-            writable?: boolean;
+            columnNumber?: number;
+            type?: string;
+        }
+
+        export interface ContinueToLocationParameterType {
             /**
-             * A function which serves as a getter for the property, or <code>undefined</code> if there is no getter (accessor descriptors only).
+             * Location to continue to.
              */
-            get?: Runtime.RemoteObject;
+            location: Debugger.Location;
+            targetCallFrames?: string;
+        }
+
+        export interface EvaluateOnCallFrameParameterType {
             /**
-             * A function which serves as a setter for the property, or <code>undefined</code> if there is no setter (accessor descriptors only).
+             * Call frame identifier to evaluate on.
              */
-            set?: Runtime.RemoteObject;
+            callFrameId: Debugger.CallFrameId;
             /**
-             * True if the type of this property descriptor may be changed and if the property may be deleted from the corresponding object.
+             * Expression to evaluate.
              */
-            configurable: boolean;
+            expression: string;
             /**
-             * True if this property shows up during enumeration of the properties on the corresponding object.
+             * String object group name to put result into (allows rapid releasing resulting object handles
+using `releaseObjectGroup`).
              */
-            enumerable: boolean;
+            objectGroup?: string;
             /**
-             * True if the result was thrown during the evaluation.
+             * Specifies whether command line API should be available to the evaluated expression, defaults
+to false.
              */
-            wasThrown?: boolean;
+            includeCommandLineAPI?: boolean;
             /**
-             * True if the property is owned for the object.
+             * In silent mode exceptions thrown during evaluation are not reported and do not pause
+execution. Overrides `setPauseOnException` state.
              */
-            isOwn?: boolean;
+            silent?: boolean;
             /**
-             * Property symbol object, if the property is of the <code>symbol</code> type.
+             * Whether the result is expected to be a JSON object that should be sent by value.
              */
-            symbol?: Runtime.RemoteObject;
-        }
-
-        /**
-         * Object internal property descriptor. This property isn't normally visible in JavaScript code.
-         */
-        export interface InternalPropertyDescriptor {
+            returnByValue?: boolean;
             /**
-             * Conventional property name.
+             * Whether preview should be generated for the result.
+             * @experimental
              */
-            name: string;
+            generatePreview?: boolean;
             /**
-             * The value associated with the property.
+             * Whether to throw an exception if side effect cannot be ruled out during evaluation.
              */
-            value?: Runtime.RemoteObject;
+            throwOnSideEffect?: boolean;
         }
 
-        /**
-         * Represents function call argument. Either remote object id <code>objectId</code>, primitive <code>value</code>, unserializable primitive value or neither of (for undefined) them should be specified.
-         */
-        export interface CallArgument {
+        export interface GetPossibleBreakpointsParameterType {
             /**
-             * Primitive value.
+             * Start of range to search possible breakpoint locations in.
              */
-            value?: any;
+            start: Debugger.Location;
             /**
-             * Primitive value which can not be JSON-stringified.
+             * End of range to search possible breakpoint locations in (excluding). When not specified, end
+of scripts is used as end of range.
              */
-            unserializableValue?: Runtime.UnserializableValue;
+            end?: Debugger.Location;
             /**
-             * Remote object handle.
+             * Only consider locations which are in the same (non-nested) function as start.
              */
-            objectId?: Runtime.RemoteObjectId;
+            restrictToFunction?: boolean;
         }
 
-        /**
-         * Id of an execution context.
-         */
-        export type ExecutionContextId = number;
-
-        /**
-         * Description of an isolated world.
-         */
-        export interface ExecutionContextDescription {
+        export interface GetScriptSourceParameterType {
             /**
-             * Unique id of the execution context. It can be used to specify in which execution context script evaluation should be performed.
+             * Id of the script to get source for.
              */
-            id: Runtime.ExecutionContextId;
+            scriptId: Runtime.ScriptId;
+        }
+
+        export interface GetStackTraceParameterType {
+            stackTraceId: Runtime.StackTraceId;
+        }
+
+        export interface PauseOnAsyncCallParameterType {
             /**
-             * Execution context origin.
+             * Debugger will pause when async call with given stack trace is started.
              */
-            origin: string;
-            /**
-             * Human readable name describing given context.
-             */
-            name: string;
-            /**
-             * Embedder-specific auxiliary data.
-             */
-            auxData?: {};
+            parentStackTraceId: Runtime.StackTraceId;
         }
 
-        /**
-         * Detailed information about exception (or error) that was thrown during script compilation or execution.
-         */
-        export interface ExceptionDetails {
-            /**
-             * Exception id.
-             */
-            exceptionId: number;
-            /**
-             * Exception text, which should be used together with exception object when available.
-             */
-            text: string;
-            /**
-             * Line number of the exception location (0-based).
-             */
-            lineNumber: number;
+        export interface RemoveBreakpointParameterType {
+            breakpointId: Debugger.BreakpointId;
+        }
+
+        export interface RestartFrameParameterType {
             /**
-             * Column number of the exception location (0-based).
+             * Call frame identifier to evaluate on.
              */
-            columnNumber: number;
+            callFrameId: Debugger.CallFrameId;
+        }
+
+        export interface SearchInContentParameterType {
             /**
-             * Script ID of the exception location.
+             * Id of the script to search in.
              */
-            scriptId?: Runtime.ScriptId;
+            scriptId: Runtime.ScriptId;
             /**
-             * URL of the exception location, to be used when the script was not reported.
+             * String to search for.
              */
-            url?: string;
+            query: string;
             /**
-             * JavaScript stack trace if available.
+             * If true, search is case sensitive.
              */
-            stackTrace?: Runtime.StackTrace;
+            caseSensitive?: boolean;
             /**
-             * Exception object if available.
+             * If true, treats string parameter as regex.
              */
-            exception?: Runtime.RemoteObject;
+            isRegex?: boolean;
+        }
+
+        export interface SetAsyncCallStackDepthParameterType {
             /**
-             * Identifier of the context where exception happened.
+             * Maximum depth of async call stacks. Setting to `0` will effectively disable collecting async
+call stacks (default).
              */
-            executionContextId?: Runtime.ExecutionContextId;
+            maxDepth: number;
         }
 
-        /**
-         * Number of milliseconds since epoch.
-         */
-        export type Timestamp = number;
-
-        /**
-         * Stack entry for runtime errors and assertions.
-         */
-        export interface CallFrame {
+        export interface SetBlackboxPatternsParameterType {
             /**
-             * JavaScript function name.
+             * Array of regexps that will be used to check script url for blackbox state.
              */
-            functionName: string;
+            patterns: string[];
+        }
+
+        export interface SetBlackboxedRangesParameterType {
             /**
-             * JavaScript script id.
+             * Id of the script.
              */
             scriptId: Runtime.ScriptId;
-            /**
-             * JavaScript script name or url.
-             */
-            url: string;
-            /**
-             * JavaScript script line number (0-based).
-             */
-            lineNumber: number;
-            /**
-             * JavaScript script column number (0-based).
-             */
-            columnNumber: number;
+            positions: Debugger.ScriptPosition[];
         }
 
-        /**
-         * Call frames for assertions or error messages.
-         */
-        export interface StackTrace {
-            /**
-             * String label of this stack trace. For async traces this may be a name of the function that initiated the async call.
-             */
-            description?: string;
-            /**
-             * JavaScript function name.
-             */
-            callFrames: Runtime.CallFrame[];
+        export interface SetBreakpointParameterType {
             /**
-             * Asynchronous JavaScript stack trace that preceded this stack, if available.
+             * Location to set breakpoint in.
              */
-            parent?: Runtime.StackTrace;
+            location: Debugger.Location;
             /**
-             * Creation frame of the Promise which produced the next synchronous trace when resolved, if available.
-             * @experimental
+             * Expression to use as a breakpoint condition. When specified, debugger will only stop on the
+breakpoint if this expression evaluates to true.
              */
-            promiseCreationFrame?: Runtime.CallFrame;
+            condition?: string;
         }
 
-        export interface EvaluateParameterType {
+        export interface SetBreakpointByUrlParameterType {
             /**
-             * Expression to evaluate.
+             * Line number to set breakpoint at.
              */
-            expression: string;
+            lineNumber: number;
             /**
-             * Symbolic group name that can be used to release multiple objects.
+             * URL of the resources to set breakpoint on.
              */
-            objectGroup?: string;
+            url?: string;
             /**
-             * Determines whether Command Line API should be available during the evaluation.
+             * Regex pattern for the URLs of the resources to set breakpoints on. Either `url` or
+`urlRegex` must be specified.
              */
-            includeCommandLineAPI?: boolean;
+            urlRegex?: string;
             /**
-             * In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides <code>setPauseOnException</code> state.
+             * Script hash of the resources to set breakpoint on.
              */
-            silent?: boolean;
+            scriptHash?: string;
             /**
-             * Specifies in which execution context to perform evaluation. If the parameter is omitted the evaluation will be performed in the context of the inspected page.
+             * Offset in the line to set breakpoint at.
              */
-            contextId?: Runtime.ExecutionContextId;
+            columnNumber?: number;
             /**
-             * Whether the result is expected to be a JSON object that should be sent by value.
+             * Expression to use as a breakpoint condition. When specified, debugger will only stop on the
+breakpoint if this expression evaluates to true.
              */
-            returnByValue?: boolean;
+            condition?: string;
+        }
+
+        export interface SetBreakpointsActiveParameterType {
             /**
-             * Whether preview should be generated for the result.
-             * @experimental
+             * New value for breakpoints active state.
              */
-            generatePreview?: boolean;
+            active: boolean;
+        }
+
+        export interface SetPauseOnExceptionsParameterType {
             /**
-             * Whether execution should be treated as initiated by user in the UI.
-             * @experimental
+             * Pause on exceptions mode.
              */
-            userGesture?: boolean;
+            state: string;
+        }
+
+        export interface SetReturnValueParameterType {
             /**
-             * Whether execution should wait for promise to be resolved. If the result of evaluation is not a Promise, it's considered to be an error.
+             * New return value.
              */
-            awaitPromise?: boolean;
+            newValue: Runtime.CallArgument;
         }
 
-        export interface AwaitPromiseParameterType {
+        export interface SetScriptSourceParameterType {
             /**
-             * Identifier of the promise.
+             * Id of the script to edit.
              */
-            promiseObjectId: Runtime.RemoteObjectId;
+            scriptId: Runtime.ScriptId;
             /**
-             * Whether the result is expected to be a JSON object that should be sent by value.
+             * New content of the script.
              */
-            returnByValue?: boolean;
+            scriptSource: string;
             /**
-             * Whether preview should be generated for the result.
+             * If true the change will not actually be applied. Dry run may be used to get result
+description without actually modifying the code.
              */
-            generatePreview?: boolean;
+            dryRun?: boolean;
         }
 
-        export interface CallFunctionOnParameterType {
+        export interface SetSkipAllPausesParameterType {
             /**
-             * Identifier of the object to call function on.
+             * New value for skip pauses state.
              */
-            objectId: Runtime.RemoteObjectId;
+            skip: boolean;
+        }
+
+        export interface SetVariableValueParameterType {
             /**
-             * Declaration of the function to call.
+             * 0-based number of scope as was listed in scope chain. Only 'local', 'closure' and 'catch'
+scope types are allowed. Other scopes could be manipulated manually.
              */
-            functionDeclaration: string;
+            scopeNumber: number;
             /**
-             * Call arguments. All call arguments must belong to the same JavaScript world as the target object.
+             * Variable name.
              */
-            arguments?: Runtime.CallArgument[];
+            variableName: string;
             /**
-             * In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides <code>setPauseOnException</code> state.
+             * New variable value.
              */
-            silent?: boolean;
+            newValue: Runtime.CallArgument;
             /**
-             * Whether the result is expected to be a JSON object which should be sent by value.
+             * Id of callframe that holds variable.
              */
-            returnByValue?: boolean;
+            callFrameId: Debugger.CallFrameId;
+        }
+
+        export interface StepIntoParameterType {
             /**
-             * Whether preview should be generated for the result.
+             * Debugger will issue additional Debugger.paused notification if any async task is scheduled
+before next pause.
              * @experimental
              */
-            generatePreview?: boolean;
+            breakOnAsyncCall?: boolean;
+        }
+
+        export interface EnableReturnType {
             /**
-             * Whether execution should be treated as initiated by user in the UI.
+             * Unique identifier of the debugger.
              * @experimental
              */
-            userGesture?: boolean;
-            /**
-             * Whether execution should wait for promise to be resolved. If the result of evaluation is not a Promise, it's considered to be an error.
-             */
-            awaitPromise?: boolean;
+            debuggerId: Runtime.UniqueDebuggerId;
         }
 
-        export interface GetPropertiesParameterType {
-            /**
-             * Identifier of the object to return properties for.
-             */
-            objectId: Runtime.RemoteObjectId;
-            /**
-             * If true, returns properties belonging only to the element itself, not to its prototype chain.
-             */
-            ownProperties?: boolean;
+        export interface EvaluateOnCallFrameReturnType {
             /**
-             * If true, returns accessor properties (with getter/setter) only; internal properties are not returned either.
-             * @experimental
+             * Object wrapper for the evaluation result.
              */
-            accessorPropertiesOnly?: boolean;
+            result: Runtime.RemoteObject;
             /**
-             * Whether preview should be generated for the results.
-             * @experimental
+             * Exception details.
              */
-            generatePreview?: boolean;
+            exceptionDetails?: Runtime.ExceptionDetails;
         }
 
-        export interface ReleaseObjectParameterType {
+        export interface GetPossibleBreakpointsReturnType {
             /**
-             * Identifier of the object to release.
+             * List of the possible breakpoint locations.
              */
-            objectId: Runtime.RemoteObjectId;
+            locations: Debugger.BreakLocation[];
         }
 
-        export interface ReleaseObjectGroupParameterType {
+        export interface GetScriptSourceReturnType {
             /**
-             * Symbolic object group name.
+             * Script source.
              */
-            objectGroup: string;
+            scriptSource: string;
         }
 
-        export interface SetCustomObjectFormatterEnabledParameterType {
-            enabled: boolean;
+        export interface GetStackTraceReturnType {
+            stackTrace: Runtime.StackTrace;
         }
 
-        export interface CompileScriptParameterType {
+        export interface RestartFrameReturnType {
             /**
-             * Expression to compile.
+             * New stack trace.
              */
-            expression: string;
+            callFrames: Debugger.CallFrame[];
             /**
-             * Source url to be set for the script.
+             * Async stack trace, if any.
              */
-            sourceURL: string;
+            asyncStackTrace?: Runtime.StackTrace;
             /**
-             * Specifies whether the compiled script should be persisted.
+             * Async stack trace, if any.
+             * @experimental
              */
-            persistScript: boolean;
+            asyncStackTraceId?: Runtime.StackTraceId;
+        }
+
+        export interface SearchInContentReturnType {
             /**
-             * Specifies in which execution context to perform script run. If the parameter is omitted the evaluation will be performed in the context of the inspected page.
+             * List of search matches.
              */
-            executionContextId?: Runtime.ExecutionContextId;
+            result: Debugger.SearchMatch[];
         }
 
-        export interface RunScriptParameterType {
+        export interface SetBreakpointReturnType {
             /**
-             * Id of the script to run.
+             * Id of the created breakpoint for further reference.
              */
-            scriptId: Runtime.ScriptId;
+            breakpointId: Debugger.BreakpointId;
             /**
-             * Specifies in which execution context to perform script run. If the parameter is omitted the evaluation will be performed in the context of the inspected page.
+             * Location this breakpoint resolved into.
              */
-            executionContextId?: Runtime.ExecutionContextId;
+            actualLocation: Debugger.Location;
+        }
+
+        export interface SetBreakpointByUrlReturnType {
             /**
-             * Symbolic group name that can be used to release multiple objects.
-             */
-            objectGroup?: string;
-            /**
-             * In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides <code>setPauseOnException</code> state.
+             * Id of the created breakpoint for further reference.
              */
-            silent?: boolean;
+            breakpointId: Debugger.BreakpointId;
             /**
-             * Determines whether Command Line API should be available during the evaluation.
+             * List of the locations this breakpoint resolved into upon addition.
              */
-            includeCommandLineAPI?: boolean;
+            locations: Debugger.Location[];
+        }
+
+        export interface SetScriptSourceReturnType {
             /**
-             * Whether the result is expected to be a JSON object which should be sent by value.
+             * New stack trace in case editing has happened while VM was stopped.
              */
-            returnByValue?: boolean;
+            callFrames?: Debugger.CallFrame[];
             /**
-             * Whether preview should be generated for the result.
+             * Whether current call stack  was modified after applying the changes.
              */
-            generatePreview?: boolean;
+            stackChanged?: boolean;
             /**
-             * Whether execution should wait for promise to be resolved. If the result of evaluation is not a Promise, it's considered to be an error.
+             * Async stack trace, if any.
              */
-            awaitPromise?: boolean;
-        }
-
-        export interface EvaluateReturnType {
+            asyncStackTrace?: Runtime.StackTrace;
             /**
-             * Evaluation result.
+             * Async stack trace, if any.
+             * @experimental
              */
-            result: Runtime.RemoteObject;
+            asyncStackTraceId?: Runtime.StackTraceId;
             /**
-             * Exception details.
+             * Exception details if any.
              */
             exceptionDetails?: Runtime.ExceptionDetails;
         }
 
-        export interface AwaitPromiseReturnType {
+        export interface BreakpointResolvedEventDataType {
             /**
-             * Promise result. Will contain rejected value if promise was rejected.
+             * Breakpoint unique identifier.
              */
-            result: Runtime.RemoteObject;
+            breakpointId: Debugger.BreakpointId;
             /**
-             * Exception details if stack strace is available.
+             * Actual breakpoint location.
              */
-            exceptionDetails?: Runtime.ExceptionDetails;
+            location: Debugger.Location;
         }
 
-        export interface CallFunctionOnReturnType {
+        export interface PausedEventDataType {
             /**
-             * Call result.
+             * Call stack the virtual machine stopped on.
              */
-            result: Runtime.RemoteObject;
+            callFrames: Debugger.CallFrame[];
             /**
-             * Exception details.
+             * Pause reason.
              */
-            exceptionDetails?: Runtime.ExceptionDetails;
-        }
-
-        export interface GetPropertiesReturnType {
+            reason: string;
             /**
-             * Object properties.
+             * Object containing break-specific auxiliary properties.
              */
-            result: Runtime.PropertyDescriptor[];
+            data?: {};
             /**
-             * Internal object properties (only of the element itself).
+             * Hit breakpoints IDs
              */
-            internalProperties?: Runtime.InternalPropertyDescriptor[];
+            hitBreakpoints?: string[];
             /**
-             * Exception details.
+             * Async stack trace, if any.
              */
-            exceptionDetails?: Runtime.ExceptionDetails;
-        }
-
-        export interface CompileScriptReturnType {
+            asyncStackTrace?: Runtime.StackTrace;
             /**
-             * Id of the script.
+             * Async stack trace, if any.
+             * @experimental
              */
-            scriptId?: Runtime.ScriptId;
+            asyncStackTraceId?: Runtime.StackTraceId;
             /**
-             * Exception details.
+             * Just scheduled async call will have this stack trace as parent stack during async execution.
+This field is available only after `Debugger.stepInto` call with `breakOnAsynCall` flag.
+             * @experimental
              */
-            exceptionDetails?: Runtime.ExceptionDetails;
+            asyncCallStackTraceId?: Runtime.StackTraceId;
         }
 
-        export interface RunScriptReturnType {
+        export interface ScriptFailedToParseEventDataType {
             /**
-             * Run result.
+             * Identifier of the script parsed.
              */
-            result: Runtime.RemoteObject;
+            scriptId: Runtime.ScriptId;
             /**
-             * Exception details.
+             * URL or name of the script parsed (if any).
              */
-            exceptionDetails?: Runtime.ExceptionDetails;
-        }
-
-        export interface ExecutionContextCreatedEventDataType {
+            url: string;
             /**
-             * A newly created execution context.
+             * Line offset of the script within the resource with given URL (for script tags).
              */
-            context: Runtime.ExecutionContextDescription;
-        }
-
-        export interface ExecutionContextDestroyedEventDataType {
+            startLine: number;
             /**
-             * Id of the destroyed context
+             * Column offset of the script within the resource with given URL.
              */
-            executionContextId: Runtime.ExecutionContextId;
-        }
-
-        export interface ExceptionThrownEventDataType {
+            startColumn: number;
             /**
-             * Timestamp of the exception.
+             * Last line of the script.
              */
-            timestamp: Runtime.Timestamp;
-            exceptionDetails: Runtime.ExceptionDetails;
-        }
-
-        export interface ExceptionRevokedEventDataType {
+            endLine: number;
             /**
-             * Reason describing why exception was revoked.
+             * Length of the last line of the script.
              */
-            reason: string;
+            endColumn: number;
             /**
-             * The id of revoked exception, as reported in <code>exceptionUnhandled</code>.
+             * Specifies script creation context.
              */
-            exceptionId: number;
-        }
-
-        export interface ConsoleAPICalledEventDataType {
+            executionContextId: Runtime.ExecutionContextId;
             /**
-             * Type of the call.
+             * Content hash of the script.
              */
-            type: string;
+            hash: string;
             /**
-             * Call arguments.
+             * Embedder-specific auxiliary data.
              */
-            args: Runtime.RemoteObject[];
+            executionContextAuxData?: {};
             /**
-             * Identifier of the context where the call was made.
+             * URL of source map associated with script (if any).
              */
-            executionContextId: Runtime.ExecutionContextId;
+            sourceMapURL?: string;
             /**
-             * Call timestamp.
+             * True, if this script has sourceURL.
              */
-            timestamp: Runtime.Timestamp;
+            hasSourceURL?: boolean;
             /**
-             * Stack trace captured when the call was made.
+             * True, if this script is ES6 module.
              */
-            stackTrace?: Runtime.StackTrace;
+            isModule?: boolean;
+            /**
+             * This script length.
+             */
+            length?: number;
             /**
-             * Console context descriptor for calls on non-default console context (not console.*): 'anonymous#unique-logger-id' for call on unnamed context, 'name#unique-logger-id' for call on named context.
+             * JavaScript top stack frame of where the script parsed event was triggered if available.
              * @experimental
              */
-            context?: string;
-        }
-
-        export interface InspectRequestedEventDataType {
-            object: Runtime.RemoteObject;
-            hints: {};
+            stackTrace?: Runtime.StackTrace;
         }
-    }
-
-    export namespace Debugger {
-        /**
-         * Breakpoint identifier.
-         */
-        export type BreakpointId = string;
-
-        /**
-         * Call frame identifier.
-         */
-        export type CallFrameId = string;
 
-        /**
-         * Location in the source code.
-         */
-        export interface Location {
+        export interface ScriptParsedEventDataType {
             /**
-             * Script identifier as reported in the <code>Debugger.scriptParsed</code>.
+             * Identifier of the script parsed.
              */
             scriptId: Runtime.ScriptId;
             /**
-             * Line number in the script (0-based).
+             * URL or name of the script parsed (if any).
              */
-            lineNumber: number;
+            url: string;
             /**
-             * Column number in the script (0-based).
+             * Line offset of the script within the resource with given URL (for script tags).
              */
-            columnNumber?: number;
-        }
-
-        /**
-         * Location in the source code.
-         * @experimental
-         */
-        export interface ScriptPosition {
-            lineNumber: number;
-            columnNumber: number;
-        }
-
-        /**
-         * JavaScript call frame. Array of call frames form the call stack.
-         */
-        export interface CallFrame {
+            startLine: number;
             /**
-             * Call frame identifier. This identifier is only valid while the virtual machine is paused.
+             * Column offset of the script within the resource with given URL.
              */
-            callFrameId: Debugger.CallFrameId;
+            startColumn: number;
             /**
-             * Name of the JavaScript function called on this call frame.
+             * Last line of the script.
              */
-            functionName: string;
+            endLine: number;
             /**
-             * Location in the source code.
-             * @experimental
+             * Length of the last line of the script.
              */
-            functionLocation?: Debugger.Location;
+            endColumn: number;
             /**
-             * Location in the source code.
+             * Specifies script creation context.
              */
-            location: Debugger.Location;
+            executionContextId: Runtime.ExecutionContextId;
             /**
-             * Scope chain for this call frame.
+             * Content hash of the script.
              */
-            scopeChain: Debugger.Scope[];
+            hash: string;
             /**
-             * <code>this</code> object for this call frame.
+             * Embedder-specific auxiliary data.
              */
-            this: Runtime.RemoteObject;
+            executionContextAuxData?: {};
             /**
-             * The value being returned, if the function is at return point.
+             * True, if this script is generated as a result of the live edit operation.
+             * @experimental
              */
-            returnValue?: Runtime.RemoteObject;
-        }
-
-        /**
-         * Scope description.
-         */
-        export interface Scope {
+            isLiveEdit?: boolean;
             /**
-             * Scope type.
+             * URL of source map associated with script (if any).
              */
-            type: string;
+            sourceMapURL?: string;
             /**
-             * Object representing the scope. For <code>global</code> and <code>with</code> scopes it represents the actual object; for the rest of the scopes, it is artificial transient object enumerating scope variables as its properties.
+             * True, if this script has sourceURL.
              */
-            object: Runtime.RemoteObject;
-            name?: string;
+            hasSourceURL?: boolean;
             /**
-             * Location in the source code where scope starts
+             * True, if this script is ES6 module.
              */
-            startLocation?: Debugger.Location;
+            isModule?: boolean;
             /**
-             * Location in the source code where scope ends
+             * This script length.
              */
-            endLocation?: Debugger.Location;
+            length?: number;
+            /**
+             * JavaScript top stack frame of where the script parsed event was triggered if available.
+             * @experimental
+             */
+            stackTrace?: Runtime.StackTrace;
         }
+    }
 
+    export namespace HeapProfiler {
         /**
-         * Search match for resource.
-         * @experimental
+         * Heap snapshot object id.
          */
-        export interface SearchMatch {
+        export type HeapSnapshotObjectId = string;
+
+        /**
+         * Sampling Heap Profile node. Holds callsite information, allocation statistics and child nodes.
+         */
+        export interface SamplingHeapProfileNode {
             /**
-             * Line number in resource content.
+             * Function location.
              */
-            lineNumber: number;
+            callFrame: Runtime.CallFrame;
             /**
-             * Line with match content.
+             * Allocations size in bytes for the node excluding children.
              */
-            lineContent: string;
+            selfSize: number;
+            /**
+             * Child nodes.
+             */
+            children: HeapProfiler.SamplingHeapProfileNode[];
         }
 
         /**
-         * @experimental
+         * Profile.
          */
-        export interface BreakLocation {
-            /**
-             * Script identifier as reported in the <code>Debugger.scriptParsed</code>.
-             */
-            scriptId: Runtime.ScriptId;
+        export interface SamplingHeapProfile {
+            head: HeapProfiler.SamplingHeapProfileNode;
+        }
+
+        export interface AddInspectedHeapObjectParameterType {
             /**
-             * Line number in the script (0-based).
+             * Heap snapshot object id to be accessible by means of $x command line API.
              */
-            lineNumber: number;
+            heapObjectId: HeapProfiler.HeapSnapshotObjectId;
+        }
+
+        export interface GetHeapObjectIdParameterType {
             /**
-             * Column number in the script (0-based).
+             * Identifier of the object to get heap object id for.
              */
-            columnNumber?: number;
-            type?: string;
+            objectId: Runtime.RemoteObjectId;
         }
 
-        export interface SetBreakpointsActiveParameterType {
+        export interface GetObjectByHeapObjectIdParameterType {
+            objectId: HeapProfiler.HeapSnapshotObjectId;
             /**
-             * New value for breakpoints active state.
+             * Symbolic group name that can be used to release multiple objects.
              */
-            active: boolean;
+            objectGroup?: string;
         }
 
-        export interface SetSkipAllPausesParameterType {
+        export interface StartSamplingParameterType {
             /**
-             * New value for skip pauses state.
+             * Average sample interval in bytes. Poisson distribution is used for the intervals. The
+default value is 32768 bytes.
              */
-            skip: boolean;
+            samplingInterval?: number;
         }
 
-        export interface SetBreakpointByUrlParameterType {
+        export interface StartTrackingHeapObjectsParameterType {
+            trackAllocations?: boolean;
+        }
+
+        export interface StopTrackingHeapObjectsParameterType {
             /**
-             * Line number to set breakpoint at.
+             * If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken
+when the tracking is stopped.
              */
-            lineNumber: number;
+            reportProgress?: boolean;
+        }
+
+        export interface TakeHeapSnapshotParameterType {
             /**
-             * URL of the resources to set breakpoint on.
+             * If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken.
              */
-            url?: string;
+            reportProgress?: boolean;
+        }
+
+        export interface GetHeapObjectIdReturnType {
             /**
-             * Regex pattern for the URLs of the resources to set breakpoints on. Either <code>url</code> or <code>urlRegex</code> must be specified.
+             * Id of the heap snapshot object corresponding to the passed remote object id.
              */
-            urlRegex?: string;
+            heapSnapshotObjectId: HeapProfiler.HeapSnapshotObjectId;
+        }
+
+        export interface GetObjectByHeapObjectIdReturnType {
             /**
-             * Offset in the line to set breakpoint at.
+             * Evaluation result.
              */
-            columnNumber?: number;
+            result: Runtime.RemoteObject;
+        }
+
+        export interface GetSamplingProfileReturnType {
             /**
-             * Expression to use as a breakpoint condition. When specified, debugger will only stop on the breakpoint if this expression evaluates to true.
+             * Return the sampling profile being collected.
              */
-            condition?: string;
+            profile: HeapProfiler.SamplingHeapProfile;
         }
 
-        export interface SetBreakpointParameterType {
+        export interface StopSamplingReturnType {
             /**
-             * Location to set breakpoint in.
+             * Recorded sampling heap profile.
              */
-            location: Debugger.Location;
+            profile: HeapProfiler.SamplingHeapProfile;
+        }
+
+        export interface AddHeapSnapshotChunkEventDataType {
+            chunk: string;
+        }
+
+        export interface HeapStatsUpdateEventDataType {
             /**
-             * Expression to use as a breakpoint condition. When specified, debugger will only stop on the breakpoint if this expression evaluates to true.
+             * An array of triplets. Each triplet describes a fragment. The first integer is the fragment
+index, the second integer is a total count of objects for the fragment, the third integer is
+a total size of the objects for the fragment.
              */
-            condition?: string;
+            statsUpdate: number[];
         }
 
-        export interface RemoveBreakpointParameterType {
-            breakpointId: Debugger.BreakpointId;
+        export interface LastSeenObjectIdEventDataType {
+            lastSeenObjectId: number;
+            timestamp: number;
         }
 
-        export interface GetPossibleBreakpointsParameterType {
+        export interface ReportHeapSnapshotProgressEventDataType {
+            done: number;
+            total: number;
+            finished?: boolean;
+        }
+    }
+
+    export namespace Profiler {
+        /**
+         * Profile node. Holds callsite information, execution statistics and child nodes.
+         */
+        export interface ProfileNode {
             /**
-             * Start of range to search possible breakpoint locations in.
+             * Unique id of the node.
              */
-            start: Debugger.Location;
+            id: number;
             /**
-             * End of range to search possible breakpoint locations in (excluding). When not specified, end of scripts is used as end of range.
+             * Function location.
              */
-            end?: Debugger.Location;
+            callFrame: Runtime.CallFrame;
             /**
-             * Only consider locations which are in the same (non-nested) function as start.
+             * Number of samples where this node was on top of the call stack.
              */
-            restrictToFunction?: boolean;
-        }
-
-        export interface ContinueToLocationParameterType {
+            hitCount?: number;
             /**
-             * Location to continue to.
+             * Child node ids.
              */
-            location: Debugger.Location;
+            children?: number[];
             /**
-             * @experimental
+             * The reason of being not optimized. The function may be deoptimized or marked as don't
+optimize.
              */
-            targetCallFrames?: string;
+            deoptReason?: string;
+            /**
+             * An array of source position ticks.
+             */
+            positionTicks?: Profiler.PositionTickInfo[];
         }
 
-        export interface SearchInContentParameterType {
+        /**
+         * Profile.
+         */
+        export interface Profile {
             /**
-             * Id of the script to search in.
+             * The list of profile nodes. First item is the root node.
              */
-            scriptId: Runtime.ScriptId;
+            nodes: Profiler.ProfileNode[];
             /**
-             * String to search for.
+             * Profiling start timestamp in microseconds.
              */
-            query: string;
+            startTime: number;
             /**
-             * If true, search is case sensitive.
+             * Profiling end timestamp in microseconds.
              */
-            caseSensitive?: boolean;
+            endTime: number;
             /**
-             * If true, treats string parameter as regex.
+             * Ids of samples top nodes.
              */
-            isRegex?: boolean;
+            samples?: number[];
+            /**
+             * Time intervals between adjacent samples in microseconds. The first delta is relative to the
+profile startTime.
+             */
+            timeDeltas?: number[];
         }
 
-        export interface SetScriptSourceParameterType {
+        /**
+         * Specifies a number of samples attributed to a certain source position.
+         */
+        export interface PositionTickInfo {
             /**
-             * Id of the script to edit.
+             * Source line number (1-based).
              */
-            scriptId: Runtime.ScriptId;
+            line: number;
             /**
-             * New content of the script.
+             * Number of samples attributed to the source line.
              */
-            scriptSource: string;
+            ticks: number;
+        }
+
+        /**
+         * Coverage data for a source range.
+         */
+        export interface CoverageRange {
             /**
-             *  If true the change will not actually be applied. Dry run may be used to get result description without actually modifying the code.
+             * JavaScript script source offset for the range start.
              */
-            dryRun?: boolean;
+            startOffset: number;
+            /**
+             * JavaScript script source offset for the range end.
+             */
+            endOffset: number;
+            /**
+             * Collected execution count of the source range.
+             */
+            count: number;
         }
 
-        export interface RestartFrameParameterType {
+        /**
+         * Coverage data for a JavaScript function.
+         */
+        export interface FunctionCoverage {
             /**
-             * Call frame identifier to evaluate on.
+             * JavaScript function name.
              */
-            callFrameId: Debugger.CallFrameId;
+            functionName: string;
+            /**
+             * Source ranges inside the function with coverage data.
+             */
+            ranges: Profiler.CoverageRange[];
+            /**
+             * Whether coverage data for this function has block granularity.
+             */
+            isBlockCoverage: boolean;
         }
 
-        export interface GetScriptSourceParameterType {
+        /**
+         * Coverage data for a JavaScript script.
+         */
+        export interface ScriptCoverage {
             /**
-             * Id of the script to get source for.
+             * JavaScript script id.
              */
             scriptId: Runtime.ScriptId;
+            /**
+             * JavaScript script name or url.
+             */
+            url: string;
+            /**
+             * Functions contained in the script that has coverage data.
+             */
+            functions: Profiler.FunctionCoverage[];
         }
 
-        export interface SetPauseOnExceptionsParameterType {
+        /**
+         * Describes a type collected during runtime.
+         * @experimental
+         */
+        export interface TypeObject {
             /**
-             * Pause on exceptions mode.
+             * Name of a type collected with type profiling.
              */
-            state: string;
+            name: string;
         }
 
-        export interface EvaluateOnCallFrameParameterType {
+        /**
+         * Source offset and types for a parameter or return value.
+         * @experimental
+         */
+        export interface TypeProfileEntry {
             /**
-             * Call frame identifier to evaluate on.
+             * Source offset of the parameter or end of function for return values.
              */
-            callFrameId: Debugger.CallFrameId;
+            offset: number;
             /**
-             * Expression to evaluate.
+             * The types for this parameter or return value.
              */
-            expression: string;
+            types: Profiler.TypeObject[];
+        }
+
+        /**
+         * Type profile data collected during runtime for a JavaScript script.
+         * @experimental
+         */
+        export interface ScriptTypeProfile {
             /**
-             * String object group name to put result into (allows rapid releasing resulting object handles using <code>releaseObjectGroup</code>).
+             * JavaScript script id.
              */
-            objectGroup?: string;
+            scriptId: Runtime.ScriptId;
             /**
-             * Specifies whether command line API should be available to the evaluated expression, defaults to false.
+             * JavaScript script name or url.
              */
-            includeCommandLineAPI?: boolean;
+            url: string;
             /**
-             * In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides <code>setPauseOnException</code> state.
+             * Type profile entries for parameters and return values of the functions in the script.
              */
-            silent?: boolean;
+            entries: Profiler.TypeProfileEntry[];
+        }
+
+        export interface SetSamplingIntervalParameterType {
             /**
-             * Whether the result is expected to be a JSON object that should be sent by value.
+             * New sampling interval in microseconds.
              */
-            returnByValue?: boolean;
+            interval: number;
+        }
+
+        export interface StartPreciseCoverageParameterType {
             /**
-             * Whether preview should be generated for the result.
-             * @experimental
+             * Collect accurate call counts beyond simple 'covered' or 'not covered'.
              */
-            generatePreview?: boolean;
+            callCount?: boolean;
             /**
-             * Whether to throw an exception if side effect cannot be ruled out during evaluation.
-             * @experimental
+             * Collect block-based coverage.
              */
-            throwOnSideEffect?: boolean;
+            detailed?: boolean;
         }
 
-        export interface SetVariableValueParameterType {
-            /**
-             * 0-based number of scope as was listed in scope chain. Only 'local', 'closure' and 'catch' scope types are allowed. Other scopes could be manipulated manually.
-             */
-            scopeNumber: number;
+        export interface GetBestEffortCoverageReturnType {
             /**
-             * Variable name.
+             * Coverage data for the current isolate.
              */
-            variableName: string;
+            result: Profiler.ScriptCoverage[];
+        }
+
+        export interface StopReturnType {
             /**
-             * New variable value.
+             * Recorded profile.
              */
-            newValue: Runtime.CallArgument;
+            profile: Profiler.Profile;
+        }
+
+        export interface TakePreciseCoverageReturnType {
             /**
-             * Id of callframe that holds variable.
+             * Coverage data for the current isolate.
              */
-            callFrameId: Debugger.CallFrameId;
+            result: Profiler.ScriptCoverage[];
         }
 
-        export interface SetAsyncCallStackDepthParameterType {
+        export interface TakeTypeProfileReturnType {
             /**
-             * Maximum depth of async call stacks. Setting to <code>0</code> will effectively disable collecting async call stacks (default).
+             * Type profile for all scripts since startTypeProfile() was turned on.
              */
-            maxDepth: number;
+            result: Profiler.ScriptTypeProfile[];
         }
 
-        export interface SetBlackboxPatternsParameterType {
+        export interface ConsoleProfileFinishedEventDataType {
+            id: string;
             /**
-             * Array of regexps that will be used to check script url for blackbox state.
+             * Location of console.profileEnd().
              */
-            patterns: string[];
+            location: Debugger.Location;
+            profile: Profiler.Profile;
+            /**
+             * Profile title passed as an argument to console.profile().
+             */
+            title?: string;
         }
 
-        export interface SetBlackboxedRangesParameterType {
+        export interface ConsoleProfileStartedEventDataType {
+            id: string;
             /**
-             * Id of the script.
+             * Location of console.profile().
              */
-            scriptId: Runtime.ScriptId;
-            positions: Debugger.ScriptPosition[];
+            location: Debugger.Location;
+            /**
+             * Profile title passed as an argument to console.profile().
+             */
+            title?: string;
         }
+    }
 
-        export interface SetBreakpointByUrlReturnType {
+    export namespace Runtime {
+        /**
+         * Unique script identifier.
+         */
+        export type ScriptId = string;
+
+        /**
+         * Unique object identifier.
+         */
+        export type RemoteObjectId = string;
+
+        /**
+         * Primitive value which cannot be JSON-stringified. Includes values `-0`, `NaN`, `Infinity`,
+`-Infinity`, and bigint literals.
+         */
+        export type UnserializableValue = string;
+
+        /**
+         * Mirror object referencing original JavaScript object.
+         */
+        export interface RemoteObject {
             /**
-             * Id of the created breakpoint for further reference.
+             * Object type.
              */
-            breakpointId: Debugger.BreakpointId;
+            type: string;
             /**
-             * List of the locations this breakpoint resolved into upon addition.
+             * Object subtype hint. Specified for `object` type values only.
              */
-            locations: Debugger.Location[];
+            subtype?: string;
+            /**
+             * Object class (constructor) name. Specified for `object` type values only.
+             */
+            className?: string;
+            /**
+             * Remote object value in case of primitive values or JSON values (if it was requested).
+             */
+            value?: any;
+            /**
+             * Primitive value which can not be JSON-stringified does not have `value`, but gets this
+property.
+             */
+            unserializableValue?: Runtime.UnserializableValue;
+            /**
+             * String representation of the object.
+             */
+            description?: string;
+            /**
+             * Unique object identifier (for non-primitive values).
+             */
+            objectId?: Runtime.RemoteObjectId;
+            /**
+             * Preview containing abbreviated property values. Specified for `object` type values only.
+             * @experimental
+             */
+            preview?: Runtime.ObjectPreview;
+            /**
+             * @experimental
+             */
+            customPreview?: Runtime.CustomPreview;
         }
 
-        export interface SetBreakpointReturnType {
+        /**
+         * @experimental
+         */
+        export interface CustomPreview {
+            header: string;
+            hasBody: boolean;
+            formatterObjectId: Runtime.RemoteObjectId;
+            bindRemoteObjectFunctionId: Runtime.RemoteObjectId;
+            configObjectId?: Runtime.RemoteObjectId;
+        }
+
+        /**
+         * Object containing abbreviated remote object value.
+         * @experimental
+         */
+        export interface ObjectPreview {
             /**
-             * Id of the created breakpoint for further reference.
+             * Object type.
              */
-            breakpointId: Debugger.BreakpointId;
+            type: string;
             /**
-             * Location this breakpoint resolved into.
+             * Object subtype hint. Specified for `object` type values only.
              */
-            actualLocation: Debugger.Location;
+            subtype?: string;
+            /**
+             * String representation of the object.
+             */
+            description?: string;
+            /**
+             * True iff some of the properties or entries of the original object did not fit.
+             */
+            overflow: boolean;
+            /**
+             * List of the properties.
+             */
+            properties: Runtime.PropertyPreview[];
+            /**
+             * List of the entries. Specified for `map` and `set` subtype values only.
+             */
+            entries?: Runtime.EntryPreview[];
         }
 
-        export interface GetPossibleBreakpointsReturnType {
+        /**
+         * @experimental
+         */
+        export interface PropertyPreview {
             /**
-             * List of the possible breakpoint locations.
+             * Property name.
              */
-            locations: Debugger.BreakLocation[];
+            name: string;
+            /**
+             * Object type. Accessor means that the property itself is an accessor property.
+             */
+            type: string;
+            /**
+             * User-friendly property value string.
+             */
+            value?: string;
+            /**
+             * Nested value preview.
+             */
+            valuePreview?: Runtime.ObjectPreview;
+            /**
+             * Object subtype hint. Specified for `object` type values only.
+             */
+            subtype?: string;
         }
 
-        export interface SearchInContentReturnType {
+        /**
+         * @experimental
+         */
+        export interface EntryPreview {
             /**
-             * List of search matches.
+             * Preview of the key. Specified for map-like collection entries.
              */
-            result: Debugger.SearchMatch[];
+            key?: Runtime.ObjectPreview;
+            /**
+             * Preview of the value.
+             */
+            value: Runtime.ObjectPreview;
         }
 
-        export interface SetScriptSourceReturnType {
+        /**
+         * Object property descriptor.
+         */
+        export interface PropertyDescriptor {
             /**
-             * New stack trace in case editing has happened while VM was stopped.
+             * Property name or symbol description.
              */
-            callFrames?: Debugger.CallFrame[];
+            name: string;
             /**
-             * Whether current call stack  was modified after applying the changes.
+             * The value associated with the property.
              */
-            stackChanged?: boolean;
+            value?: Runtime.RemoteObject;
             /**
-             * Async stack trace, if any.
+             * True if the value associated with the property may be changed (data descriptors only).
              */
-            asyncStackTrace?: Runtime.StackTrace;
+            writable?: boolean;
             /**
-             * Exception details if any.
+             * A function which serves as a getter for the property, or `undefined` if there is no getter
+(accessor descriptors only).
              */
-            exceptionDetails?: Runtime.ExceptionDetails;
-        }
-
-        export interface RestartFrameReturnType {
+            get?: Runtime.RemoteObject;
             /**
-             * New stack trace.
+             * A function which serves as a setter for the property, or `undefined` if there is no setter
+(accessor descriptors only).
              */
-            callFrames: Debugger.CallFrame[];
+            set?: Runtime.RemoteObject;
             /**
-             * Async stack trace, if any.
+             * True if the type of this property descriptor may be changed and if the property may be
+deleted from the corresponding object.
+             */
+            configurable: boolean;
+            /**
+             * True if this property shows up during enumeration of the properties on the corresponding
+object.
+             */
+            enumerable: boolean;
+            /**
+             * True if the result was thrown during the evaluation.
+             */
+            wasThrown?: boolean;
+            /**
+             * True if the property is owned for the object.
              */
-            asyncStackTrace?: Runtime.StackTrace;
-        }
-
-        export interface GetScriptSourceReturnType {
+            isOwn?: boolean;
             /**
-             * Script source.
+             * Property symbol object, if the property is of the `symbol` type.
              */
-            scriptSource: string;
+            symbol?: Runtime.RemoteObject;
         }
 
-        export interface EvaluateOnCallFrameReturnType {
+        /**
+         * Object internal property descriptor. This property isn't normally visible in JavaScript code.
+         */
+        export interface InternalPropertyDescriptor {
             /**
-             * Object wrapper for the evaluation result.
+             * Conventional property name.
              */
-            result: Runtime.RemoteObject;
+            name: string;
             /**
-             * Exception details.
+             * The value associated with the property.
              */
-            exceptionDetails?: Runtime.ExceptionDetails;
+            value?: Runtime.RemoteObject;
         }
 
-        export interface ScriptParsedEventDataType {
+        /**
+         * Represents function call argument. Either remote object id `objectId`, primitive `value`,
+unserializable primitive value or neither of (for undefined) them should be specified.
+         */
+        export interface CallArgument {
             /**
-             * Identifier of the script parsed.
+             * Primitive value or serializable javascript object.
              */
-            scriptId: Runtime.ScriptId;
+            value?: any;
             /**
-             * URL or name of the script parsed (if any).
+             * Primitive value which can not be JSON-stringified.
              */
-            url: string;
+            unserializableValue?: Runtime.UnserializableValue;
             /**
-             * Line offset of the script within the resource with given URL (for script tags).
+             * Remote object handle.
              */
-            startLine: number;
+            objectId?: Runtime.RemoteObjectId;
+        }
+
+        /**
+         * Id of an execution context.
+         */
+        export type ExecutionContextId = number;
+
+        /**
+         * Description of an isolated world.
+         */
+        export interface ExecutionContextDescription {
             /**
-             * Column offset of the script within the resource with given URL.
+             * Unique id of the execution context. It can be used to specify in which execution context
+script evaluation should be performed.
              */
-            startColumn: number;
+            id: Runtime.ExecutionContextId;
             /**
-             * Last line of the script.
+             * Execution context origin.
              */
-            endLine: number;
+            origin: string;
             /**
-             * Length of the last line of the script.
+             * Human readable name describing given context.
              */
-            endColumn: number;
+            name: string;
             /**
-             * Specifies script creation context.
+             * Embedder-specific auxiliary data.
              */
-            executionContextId: Runtime.ExecutionContextId;
+            auxData?: {};
+        }
+
+        /**
+         * Detailed information about exception (or error) that was thrown during script compilation or
+execution.
+         */
+        export interface ExceptionDetails {
             /**
-             * Content hash of the script.
+             * Exception id.
              */
-            hash: string;
+            exceptionId: number;
             /**
-             * Embedder-specific auxiliary data.
+             * Exception text, which should be used together with exception object when available.
              */
-            executionContextAuxData?: {};
+            text: string;
             /**
-             * True, if this script is generated as a result of the live edit operation.
-             * @experimental
+             * Line number of the exception location (0-based).
              */
-            isLiveEdit?: boolean;
+            lineNumber: number;
             /**
-             * URL of source map associated with script (if any).
+             * Column number of the exception location (0-based).
              */
-            sourceMapURL?: string;
+            columnNumber: number;
             /**
-             * True, if this script has sourceURL.
-             * @experimental
+             * Script ID of the exception location.
              */
-            hasSourceURL?: boolean;
+            scriptId?: Runtime.ScriptId;
             /**
-             * True, if this script is ES6 module.
-             * @experimental
+             * URL of the exception location, to be used when the script was not reported.
              */
-            isModule?: boolean;
+            url?: string;
             /**
-             * This script length.
-             * @experimental
+             * JavaScript stack trace if available.
              */
-            length?: number;
+            stackTrace?: Runtime.StackTrace;
             /**
-             * JavaScript top stack frame of where the script parsed event was triggered if available.
-             * @experimental
+             * Exception object if available.
              */
-            stackTrace?: Runtime.StackTrace;
+            exception?: Runtime.RemoteObject;
+            /**
+             * Identifier of the context where exception happened.
+             */
+            executionContextId?: Runtime.ExecutionContextId;
         }
 
-        export interface ScriptFailedToParseEventDataType {
+        /**
+         * Number of milliseconds since epoch.
+         */
+        export type Timestamp = number;
+
+        /**
+         * Stack entry for runtime errors and assertions.
+         */
+        export interface CallFrame {
             /**
-             * Identifier of the script parsed.
+             * JavaScript function name.
+             */
+            functionName: string;
+            /**
+             * JavaScript script id.
              */
             scriptId: Runtime.ScriptId;
             /**
-             * URL or name of the script parsed (if any).
+             * JavaScript script name or url.
              */
             url: string;
             /**
-             * Line offset of the script within the resource with given URL (for script tags).
+             * JavaScript script line number (0-based).
              */
-            startLine: number;
+            lineNumber: number;
             /**
-             * Column offset of the script within the resource with given URL.
+             * JavaScript script column number (0-based).
              */
-            startColumn: number;
+            columnNumber: number;
+        }
+
+        /**
+         * Call frames for assertions or error messages.
+         */
+        export interface StackTrace {
             /**
-             * Last line of the script.
+             * String label of this stack trace. For async traces this may be a name of the function that
+initiated the async call.
              */
-            endLine: number;
+            description?: string;
             /**
-             * Length of the last line of the script.
+             * JavaScript function name.
              */
-            endColumn: number;
+            callFrames: Runtime.CallFrame[];
             /**
-             * Specifies script creation context.
+             * Asynchronous JavaScript stack trace that preceded this stack, if available.
              */
-            executionContextId: Runtime.ExecutionContextId;
+            parent?: Runtime.StackTrace;
             /**
-             * Content hash of the script.
+             * Asynchronous JavaScript stack trace that preceded this stack, if available.
+             * @experimental
              */
-            hash: string;
+            parentId?: Runtime.StackTraceId;
+        }
+
+        /**
+         * Unique identifier of current debugger.
+         * @experimental
+         */
+        export type UniqueDebuggerId = string;
+
+        /**
+         * If `debuggerId` is set stack trace comes from another debugger and can be resolved there. This
+allows to track cross-debugger calls. See `Runtime.StackTrace` and `Debugger.paused` for usages.
+         * @experimental
+         */
+        export interface StackTraceId {
+            id: string;
+            debuggerId?: Runtime.UniqueDebuggerId;
+        }
+
+        export interface AwaitPromiseParameterType {
             /**
-             * Embedder-specific auxiliary data.
+             * Identifier of the promise.
              */
-            executionContextAuxData?: {};
+            promiseObjectId: Runtime.RemoteObjectId;
             /**
-             * URL of source map associated with script (if any).
+             * Whether the result is expected to be a JSON object that should be sent by value.
              */
-            sourceMapURL?: string;
+            returnByValue?: boolean;
             /**
-             * True, if this script has sourceURL.
-             * @experimental
+             * Whether preview should be generated for the result.
              */
-            hasSourceURL?: boolean;
+            generatePreview?: boolean;
+        }
+
+        export interface CallFunctionOnParameterType {
             /**
-             * True, if this script is ES6 module.
-             * @experimental
+             * Declaration of the function to call.
              */
-            isModule?: boolean;
+            functionDeclaration: string;
             /**
-             * This script length.
-             * @experimental
+             * Identifier of the object to call function on. Either objectId or executionContextId should
+be specified.
              */
-            length?: number;
+            objectId?: Runtime.RemoteObjectId;
             /**
-             * JavaScript top stack frame of where the script parsed event was triggered if available.
-             * @experimental
+             * Call arguments. All call arguments must belong to the same JavaScript world as the target
+object.
              */
-            stackTrace?: Runtime.StackTrace;
-        }
-
-        export interface BreakpointResolvedEventDataType {
+            arguments?: Runtime.CallArgument[];
             /**
-             * Breakpoint unique identifier.
+             * In silent mode exceptions thrown during evaluation are not reported and do not pause
+execution. Overrides `setPauseOnException` state.
              */
-            breakpointId: Debugger.BreakpointId;
+            silent?: boolean;
             /**
-             * Actual breakpoint location.
+             * Whether the result is expected to be a JSON object which should be sent by value.
              */
-            location: Debugger.Location;
-        }
-
-        export interface PausedEventDataType {
+            returnByValue?: boolean;
             /**
-             * Call stack the virtual machine stopped on.
+             * Whether preview should be generated for the result.
+             * @experimental
              */
-            callFrames: Debugger.CallFrame[];
+            generatePreview?: boolean;
             /**
-             * Pause reason.
+             * Whether execution should be treated as initiated by user in the UI.
              */
-            reason: string;
+            userGesture?: boolean;
             /**
-             * Object containing break-specific auxiliary properties.
+             * Whether execution should `await` for resulting value and return once awaited promise is
+resolved.
              */
-            data?: {};
+            awaitPromise?: boolean;
             /**
-             * Hit breakpoints IDs
+             * Specifies execution context which global object will be used to call function on. Either
+executionContextId or objectId should be specified.
              */
-            hitBreakpoints?: string[];
+            executionContextId?: Runtime.ExecutionContextId;
             /**
-             * Async stack trace, if any.
+             * Symbolic group name that can be used to release multiple objects. If objectGroup is not
+specified and objectId is, objectGroup will be inherited from object.
              */
-            asyncStackTrace?: Runtime.StackTrace;
+            objectGroup?: string;
         }
-    }
 
-    export namespace Console {
-        /**
-         * Console message.
-         */
-        export interface ConsoleMessage {
+        export interface CompileScriptParameterType {
             /**
-             * Message source.
+             * Expression to compile.
              */
-            source: string;
+            expression: string;
             /**
-             * Message severity.
+             * Source url to be set for the script.
              */
-            level: string;
+            sourceURL: string;
             /**
-             * Message text.
+             * Specifies whether the compiled script should be persisted.
              */
-            text: string;
+            persistScript: boolean;
             /**
-             * URL of the message origin.
+             * Specifies in which execution context to perform script run. If the parameter is omitted the
+evaluation will be performed in the context of the inspected page.
+             */
+            executionContextId?: Runtime.ExecutionContextId;
+        }
+
+        export interface EvaluateParameterType {
+            /**
+             * Expression to evaluate.
              */
-            url?: string;
+            expression: string;
             /**
-             * Line number in the resource that generated this message (1-based).
+             * Symbolic group name that can be used to release multiple objects.
              */
-            line?: number;
+            objectGroup?: string;
             /**
-             * Column number in the resource that generated this message (1-based).
+             * Determines whether Command Line API should be available during the evaluation.
              */
-            column?: number;
-        }
-
-        export interface MessageAddedEventDataType {
+            includeCommandLineAPI?: boolean;
             /**
-             * Console message that has been added.
+             * In silent mode exceptions thrown during evaluation are not reported and do not pause
+execution. Overrides `setPauseOnException` state.
              */
-            message: Console.ConsoleMessage;
-        }
-    }
-
-    export namespace Profiler {
-        /**
-         * Profile node. Holds callsite information, execution statistics and child nodes.
-         */
-        export interface ProfileNode {
+            silent?: boolean;
             /**
-             * Unique id of the node.
+             * Specifies in which execution context to perform evaluation. If the parameter is omitted the
+evaluation will be performed in the context of the inspected page.
              */
-            id: number;
+            contextId?: Runtime.ExecutionContextId;
             /**
-             * Function location.
+             * Whether the result is expected to be a JSON object that should be sent by value.
              */
-            callFrame: Runtime.CallFrame;
+            returnByValue?: boolean;
             /**
-             * Number of samples where this node was on top of the call stack.
+             * Whether preview should be generated for the result.
              * @experimental
              */
-            hitCount?: number;
+            generatePreview?: boolean;
             /**
-             * Child node ids.
+             * Whether execution should be treated as initiated by user in the UI.
              */
-            children?: number[];
+            userGesture?: boolean;
             /**
-             * The reason of being not optimized. The function may be deoptimized or marked as don't optimize.
+             * Whether execution should `await` for resulting value and return once awaited promise is
+resolved.
              */
-            deoptReason?: string;
+            awaitPromise?: boolean;
             /**
-             * An array of source position ticks.
+             * Whether to throw an exception if side effect cannot be ruled out during evaluation.
              * @experimental
              */
-            positionTicks?: Profiler.PositionTickInfo[];
+            throwOnSideEffect?: boolean;
         }
 
-        /**
-         * Profile.
-         */
-        export interface Profile {
+        export interface GetPropertiesParameterType {
             /**
-             * The list of profile nodes. First item is the root node.
+             * Identifier of the object to return properties for.
              */
-            nodes: Profiler.ProfileNode[];
+            objectId: Runtime.RemoteObjectId;
             /**
-             * Profiling start timestamp in microseconds.
+             * If true, returns properties belonging only to the element itself, not to its prototype
+chain.
              */
-            startTime: number;
+            ownProperties?: boolean;
             /**
-             * Profiling end timestamp in microseconds.
+             * If true, returns accessor properties (with getter/setter) only; internal properties are not
+returned either.
+             * @experimental
              */
-            endTime: number;
+            accessorPropertiesOnly?: boolean;
             /**
-             * Ids of samples top nodes.
+             * Whether preview should be generated for the results.
+             * @experimental
              */
-            samples?: number[];
+            generatePreview?: boolean;
+        }
+
+        export interface GlobalLexicalScopeNamesParameterType {
             /**
-             * Time intervals between adjacent samples in microseconds. The first delta is relative to the profile startTime.
+             * Specifies in which execution context to lookup global scope variables.
              */
-            timeDeltas?: number[];
+            executionContextId?: Runtime.ExecutionContextId;
         }
 
-        /**
-         * Specifies a number of samples attributed to a certain source position.
-         * @experimental
-         */
-        export interface PositionTickInfo {
+        export interface QueryObjectsParameterType {
             /**
-             * Source line number (1-based).
+             * Identifier of the prototype to return objects for.
              */
-            line: number;
+            prototypeObjectId: Runtime.RemoteObjectId;
             /**
-             * Number of samples attributed to the source line.
+             * Symbolic group name that can be used to release the results.
              */
-            ticks: number;
+            objectGroup?: string;
         }
 
-        /**
-         * Coverage data for a source range.
-         * @experimental
-         */
-        export interface CoverageRange {
-            /**
-             * JavaScript script source offset for the range start.
-             */
-            startOffset: number;
+        export interface ReleaseObjectParameterType {
             /**
-             * JavaScript script source offset for the range end.
+             * Identifier of the object to release.
              */
-            endOffset: number;
+            objectId: Runtime.RemoteObjectId;
+        }
+
+        export interface ReleaseObjectGroupParameterType {
             /**
-             * Collected execution count of the source range.
+             * Symbolic object group name.
              */
-            count: number;
+            objectGroup: string;
         }
 
-        /**
-         * Coverage data for a JavaScript function.
-         * @experimental
-         */
-        export interface FunctionCoverage {
+        export interface RunScriptParameterType {
             /**
-             * JavaScript function name.
+             * Id of the script to run.
              */
-            functionName: string;
+            scriptId: Runtime.ScriptId;
             /**
-             * Source ranges inside the function with coverage data.
+             * Specifies in which execution context to perform script run. If the parameter is omitted the
+evaluation will be performed in the context of the inspected page.
              */
-            ranges: Profiler.CoverageRange[];
+            executionContextId?: Runtime.ExecutionContextId;
             /**
-             * Whether coverage data for this function has block granularity.
+             * Symbolic group name that can be used to release multiple objects.
              */
-            isBlockCoverage: boolean;
-        }
-
-        /**
-         * Coverage data for a JavaScript script.
-         * @experimental
-         */
-        export interface ScriptCoverage {
+            objectGroup?: string;
             /**
-             * JavaScript script id.
+             * In silent mode exceptions thrown during evaluation are not reported and do not pause
+execution. Overrides `setPauseOnException` state.
              */
-            scriptId: Runtime.ScriptId;
+            silent?: boolean;
             /**
-             * JavaScript script name or url.
+             * Determines whether Command Line API should be available during the evaluation.
              */
-            url: string;
+            includeCommandLineAPI?: boolean;
             /**
-             * Functions contained in the script that has coverage data.
+             * Whether the result is expected to be a JSON object which should be sent by value.
              */
-            functions: Profiler.FunctionCoverage[];
-        }
-
-        export interface SetSamplingIntervalParameterType {
+            returnByValue?: boolean;
             /**
-             * New sampling interval in microseconds.
+             * Whether preview should be generated for the result.
              */
-            interval: number;
-        }
-
-        export interface StartPreciseCoverageParameterType {
+            generatePreview?: boolean;
             /**
-             * Collect accurate call counts beyond simple 'covered' or 'not covered'.
+             * Whether execution should `await` for resulting value and return once awaited promise is
+resolved.
              */
-            callCount?: boolean;
+            awaitPromise?: boolean;
         }
 
-        export interface StopReturnType {
+        export interface SetCustomObjectFormatterEnabledParameterType {
+            enabled: boolean;
+        }
+
+        export interface AwaitPromiseReturnType {
             /**
-             * Recorded profile.
+             * Promise result. Will contain rejected value if promise was rejected.
              */
-            profile: Profiler.Profile;
+            result: Runtime.RemoteObject;
+            /**
+             * Exception details if stack strace is available.
+             */
+            exceptionDetails?: Runtime.ExceptionDetails;
         }
 
-        export interface TakePreciseCoverageReturnType {
+        export interface CallFunctionOnReturnType {
             /**
-             * Coverage data for the current isolate.
+             * Call result.
              */
-            result: Profiler.ScriptCoverage[];
+            result: Runtime.RemoteObject;
+            /**
+             * Exception details.
+             */
+            exceptionDetails?: Runtime.ExceptionDetails;
         }
 
-        export interface GetBestEffortCoverageReturnType {
+        export interface CompileScriptReturnType {
             /**
-             * Coverage data for the current isolate.
+             * Id of the script.
              */
-            result: Profiler.ScriptCoverage[];
+            scriptId?: Runtime.ScriptId;
+            /**
+             * Exception details.
+             */
+            exceptionDetails?: Runtime.ExceptionDetails;
         }
 
-        export interface ConsoleProfileStartedEventDataType {
-            id: string;
+        export interface EvaluateReturnType {
             /**
-             * Location of console.profile().
+             * Evaluation result.
              */
-            location: Debugger.Location;
+            result: Runtime.RemoteObject;
             /**
-             * Profile title passed as an argument to console.profile().
+             * Exception details.
              */
-            title?: string;
+            exceptionDetails?: Runtime.ExceptionDetails;
         }
 
-        export interface ConsoleProfileFinishedEventDataType {
+        export interface GetIsolateIdReturnType {
+            /**
+             * The isolate id.
+             */
             id: string;
+        }
+
+        export interface GetHeapUsageReturnType {
             /**
-             * Location of console.profileEnd().
+             * Used heap size in bytes.
              */
-            location: Debugger.Location;
-            profile: Profiler.Profile;
+            usedSize: number;
             /**
-             * Profile title passed as an argument to console.profile().
+             * Allocated heap size in bytes.
              */
-            title?: string;
+            totalSize: number;
         }
-    }
-
-    export namespace HeapProfiler {
-        /**
-         * Heap snapshot object id.
-         */
-        export type HeapSnapshotObjectId = string;
 
-        /**
-         * Sampling Heap Profile node. Holds callsite information, allocation statistics and child nodes.
-         */
-        export interface SamplingHeapProfileNode {
+        export interface GetPropertiesReturnType {
             /**
-             * Function location.
+             * Object properties.
              */
-            callFrame: Runtime.CallFrame;
+            result: Runtime.PropertyDescriptor[];
             /**
-             * Allocations size in bytes for the node excluding children.
+             * Internal object properties (only of the element itself).
              */
-            selfSize: number;
+            internalProperties?: Runtime.InternalPropertyDescriptor[];
             /**
-             * Child nodes.
+             * Exception details.
              */
-            children: HeapProfiler.SamplingHeapProfileNode[];
+            exceptionDetails?: Runtime.ExceptionDetails;
         }
 
-        /**
-         * Profile.
-         */
-        export interface SamplingHeapProfile {
-            head: HeapProfiler.SamplingHeapProfileNode;
+        export interface GlobalLexicalScopeNamesReturnType {
+            names: string[];
         }
 
-        export interface StartTrackingHeapObjectsParameterType {
-            trackAllocations?: boolean;
+        export interface QueryObjectsReturnType {
+            /**
+             * Array with objects.
+             */
+            objects: Runtime.RemoteObject;
         }
 
-        export interface StopTrackingHeapObjectsParameterType {
+        export interface RunScriptReturnType {
+            /**
+             * Run result.
+             */
+            result: Runtime.RemoteObject;
             /**
-             * If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken when the tracking is stopped.
+             * Exception details.
              */
-            reportProgress?: boolean;
+            exceptionDetails?: Runtime.ExceptionDetails;
         }
 
-        export interface TakeHeapSnapshotParameterType {
+        export interface ConsoleAPICalledEventDataType {
+            /**
+             * Type of the call.
+             */
+            type: string;
+            /**
+             * Call arguments.
+             */
+            args: Runtime.RemoteObject[];
             /**
-             * If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken.
+             * Identifier of the context where the call was made.
              */
-            reportProgress?: boolean;
-        }
-
-        export interface GetObjectByHeapObjectIdParameterType {
-            objectId: HeapProfiler.HeapSnapshotObjectId;
+            executionContextId: Runtime.ExecutionContextId;
             /**
-             * Symbolic group name that can be used to release multiple objects.
+             * Call timestamp.
              */
-            objectGroup?: string;
-        }
-
-        export interface AddInspectedHeapObjectParameterType {
+            timestamp: Runtime.Timestamp;
             /**
-             * Heap snapshot object id to be accessible by means of $x command line API.
+             * Stack trace captured when the call was made.
              */
-            heapObjectId: HeapProfiler.HeapSnapshotObjectId;
-        }
-
-        export interface GetHeapObjectIdParameterType {
+            stackTrace?: Runtime.StackTrace;
             /**
-             * Identifier of the object to get heap object id for.
+             * Console context descriptor for calls on non-default console context (not console.*):
+'anonymous#unique-logger-id' for call on unnamed context, 'name#unique-logger-id' for call
+on named context.
+             * @experimental
              */
-            objectId: Runtime.RemoteObjectId;
+            context?: string;
         }
 
-        export interface StartSamplingParameterType {
+        export interface ExceptionRevokedEventDataType {
             /**
-             * Average sample interval in bytes. Poisson distribution is used for the intervals. The default value is 32768 bytes.
+             * Reason describing why exception was revoked.
              */
-            samplingInterval?: number;
-        }
-
-        export interface GetObjectByHeapObjectIdReturnType {
+            reason: string;
             /**
-             * Evaluation result.
+             * The id of revoked exception, as reported in `exceptionThrown`.
              */
-            result: Runtime.RemoteObject;
+            exceptionId: number;
         }
 
-        export interface GetHeapObjectIdReturnType {
+        export interface ExceptionThrownEventDataType {
             /**
-             * Id of the heap snapshot object corresponding to the passed remote object id.
+             * Timestamp of the exception.
              */
-            heapSnapshotObjectId: HeapProfiler.HeapSnapshotObjectId;
+            timestamp: Runtime.Timestamp;
+            exceptionDetails: Runtime.ExceptionDetails;
         }
 
-        export interface StopSamplingReturnType {
+        export interface ExecutionContextCreatedEventDataType {
             /**
-             * Recorded sampling heap profile.
+             * A newly created execution context.
              */
-            profile: HeapProfiler.SamplingHeapProfile;
+            context: Runtime.ExecutionContextDescription;
         }
 
-        export interface AddHeapSnapshotChunkEventDataType {
-            chunk: string;
+        export interface ExecutionContextDestroyedEventDataType {
+            /**
+             * Id of the destroyed context
+             */
+            executionContextId: Runtime.ExecutionContextId;
         }
 
-        export interface ReportHeapSnapshotProgressEventDataType {
-            done: number;
-            total: number;
-            finished?: boolean;
+        export interface InspectRequestedEventDataType {
+            object: Runtime.RemoteObject;
+            hints: {};
         }
+    }
 
-        export interface LastSeenObjectIdEventDataType {
-            lastSeenObjectId: number;
-            timestamp: number;
+    export namespace Schema {
+        /**
+         * Description of the protocol domain.
+         */
+        export interface Domain {
+            /**
+             * Domain name.
+             */
+            name: string;
+            /**
+             * Domain version.
+             */
+            version: string;
         }
 
-        export interface HeapStatsUpdateEventDataType {
+        export interface GetDomainsReturnType {
             /**
-             * An array of triplets. Each triplet describes a fragment. The first integer is the fragment index, the second integer is a total count of objects for the fragment, the third integer is a total size of the objects for the fragment.
+             * List of supported domains.
              */
-            statsUpdate: number[];
+            domains: Schema.Domain[];
         }
     }
 
@@ -1673,109 +1902,130 @@ declare module "inspector" {
         post(method: string, callback?: (err: Error | null, params?: {}) => void): void;
 
         /**
-         * Returns supported domains.
+         * Does nothing.
          */
-        post(method: "Schema.getDomains", callback?: (err: Error | null, params: Schema.GetDomainsReturnType) => void): void;
+        post(method: "Console.clearMessages", callback?: (err: Error | null) => void): void;
+
         /**
-         * Evaluates expression on global object.
+         * Disables console domain, prevents further console messages from being reported to the client.
          */
-        post(method: "Runtime.evaluate", params?: Runtime.EvaluateParameterType, callback?: (err: Error | null, params: Runtime.EvaluateReturnType) => void): void;
-        post(method: "Runtime.evaluate", callback?: (err: Error | null, params: Runtime.EvaluateReturnType) => void): void;
+        post(method: "Console.disable", callback?: (err: Error | null) => void): void;
 
         /**
-         * Add handler to promise with given promise object id.
+         * Enables console domain, sends the messages collected so far to the client by means of the
+`messageAdded` notification.
          */
-        post(method: "Runtime.awaitPromise", params?: Runtime.AwaitPromiseParameterType, callback?: (err: Error | null, params: Runtime.AwaitPromiseReturnType) => void): void;
-        post(method: "Runtime.awaitPromise", callback?: (err: Error | null, params: Runtime.AwaitPromiseReturnType) => void): void;
-
+        post(method: "Console.enable", callback?: (err: Error | null) => void): void;
         /**
-         * Calls function with given declaration on the given object. Object group of the result is inherited from the target object.
+         * Continues execution until specific location is reached.
          */
-        post(method: "Runtime.callFunctionOn", params?: Runtime.CallFunctionOnParameterType, callback?: (err: Error | null, params: Runtime.CallFunctionOnReturnType) => void): void;
-        post(method: "Runtime.callFunctionOn", callback?: (err: Error | null, params: Runtime.CallFunctionOnReturnType) => void): void;
+        post(method: "Debugger.continueToLocation", params?: Debugger.ContinueToLocationParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.continueToLocation", callback?: (err: Error | null) => void): void;
 
         /**
-         * Returns properties of a given object. Object group of the result is inherited from the target object.
+         * Disables debugger for given page.
          */
-        post(method: "Runtime.getProperties", params?: Runtime.GetPropertiesParameterType, callback?: (err: Error | null, params: Runtime.GetPropertiesReturnType) => void): void;
-        post(method: "Runtime.getProperties", callback?: (err: Error | null, params: Runtime.GetPropertiesReturnType) => void): void;
+        post(method: "Debugger.disable", callback?: (err: Error | null) => void): void;
 
         /**
-         * Releases remote object with given id.
+         * Enables debugger for the given page. Clients should not assume that the debugging has been
+enabled until the result for this command is received.
          */
-        post(method: "Runtime.releaseObject", params?: Runtime.ReleaseObjectParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "Runtime.releaseObject", callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.enable", callback?: (err: Error | null, params: Debugger.EnableReturnType) => void): void;
 
         /**
-         * Releases all remote objects that belong to a given group.
+         * Evaluates expression on a given call frame.
          */
-        post(method: "Runtime.releaseObjectGroup", params?: Runtime.ReleaseObjectGroupParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "Runtime.releaseObjectGroup", callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.evaluateOnCallFrame", params?: Debugger.EvaluateOnCallFrameParameterType, callback?: (err: Error | null, params: Debugger.EvaluateOnCallFrameReturnType) => void): void;
+        post(method: "Debugger.evaluateOnCallFrame", callback?: (err: Error | null, params: Debugger.EvaluateOnCallFrameReturnType) => void): void;
 
         /**
-         * Tells inspected instance to run if it was waiting for debugger to attach.
+         * Returns possible locations for breakpoint. scriptId in start and end range locations should be
+the same.
          */
-        post(method: "Runtime.runIfWaitingForDebugger", callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.getPossibleBreakpoints", params?: Debugger.GetPossibleBreakpointsParameterType, callback?: (err: Error | null, params: Debugger.GetPossibleBreakpointsReturnType) => void): void;
+        post(method: "Debugger.getPossibleBreakpoints", callback?: (err: Error | null, params: Debugger.GetPossibleBreakpointsReturnType) => void): void;
 
         /**
-         * Enables reporting of execution contexts creation by means of <code>executionContextCreated</code> event. When the reporting gets enabled the event will be sent immediately for each existing execution context.
+         * Returns source for the script with given id.
          */
-        post(method: "Runtime.enable", callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.getScriptSource", params?: Debugger.GetScriptSourceParameterType, callback?: (err: Error | null, params: Debugger.GetScriptSourceReturnType) => void): void;
+        post(method: "Debugger.getScriptSource", callback?: (err: Error | null, params: Debugger.GetScriptSourceReturnType) => void): void;
 
         /**
-         * Disables reporting of execution contexts creation.
+         * Returns stack trace with given `stackTraceId`.
+         * @experimental
          */
-        post(method: "Runtime.disable", callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.getStackTrace", params?: Debugger.GetStackTraceParameterType, callback?: (err: Error | null, params: Debugger.GetStackTraceReturnType) => void): void;
+        post(method: "Debugger.getStackTrace", callback?: (err: Error | null, params: Debugger.GetStackTraceReturnType) => void): void;
 
         /**
-         * Discards collected exceptions and console API calls.
+         * Stops on the next JavaScript statement.
          */
-        post(method: "Runtime.discardConsoleEntries", callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.pause", callback?: (err: Error | null) => void): void;
 
         /**
          * @experimental
          */
-        post(method: "Runtime.setCustomObjectFormatterEnabled", params?: Runtime.SetCustomObjectFormatterEnabledParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "Runtime.setCustomObjectFormatterEnabled", callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.pauseOnAsyncCall", params?: Debugger.PauseOnAsyncCallParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.pauseOnAsyncCall", callback?: (err: Error | null) => void): void;
 
         /**
-         * Compiles expression.
+         * Removes JavaScript breakpoint.
          */
-        post(method: "Runtime.compileScript", params?: Runtime.CompileScriptParameterType, callback?: (err: Error | null, params: Runtime.CompileScriptReturnType) => void): void;
-        post(method: "Runtime.compileScript", callback?: (err: Error | null, params: Runtime.CompileScriptReturnType) => void): void;
+        post(method: "Debugger.removeBreakpoint", params?: Debugger.RemoveBreakpointParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.removeBreakpoint", callback?: (err: Error | null) => void): void;
 
         /**
-         * Runs script with given id in a given context.
+         * Restarts particular call frame from the beginning.
          */
-        post(method: "Runtime.runScript", params?: Runtime.RunScriptParameterType, callback?: (err: Error | null, params: Runtime.RunScriptReturnType) => void): void;
-        post(method: "Runtime.runScript", callback?: (err: Error | null, params: Runtime.RunScriptReturnType) => void): void;
+        post(method: "Debugger.restartFrame", params?: Debugger.RestartFrameParameterType, callback?: (err: Error | null, params: Debugger.RestartFrameReturnType) => void): void;
+        post(method: "Debugger.restartFrame", callback?: (err: Error | null, params: Debugger.RestartFrameReturnType) => void): void;
+
         /**
-         * Enables debugger for the given page. Clients should not assume that the debugging has been enabled until the result for this command is received.
+         * Resumes JavaScript execution.
          */
-        post(method: "Debugger.enable", callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.resume", callback?: (err: Error | null) => void): void;
 
         /**
-         * Disables debugger for given page.
+         * This method is deprecated - use Debugger.stepInto with breakOnAsyncCall and
+Debugger.pauseOnAsyncTask instead. Steps into next scheduled async task if any is scheduled
+before next pause. Returns success when async task is actually scheduled, returns error if no
+task were scheduled or another scheduleStepIntoAsync was called.
+         * @experimental
          */
-        post(method: "Debugger.disable", callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.scheduleStepIntoAsync", callback?: (err: Error | null) => void): void;
 
         /**
-         * Activates / deactivates all breakpoints on the page.
+         * Searches for given string in script content.
          */
-        post(method: "Debugger.setBreakpointsActive", params?: Debugger.SetBreakpointsActiveParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "Debugger.setBreakpointsActive", callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.searchInContent", params?: Debugger.SearchInContentParameterType, callback?: (err: Error | null, params: Debugger.SearchInContentReturnType) => void): void;
+        post(method: "Debugger.searchInContent", callback?: (err: Error | null, params: Debugger.SearchInContentReturnType) => void): void;
 
         /**
-         * Makes page not interrupt on any pauses (breakpoint, exception, dom exception etc).
+         * Enables or disables async call stacks tracking.
          */
-        post(method: "Debugger.setSkipAllPauses", params?: Debugger.SetSkipAllPausesParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "Debugger.setSkipAllPauses", callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.setAsyncCallStackDepth", params?: Debugger.SetAsyncCallStackDepthParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.setAsyncCallStackDepth", callback?: (err: Error | null) => void): void;
+
+        /**
+         * Replace previous blackbox patterns with passed ones. Forces backend to skip stepping/pausing in
+scripts with url matching one of the patterns. VM will try to leave blackboxed script by
+performing 'step in' several times, finally resorting to 'step out' if unsuccessful.
+         * @experimental
+         */
+        post(method: "Debugger.setBlackboxPatterns", params?: Debugger.SetBlackboxPatternsParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.setBlackboxPatterns", callback?: (err: Error | null) => void): void;
 
         /**
-         * Sets JavaScript breakpoint at given location specified either by URL or URL regex. Once this command is issued, all existing parsed scripts will have breakpoints resolved and returned in <code>locations</code> property. Further matching script parsing will result in subsequent <code>breakpointResolved</code> events issued. This logical breakpoint will survive page reloads.
+         * Makes backend skip steps in the script in blackboxed ranges. VM will try leave blacklisted
+scripts by performing 'step in' several times, finally resorting to 'step out' if unsuccessful.
+Positions array contains positions where blackbox state is changed. First interval isn't
+blackboxed. Array should be sorted.
+         * @experimental
          */
-        post(method: "Debugger.setBreakpointByUrl", params?: Debugger.SetBreakpointByUrlParameterType, callback?: (err: Error | null, params: Debugger.SetBreakpointByUrlReturnType) => void): void;
-        post(method: "Debugger.setBreakpointByUrl", callback?: (err: Error | null, params: Debugger.SetBreakpointByUrlReturnType) => void): void;
+        post(method: "Debugger.setBlackboxedRanges", params?: Debugger.SetBlackboxedRangesParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.setBlackboxedRanges", callback?: (err: Error | null) => void): void;
 
         /**
          * Sets JavaScript breakpoint at a given location.
@@ -1784,254 +2034,283 @@ declare module "inspector" {
         post(method: "Debugger.setBreakpoint", callback?: (err: Error | null, params: Debugger.SetBreakpointReturnType) => void): void;
 
         /**
-         * Removes JavaScript breakpoint.
+         * Sets JavaScript breakpoint at given location specified either by URL or URL regex. Once this
+command is issued, all existing parsed scripts will have breakpoints resolved and returned in
+`locations` property. Further matching script parsing will result in subsequent
+`breakpointResolved` events issued. This logical breakpoint will survive page reloads.
          */
-        post(method: "Debugger.removeBreakpoint", params?: Debugger.RemoveBreakpointParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "Debugger.removeBreakpoint", callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.setBreakpointByUrl", params?: Debugger.SetBreakpointByUrlParameterType, callback?: (err: Error | null, params: Debugger.SetBreakpointByUrlReturnType) => void): void;
+        post(method: "Debugger.setBreakpointByUrl", callback?: (err: Error | null, params: Debugger.SetBreakpointByUrlReturnType) => void): void;
+
+        /**
+         * Activates / deactivates all breakpoints on the page.
+         */
+        post(method: "Debugger.setBreakpointsActive", params?: Debugger.SetBreakpointsActiveParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.setBreakpointsActive", callback?: (err: Error | null) => void): void;
+
+        /**
+         * Defines pause on exceptions state. Can be set to stop on all exceptions, uncaught exceptions or
+no exceptions. Initial pause on exceptions state is `none`.
+         */
+        post(method: "Debugger.setPauseOnExceptions", params?: Debugger.SetPauseOnExceptionsParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.setPauseOnExceptions", callback?: (err: Error | null) => void): void;
 
         /**
-         * Returns possible locations for breakpoint. scriptId in start and end range locations should be the same.
+         * Changes return value in top frame. Available only at return break position.
          * @experimental
          */
-        post(method: "Debugger.getPossibleBreakpoints", params?: Debugger.GetPossibleBreakpointsParameterType, callback?: (err: Error | null, params: Debugger.GetPossibleBreakpointsReturnType) => void): void;
-        post(method: "Debugger.getPossibleBreakpoints", callback?: (err: Error | null, params: Debugger.GetPossibleBreakpointsReturnType) => void): void;
+        post(method: "Debugger.setReturnValue", params?: Debugger.SetReturnValueParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.setReturnValue", callback?: (err: Error | null) => void): void;
 
         /**
-         * Continues execution until specific location is reached.
+         * Edits JavaScript source live.
          */
-        post(method: "Debugger.continueToLocation", params?: Debugger.ContinueToLocationParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "Debugger.continueToLocation", callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.setScriptSource", params?: Debugger.SetScriptSourceParameterType, callback?: (err: Error | null, params: Debugger.SetScriptSourceReturnType) => void): void;
+        post(method: "Debugger.setScriptSource", callback?: (err: Error | null, params: Debugger.SetScriptSourceReturnType) => void): void;
 
         /**
-         * Steps over the statement.
+         * Makes page not interrupt on any pauses (breakpoint, exception, dom exception etc).
          */
-        post(method: "Debugger.stepOver", callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.setSkipAllPauses", params?: Debugger.SetSkipAllPausesParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.setSkipAllPauses", callback?: (err: Error | null) => void): void;
+
+        /**
+         * Changes value of variable in a callframe. Object-based scopes are not supported and must be
+mutated manually.
+         */
+        post(method: "Debugger.setVariableValue", params?: Debugger.SetVariableValueParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "Debugger.setVariableValue", callback?: (err: Error | null) => void): void;
 
         /**
          * Steps into the function call.
          */
+        post(method: "Debugger.stepInto", params?: Debugger.StepIntoParameterType, callback?: (err: Error | null) => void): void;
         post(method: "Debugger.stepInto", callback?: (err: Error | null) => void): void;
 
         /**
-         * Steps out of the function call.
+         * Steps out of the function call.
+         */
+        post(method: "Debugger.stepOut", callback?: (err: Error | null) => void): void;
+
+        /**
+         * Steps over the statement.
+         */
+        post(method: "Debugger.stepOver", callback?: (err: Error | null) => void): void;
+        /**
+         * Enables console to refer to the node with given id via $x (see Command Line API for more details
+$x functions).
+         */
+        post(method: "HeapProfiler.addInspectedHeapObject", params?: HeapProfiler.AddInspectedHeapObjectParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "HeapProfiler.addInspectedHeapObject", callback?: (err: Error | null) => void): void;
+
+        post(method: "HeapProfiler.collectGarbage", callback?: (err: Error | null) => void): void;
+
+        post(method: "HeapProfiler.disable", callback?: (err: Error | null) => void): void;
+
+        post(method: "HeapProfiler.enable", callback?: (err: Error | null) => void): void;
+
+        post(method: "HeapProfiler.getHeapObjectId", params?: HeapProfiler.GetHeapObjectIdParameterType, callback?: (err: Error | null, params: HeapProfiler.GetHeapObjectIdReturnType) => void): void;
+        post(method: "HeapProfiler.getHeapObjectId", callback?: (err: Error | null, params: HeapProfiler.GetHeapObjectIdReturnType) => void): void;
+
+        post(method: "HeapProfiler.getObjectByHeapObjectId", params?: HeapProfiler.GetObjectByHeapObjectIdParameterType, callback?: (err: Error | null, params: HeapProfiler.GetObjectByHeapObjectIdReturnType) => void): void;
+        post(method: "HeapProfiler.getObjectByHeapObjectId", callback?: (err: Error | null, params: HeapProfiler.GetObjectByHeapObjectIdReturnType) => void): void;
+
+        post(method: "HeapProfiler.getSamplingProfile", callback?: (err: Error | null, params: HeapProfiler.GetSamplingProfileReturnType) => void): void;
+
+        post(method: "HeapProfiler.startSampling", params?: HeapProfiler.StartSamplingParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "HeapProfiler.startSampling", callback?: (err: Error | null) => void): void;
+
+        post(method: "HeapProfiler.startTrackingHeapObjects", params?: HeapProfiler.StartTrackingHeapObjectsParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "HeapProfiler.startTrackingHeapObjects", callback?: (err: Error | null) => void): void;
+
+        post(method: "HeapProfiler.stopSampling", callback?: (err: Error | null, params: HeapProfiler.StopSamplingReturnType) => void): void;
+
+        post(method: "HeapProfiler.stopTrackingHeapObjects", params?: HeapProfiler.StopTrackingHeapObjectsParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "HeapProfiler.stopTrackingHeapObjects", callback?: (err: Error | null) => void): void;
+
+        post(method: "HeapProfiler.takeHeapSnapshot", params?: HeapProfiler.TakeHeapSnapshotParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "HeapProfiler.takeHeapSnapshot", callback?: (err: Error | null) => void): void;
+        post(method: "Profiler.disable", callback?: (err: Error | null) => void): void;
+
+        post(method: "Profiler.enable", callback?: (err: Error | null) => void): void;
+
+        /**
+         * Collect coverage data for the current isolate. The coverage data may be incomplete due to
+garbage collection.
          */
-        post(method: "Debugger.stepOut", callback?: (err: Error | null) => void): void;
+        post(method: "Profiler.getBestEffortCoverage", callback?: (err: Error | null, params: Profiler.GetBestEffortCoverageReturnType) => void): void;
 
         /**
-         * Stops on the next JavaScript statement.
+         * Changes CPU profiler sampling interval. Must be called before CPU profiles recording started.
          */
-        post(method: "Debugger.pause", callback?: (err: Error | null) => void): void;
+        post(method: "Profiler.setSamplingInterval", params?: Profiler.SetSamplingIntervalParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "Profiler.setSamplingInterval", callback?: (err: Error | null) => void): void;
 
-        /**
-         * Steps into next scheduled async task if any is scheduled before next pause. Returns success when async task is actually scheduled, returns error if no task were scheduled or another scheduleStepIntoAsync was called.
-         * @experimental
-         */
-        post(method: "Debugger.scheduleStepIntoAsync", callback?: (err: Error | null) => void): void;
+        post(method: "Profiler.start", callback?: (err: Error | null) => void): void;
 
         /**
-         * Resumes JavaScript execution.
+         * 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.
          */
-        post(method: "Debugger.resume", callback?: (err: Error | null) => void): void;
+        post(method: "Profiler.startPreciseCoverage", params?: Profiler.StartPreciseCoverageParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "Profiler.startPreciseCoverage", callback?: (err: Error | null) => void): void;
 
         /**
-         * Searches for given string in script content.
+         * Enable type profile.
          * @experimental
          */
-        post(method: "Debugger.searchInContent", params?: Debugger.SearchInContentParameterType, callback?: (err: Error | null, params: Debugger.SearchInContentReturnType) => void): void;
-        post(method: "Debugger.searchInContent", callback?: (err: Error | null, params: Debugger.SearchInContentReturnType) => void): void;
+        post(method: "Profiler.startTypeProfile", callback?: (err: Error | null) => void): void;
 
-        /**
-         * Edits JavaScript source live.
-         */
-        post(method: "Debugger.setScriptSource", params?: Debugger.SetScriptSourceParameterType, callback?: (err: Error | null, params: Debugger.SetScriptSourceReturnType) => void): void;
-        post(method: "Debugger.setScriptSource", callback?: (err: Error | null, params: Debugger.SetScriptSourceReturnType) => void): void;
+        post(method: "Profiler.stop", callback?: (err: Error | null, params: Profiler.StopReturnType) => void): void;
 
         /**
-         * Restarts particular call frame from the beginning.
+         * Disable precise code coverage. Disabling releases unnecessary execution count records and allows
+executing optimized code.
          */
-        post(method: "Debugger.restartFrame", params?: Debugger.RestartFrameParameterType, callback?: (err: Error | null, params: Debugger.RestartFrameReturnType) => void): void;
-        post(method: "Debugger.restartFrame", callback?: (err: Error | null, params: Debugger.RestartFrameReturnType) => void): void;
+        post(method: "Profiler.stopPreciseCoverage", callback?: (err: Error | null) => void): void;
 
         /**
-         * Returns source for the script with given id.
+         * Disable type profile. Disabling releases type profile data collected so far.
+         * @experimental
          */
-        post(method: "Debugger.getScriptSource", params?: Debugger.GetScriptSourceParameterType, callback?: (err: Error | null, params: Debugger.GetScriptSourceReturnType) => void): void;
-        post(method: "Debugger.getScriptSource", callback?: (err: Error | null, params: Debugger.GetScriptSourceReturnType) => void): void;
+        post(method: "Profiler.stopTypeProfile", callback?: (err: Error | null) => void): void;
 
         /**
-         * Defines pause on exceptions state. Can be set to stop on all exceptions, uncaught exceptions or no exceptions. Initial pause on exceptions state is <code>none</code>.
+         * Collect coverage data for the current isolate, and resets execution counters. Precise code
+coverage needs to have started.
          */
-        post(method: "Debugger.setPauseOnExceptions", params?: Debugger.SetPauseOnExceptionsParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "Debugger.setPauseOnExceptions", callback?: (err: Error | null) => void): void;
+        post(method: "Profiler.takePreciseCoverage", callback?: (err: Error | null, params: Profiler.TakePreciseCoverageReturnType) => void): void;
 
         /**
-         * Evaluates expression on a given call frame.
+         * Collect type profile.
+         * @experimental
          */
-        post(method: "Debugger.evaluateOnCallFrame", params?: Debugger.EvaluateOnCallFrameParameterType, callback?: (err: Error | null, params: Debugger.EvaluateOnCallFrameReturnType) => void): void;
-        post(method: "Debugger.evaluateOnCallFrame", callback?: (err: Error | null, params: Debugger.EvaluateOnCallFrameReturnType) => void): void;
-
+        post(method: "Profiler.takeTypeProfile", callback?: (err: Error | null, params: Profiler.TakeTypeProfileReturnType) => void): void;
         /**
-         * Changes value of variable in a callframe. Object-based scopes are not supported and must be mutated manually.
+         * Add handler to promise with given promise object id.
          */
-        post(method: "Debugger.setVariableValue", params?: Debugger.SetVariableValueParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "Debugger.setVariableValue", callback?: (err: Error | null) => void): void;
+        post(method: "Runtime.awaitPromise", params?: Runtime.AwaitPromiseParameterType, callback?: (err: Error | null, params: Runtime.AwaitPromiseReturnType) => void): void;
+        post(method: "Runtime.awaitPromise", callback?: (err: Error | null, params: Runtime.AwaitPromiseReturnType) => void): void;
 
         /**
-         * Enables or disables async call stacks tracking.
+         * Calls function with given declaration on the given object. Object group of the result is
+inherited from the target object.
          */
-        post(method: "Debugger.setAsyncCallStackDepth", params?: Debugger.SetAsyncCallStackDepthParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "Debugger.setAsyncCallStackDepth", callback?: (err: Error | null) => void): void;
+        post(method: "Runtime.callFunctionOn", params?: Runtime.CallFunctionOnParameterType, callback?: (err: Error | null, params: Runtime.CallFunctionOnReturnType) => void): void;
+        post(method: "Runtime.callFunctionOn", callback?: (err: Error | null, params: Runtime.CallFunctionOnReturnType) => void): void;
 
         /**
-         * Replace previous blackbox patterns with passed ones. Forces backend to skip stepping/pausing in scripts with url matching one of the patterns. VM will try to leave blackboxed script by performing 'step in' several times, finally resorting to 'step out' if unsuccessful.
-         * @experimental
+         * Compiles expression.
          */
-        post(method: "Debugger.setBlackboxPatterns", params?: Debugger.SetBlackboxPatternsParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "Debugger.setBlackboxPatterns", callback?: (err: Error | null) => void): void;
+        post(method: "Runtime.compileScript", params?: Runtime.CompileScriptParameterType, callback?: (err: Error | null, params: Runtime.CompileScriptReturnType) => void): void;
+        post(method: "Runtime.compileScript", callback?: (err: Error | null, params: Runtime.CompileScriptReturnType) => void): void;
 
         /**
-         * Makes backend skip steps in the script in blackboxed ranges. VM will try leave blacklisted scripts by performing 'step in' several times, finally resorting to 'step out' if unsuccessful. Positions array contains positions where blackbox state is changed. First interval isn't blackboxed. Array should be sorted.
-         * @experimental
-         */
-        post(method: "Debugger.setBlackboxedRanges", params?: Debugger.SetBlackboxedRangesParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "Debugger.setBlackboxedRanges", callback?: (err: Error | null) => void): void;
-        /**
-         * Enables console domain, sends the messages collected so far to the client by means of the <code>messageAdded</code> notification.
+         * Disables reporting of execution contexts creation.
          */
-        post(method: "Console.enable", callback?: (err: Error | null) => void): void;
+        post(method: "Runtime.disable", callback?: (err: Error | null) => void): void;
 
         /**
-         * Disables console domain, prevents further console messages from being reported to the client.
+         * Discards collected exceptions and console API calls.
          */
-        post(method: "Console.disable", callback?: (err: Error | null) => void): void;
+        post(method: "Runtime.discardConsoleEntries", callback?: (err: Error | null) => void): void;
 
         /**
-         * Does nothing.
+         * 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.
          */
-        post(method: "Console.clearMessages", callback?: (err: Error | null) => void): void;
-        post(method: "Profiler.enable", callback?: (err: Error | null) => void): void;
-
-        post(method: "Profiler.disable", callback?: (err: Error | null) => void): void;
+        post(method: "Runtime.enable", callback?: (err: Error | null) => void): void;
 
         /**
-         * Changes CPU profiler sampling interval. Must be called before CPU profiles recording started.
+         * Evaluates expression on global object.
          */
-        post(method: "Profiler.setSamplingInterval", params?: Profiler.SetSamplingIntervalParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "Profiler.setSamplingInterval", callback?: (err: Error | null) => void): void;
-
-        post(method: "Profiler.start", callback?: (err: Error | null) => void): void;
-
-        post(method: "Profiler.stop", callback?: (err: Error | null, params: Profiler.StopReturnType) => void): void;
+        post(method: "Runtime.evaluate", params?: Runtime.EvaluateParameterType, callback?: (err: Error | null, params: Runtime.EvaluateReturnType) => void): void;
+        post(method: "Runtime.evaluate", callback?: (err: Error | null, params: Runtime.EvaluateReturnType) => void): void;
 
         /**
-         * 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.
+         * Returns the isolate id.
          * @experimental
          */
-        post(method: "Profiler.startPreciseCoverage", params?: Profiler.StartPreciseCoverageParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "Profiler.startPreciseCoverage", callback?: (err: Error | null) => void): void;
+        post(method: "Runtime.getIsolateId", callback?: (err: Error | null, params: Runtime.GetIsolateIdReturnType) => void): void;
 
         /**
-         * Disable precise code coverage. Disabling releases unnecessary execution count records and allows executing optimized code.
+         * Returns the JavaScript heap usage.
+It is the total usage of the corresponding isolate not scoped to a particular Runtime.
          * @experimental
          */
-        post(method: "Profiler.stopPreciseCoverage", callback?: (err: Error | null) => void): void;
+        post(method: "Runtime.getHeapUsage", callback?: (err: Error | null, params: Runtime.GetHeapUsageReturnType) => void): void;
 
         /**
-         * Collect coverage data for the current isolate, and resets execution counters. Precise code coverage needs to have started.
-         * @experimental
+         * Returns properties of a given object. Object group of the result is inherited from the target
+object.
          */
-        post(method: "Profiler.takePreciseCoverage", callback?: (err: Error | null, params: Profiler.TakePreciseCoverageReturnType) => void): void;
+        post(method: "Runtime.getProperties", params?: Runtime.GetPropertiesParameterType, callback?: (err: Error | null, params: Runtime.GetPropertiesReturnType) => void): void;
+        post(method: "Runtime.getProperties", callback?: (err: Error | null, params: Runtime.GetPropertiesReturnType) => void): void;
 
         /**
-         * Collect coverage data for the current isolate. The coverage data may be incomplete due to garbage collection.
-         * @experimental
+         * Returns all let, const and class variables from global scope.
          */
-        post(method: "Profiler.getBestEffortCoverage", callback?: (err: Error | null, params: Profiler.GetBestEffortCoverageReturnType) => void): void;
-        post(method: "HeapProfiler.enable", callback?: (err: Error | null) => void): void;
+        post(method: "Runtime.globalLexicalScopeNames", params?: Runtime.GlobalLexicalScopeNamesParameterType, callback?: (err: Error | null, params: Runtime.GlobalLexicalScopeNamesReturnType) => void): void;
+        post(method: "Runtime.globalLexicalScopeNames", callback?: (err: Error | null, params: Runtime.GlobalLexicalScopeNamesReturnType) => void): void;
 
-        post(method: "HeapProfiler.disable", callback?: (err: Error | null) => void): void;
-
-        post(method: "HeapProfiler.startTrackingHeapObjects", params?: HeapProfiler.StartTrackingHeapObjectsParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "HeapProfiler.startTrackingHeapObjects", callback?: (err: Error | null) => void): void;
-
-        post(method: "HeapProfiler.stopTrackingHeapObjects", params?: HeapProfiler.StopTrackingHeapObjectsParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "HeapProfiler.stopTrackingHeapObjects", callback?: (err: Error | null) => void): void;
-
-        post(method: "HeapProfiler.takeHeapSnapshot", params?: HeapProfiler.TakeHeapSnapshotParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "HeapProfiler.takeHeapSnapshot", callback?: (err: Error | null) => void): void;
-
-        post(method: "HeapProfiler.collectGarbage", callback?: (err: Error | null) => void): void;
-
-        post(method: "HeapProfiler.getObjectByHeapObjectId", params?: HeapProfiler.GetObjectByHeapObjectIdParameterType, callback?: (err: Error | null, params: HeapProfiler.GetObjectByHeapObjectIdReturnType) => void): void;
-        post(method: "HeapProfiler.getObjectByHeapObjectId", callback?: (err: Error | null, params: HeapProfiler.GetObjectByHeapObjectIdReturnType) => void): void;
+        post(method: "Runtime.queryObjects", params?: Runtime.QueryObjectsParameterType, callback?: (err: Error | null, params: Runtime.QueryObjectsReturnType) => void): void;
+        post(method: "Runtime.queryObjects", callback?: (err: Error | null, params: Runtime.QueryObjectsReturnType) => void): void;
 
         /**
-         * Enables console to refer to the node with given id via $x (see Command Line API for more details $x functions).
+         * Releases remote object with given id.
          */
-        post(method: "HeapProfiler.addInspectedHeapObject", params?: HeapProfiler.AddInspectedHeapObjectParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "HeapProfiler.addInspectedHeapObject", callback?: (err: Error | null) => void): void;
-
-        post(method: "HeapProfiler.getHeapObjectId", params?: HeapProfiler.GetHeapObjectIdParameterType, callback?: (err: Error | null, params: HeapProfiler.GetHeapObjectIdReturnType) => void): void;
-        post(method: "HeapProfiler.getHeapObjectId", callback?: (err: Error | null, params: HeapProfiler.GetHeapObjectIdReturnType) => void): void;
-
-        post(method: "HeapProfiler.startSampling", params?: HeapProfiler.StartSamplingParameterType, callback?: (err: Error | null) => void): void;
-        post(method: "HeapProfiler.startSampling", callback?: (err: Error | null) => void): void;
-
-        post(method: "HeapProfiler.stopSampling", callback?: (err: Error | null, params: HeapProfiler.StopSamplingReturnType) => void): void;
-
-        // Events
-
-        addListener(event: string, listener: (...args: any[]) => void): this;
+        post(method: "Runtime.releaseObject", params?: Runtime.ReleaseObjectParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "Runtime.releaseObject", callback?: (err: Error | null) => void): void;
 
         /**
-         * Emitted when any notification from the V8 Inspector is received.
+         * Releases all remote objects that belong to a given group.
          */
-        addListener(event: "inspectorNotification", listener: (message: InspectorNotification<{}>) => void): this;
+        post(method: "Runtime.releaseObjectGroup", params?: Runtime.ReleaseObjectGroupParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "Runtime.releaseObjectGroup", callback?: (err: Error | null) => void): void;
 
         /**
-         * Issued when new execution context is created.
+         * Tells inspected instance to run if it was waiting for debugger to attach.
          */
-        addListener(event: "Runtime.executionContextCreated", listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+        post(method: "Runtime.runIfWaitingForDebugger", callback?: (err: Error | null) => void): void;
 
         /**
-         * Issued when execution context is destroyed.
+         * Runs script with given id in a given context.
          */
-        addListener(event: "Runtime.executionContextDestroyed", listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+        post(method: "Runtime.runScript", params?: Runtime.RunScriptParameterType, callback?: (err: Error | null, params: Runtime.RunScriptReturnType) => void): void;
+        post(method: "Runtime.runScript", callback?: (err: Error | null, params: Runtime.RunScriptReturnType) => void): void;
 
         /**
-         * Issued when all executionContexts were cleared in browser
+         * @experimental
          */
-        addListener(event: "Runtime.executionContextsCleared", listener: () => void): this;
+        post(method: "Runtime.setCustomObjectFormatterEnabled", params?: Runtime.SetCustomObjectFormatterEnabledParameterType, callback?: (err: Error | null) => void): void;
+        post(method: "Runtime.setCustomObjectFormatterEnabled", callback?: (err: Error | null) => void): void;
 
         /**
-         * Issued when exception was thrown and unhandled.
+         * Terminate current or next JavaScript execution.
+Will cancel the termination when the outer-most script execution ends.
+         * @experimental
          */
-        addListener(event: "Runtime.exceptionThrown", listener: (message: InspectorNotification<Runtime.ExceptionThrownEventDataType>) => void): this;
-
+        post(method: "Runtime.terminateExecution", callback?: (err: Error | null) => void): void;
         /**
-         * Issued when unhandled exception was revoked.
+         * Returns supported domains.
          */
-        addListener(event: "Runtime.exceptionRevoked", listener: (message: InspectorNotification<Runtime.ExceptionRevokedEventDataType>) => void): this;
+        post(method: "Schema.getDomains", callback?: (err: Error | null, params: Schema.GetDomainsReturnType) => void): void;
 
-        /**
-         * Issued when console API was called.
-         */
-        addListener(event: "Runtime.consoleAPICalled", listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
+        // Events
 
-        /**
-         * Issued when object should be inspected (for example, as a result of inspect() command line API call).
-         */
-        addListener(event: "Runtime.inspectRequested", listener: (message: InspectorNotification<Runtime.InspectRequestedEventDataType>) => void): this;
+        addListener(event: string, listener: (...args: any[]) => void): this;
 
         /**
-         * Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.
+         * Emitted when any notification from the V8 Inspector is received.
          */
-        addListener(event: "Debugger.scriptParsed", listener: (message: InspectorNotification<Debugger.ScriptParsedEventDataType>) => void): this;
+        addListener(event: "inspectorNotification", listener: (message: InspectorNotification<{}>) => void): this;
 
         /**
-         * Fired when virtual machine fails to parse the script.
+         * Issued when new console message is added.
          */
-        addListener(event: "Debugger.scriptFailedToParse", listener: (message: InspectorNotification<Debugger.ScriptFailedToParseEventDataType>) => void): this;
+        addListener(event: "Console.messageAdded", listener: (message: InspectorNotification<Console.MessageAddedEventDataType>) => void): this;
 
         /**
          * Fired when breakpoint is resolved to an actual script and location.
@@ -2049,104 +2328,109 @@ declare module "inspector" {
         addListener(event: "Debugger.resumed", listener: () => void): this;
 
         /**
-         * Issued when new console message is added.
+         * Fired when virtual machine fails to parse the script.
          */
-        addListener(event: "Console.messageAdded", listener: (message: InspectorNotification<Console.MessageAddedEventDataType>) => void): this;
+        addListener(event: "Debugger.scriptFailedToParse", listener: (message: InspectorNotification<Debugger.ScriptFailedToParseEventDataType>) => void): this;
 
         /**
-         * Sent when new profile recording is started using console.profile() call.
+         * Fired when virtual machine parses script. This event is also fired for all known and uncollected
+scripts upon enabling debugger.
          */
-        addListener(event: "Profiler.consoleProfileStarted", listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
+        addListener(event: "Debugger.scriptParsed", listener: (message: InspectorNotification<Debugger.ScriptParsedEventDataType>) => void): this;
 
-        addListener(event: "Profiler.consoleProfileFinished", listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
         addListener(event: "HeapProfiler.addHeapSnapshotChunk", listener: (message: InspectorNotification<HeapProfiler.AddHeapSnapshotChunkEventDataType>) => void): this;
-        addListener(event: "HeapProfiler.resetProfiles", listener: () => void): this;
-        addListener(event: "HeapProfiler.reportHeapSnapshotProgress", listener: (message: InspectorNotification<HeapProfiler.ReportHeapSnapshotProgressEventDataType>) => void): this;
 
         /**
-         * If heap objects tracking has been started then backend regularly sends a current value for last seen object id and corresponding timestamp. If the were changes in the heap since last event then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
+         * If heap objects tracking has been started then backend may send update for one or more fragments
          */
-        addListener(event: "HeapProfiler.lastSeenObjectId", listener: (message: InspectorNotification<HeapProfiler.LastSeenObjectIdEventDataType>) => void): this;
+        addListener(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
 
         /**
-         * If heap objects tracking has been started then backend may send update for one or more fragments
+         * If heap objects tracking has been started then backend regularly sends a current value for last
+seen object id and corresponding timestamp. If the were changes in the heap since last event
+then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
          */
-        addListener(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
+        addListener(event: "HeapProfiler.lastSeenObjectId", listener: (message: InspectorNotification<HeapProfiler.LastSeenObjectIdEventDataType>) => void): this;
 
-        emit(event: string | symbol, ...args: any[]): boolean;
-        emit(event: "inspectorNotification", message: InspectorNotification<{}>): boolean;
-        emit(event: "Runtime.executionContextCreated", message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>): boolean;
-        emit(event: "Runtime.executionContextDestroyed", message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>): boolean;
-        emit(event: "Runtime.executionContextsCleared"): boolean;
-        emit(event: "Runtime.exceptionThrown", message: InspectorNotification<Runtime.ExceptionThrownEventDataType>): boolean;
-        emit(event: "Runtime.exceptionRevoked", message: InspectorNotification<Runtime.ExceptionRevokedEventDataType>): boolean;
-        emit(event: "Runtime.consoleAPICalled", message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>): boolean;
-        emit(event: "Runtime.inspectRequested", message: InspectorNotification<Runtime.InspectRequestedEventDataType>): boolean;
-        emit(event: "Debugger.scriptParsed", message: InspectorNotification<Debugger.ScriptParsedEventDataType>): boolean;
-        emit(event: "Debugger.scriptFailedToParse", message: InspectorNotification<Debugger.ScriptFailedToParseEventDataType>): boolean;
-        emit(event: "Debugger.breakpointResolved", message: InspectorNotification<Debugger.BreakpointResolvedEventDataType>): boolean;
-        emit(event: "Debugger.paused", message: InspectorNotification<Debugger.PausedEventDataType>): boolean;
-        emit(event: "Debugger.resumed"): boolean;
-        emit(event: "Console.messageAdded", message: InspectorNotification<Console.MessageAddedEventDataType>): boolean;
-        emit(event: "Profiler.consoleProfileStarted", message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>): boolean;
-        emit(event: "Profiler.consoleProfileFinished", message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>): boolean;
-        emit(event: "HeapProfiler.addHeapSnapshotChunk", message: InspectorNotification<HeapProfiler.AddHeapSnapshotChunkEventDataType>): boolean;
-        emit(event: "HeapProfiler.resetProfiles"): boolean;
-        emit(event: "HeapProfiler.reportHeapSnapshotProgress", message: InspectorNotification<HeapProfiler.ReportHeapSnapshotProgressEventDataType>): boolean;
-        emit(event: "HeapProfiler.lastSeenObjectId", message: InspectorNotification<HeapProfiler.LastSeenObjectIdEventDataType>): boolean;
-        emit(event: "HeapProfiler.heapStatsUpdate", message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>): boolean;
+        addListener(event: "HeapProfiler.reportHeapSnapshotProgress", listener: (message: InspectorNotification<HeapProfiler.ReportHeapSnapshotProgressEventDataType>) => void): this;
+        addListener(event: "HeapProfiler.resetProfiles", listener: () => void): this;
+        addListener(event: "Profiler.consoleProfileFinished", listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
 
-        on(event: string, listener: (...args: any[]) => void): this;
+        /**
+         * Sent when new profile recording is started using console.profile() call.
+         */
+        addListener(event: "Profiler.consoleProfileStarted", listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
 
         /**
-         * Emitted when any notification from the V8 Inspector is received.
+         * Issued when console API was called.
          */
-        on(event: "inspectorNotification", listener: (message: InspectorNotification<{}>) => void): this;
+        addListener(event: "Runtime.consoleAPICalled", listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
 
         /**
-         * Issued when new execution context is created.
+         * Issued when unhandled exception was revoked.
          */
-        on(event: "Runtime.executionContextCreated", listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+        addListener(event: "Runtime.exceptionRevoked", listener: (message: InspectorNotification<Runtime.ExceptionRevokedEventDataType>) => void): this;
 
         /**
-         * Issued when execution context is destroyed.
+         * Issued when exception was thrown and unhandled.
          */
-        on(event: "Runtime.executionContextDestroyed", listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+        addListener(event: "Runtime.exceptionThrown", listener: (message: InspectorNotification<Runtime.ExceptionThrownEventDataType>) => void): this;
 
         /**
-         * Issued when all executionContexts were cleared in browser
+         * Issued when new execution context is created.
          */
-        on(event: "Runtime.executionContextsCleared", listener: () => void): this;
+        addListener(event: "Runtime.executionContextCreated", listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
 
         /**
-         * Issued when exception was thrown and unhandled.
+         * Issued when execution context is destroyed.
          */
-        on(event: "Runtime.exceptionThrown", listener: (message: InspectorNotification<Runtime.ExceptionThrownEventDataType>) => void): this;
+        addListener(event: "Runtime.executionContextDestroyed", listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
 
         /**
-         * Issued when unhandled exception was revoked.
+         * Issued when all executionContexts were cleared in browser
          */
-        on(event: "Runtime.exceptionRevoked", listener: (message: InspectorNotification<Runtime.ExceptionRevokedEventDataType>) => void): this;
+        addListener(event: "Runtime.executionContextsCleared", listener: () => void): this;
 
         /**
-         * Issued when console API was called.
+         * Issued when object should be inspected (for example, as a result of inspect() command line API
+call).
          */
-        on(event: "Runtime.consoleAPICalled", listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
+        addListener(event: "Runtime.inspectRequested", listener: (message: InspectorNotification<Runtime.InspectRequestedEventDataType>) => void): this;
+
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "inspectorNotification", message: InspectorNotification<{}>): boolean;
+        emit(event: "Console.messageAdded", message: InspectorNotification<Console.MessageAddedEventDataType>): boolean;
+        emit(event: "Debugger.breakpointResolved", message: InspectorNotification<Debugger.BreakpointResolvedEventDataType>): boolean;
+        emit(event: "Debugger.paused", message: InspectorNotification<Debugger.PausedEventDataType>): boolean;
+        emit(event: "Debugger.resumed"): boolean;
+        emit(event: "Debugger.scriptFailedToParse", message: InspectorNotification<Debugger.ScriptFailedToParseEventDataType>): boolean;
+        emit(event: "Debugger.scriptParsed", message: InspectorNotification<Debugger.ScriptParsedEventDataType>): boolean;
+        emit(event: "HeapProfiler.addHeapSnapshotChunk", message: InspectorNotification<HeapProfiler.AddHeapSnapshotChunkEventDataType>): boolean;
+        emit(event: "HeapProfiler.heapStatsUpdate", message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>): boolean;
+        emit(event: "HeapProfiler.lastSeenObjectId", message: InspectorNotification<HeapProfiler.LastSeenObjectIdEventDataType>): boolean;
+        emit(event: "HeapProfiler.reportHeapSnapshotProgress", message: InspectorNotification<HeapProfiler.ReportHeapSnapshotProgressEventDataType>): boolean;
+        emit(event: "HeapProfiler.resetProfiles"): boolean;
+        emit(event: "Profiler.consoleProfileFinished", message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>): boolean;
+        emit(event: "Profiler.consoleProfileStarted", message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>): boolean;
+        emit(event: "Runtime.consoleAPICalled", message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>): boolean;
+        emit(event: "Runtime.exceptionRevoked", message: InspectorNotification<Runtime.ExceptionRevokedEventDataType>): boolean;
+        emit(event: "Runtime.exceptionThrown", message: InspectorNotification<Runtime.ExceptionThrownEventDataType>): boolean;
+        emit(event: "Runtime.executionContextCreated", message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>): boolean;
+        emit(event: "Runtime.executionContextDestroyed", message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>): boolean;
+        emit(event: "Runtime.executionContextsCleared"): boolean;
+        emit(event: "Runtime.inspectRequested", message: InspectorNotification<Runtime.InspectRequestedEventDataType>): boolean;
 
-        /**
-         * Issued when object should be inspected (for example, as a result of inspect() command line API call).
-         */
-        on(event: "Runtime.inspectRequested", listener: (message: InspectorNotification<Runtime.InspectRequestedEventDataType>) => void): this;
+        on(event: string, listener: (...args: any[]) => void): this;
 
         /**
-         * Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.
+         * Emitted when any notification from the V8 Inspector is received.
          */
-        on(event: "Debugger.scriptParsed", listener: (message: InspectorNotification<Debugger.ScriptParsedEventDataType>) => void): this;
+        on(event: "inspectorNotification", listener: (message: InspectorNotification<{}>) => void): this;
 
         /**
-         * Fired when virtual machine fails to parse the script.
+         * Issued when new console message is added.
          */
-        on(event: "Debugger.scriptFailedToParse", listener: (message: InspectorNotification<Debugger.ScriptFailedToParseEventDataType>) => void): this;
+        on(event: "Console.messageAdded", listener: (message: InspectorNotification<Console.MessageAddedEventDataType>) => void): this;
 
         /**
          * Fired when breakpoint is resolved to an actual script and location.
@@ -2164,81 +2448,86 @@ declare module "inspector" {
         on(event: "Debugger.resumed", listener: () => void): this;
 
         /**
-         * Issued when new console message is added.
+         * Fired when virtual machine fails to parse the script.
          */
-        on(event: "Console.messageAdded", listener: (message: InspectorNotification<Console.MessageAddedEventDataType>) => void): this;
+        on(event: "Debugger.scriptFailedToParse", listener: (message: InspectorNotification<Debugger.ScriptFailedToParseEventDataType>) => void): this;
 
         /**
-         * Sent when new profile recording is started using console.profile() call.
+         * Fired when virtual machine parses script. This event is also fired for all known and uncollected
+scripts upon enabling debugger.
          */
-        on(event: "Profiler.consoleProfileStarted", listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
+        on(event: "Debugger.scriptParsed", listener: (message: InspectorNotification<Debugger.ScriptParsedEventDataType>) => void): this;
 
-        on(event: "Profiler.consoleProfileFinished", listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
         on(event: "HeapProfiler.addHeapSnapshotChunk", listener: (message: InspectorNotification<HeapProfiler.AddHeapSnapshotChunkEventDataType>) => void): this;
-        on(event: "HeapProfiler.resetProfiles", listener: () => void): this;
-        on(event: "HeapProfiler.reportHeapSnapshotProgress", listener: (message: InspectorNotification<HeapProfiler.ReportHeapSnapshotProgressEventDataType>) => void): this;
 
         /**
-         * If heap objects tracking has been started then backend regularly sends a current value for last seen object id and corresponding timestamp. If the were changes in the heap since last event then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
+         * If heap objects tracking has been started then backend may send update for one or more fragments
          */
-        on(event: "HeapProfiler.lastSeenObjectId", listener: (message: InspectorNotification<HeapProfiler.LastSeenObjectIdEventDataType>) => void): this;
+        on(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
 
         /**
-         * If heap objects tracking has been started then backend may send update for one or more fragments
+         * If heap objects tracking has been started then backend regularly sends a current value for last
+seen object id and corresponding timestamp. If the were changes in the heap since last event
+then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
          */
-        on(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
+        on(event: "HeapProfiler.lastSeenObjectId", listener: (message: InspectorNotification<HeapProfiler.LastSeenObjectIdEventDataType>) => void): this;
 
-        once(event: string, listener: (...args: any[]) => void): this;
+        on(event: "HeapProfiler.reportHeapSnapshotProgress", listener: (message: InspectorNotification<HeapProfiler.ReportHeapSnapshotProgressEventDataType>) => void): this;
+        on(event: "HeapProfiler.resetProfiles", listener: () => void): this;
+        on(event: "Profiler.consoleProfileFinished", listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
 
         /**
-         * Emitted when any notification from the V8 Inspector is received.
+         * Sent when new profile recording is started using console.profile() call.
          */
-        once(event: "inspectorNotification", listener: (message: InspectorNotification<{}>) => void): this;
+        on(event: "Profiler.consoleProfileStarted", listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
 
         /**
-         * Issued when new execution context is created.
+         * Issued when console API was called.
          */
-        once(event: "Runtime.executionContextCreated", listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+        on(event: "Runtime.consoleAPICalled", listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
 
         /**
-         * Issued when execution context is destroyed.
+         * Issued when unhandled exception was revoked.
          */
-        once(event: "Runtime.executionContextDestroyed", listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+        on(event: "Runtime.exceptionRevoked", listener: (message: InspectorNotification<Runtime.ExceptionRevokedEventDataType>) => void): this;
 
         /**
-         * Issued when all executionContexts were cleared in browser
+         * Issued when exception was thrown and unhandled.
          */
-        once(event: "Runtime.executionContextsCleared", listener: () => void): this;
+        on(event: "Runtime.exceptionThrown", listener: (message: InspectorNotification<Runtime.ExceptionThrownEventDataType>) => void): this;
 
         /**
-         * Issued when exception was thrown and unhandled.
+         * Issued when new execution context is created.
          */
-        once(event: "Runtime.exceptionThrown", listener: (message: InspectorNotification<Runtime.ExceptionThrownEventDataType>) => void): this;
+        on(event: "Runtime.executionContextCreated", listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
 
         /**
-         * Issued when unhandled exception was revoked.
+         * Issued when execution context is destroyed.
          */
-        once(event: "Runtime.exceptionRevoked", listener: (message: InspectorNotification<Runtime.ExceptionRevokedEventDataType>) => void): this;
+        on(event: "Runtime.executionContextDestroyed", listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
 
         /**
-         * Issued when console API was called.
+         * Issued when all executionContexts were cleared in browser
          */
-        once(event: "Runtime.consoleAPICalled", listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
+        on(event: "Runtime.executionContextsCleared", listener: () => void): this;
 
         /**
-         * Issued when object should be inspected (for example, as a result of inspect() command line API call).
+         * Issued when object should be inspected (for example, as a result of inspect() command line API
+call).
          */
-        once(event: "Runtime.inspectRequested", listener: (message: InspectorNotification<Runtime.InspectRequestedEventDataType>) => void): this;
+        on(event: "Runtime.inspectRequested", listener: (message: InspectorNotification<Runtime.InspectRequestedEventDataType>) => void): this;
+
+        once(event: string, listener: (...args: any[]) => void): this;
 
         /**
-         * Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.
+         * Emitted when any notification from the V8 Inspector is received.
          */
-        once(event: "Debugger.scriptParsed", listener: (message: InspectorNotification<Debugger.ScriptParsedEventDataType>) => void): this;
+        once(event: "inspectorNotification", listener: (message: InspectorNotification<{}>) => void): this;
 
         /**
-         * Fired when virtual machine fails to parse the script.
+         * Issued when new console message is added.
          */
-        once(event: "Debugger.scriptFailedToParse", listener: (message: InspectorNotification<Debugger.ScriptFailedToParseEventDataType>) => void): this;
+        once(event: "Console.messageAdded", listener: (message: InspectorNotification<Console.MessageAddedEventDataType>) => void): this;
 
         /**
          * Fired when breakpoint is resolved to an actual script and location.
@@ -2256,81 +2545,86 @@ declare module "inspector" {
         once(event: "Debugger.resumed", listener: () => void): this;
 
         /**
-         * Issued when new console message is added.
+         * Fired when virtual machine fails to parse the script.
          */
-        once(event: "Console.messageAdded", listener: (message: InspectorNotification<Console.MessageAddedEventDataType>) => void): this;
+        once(event: "Debugger.scriptFailedToParse", listener: (message: InspectorNotification<Debugger.ScriptFailedToParseEventDataType>) => void): this;
 
         /**
-         * Sent when new profile recording is started using console.profile() call.
+         * Fired when virtual machine parses script. This event is also fired for all known and uncollected
+scripts upon enabling debugger.
          */
-        once(event: "Profiler.consoleProfileStarted", listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
+        once(event: "Debugger.scriptParsed", listener: (message: InspectorNotification<Debugger.ScriptParsedEventDataType>) => void): this;
 
-        once(event: "Profiler.consoleProfileFinished", listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
         once(event: "HeapProfiler.addHeapSnapshotChunk", listener: (message: InspectorNotification<HeapProfiler.AddHeapSnapshotChunkEventDataType>) => void): this;
-        once(event: "HeapProfiler.resetProfiles", listener: () => void): this;
-        once(event: "HeapProfiler.reportHeapSnapshotProgress", listener: (message: InspectorNotification<HeapProfiler.ReportHeapSnapshotProgressEventDataType>) => void): this;
 
         /**
-         * If heap objects tracking has been started then backend regularly sends a current value for last seen object id and corresponding timestamp. If the were changes in the heap since last event then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
+         * If heap objects tracking has been started then backend may send update for one or more fragments
          */
-        once(event: "HeapProfiler.lastSeenObjectId", listener: (message: InspectorNotification<HeapProfiler.LastSeenObjectIdEventDataType>) => void): this;
+        once(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
 
         /**
-         * If heap objects tracking has been started then backend may send update for one or more fragments
+         * If heap objects tracking has been started then backend regularly sends a current value for last
+seen object id and corresponding timestamp. If the were changes in the heap since last event
+then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
          */
-        once(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
+        once(event: "HeapProfiler.lastSeenObjectId", listener: (message: InspectorNotification<HeapProfiler.LastSeenObjectIdEventDataType>) => void): this;
 
-        prependListener(event: string, listener: (...args: any[]) => void): this;
+        once(event: "HeapProfiler.reportHeapSnapshotProgress", listener: (message: InspectorNotification<HeapProfiler.ReportHeapSnapshotProgressEventDataType>) => void): this;
+        once(event: "HeapProfiler.resetProfiles", listener: () => void): this;
+        once(event: "Profiler.consoleProfileFinished", listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
 
         /**
-         * Emitted when any notification from the V8 Inspector is received.
+         * Sent when new profile recording is started using console.profile() call.
          */
-        prependListener(event: "inspectorNotification", listener: (message: InspectorNotification<{}>) => void): this;
+        once(event: "Profiler.consoleProfileStarted", listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
 
         /**
-         * Issued when new execution context is created.
+         * Issued when console API was called.
          */
-        prependListener(event: "Runtime.executionContextCreated", listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+        once(event: "Runtime.consoleAPICalled", listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
 
         /**
-         * Issued when execution context is destroyed.
+         * Issued when unhandled exception was revoked.
          */
-        prependListener(event: "Runtime.executionContextDestroyed", listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+        once(event: "Runtime.exceptionRevoked", listener: (message: InspectorNotification<Runtime.ExceptionRevokedEventDataType>) => void): this;
 
         /**
-         * Issued when all executionContexts were cleared in browser
+         * Issued when exception was thrown and unhandled.
          */
-        prependListener(event: "Runtime.executionContextsCleared", listener: () => void): this;
+        once(event: "Runtime.exceptionThrown", listener: (message: InspectorNotification<Runtime.ExceptionThrownEventDataType>) => void): this;
 
         /**
-         * Issued when exception was thrown and unhandled.
+         * Issued when new execution context is created.
          */
-        prependListener(event: "Runtime.exceptionThrown", listener: (message: InspectorNotification<Runtime.ExceptionThrownEventDataType>) => void): this;
+        once(event: "Runtime.executionContextCreated", listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
 
         /**
-         * Issued when unhandled exception was revoked.
+         * Issued when execution context is destroyed.
          */
-        prependListener(event: "Runtime.exceptionRevoked", listener: (message: InspectorNotification<Runtime.ExceptionRevokedEventDataType>) => void): this;
+        once(event: "Runtime.executionContextDestroyed", listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
 
         /**
-         * Issued when console API was called.
+         * Issued when all executionContexts were cleared in browser
          */
-        prependListener(event: "Runtime.consoleAPICalled", listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
+        once(event: "Runtime.executionContextsCleared", listener: () => void): this;
 
         /**
-         * Issued when object should be inspected (for example, as a result of inspect() command line API call).
+         * Issued when object should be inspected (for example, as a result of inspect() command line API
+call).
          */
-        prependListener(event: "Runtime.inspectRequested", listener: (message: InspectorNotification<Runtime.InspectRequestedEventDataType>) => void): this;
+        once(event: "Runtime.inspectRequested", listener: (message: InspectorNotification<Runtime.InspectRequestedEventDataType>) => void): this;
+
+        prependListener(event: string, listener: (...args: any[]) => void): this;
 
         /**
-         * Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.
+         * Emitted when any notification from the V8 Inspector is received.
          */
-        prependListener(event: "Debugger.scriptParsed", listener: (message: InspectorNotification<Debugger.ScriptParsedEventDataType>) => void): this;
+        prependListener(event: "inspectorNotification", listener: (message: InspectorNotification<{}>) => void): this;
 
         /**
-         * Fired when virtual machine fails to parse the script.
+         * Issued when new console message is added.
          */
-        prependListener(event: "Debugger.scriptFailedToParse", listener: (message: InspectorNotification<Debugger.ScriptFailedToParseEventDataType>) => void): this;
+        prependListener(event: "Console.messageAdded", listener: (message: InspectorNotification<Console.MessageAddedEventDataType>) => void): this;
 
         /**
          * Fired when breakpoint is resolved to an actual script and location.
@@ -2348,81 +2642,86 @@ declare module "inspector" {
         prependListener(event: "Debugger.resumed", listener: () => void): this;
 
         /**
-         * Issued when new console message is added.
+         * Fired when virtual machine fails to parse the script.
          */
-        prependListener(event: "Console.messageAdded", listener: (message: InspectorNotification<Console.MessageAddedEventDataType>) => void): this;
+        prependListener(event: "Debugger.scriptFailedToParse", listener: (message: InspectorNotification<Debugger.ScriptFailedToParseEventDataType>) => void): this;
 
         /**
-         * Sent when new profile recording is started using console.profile() call.
+         * Fired when virtual machine parses script. This event is also fired for all known and uncollected
+scripts upon enabling debugger.
          */
-        prependListener(event: "Profiler.consoleProfileStarted", listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
+        prependListener(event: "Debugger.scriptParsed", listener: (message: InspectorNotification<Debugger.ScriptParsedEventDataType>) => void): this;
 
-        prependListener(event: "Profiler.consoleProfileFinished", listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
         prependListener(event: "HeapProfiler.addHeapSnapshotChunk", listener: (message: InspectorNotification<HeapProfiler.AddHeapSnapshotChunkEventDataType>) => void): this;
-        prependListener(event: "HeapProfiler.resetProfiles", listener: () => void): this;
-        prependListener(event: "HeapProfiler.reportHeapSnapshotProgress", listener: (message: InspectorNotification<HeapProfiler.ReportHeapSnapshotProgressEventDataType>) => void): this;
 
         /**
-         * If heap objects tracking has been started then backend regularly sends a current value for last seen object id and corresponding timestamp. If the were changes in the heap since last event then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
+         * If heap objects tracking has been started then backend may send update for one or more fragments
          */
-        prependListener(event: "HeapProfiler.lastSeenObjectId", listener: (message: InspectorNotification<HeapProfiler.LastSeenObjectIdEventDataType>) => void): this;
+        prependListener(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
 
         /**
-         * If heap objects tracking has been started then backend may send update for one or more fragments
+         * If heap objects tracking has been started then backend regularly sends a current value for last
+seen object id and corresponding timestamp. If the were changes in the heap since last event
+then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
          */
-        prependListener(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
+        prependListener(event: "HeapProfiler.lastSeenObjectId", listener: (message: InspectorNotification<HeapProfiler.LastSeenObjectIdEventDataType>) => void): this;
 
-        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "HeapProfiler.reportHeapSnapshotProgress", listener: (message: InspectorNotification<HeapProfiler.ReportHeapSnapshotProgressEventDataType>) => void): this;
+        prependListener(event: "HeapProfiler.resetProfiles", listener: () => void): this;
+        prependListener(event: "Profiler.consoleProfileFinished", listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
 
         /**
-         * Emitted when any notification from the V8 Inspector is received.
+         * Sent when new profile recording is started using console.profile() call.
          */
-        prependOnceListener(event: "inspectorNotification", listener: (message: InspectorNotification<{}>) => void): this;
+        prependListener(event: "Profiler.consoleProfileStarted", listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
 
         /**
-         * Issued when new execution context is created.
+         * Issued when console API was called.
          */
-        prependOnceListener(event: "Runtime.executionContextCreated", listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+        prependListener(event: "Runtime.consoleAPICalled", listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
 
         /**
-         * Issued when execution context is destroyed.
+         * Issued when unhandled exception was revoked.
          */
-        prependOnceListener(event: "Runtime.executionContextDestroyed", listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+        prependListener(event: "Runtime.exceptionRevoked", listener: (message: InspectorNotification<Runtime.ExceptionRevokedEventDataType>) => void): this;
 
         /**
-         * Issued when all executionContexts were cleared in browser
+         * Issued when exception was thrown and unhandled.
          */
-        prependOnceListener(event: "Runtime.executionContextsCleared", listener: () => void): this;
+        prependListener(event: "Runtime.exceptionThrown", listener: (message: InspectorNotification<Runtime.ExceptionThrownEventDataType>) => void): this;
 
         /**
-         * Issued when exception was thrown and unhandled.
+         * Issued when new execution context is created.
          */
-        prependOnceListener(event: "Runtime.exceptionThrown", listener: (message: InspectorNotification<Runtime.ExceptionThrownEventDataType>) => void): this;
+        prependListener(event: "Runtime.executionContextCreated", listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
 
         /**
-         * Issued when unhandled exception was revoked.
+         * Issued when execution context is destroyed.
          */
-        prependOnceListener(event: "Runtime.exceptionRevoked", listener: (message: InspectorNotification<Runtime.ExceptionRevokedEventDataType>) => void): this;
+        prependListener(event: "Runtime.executionContextDestroyed", listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
 
         /**
-         * Issued when console API was called.
+         * Issued when all executionContexts were cleared in browser
          */
-        prependOnceListener(event: "Runtime.consoleAPICalled", listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
+        prependListener(event: "Runtime.executionContextsCleared", listener: () => void): this;
 
         /**
-         * Issued when object should be inspected (for example, as a result of inspect() command line API call).
+         * Issued when object should be inspected (for example, as a result of inspect() command line API
+call).
          */
-        prependOnceListener(event: "Runtime.inspectRequested", listener: (message: InspectorNotification<Runtime.InspectRequestedEventDataType>) => void): this;
+        prependListener(event: "Runtime.inspectRequested", listener: (message: InspectorNotification<Runtime.InspectRequestedEventDataType>) => void): this;
+
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
 
         /**
-         * Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.
+         * Emitted when any notification from the V8 Inspector is received.
          */
-        prependOnceListener(event: "Debugger.scriptParsed", listener: (message: InspectorNotification<Debugger.ScriptParsedEventDataType>) => void): this;
+        prependOnceListener(event: "inspectorNotification", listener: (message: InspectorNotification<{}>) => void): this;
 
         /**
-         * Fired when virtual machine fails to parse the script.
+         * Issued when new console message is added.
          */
-        prependOnceListener(event: "Debugger.scriptFailedToParse", listener: (message: InspectorNotification<Debugger.ScriptFailedToParseEventDataType>) => void): this;
+        prependOnceListener(event: "Console.messageAdded", listener: (message: InspectorNotification<Console.MessageAddedEventDataType>) => void): this;
 
         /**
          * Fired when breakpoint is resolved to an actual script and location.
@@ -2440,29 +2739,74 @@ declare module "inspector" {
         prependOnceListener(event: "Debugger.resumed", listener: () => void): this;
 
         /**
-         * Issued when new console message is added.
+         * Fired when virtual machine fails to parse the script.
          */
-        prependOnceListener(event: "Console.messageAdded", listener: (message: InspectorNotification<Console.MessageAddedEventDataType>) => void): this;
+        prependOnceListener(event: "Debugger.scriptFailedToParse", listener: (message: InspectorNotification<Debugger.ScriptFailedToParseEventDataType>) => void): this;
 
         /**
-         * Sent when new profile recording is started using console.profile() call.
+         * Fired when virtual machine parses script. This event is also fired for all known and uncollected
+scripts upon enabling debugger.
          */
-        prependOnceListener(event: "Profiler.consoleProfileStarted", listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
+        prependOnceListener(event: "Debugger.scriptParsed", listener: (message: InspectorNotification<Debugger.ScriptParsedEventDataType>) => void): this;
 
-        prependOnceListener(event: "Profiler.consoleProfileFinished", listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
         prependOnceListener(event: "HeapProfiler.addHeapSnapshotChunk", listener: (message: InspectorNotification<HeapProfiler.AddHeapSnapshotChunkEventDataType>) => void): this;
-        prependOnceListener(event: "HeapProfiler.resetProfiles", listener: () => void): this;
-        prependOnceListener(event: "HeapProfiler.reportHeapSnapshotProgress", listener: (message: InspectorNotification<HeapProfiler.ReportHeapSnapshotProgressEventDataType>) => void): this;
 
         /**
-         * If heap objects tracking has been started then backend regularly sends a current value for last seen object id and corresponding timestamp. If the were changes in the heap since last event then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
+         * If heap objects tracking has been started then backend may send update for one or more fragments
+         */
+        prependOnceListener(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
+
+        /**
+         * If heap objects tracking has been started then backend regularly sends a current value for last
+seen object id and corresponding timestamp. If the were changes in the heap since last event
+then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
          */
         prependOnceListener(event: "HeapProfiler.lastSeenObjectId", listener: (message: InspectorNotification<HeapProfiler.LastSeenObjectIdEventDataType>) => void): this;
 
+        prependOnceListener(event: "HeapProfiler.reportHeapSnapshotProgress", listener: (message: InspectorNotification<HeapProfiler.ReportHeapSnapshotProgressEventDataType>) => void): this;
+        prependOnceListener(event: "HeapProfiler.resetProfiles", listener: () => void): this;
+        prependOnceListener(event: "Profiler.consoleProfileFinished", listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
+
         /**
-         * If heap objects tracking has been started then backend may send update for one or more fragments
+         * Sent when new profile recording is started using console.profile() call.
          */
-        prependOnceListener(event: "HeapProfiler.heapStatsUpdate", listener: (message: InspectorNotification<HeapProfiler.HeapStatsUpdateEventDataType>) => void): this;
+        prependOnceListener(event: "Profiler.consoleProfileStarted", listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
+
+        /**
+         * Issued when console API was called.
+         */
+        prependOnceListener(event: "Runtime.consoleAPICalled", listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
+
+        /**
+         * Issued when unhandled exception was revoked.
+         */
+        prependOnceListener(event: "Runtime.exceptionRevoked", listener: (message: InspectorNotification<Runtime.ExceptionRevokedEventDataType>) => void): this;
+
+        /**
+         * Issued when exception was thrown and unhandled.
+         */
+        prependOnceListener(event: "Runtime.exceptionThrown", listener: (message: InspectorNotification<Runtime.ExceptionThrownEventDataType>) => void): this;
+
+        /**
+         * Issued when new execution context is created.
+         */
+        prependOnceListener(event: "Runtime.executionContextCreated", listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+
+        /**
+         * Issued when execution context is destroyed.
+         */
+        prependOnceListener(event: "Runtime.executionContextDestroyed", listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+
+        /**
+         * Issued when all executionContexts were cleared in browser
+         */
+        prependOnceListener(event: "Runtime.executionContextsCleared", listener: () => void): this;
+
+        /**
+         * Issued when object should be inspected (for example, as a result of inspect() command line API
+call).
+         */
+        prependOnceListener(event: "Runtime.inspectRequested", listener: (message: InspectorNotification<Runtime.InspectRequestedEventDataType>) => void): this;
     }
 
     // Top Level API