@types/node 8.10.32 → 8.10.36

node v8/inspector.d.ts

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