import { EventHandler, EventListener } from '../events/index.mjs';
import { DevToolsAdapter } from './adapter.mjs';
export declare namespace DevToolsInterface {
    namespace Accessibility {
        /** Unique accessibility node identifier. */
        type AXNodeId = string;
        /** Enum of possible property types. */
        type AXValueType = 'boolean' | 'tristate' | 'booleanOrUndefined' | 'idref' | 'idrefList' | 'integer' | 'node' | 'nodeList' | 'number' | 'string' | 'computedString' | 'token' | 'tokenList' | 'domRelation' | 'role' | 'internalRole' | 'valueUndefined';
        /** Enum of possible property sources. */
        type AXValueSourceType = 'attribute' | 'implicit' | 'style' | 'contents' | 'placeholder' | 'relatedElement';
        /** Enum of possible native property sources (as a subtype of a particular AXValueSourceType). */
        type AXValueNativeSourceType = 'figcaption' | 'label' | 'labelfor' | 'labelwrapped' | 'legend' | 'tablecaption' | 'title' | 'other';
        /** A single source for a computed AX property. */
        type AXValueSource = {
            type: AXValueSourceType;
            value?: AXValue;
            attribute?: string;
            attributeValue?: AXValue;
            superseded?: boolean;
            nativeSource?: AXValueNativeSourceType;
            nativeSourceValue?: AXValue;
            invalid?: boolean;
            invalidReason?: string;
        };
        type AXRelatedNode = {
            backendDOMNodeId: DOM.BackendNodeId;
            idref?: string;
            text?: string;
        };
        type AXProperty = {
            name: AXPropertyName;
            value: AXValue;
        };
        /** A single computed AX property. */
        type AXValue = {
            type: AXValueType;
            value?: any;
            relatedNodes?: AXRelatedNode[];
            sources?: AXValueSource[];
        };
        /** Values of AXProperty name: - from 'busy' to 'roledescription': states which apply to every AX node - from 'live' to 'root': attributes which apply to nodes in live regions - from 'autocomplete' to 'valuetext': attributes which apply to widgets - from 'checked' to 'selected': states which apply to widgets - from 'activedescendant' to 'owns' - relationships between elements other than parent/child/sibling. */
        type AXPropertyName = 'busy' | 'disabled' | 'editable' | 'focusable' | 'focused' | 'hidden' | 'hiddenRoot' | 'invalid' | 'keyshortcuts' | 'settable' | 'roledescription' | 'live' | 'atomic' | 'relevant' | 'root' | 'autocomplete' | 'hasPopup' | 'level' | 'multiselectable' | 'orientation' | 'multiline' | 'readonly' | 'required' | 'valuemin' | 'valuemax' | 'valuetext' | 'checked' | 'expanded' | 'modal' | 'pressed' | 'selected' | 'activedescendant' | 'controls' | 'describedby' | 'details' | 'errormessage' | 'flowto' | 'labelledby' | 'owns';
        /** A node in the accessibility tree. */
        type AXNode = {
            nodeId: AXNodeId;
            ignored: boolean;
            ignoredReasons?: AXProperty[];
            role?: AXValue;
            name?: AXValue;
            description?: AXValue;
            value?: AXValue;
            properties?: AXProperty[];
            childIds?: AXNodeId[];
            backendDOMNodeId?: DOM.BackendNodeId;
        };
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type GetPartialAXTreeRequest = {
            nodeId?: DOM.NodeId;
            backendNodeId?: DOM.BackendNodeId;
            objectId?: Runtime.RemoteObjectId;
            fetchRelatives?: boolean;
        };
        type GetPartialAXTreeResponse = {
            nodes: AXNode[];
        };
        type GetFullAXTreeRequest = {};
        type GetFullAXTreeResponse = {
            nodes: AXNode[];
        };
    }
    namespace Animation {
        /** Animation instance. */
        type Animation = {
            id: string;
            name: string;
            pausedState: boolean;
            playState: string;
            playbackRate: number;
            startTime: number;
            currentTime: number;
            type: 'CSSTransition' | 'CSSAnimation' | 'WebAnimation';
            source?: AnimationEffect;
            cssId?: string;
        };
        /** AnimationEffect instance */
        type AnimationEffect = {
            delay: number;
            endDelay: number;
            iterationStart: number;
            iterations: number;
            duration: number;
            direction: string;
            fill: string;
            backendNodeId?: DOM.BackendNodeId;
            keyframesRule?: KeyframesRule;
            easing: string;
        };
        /** Keyframes Rule */
        type KeyframesRule = {
            name?: string;
            keyframes: KeyframeStyle[];
        };
        /** Keyframe Style */
        type KeyframeStyle = {
            offset: string;
            easing: string;
        };
        type AnimationCanceledEvent = {
            id: string;
        };
        type AnimationCreatedEvent = {
            id: string;
        };
        type AnimationStartedEvent = {
            animation: Animation;
        };
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type GetCurrentTimeRequest = {
            id: string;
        };
        type GetCurrentTimeResponse = {
            currentTime: number;
        };
        type GetPlaybackRateRequest = {};
        type GetPlaybackRateResponse = {
            playbackRate: number;
        };
        type ReleaseAnimationsRequest = {
            animations: string[];
        };
        type ReleaseAnimationsResponse = {};
        type ResolveAnimationRequest = {
            animationId: string;
        };
        type ResolveAnimationResponse = {
            remoteObject: Runtime.RemoteObject;
        };
        type SeekAnimationsRequest = {
            animations: string[];
            currentTime: number;
        };
        type SeekAnimationsResponse = {};
        type SetPausedRequest = {
            animations: string[];
            paused: boolean;
        };
        type SetPausedResponse = {};
        type SetPlaybackRateRequest = {
            playbackRate: number;
        };
        type SetPlaybackRateResponse = {};
        type SetTimingRequest = {
            animationId: string;
            duration: number;
            delay: number;
        };
        type SetTimingResponse = {};
    }
    namespace ApplicationCache {
        /** Detailed application cache resource information. */
        type ApplicationCacheResource = {
            url: string;
            size: number;
            type: string;
        };
        /** Detailed application cache information. */
        type ApplicationCache = {
            manifestURL: string;
            size: number;
            creationTime: number;
            updateTime: number;
            resources: ApplicationCacheResource[];
        };
        /** Frame identifier - manifest URL pair. */
        type FrameWithManifest = {
            frameId: Page.FrameId;
            manifestURL: string;
            status: number;
        };
        type ApplicationCacheStatusUpdatedEvent = {
            frameId: Page.FrameId;
            manifestURL: string;
            status: number;
        };
        type NetworkStateUpdatedEvent = {
            isNowOnline: boolean;
        };
        type EnableRequest = {};
        type EnableResponse = {};
        type GetApplicationCacheForFrameRequest = {
            frameId: Page.FrameId;
        };
        type GetApplicationCacheForFrameResponse = {
            applicationCache: ApplicationCache;
        };
        type GetFramesWithManifestsRequest = {};
        type GetFramesWithManifestsResponse = {
            frameIds: FrameWithManifest[];
        };
        type GetManifestForFrameRequest = {
            frameId: Page.FrameId;
        };
        type GetManifestForFrameResponse = {
            manifestURL: string;
        };
    }
    namespace Audits {
        type GetEncodedResponseRequest = {
            requestId: Network.RequestId;
            encoding: 'webp' | 'jpeg' | 'png';
            quality?: number;
            sizeOnly?: boolean;
        };
        type GetEncodedResponseResponse = {
            body?: string;
            originalSize: number;
            encodedSize: number;
        };
    }
    namespace BackgroundService {
        /** The Background Service that will be associated with the commands/events. Every Background Service operates independently, but they share the same API. */
        type ServiceName = 'backgroundFetch' | 'backgroundSync' | 'pushMessaging' | 'notifications' | 'paymentHandler';
        /** A key-value pair for additional event information to pass along. */
        type EventMetadata = {
            key: string;
            value: string;
        };
        type BackgroundServiceEvent = {
            timestamp: Network.TimeSinceEpoch;
            origin: string;
            serviceWorkerRegistrationId: ServiceWorker.RegistrationID;
            service: ServiceName;
            eventName: string;
            instanceId: string;
            eventMetadata: EventMetadata[];
        };
        type RecordingStateChangedEvent = {
            isRecording: boolean;
            service: ServiceName;
        };
        type BackgroundServiceEventReceivedEvent = {
            backgroundServiceEvent: BackgroundServiceEvent;
        };
        type StartObservingRequest = {
            service: ServiceName;
        };
        type StartObservingResponse = {};
        type StopObservingRequest = {
            service: ServiceName;
        };
        type StopObservingResponse = {};
        type SetRecordingRequest = {
            shouldRecord: boolean;
            service: ServiceName;
        };
        type SetRecordingResponse = {};
        type ClearEventsRequest = {
            service: ServiceName;
        };
        type ClearEventsResponse = {};
    }
    namespace Browser {
        type WindowID = number;
        /** The state of the browser window. */
        type WindowState = 'normal' | 'minimized' | 'maximized' | 'fullscreen';
        /** Browser window bounds information */
        type Bounds = {
            left?: number;
            top?: number;
            width?: number;
            height?: number;
            windowState?: WindowState;
        };
        type PermissionType = 'accessibilityEvents' | 'audioCapture' | 'backgroundSync' | 'backgroundFetch' | 'clipboardRead' | 'clipboardWrite' | 'durableStorage' | 'flash' | 'geolocation' | 'midi' | 'midiSysex' | 'notifications' | 'paymentHandler' | 'periodicBackgroundSync' | 'protectedMediaIdentifier' | 'sensors' | 'videoCapture' | 'idleDetection' | 'wakeLockScreen' | 'wakeLockSystem';
        /** Chrome histogram bucket. */
        type Bucket = {
            low: number;
            high: number;
            count: number;
        };
        /** Chrome histogram. */
        type Histogram = {
            name: string;
            sum: number;
            count: number;
            buckets: Bucket[];
        };
        type GrantPermissionsRequest = {
            origin: string;
            permissions: PermissionType[];
            browserContextId?: Target.BrowserContextID;
        };
        type GrantPermissionsResponse = {};
        type ResetPermissionsRequest = {
            browserContextId?: Target.BrowserContextID;
        };
        type ResetPermissionsResponse = {};
        type CloseRequest = {};
        type CloseResponse = {};
        type CrashRequest = {};
        type CrashResponse = {};
        type CrashGpuProcessRequest = {};
        type CrashGpuProcessResponse = {};
        type GetVersionRequest = {};
        type GetVersionResponse = {
            protocolVersion: string;
            product: string;
            revision: string;
            userAgent: string;
            jsVersion: string;
        };
        type GetBrowserCommandLineRequest = {};
        type GetBrowserCommandLineResponse = {
            arguments: string[];
        };
        type GetHistogramsRequest = {
            query?: string;
            delta?: boolean;
        };
        type GetHistogramsResponse = {
            histograms: Histogram[];
        };
        type GetHistogramRequest = {
            name: string;
            delta?: boolean;
        };
        type GetHistogramResponse = {
            histogram: Histogram;
        };
        type GetWindowBoundsRequest = {
            windowId: WindowID;
        };
        type GetWindowBoundsResponse = {
            bounds: Bounds;
        };
        type GetWindowForTargetRequest = {
            targetId?: Target.TargetID;
        };
        type GetWindowForTargetResponse = {
            windowId: WindowID;
            bounds: Bounds;
        };
        type SetWindowBoundsRequest = {
            windowId: WindowID;
            bounds: Bounds;
        };
        type SetWindowBoundsResponse = {};
        type SetDockTileRequest = {
            badgeLabel?: string;
            image?: string;
        };
        type SetDockTileResponse = {};
    }
    namespace CSS {
        type StyleSheetId = string;
        /** Stylesheet type: "injected" for stylesheets injected via extension, "user-agent" for user-agent stylesheets, "inspector" for stylesheets created by the inspector (i.e. those holding the "via inspector" rules), "regular" for regular stylesheets. */
        type StyleSheetOrigin = 'injected' | 'user-agent' | 'inspector' | 'regular';
        /** CSS rule collection for a single pseudo style. */
        type PseudoElementMatches = {
            pseudoType: DOM.PseudoType;
            matches: RuleMatch[];
        };
        /** Inherited CSS rule collection from ancestor node. */
        type InheritedStyleEntry = {
            inlineStyle?: CSSStyle;
            matchedCSSRules: RuleMatch[];
        };
        /** Match data for a CSS rule. */
        type RuleMatch = {
            rule: CSSRule;
            matchingSelectors: number[];
        };
        /** Data for a simple selector (these are delimited by commas in a selector list). */
        type Value = {
            text: string;
            range?: SourceRange;
        };
        /** Selector list data. */
        type SelectorList = {
            selectors: Value[];
            text: string;
        };
        /** CSS stylesheet metainformation. */
        type CSSStyleSheetHeader = {
            styleSheetId: StyleSheetId;
            frameId: Page.FrameId;
            sourceURL: string;
            sourceMapURL?: string;
            origin: StyleSheetOrigin;
            title: string;
            ownerNode?: DOM.BackendNodeId;
            disabled: boolean;
            hasSourceURL?: boolean;
            isInline: boolean;
            startLine: number;
            startColumn: number;
            length: number;
        };
        /** CSS rule representation. */
        type CSSRule = {
            styleSheetId?: StyleSheetId;
            selectorList: SelectorList;
            origin: StyleSheetOrigin;
            style: CSSStyle;
            media?: CSSMedia[];
        };
        /** CSS coverage information. */
        type RuleUsage = {
            styleSheetId: StyleSheetId;
            startOffset: number;
            endOffset: number;
            used: boolean;
        };
        /** Text range within a resource. All numbers are zero-based. */
        type SourceRange = {
            startLine: number;
            startColumn: number;
            endLine: number;
            endColumn: number;
        };
        type ShorthandEntry = {
            name: string;
            value: string;
            important?: boolean;
        };
        type CSSComputedStyleProperty = {
            name: string;
            value: string;
        };
        /** CSS style representation. */
        type CSSStyle = {
            styleSheetId?: StyleSheetId;
            cssProperties: CSSProperty[];
            shorthandEntries: ShorthandEntry[];
            cssText?: string;
            range?: SourceRange;
        };
        /** CSS property declaration data. */
        type CSSProperty = {
            name: string;
            value: string;
            important?: boolean;
            implicit?: boolean;
            text?: string;
            parsedOk?: boolean;
            disabled?: boolean;
            range?: SourceRange;
        };
        /** CSS media rule descriptor. */
        type CSSMedia = {
            text: string;
            source: 'mediaRule' | 'importRule' | 'linkedSheet' | 'inlineSheet';
            sourceURL?: string;
            range?: SourceRange;
            styleSheetId?: StyleSheetId;
            mediaList?: MediaQuery[];
        };
        /** Media query descriptor. */
        type MediaQuery = {
            expressions: MediaQueryExpression[];
            active: boolean;
        };
        /** Media query expression descriptor. */
        type MediaQueryExpression = {
            value: number;
            unit: string;
            feature: string;
            valueRange?: SourceRange;
            computedLength?: number;
        };
        /** Information about amount of glyphs that were rendered with given font. */
        type PlatformFontUsage = {
            familyName: string;
            isCustomFont: boolean;
            glyphCount: number;
        };
        /** Properties of a web font: https://www.w3.org/TR/2008/REC-CSS2-20080411/fonts.html#font-descriptions */
        type FontFace = {
            fontFamily: string;
            fontStyle: string;
            fontVariant: string;
            fontWeight: string;
            fontStretch: string;
            unicodeRange: string;
            src: string;
            platformFontFamily: string;
        };
        /** CSS keyframes rule representation. */
        type CSSKeyframesRule = {
            animationName: Value;
            keyframes: CSSKeyframeRule[];
        };
        /** CSS keyframe rule representation. */
        type CSSKeyframeRule = {
            styleSheetId?: StyleSheetId;
            origin: StyleSheetOrigin;
            keyText: Value;
            style: CSSStyle;
        };
        /** A descriptor of operation to mutate style declaration text. */
        type StyleDeclarationEdit = {
            styleSheetId: StyleSheetId;
            range: SourceRange;
            text: string;
        };
        type FontsUpdatedEvent = {
            font?: FontFace;
        };
        type MediaQueryResultChangedEvent = {
            [key: string]: any;
        };
        type StyleSheetAddedEvent = {
            header: CSSStyleSheetHeader;
        };
        type StyleSheetChangedEvent = {
            styleSheetId: StyleSheetId;
        };
        type StyleSheetRemovedEvent = {
            styleSheetId: StyleSheetId;
        };
        type AddRuleRequest = {
            styleSheetId: StyleSheetId;
            ruleText: string;
            location: SourceRange;
        };
        type AddRuleResponse = {
            rule: CSSRule;
        };
        type CollectClassNamesRequest = {
            styleSheetId: StyleSheetId;
        };
        type CollectClassNamesResponse = {
            classNames: string[];
        };
        type CreateStyleSheetRequest = {
            frameId: Page.FrameId;
        };
        type CreateStyleSheetResponse = {
            styleSheetId: StyleSheetId;
        };
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type ForcePseudoStateRequest = {
            nodeId: DOM.NodeId;
            forcedPseudoClasses: string[];
        };
        type ForcePseudoStateResponse = {};
        type GetBackgroundColorsRequest = {
            nodeId: DOM.NodeId;
        };
        type GetBackgroundColorsResponse = {
            backgroundColors?: string[];
            computedFontSize?: string;
            computedFontWeight?: string;
        };
        type GetComputedStyleForNodeRequest = {
            nodeId: DOM.NodeId;
        };
        type GetComputedStyleForNodeResponse = {
            computedStyle: CSSComputedStyleProperty[];
        };
        type GetInlineStylesForNodeRequest = {
            nodeId: DOM.NodeId;
        };
        type GetInlineStylesForNodeResponse = {
            inlineStyle?: CSSStyle;
            attributesStyle?: CSSStyle;
        };
        type GetMatchedStylesForNodeRequest = {
            nodeId: DOM.NodeId;
        };
        type GetMatchedStylesForNodeResponse = {
            inlineStyle?: CSSStyle;
            attributesStyle?: CSSStyle;
            matchedCSSRules?: RuleMatch[];
            pseudoElements?: PseudoElementMatches[];
            inherited?: InheritedStyleEntry[];
            cssKeyframesRules?: CSSKeyframesRule[];
        };
        type GetMediaQueriesRequest = {};
        type GetMediaQueriesResponse = {
            medias: CSSMedia[];
        };
        type GetPlatformFontsForNodeRequest = {
            nodeId: DOM.NodeId;
        };
        type GetPlatformFontsForNodeResponse = {
            fonts: PlatformFontUsage[];
        };
        type GetStyleSheetTextRequest = {
            styleSheetId: StyleSheetId;
        };
        type GetStyleSheetTextResponse = {
            text: string;
        };
        type SetEffectivePropertyValueForNodeRequest = {
            nodeId: DOM.NodeId;
            propertyName: string;
            value: string;
        };
        type SetEffectivePropertyValueForNodeResponse = {};
        type SetKeyframeKeyRequest = {
            styleSheetId: StyleSheetId;
            range: SourceRange;
            keyText: string;
        };
        type SetKeyframeKeyResponse = {
            keyText: Value;
        };
        type SetMediaTextRequest = {
            styleSheetId: StyleSheetId;
            range: SourceRange;
            text: string;
        };
        type SetMediaTextResponse = {
            media: CSSMedia;
        };
        type SetRuleSelectorRequest = {
            styleSheetId: StyleSheetId;
            range: SourceRange;
            selector: string;
        };
        type SetRuleSelectorResponse = {
            selectorList: SelectorList;
        };
        type SetStyleSheetTextRequest = {
            styleSheetId: StyleSheetId;
            text: string;
        };
        type SetStyleSheetTextResponse = {
            sourceMapURL?: string;
        };
        type SetStyleTextsRequest = {
            edits: StyleDeclarationEdit[];
        };
        type SetStyleTextsResponse = {
            styles: CSSStyle[];
        };
        type StartRuleUsageTrackingRequest = {};
        type StartRuleUsageTrackingResponse = {};
        type StopRuleUsageTrackingRequest = {};
        type StopRuleUsageTrackingResponse = {
            ruleUsage: RuleUsage[];
        };
        type TakeCoverageDeltaRequest = {};
        type TakeCoverageDeltaResponse = {
            coverage: RuleUsage[];
        };
    }
    namespace CacheStorage {
        /** Unique identifier of the Cache object. */
        type CacheId = string;
        /** type of HTTP response cached */
        type CachedResponseType = 'basic' | 'cors' | 'default' | 'error' | 'opaqueResponse' | 'opaqueRedirect';
        /** Data entry. */
        type DataEntry = {
            requestURL: string;
            requestMethod: string;
            requestHeaders: Header[];
            responseTime: number;
            responseStatus: number;
            responseStatusText: string;
            responseType: CachedResponseType;
            responseHeaders: Header[];
        };
        /** Cache identifier. */
        type Cache = {
            cacheId: CacheId;
            securityOrigin: string;
            cacheName: string;
        };
        type Header = {
            name: string;
            value: string;
        };
        /** Cached response */
        type CachedResponse = {
            body: string;
        };
        type DeleteCacheRequest = {
            cacheId: CacheId;
        };
        type DeleteCacheResponse = {};
        type DeleteEntryRequest = {
            cacheId: CacheId;
            request: string;
        };
        type DeleteEntryResponse = {};
        type RequestCacheNamesRequest = {
            securityOrigin: string;
        };
        type RequestCacheNamesResponse = {
            caches: Cache[];
        };
        type RequestCachedResponseRequest = {
            cacheId: CacheId;
            requestURL: string;
            requestHeaders: Header[];
        };
        type RequestCachedResponseResponse = {
            response: CachedResponse;
        };
        type RequestEntriesRequest = {
            cacheId: CacheId;
            skipCount: number;
            pageSize: number;
            pathFilter?: string;
        };
        type RequestEntriesResponse = {
            cacheDataEntries: DataEntry[];
            returnCount: number;
        };
    }
    namespace Cast {
        type Sink = {
            name: string;
            id: string;
            session?: string;
        };
        type SinksUpdatedEvent = {
            sinks: Sink[];
        };
        type IssueUpdatedEvent = {
            issueMessage: string;
        };
        type EnableRequest = {
            presentationUrl?: string;
        };
        type EnableResponse = {};
        type DisableRequest = {};
        type DisableResponse = {};
        type SetSinkToUseRequest = {
            sinkName: string;
        };
        type SetSinkToUseResponse = {};
        type StartTabMirroringRequest = {
            sinkName: string;
        };
        type StartTabMirroringResponse = {};
        type StopCastingRequest = {
            sinkName: string;
        };
        type StopCastingResponse = {};
    }
    namespace DOM {
        /** Unique DOM node identifier. */
        type NodeId = number;
        /** Unique DOM node identifier used to reference a node that may not have been pushed to the front-end. */
        type BackendNodeId = number;
        /** Backend node with a friendly name. */
        type BackendNode = {
            nodeType: number;
            nodeName: string;
            backendNodeId: BackendNodeId;
        };
        /** Pseudo element type. */
        type PseudoType = 'first-line' | 'first-letter' | 'before' | 'after' | 'backdrop' | 'selection' | 'first-line-inherited' | 'scrollbar' | 'scrollbar-thumb' | 'scrollbar-button' | 'scrollbar-track' | 'scrollbar-track-piece' | 'scrollbar-corner' | 'resizer' | 'input-list-button';
        /** Shadow root type. */
        type ShadowRootType = 'user-agent' | 'open' | 'closed';
        /** DOM interaction is implemented in terms of mirror objects that represent the actual DOM nodes. DOMNode is a base node mirror type. */
        type Node = {
            nodeId: NodeId;
            parentId?: NodeId;
            backendNodeId: BackendNodeId;
            nodeType: number;
            nodeName: string;
            localName: string;
            nodeValue: string;
            childNodeCount?: number;
            children?: Node[];
            attributes?: string[];
            documentURL?: string;
            baseURL?: string;
            publicId?: string;
            systemId?: string;
            internalSubset?: string;
            xmlVersion?: string;
            name?: string;
            value?: string;
            pseudoType?: PseudoType;
            shadowRootType?: ShadowRootType;
            frameId?: Page.FrameId;
            contentDocument?: Node;
            shadowRoots?: Node[];
            templateContent?: Node;
            pseudoElements?: Node[];
            importedDocument?: Node;
            distributedNodes?: BackendNode[];
            isSVG?: boolean;
        };
        /** A structure holding an RGBA color. */
        type RGBA = {
            r: number;
            g: number;
            b: number;
            a?: number;
        };
        /** An array of quad vertices, x immediately followed by y for each point, points clock-wise. */
        type Quad = number[];
        /** Box model. */
        type BoxModel = {
            content: Quad;
            padding: Quad;
            border: Quad;
            margin: Quad;
            width: number;
            height: number;
            shapeOutside?: ShapeOutsideInfo;
        };
        /** CSS Shape Outside details. */
        type ShapeOutsideInfo = {
            bounds: Quad;
            shape: any[];
            marginShape: any[];
        };
        /** Rectangle. */
        type Rect = {
            x: number;
            y: number;
            width: number;
            height: number;
        };
        type AttributeModifiedEvent = {
            nodeId: NodeId;
            name: string;
            value: string;
        };
        type AttributeRemovedEvent = {
            nodeId: NodeId;
            name: string;
        };
        type CharacterDataModifiedEvent = {
            nodeId: NodeId;
            characterData: string;
        };
        type ChildNodeCountUpdatedEvent = {
            nodeId: NodeId;
            childNodeCount: number;
        };
        type ChildNodeInsertedEvent = {
            parentNodeId: NodeId;
            previousNodeId: NodeId;
            node: Node;
        };
        type ChildNodeRemovedEvent = {
            parentNodeId: NodeId;
            nodeId: NodeId;
        };
        type DistributedNodesUpdatedEvent = {
            insertionPointId: NodeId;
            distributedNodes: BackendNode[];
        };
        type DocumentUpdatedEvent = {
            [key: string]: any;
        };
        type InlineStyleInvalidatedEvent = {
            nodeIds: NodeId[];
        };
        type PseudoElementAddedEvent = {
            parentId: NodeId;
            pseudoElement: Node;
        };
        type PseudoElementRemovedEvent = {
            parentId: NodeId;
            pseudoElementId: NodeId;
        };
        type SetChildNodesEvent = {
            parentId: NodeId;
            nodes: Node[];
        };
        type ShadowRootPoppedEvent = {
            hostId: NodeId;
            rootId: NodeId;
        };
        type ShadowRootPushedEvent = {
            hostId: NodeId;
            root: Node;
        };
        type CollectClassNamesFromSubtreeRequest = {
            nodeId: NodeId;
        };
        type CollectClassNamesFromSubtreeResponse = {
            classNames: string[];
        };
        type CopyToRequest = {
            nodeId: NodeId;
            targetNodeId: NodeId;
            insertBeforeNodeId?: NodeId;
        };
        type CopyToResponse = {
            nodeId: NodeId;
        };
        type DescribeNodeRequest = {
            nodeId?: NodeId;
            backendNodeId?: BackendNodeId;
            objectId?: Runtime.RemoteObjectId;
            depth?: number;
            pierce?: boolean;
        };
        type DescribeNodeResponse = {
            node: Node;
        };
        type DisableRequest = {};
        type DisableResponse = {};
        type DiscardSearchResultsRequest = {
            searchId: string;
        };
        type DiscardSearchResultsResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type FocusRequest = {
            nodeId?: NodeId;
            backendNodeId?: BackendNodeId;
            objectId?: Runtime.RemoteObjectId;
        };
        type FocusResponse = {};
        type GetAttributesRequest = {
            nodeId: NodeId;
        };
        type GetAttributesResponse = {
            attributes: string[];
        };
        type GetBoxModelRequest = {
            nodeId?: NodeId;
            backendNodeId?: BackendNodeId;
            objectId?: Runtime.RemoteObjectId;
        };
        type GetBoxModelResponse = {
            model: BoxModel;
        };
        type GetContentQuadsRequest = {
            nodeId?: NodeId;
            backendNodeId?: BackendNodeId;
            objectId?: Runtime.RemoteObjectId;
        };
        type GetContentQuadsResponse = {
            quads: Quad[];
        };
        type GetDocumentRequest = {
            depth?: number;
            pierce?: boolean;
        };
        type GetDocumentResponse = {
            root: Node;
        };
        type GetFlattenedDocumentRequest = {
            depth?: number;
            pierce?: boolean;
        };
        type GetFlattenedDocumentResponse = {
            nodes: Node[];
        };
        type GetNodeForLocationRequest = {
            x: number;
            y: number;
            includeUserAgentShadowDOM?: boolean;
        };
        type GetNodeForLocationResponse = {
            backendNodeId: BackendNodeId;
            nodeId?: NodeId;
        };
        type GetOuterHTMLRequest = {
            nodeId?: NodeId;
            backendNodeId?: BackendNodeId;
            objectId?: Runtime.RemoteObjectId;
        };
        type GetOuterHTMLResponse = {
            outerHTML: string;
        };
        type GetRelayoutBoundaryRequest = {
            nodeId: NodeId;
        };
        type GetRelayoutBoundaryResponse = {
            nodeId: NodeId;
        };
        type GetSearchResultsRequest = {
            searchId: string;
            fromIndex: number;
            toIndex: number;
        };
        type GetSearchResultsResponse = {
            nodeIds: NodeId[];
        };
        type HideHighlightRequest = {};
        type HideHighlightResponse = {};
        type HighlightNodeRequest = {};
        type HighlightNodeResponse = {};
        type HighlightRectRequest = {};
        type HighlightRectResponse = {};
        type MarkUndoableStateRequest = {};
        type MarkUndoableStateResponse = {};
        type MoveToRequest = {
            nodeId: NodeId;
            targetNodeId: NodeId;
            insertBeforeNodeId?: NodeId;
        };
        type MoveToResponse = {
            nodeId: NodeId;
        };
        type PerformSearchRequest = {
            query: string;
            includeUserAgentShadowDOM?: boolean;
        };
        type PerformSearchResponse = {
            searchId: string;
            resultCount: number;
        };
        type PushNodeByPathToFrontendRequest = {
            path: string;
        };
        type PushNodeByPathToFrontendResponse = {
            nodeId: NodeId;
        };
        type PushNodesByBackendIdsToFrontendRequest = {
            backendNodeIds: BackendNodeId[];
        };
        type PushNodesByBackendIdsToFrontendResponse = {
            nodeIds: NodeId[];
        };
        type QuerySelectorRequest = {
            nodeId: NodeId;
            selector: string;
        };
        type QuerySelectorResponse = {
            nodeId: NodeId;
        };
        type QuerySelectorAllRequest = {
            nodeId: NodeId;
            selector: string;
        };
        type QuerySelectorAllResponse = {
            nodeIds: NodeId[];
        };
        type RedoRequest = {};
        type RedoResponse = {};
        type RemoveAttributeRequest = {
            nodeId: NodeId;
            name: string;
        };
        type RemoveAttributeResponse = {};
        type RemoveNodeRequest = {
            nodeId: NodeId;
        };
        type RemoveNodeResponse = {};
        type RequestChildNodesRequest = {
            nodeId: NodeId;
            depth?: number;
            pierce?: boolean;
        };
        type RequestChildNodesResponse = {};
        type RequestNodeRequest = {
            objectId: Runtime.RemoteObjectId;
        };
        type RequestNodeResponse = {
            nodeId: NodeId;
        };
        type ResolveNodeRequest = {
            nodeId?: NodeId;
            backendNodeId?: DOM.BackendNodeId;
            objectGroup?: string;
            executionContextId?: Runtime.ExecutionContextId;
        };
        type ResolveNodeResponse = {
            object: Runtime.RemoteObject;
        };
        type SetAttributeValueRequest = {
            nodeId: NodeId;
            name: string;
            value: string;
        };
        type SetAttributeValueResponse = {};
        type SetAttributesAsTextRequest = {
            nodeId: NodeId;
            text: string;
            name?: string;
        };
        type SetAttributesAsTextResponse = {};
        type SetFileInputFilesRequest = {
            files: string[];
            nodeId?: NodeId;
            backendNodeId?: BackendNodeId;
            objectId?: Runtime.RemoteObjectId;
        };
        type SetFileInputFilesResponse = {};
        type GetFileInfoRequest = {
            objectId: Runtime.RemoteObjectId;
        };
        type GetFileInfoResponse = {
            path: string;
        };
        type SetInspectedNodeRequest = {
            nodeId: NodeId;
        };
        type SetInspectedNodeResponse = {};
        type SetNodeNameRequest = {
            nodeId: NodeId;
            name: string;
        };
        type SetNodeNameResponse = {
            nodeId: NodeId;
        };
        type SetNodeValueRequest = {
            nodeId: NodeId;
            value: string;
        };
        type SetNodeValueResponse = {};
        type SetOuterHTMLRequest = {
            nodeId: NodeId;
            outerHTML: string;
        };
        type SetOuterHTMLResponse = {};
        type UndoRequest = {};
        type UndoResponse = {};
        type GetFrameOwnerRequest = {
            frameId: Page.FrameId;
        };
        type GetFrameOwnerResponse = {
            backendNodeId: BackendNodeId;
            nodeId?: NodeId;
        };
    }
    namespace DOMDebugger {
        /** DOM breakpoint type. */
        type DOMBreakpointType = 'subtree-modified' | 'attribute-modified' | 'node-removed';
        /** Object event listener. */
        type EventListener = {
            type: string;
            useCapture: boolean;
            passive: boolean;
            once: boolean;
            scriptId: Runtime.ScriptId;
            lineNumber: number;
            columnNumber: number;
            handler?: Runtime.RemoteObject;
            originalHandler?: Runtime.RemoteObject;
            backendNodeId?: DOM.BackendNodeId;
        };
        type GetEventListenersRequest = {
            objectId: Runtime.RemoteObjectId;
            depth?: number;
            pierce?: boolean;
        };
        type GetEventListenersResponse = {
            listeners: EventListener[];
        };
        type RemoveDOMBreakpointRequest = {
            nodeId: DOM.NodeId;
            type: DOMBreakpointType;
        };
        type RemoveDOMBreakpointResponse = {};
        type RemoveEventListenerBreakpointRequest = {
            eventName: string;
            targetName?: string;
        };
        type RemoveEventListenerBreakpointResponse = {};
        type RemoveInstrumentationBreakpointRequest = {
            eventName: string;
        };
        type RemoveInstrumentationBreakpointResponse = {};
        type RemoveXHRBreakpointRequest = {
            url: string;
        };
        type RemoveXHRBreakpointResponse = {};
        type SetDOMBreakpointRequest = {
            nodeId: DOM.NodeId;
            type: DOMBreakpointType;
        };
        type SetDOMBreakpointResponse = {};
        type SetEventListenerBreakpointRequest = {
            eventName: string;
            targetName?: string;
        };
        type SetEventListenerBreakpointResponse = {};
        type SetInstrumentationBreakpointRequest = {
            eventName: string;
        };
        type SetInstrumentationBreakpointResponse = {};
        type SetXHRBreakpointRequest = {
            url: string;
        };
        type SetXHRBreakpointResponse = {};
    }
    namespace DOMSnapshot {
        /** A Node in the DOM tree. */
        type DOMNode = {
            nodeType: number;
            nodeName: string;
            nodeValue: string;
            textValue?: string;
            inputValue?: string;
            inputChecked?: boolean;
            optionSelected?: boolean;
            backendNodeId: DOM.BackendNodeId;
            childNodeIndexes?: number[];
            attributes?: NameValue[];
            pseudoElementIndexes?: number[];
            layoutNodeIndex?: number;
            documentURL?: string;
            baseURL?: string;
            contentLanguage?: string;
            documentEncoding?: string;
            publicId?: string;
            systemId?: string;
            frameId?: Page.FrameId;
            contentDocumentIndex?: number;
            pseudoType?: DOM.PseudoType;
            shadowRootType?: DOM.ShadowRootType;
            isClickable?: boolean;
            eventListeners?: DOMDebugger.EventListener[];
            currentSourceURL?: string;
            originURL?: string;
            scrollOffsetX?: number;
            scrollOffsetY?: number;
        };
        /** Details of post layout rendered text positions. The exact layout should not be regarded as stable and may change between versions. */
        type InlineTextBox = {
            boundingBox: DOM.Rect;
            startCharacterIndex: number;
            numCharacters: number;
        };
        /** Details of an element in the DOM tree with a LayoutObject. */
        type LayoutTreeNode = {
            domNodeIndex: number;
            boundingBox: DOM.Rect;
            layoutText?: string;
            inlineTextNodes?: InlineTextBox[];
            styleIndex?: number;
            paintOrder?: number;
            isStackingContext?: boolean;
        };
        /** A subset of the full ComputedStyle as defined by the request whitelist. */
        type ComputedStyle = {
            properties: NameValue[];
        };
        /** A name/value pair. */
        type NameValue = {
            name: string;
            value: string;
        };
        /** Index of the string in the strings table. */
        type StringIndex = number;
        /** Index of the string in the strings table. */
        type ArrayOfStrings = StringIndex[];
        /** Data that is only present on rare nodes. */
        type RareStringData = {
            index: number[];
            value: StringIndex[];
        };
        type RareBooleanData = {
            index: number[];
        };
        type RareIntegerData = {
            index: number[];
            value: number[];
        };
        type Rectangle = number[];
        /** Document snapshot. */
        type DocumentSnapshot = {
            documentURL: StringIndex;
            baseURL: StringIndex;
            contentLanguage: StringIndex;
            encodingName: StringIndex;
            publicId: StringIndex;
            systemId: StringIndex;
            frameId: StringIndex;
            nodes: NodeTreeSnapshot;
            layout: LayoutTreeSnapshot;
            textBoxes: TextBoxSnapshot;
            scrollOffsetX?: number;
            scrollOffsetY?: number;
        };
        /** Table containing nodes. */
        type NodeTreeSnapshot = {
            parentIndex?: number[];
            nodeType?: number[];
            nodeName?: StringIndex[];
            nodeValue?: StringIndex[];
            backendNodeId?: DOM.BackendNodeId[];
            attributes?: ArrayOfStrings[];
            textValue?: RareStringData;
            inputValue?: RareStringData;
            inputChecked?: RareBooleanData;
            optionSelected?: RareBooleanData;
            contentDocumentIndex?: RareIntegerData;
            pseudoType?: RareStringData;
            isClickable?: RareBooleanData;
            currentSourceURL?: RareStringData;
            originURL?: RareStringData;
        };
        /** Table of details of an element in the DOM tree with a LayoutObject. */
        type LayoutTreeSnapshot = {
            nodeIndex: number[];
            styles: ArrayOfStrings[];
            bounds: Rectangle[];
            text: StringIndex[];
            stackingContexts: RareBooleanData;
            offsetRects?: Rectangle[];
            scrollRects?: Rectangle[];
            clientRects?: Rectangle[];
        };
        /** Table of details of the post layout rendered text positions. The exact layout should not be regarded as stable and may change between versions. */
        type TextBoxSnapshot = {
            layoutIndex: number[];
            bounds: Rectangle[];
            start: number[];
            length: number[];
        };
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type GetSnapshotRequest = {
            computedStyleWhitelist: string[];
            includeEventListeners?: boolean;
            includePaintOrder?: boolean;
            includeUserAgentShadowTree?: boolean;
        };
        type GetSnapshotResponse = {
            domNodes: DOMNode[];
            layoutTreeNodes: LayoutTreeNode[];
            computedStyles: ComputedStyle[];
        };
        type CaptureSnapshotRequest = {
            computedStyles: string[];
            includeDOMRects?: boolean;
        };
        type CaptureSnapshotResponse = {
            documents: DocumentSnapshot[];
            strings: string[];
        };
    }
    namespace DOMStorage {
        /** DOM Storage identifier. */
        type StorageId = {
            securityOrigin: string;
            isLocalStorage: boolean;
        };
        /** DOM Storage item. */
        type Item = string[];
        type DomStorageItemAddedEvent = {
            storageId: StorageId;
            key: string;
            newValue: string;
        };
        type DomStorageItemRemovedEvent = {
            storageId: StorageId;
            key: string;
        };
        type DomStorageItemUpdatedEvent = {
            storageId: StorageId;
            key: string;
            oldValue: string;
            newValue: string;
        };
        type DomStorageItemsClearedEvent = {
            storageId: StorageId;
        };
        type ClearRequest = {
            storageId: StorageId;
        };
        type ClearResponse = {};
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type GetDOMStorageItemsRequest = {
            storageId: StorageId;
        };
        type GetDOMStorageItemsResponse = {
            entries: Item[];
        };
        type RemoveDOMStorageItemRequest = {
            storageId: StorageId;
            key: string;
        };
        type RemoveDOMStorageItemResponse = {};
        type SetDOMStorageItemRequest = {
            storageId: StorageId;
            key: string;
            value: string;
        };
        type SetDOMStorageItemResponse = {};
    }
    namespace Database {
        /** Unique identifier of Database object. */
        type DatabaseId = string;
        /** Database object. */
        type Database = {
            id: DatabaseId;
            domain: string;
            name: string;
            version: string;
        };
        /** Database error. */
        type Error = {
            message: string;
            code: number;
        };
        type AddDatabaseEvent = {
            database: Database;
        };
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type ExecuteSQLRequest = {
            databaseId: DatabaseId;
            query: string;
        };
        type ExecuteSQLResponse = {
            columnNames?: string[];
            values?: any[];
            sqlError?: Error;
        };
        type GetDatabaseTableNamesRequest = {
            databaseId: DatabaseId;
        };
        type GetDatabaseTableNamesResponse = {
            tableNames: string[];
        };
    }
    namespace DeviceOrientation {
        type ClearDeviceOrientationOverrideRequest = {};
        type ClearDeviceOrientationOverrideResponse = {};
        type SetDeviceOrientationOverrideRequest = {
            alpha: number;
            beta: number;
            gamma: number;
        };
        type SetDeviceOrientationOverrideResponse = {};
    }
    namespace Emulation {
        /** Screen orientation. */
        type ScreenOrientation = {
            type: 'portraitPrimary' | 'portraitSecondary' | 'landscapePrimary' | 'landscapeSecondary';
            angle: number;
        };
        /** advance: If the scheduler runs out of immediate work, the virtual time base may fast forward to allow the next delayed task (if any) to run; pause: The virtual time base may not advance; pauseIfNetworkFetchesPending: The virtual time base may not advance if there are any pending resource fetches. */
        type VirtualTimePolicy = 'advance' | 'pause' | 'pauseIfNetworkFetchesPending';
        type VirtualTimeBudgetExpiredEvent = {
            [key: string]: any;
        };
        type CanEmulateRequest = {};
        type CanEmulateResponse = {
            result: boolean;
        };
        type ClearDeviceMetricsOverrideRequest = {};
        type ClearDeviceMetricsOverrideResponse = {};
        type ClearGeolocationOverrideRequest = {};
        type ClearGeolocationOverrideResponse = {};
        type ResetPageScaleFactorRequest = {};
        type ResetPageScaleFactorResponse = {};
        type SetFocusEmulationEnabledRequest = {
            enabled: boolean;
        };
        type SetFocusEmulationEnabledResponse = {};
        type SetCPUThrottlingRateRequest = {
            rate: number;
        };
        type SetCPUThrottlingRateResponse = {};
        type SetDefaultBackgroundColorOverrideRequest = {
            color?: DOM.RGBA;
        };
        type SetDefaultBackgroundColorOverrideResponse = {};
        type SetDeviceMetricsOverrideRequest = {
            width: number;
            height: number;
            deviceScaleFactor: number;
            mobile: boolean;
            scale?: number;
            screenWidth?: number;
            screenHeight?: number;
            positionX?: number;
            positionY?: number;
            dontSetVisibleSize?: boolean;
            screenOrientation?: ScreenOrientation;
            viewport?: Page.Viewport;
        };
        type SetDeviceMetricsOverrideResponse = {};
        type SetScrollbarsHiddenRequest = {
            hidden: boolean;
        };
        type SetScrollbarsHiddenResponse = {};
        type SetDocumentCookieDisabledRequest = {
            disabled: boolean;
        };
        type SetDocumentCookieDisabledResponse = {};
        type SetEmitTouchEventsForMouseRequest = {
            enabled: boolean;
            configuration?: 'mobile' | 'desktop';
        };
        type SetEmitTouchEventsForMouseResponse = {};
        type SetEmulatedMediaRequest = {
            media: string;
        };
        type SetEmulatedMediaResponse = {};
        type SetGeolocationOverrideRequest = {
            latitude?: number;
            longitude?: number;
            accuracy?: number;
        };
        type SetGeolocationOverrideResponse = {};
        type SetNavigatorOverridesRequest = {
            platform: string;
        };
        type SetNavigatorOverridesResponse = {};
        type SetPageScaleFactorRequest = {
            pageScaleFactor: number;
        };
        type SetPageScaleFactorResponse = {};
        type SetScriptExecutionDisabledRequest = {
            value: boolean;
        };
        type SetScriptExecutionDisabledResponse = {};
        type SetTouchEmulationEnabledRequest = {
            enabled: boolean;
            maxTouchPoints?: number;
        };
        type SetTouchEmulationEnabledResponse = {};
        type SetVirtualTimePolicyRequest = {
            policy: VirtualTimePolicy;
            budget?: number;
            maxVirtualTimeTaskStarvationCount?: number;
            waitForNavigation?: boolean;
            initialVirtualTime?: Network.TimeSinceEpoch;
        };
        type SetVirtualTimePolicyResponse = {
            virtualTimeTicksBase: number;
        };
        type SetTimezoneOverrideRequest = {
            timezoneId: string;
        };
        type SetTimezoneOverrideResponse = {};
        type SetVisibleSizeRequest = {
            width: number;
            height: number;
        };
        type SetVisibleSizeResponse = {};
        type SetUserAgentOverrideRequest = {
            userAgent: string;
            acceptLanguage?: string;
            platform?: string;
        };
        type SetUserAgentOverrideResponse = {};
    }
    namespace HeadlessExperimental {
        /** Encoding options for a screenshot. */
        type ScreenshotParams = {
            format?: 'jpeg' | 'png';
            quality?: number;
        };
        type NeedsBeginFramesChangedEvent = {
            needsBeginFrames: boolean;
        };
        type BeginFrameRequest = {
            frameTimeTicks?: number;
            interval?: number;
            noDisplayUpdates?: boolean;
            screenshot?: ScreenshotParams;
        };
        type BeginFrameResponse = {
            hasDamage: boolean;
            screenshotData?: string;
        };
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
    }
    namespace IO {
        /** This is either obtained from another method or specifed as `blob:<uuid>` where `<uuid&gt` is an UUID of a Blob. */
        type StreamHandle = string;
        type CloseRequest = {
            handle: StreamHandle;
        };
        type CloseResponse = {};
        type ReadRequest = {
            handle: StreamHandle;
            offset?: number;
            size?: number;
        };
        type ReadResponse = {
            base64Encoded?: boolean;
            data: string;
            eof: boolean;
        };
        type ResolveBlobRequest = {
            objectId: Runtime.RemoteObjectId;
        };
        type ResolveBlobResponse = {
            uuid: string;
        };
    }
    namespace IndexedDB {
        /** Database with an array of object stores. */
        type DatabaseWithObjectStores = {
            name: string;
            version: number;
            objectStores: ObjectStore[];
        };
        /** Object store. */
        type ObjectStore = {
            name: string;
            keyPath: KeyPath;
            autoIncrement: boolean;
            indexes: ObjectStoreIndex[];
        };
        /** Object store index. */
        type ObjectStoreIndex = {
            name: string;
            keyPath: KeyPath;
            unique: boolean;
            multiEntry: boolean;
        };
        /** Key. */
        type Key = {
            type: 'number' | 'string' | 'date' | 'array';
            number?: number;
            string?: string;
            date?: number;
            array?: Key[];
        };
        /** Key range. */
        type KeyRange = {
            lower?: Key;
            upper?: Key;
            lowerOpen: boolean;
            upperOpen: boolean;
        };
        /** Data entry. */
        type DataEntry = {
            key: Runtime.RemoteObject;
            primaryKey: Runtime.RemoteObject;
            value: Runtime.RemoteObject;
        };
        /** Key path. */
        type KeyPath = {
            type: 'null' | 'string' | 'array';
            string?: string;
            array?: string[];
        };
        type ClearObjectStoreRequest = {
            securityOrigin: string;
            databaseName: string;
            objectStoreName: string;
        };
        type ClearObjectStoreResponse = {};
        type DeleteDatabaseRequest = {
            securityOrigin: string;
            databaseName: string;
        };
        type DeleteDatabaseResponse = {};
        type DeleteObjectStoreEntriesRequest = {
            securityOrigin: string;
            databaseName: string;
            objectStoreName: string;
            keyRange: KeyRange;
        };
        type DeleteObjectStoreEntriesResponse = {};
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type RequestDataRequest = {
            securityOrigin: string;
            databaseName: string;
            objectStoreName: string;
            indexName: string;
            skipCount: number;
            pageSize: number;
            keyRange?: KeyRange;
        };
        type RequestDataResponse = {
            objectStoreDataEntries: DataEntry[];
            hasMore: boolean;
        };
        type GetMetadataRequest = {
            securityOrigin: string;
            databaseName: string;
            objectStoreName: string;
        };
        type GetMetadataResponse = {
            entriesCount: number;
            keyGeneratorValue: number;
        };
        type RequestDatabaseRequest = {
            securityOrigin: string;
            databaseName: string;
        };
        type RequestDatabaseResponse = {
            databaseWithObjectStores: DatabaseWithObjectStores;
        };
        type RequestDatabaseNamesRequest = {
            securityOrigin: string;
        };
        type RequestDatabaseNamesResponse = {
            databaseNames: string[];
        };
    }
    namespace Input {
        type TouchPoint = {
            x: number;
            y: number;
            radiusX?: number;
            radiusY?: number;
            rotationAngle?: number;
            force?: number;
            id?: number;
        };
        type GestureSourceType = 'default' | 'touch' | 'mouse';
        /** UTC time in seconds, counted from January 1, 1970. */
        type TimeSinceEpoch = number;
        type DispatchKeyEventRequest = {
            type: 'keyDown' | 'keyUp' | 'rawKeyDown' | 'char';
            modifiers?: number;
            timestamp?: TimeSinceEpoch;
            text?: string;
            unmodifiedText?: string;
            keyIdentifier?: string;
            code?: string;
            key?: string;
            windowsVirtualKeyCode?: number;
            nativeVirtualKeyCode?: number;
            autoRepeat?: boolean;
            isKeypad?: boolean;
            isSystemKey?: boolean;
            location?: number;
        };
        type DispatchKeyEventResponse = {};
        type InsertTextRequest = {
            text: string;
        };
        type InsertTextResponse = {};
        type DispatchMouseEventRequest = {
            type: 'mousePressed' | 'mouseReleased' | 'mouseMoved' | 'mouseWheel';
            x: number;
            y: number;
            modifiers?: number;
            timestamp?: TimeSinceEpoch;
            button?: 'none' | 'left' | 'middle' | 'right' | 'back' | 'forward';
            buttons?: number;
            clickCount?: number;
            deltaX?: number;
            deltaY?: number;
            pointerType?: 'mouse' | 'pen';
        };
        type DispatchMouseEventResponse = {};
        type DispatchTouchEventRequest = {
            type: 'touchStart' | 'touchEnd' | 'touchMove' | 'touchCancel';
            touchPoints: TouchPoint[];
            modifiers?: number;
            timestamp?: TimeSinceEpoch;
        };
        type DispatchTouchEventResponse = {};
        type EmulateTouchFromMouseEventRequest = {
            type: 'mousePressed' | 'mouseReleased' | 'mouseMoved' | 'mouseWheel';
            x: number;
            y: number;
            button: 'none' | 'left' | 'middle' | 'right';
            timestamp?: TimeSinceEpoch;
            deltaX?: number;
            deltaY?: number;
            modifiers?: number;
            clickCount?: number;
        };
        type EmulateTouchFromMouseEventResponse = {};
        type SetIgnoreInputEventsRequest = {
            ignore: boolean;
        };
        type SetIgnoreInputEventsResponse = {};
        type SynthesizePinchGestureRequest = {
            x: number;
            y: number;
            scaleFactor: number;
            relativeSpeed?: number;
            gestureSourceType?: GestureSourceType;
        };
        type SynthesizePinchGestureResponse = {};
        type SynthesizeScrollGestureRequest = {
            x: number;
            y: number;
            xDistance?: number;
            yDistance?: number;
            xOverscroll?: number;
            yOverscroll?: number;
            preventFling?: boolean;
            speed?: number;
            gestureSourceType?: GestureSourceType;
            repeatCount?: number;
            repeatDelayMs?: number;
            interactionMarkerName?: string;
        };
        type SynthesizeScrollGestureResponse = {};
        type SynthesizeTapGestureRequest = {
            x: number;
            y: number;
            duration?: number;
            tapCount?: number;
            gestureSourceType?: GestureSourceType;
        };
        type SynthesizeTapGestureResponse = {};
    }
    namespace Inspector {
        type DetachedEvent = {
            reason: string;
        };
        type TargetCrashedEvent = {
            [key: string]: any;
        };
        type TargetReloadedAfterCrashEvent = {
            [key: string]: any;
        };
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
    }
    namespace LayerTree {
        /** Unique Layer identifier. */
        type LayerId = string;
        /** Unique snapshot identifier. */
        type SnapshotId = string;
        /** Rectangle where scrolling happens on the main thread. */
        type ScrollRect = {
            rect: DOM.Rect;
            type: 'RepaintsOnScroll' | 'TouchEventHandler' | 'WheelEventHandler';
        };
        /** Sticky position constraints. */
        type StickyPositionConstraint = {
            stickyBoxRect: DOM.Rect;
            containingBlockRect: DOM.Rect;
            nearestLayerShiftingStickyBox?: LayerId;
            nearestLayerShiftingContainingBlock?: LayerId;
        };
        /** Serialized fragment of layer picture along with its offset within the layer. */
        type PictureTile = {
            x: number;
            y: number;
            picture: string;
        };
        /** Information about a compositing layer. */
        type Layer = {
            layerId: LayerId;
            parentLayerId?: LayerId;
            backendNodeId?: DOM.BackendNodeId;
            offsetX: number;
            offsetY: number;
            width: number;
            height: number;
            transform?: number[];
            anchorX?: number;
            anchorY?: number;
            anchorZ?: number;
            paintCount: number;
            drawsContent: boolean;
            invisible?: boolean;
            scrollRects?: ScrollRect[];
            stickyPositionConstraint?: StickyPositionConstraint;
        };
        /** Array of timings, one per paint step. */
        type PaintProfile = number[];
        type LayerPaintedEvent = {
            layerId: LayerId;
            clip: DOM.Rect;
        };
        type LayerTreeDidChangeEvent = {
            layers?: Layer[];
        };
        type CompositingReasonsRequest = {
            layerId: LayerId;
        };
        type CompositingReasonsResponse = {
            compositingReasons: string[];
        };
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type LoadSnapshotRequest = {
            tiles: PictureTile[];
        };
        type LoadSnapshotResponse = {
            snapshotId: SnapshotId;
        };
        type MakeSnapshotRequest = {
            layerId: LayerId;
        };
        type MakeSnapshotResponse = {
            snapshotId: SnapshotId;
        };
        type ProfileSnapshotRequest = {
            snapshotId: SnapshotId;
            minRepeatCount?: number;
            minDuration?: number;
            clipRect?: DOM.Rect;
        };
        type ProfileSnapshotResponse = {
            timings: PaintProfile[];
        };
        type ReleaseSnapshotRequest = {
            snapshotId: SnapshotId;
        };
        type ReleaseSnapshotResponse = {};
        type ReplaySnapshotRequest = {
            snapshotId: SnapshotId;
            fromStep?: number;
            toStep?: number;
            scale?: number;
        };
        type ReplaySnapshotResponse = {
            dataURL: string;
        };
        type SnapshotCommandLogRequest = {
            snapshotId: SnapshotId;
        };
        type SnapshotCommandLogResponse = {
            commandLog: {
                [key: string]: any;
            }[];
        };
    }
    namespace Log {
        /** Log entry. */
        type LogEntry = {
            source: 'xml' | 'javascript' | 'network' | 'storage' | 'appcache' | 'rendering' | 'security' | 'deprecation' | 'worker' | 'violation' | 'intervention' | 'recommendation' | 'other';
            level: 'verbose' | 'info' | 'warning' | 'error';
            text: string;
            timestamp: Runtime.Timestamp;
            url?: string;
            lineNumber?: number;
            stackTrace?: Runtime.StackTrace;
            networkRequestId?: Network.RequestId;
            workerId?: string;
            args?: Runtime.RemoteObject[];
        };
        /** Violation configuration setting. */
        type ViolationSetting = {
            name: 'longTask' | 'longLayout' | 'blockedEvent' | 'blockedParser' | 'discouragedAPIUse' | 'handler' | 'recurringHandler';
            threshold: number;
        };
        type EntryAddedEvent = {
            entry: LogEntry;
        };
        type ClearRequest = {};
        type ClearResponse = {};
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type StartViolationsReportRequest = {
            config: ViolationSetting[];
        };
        type StartViolationsReportResponse = {};
        type StopViolationsReportRequest = {};
        type StopViolationsReportResponse = {};
    }
    namespace Memory {
        /** Memory pressure level. */
        type PressureLevel = 'moderate' | 'critical';
        /** Heap profile sample. */
        type SamplingProfileNode = {
            size: number;
            total: number;
            stack: string[];
        };
        /** Array of heap profile samples. */
        type SamplingProfile = {
            samples: SamplingProfileNode[];
            modules: Module[];
        };
        /** Executable module information */
        type Module = {
            name: string;
            uuid: string;
            baseAddress: string;
            size: number;
        };
        type GetDOMCountersRequest = {};
        type GetDOMCountersResponse = {
            documents: number;
            nodes: number;
            jsEventListeners: number;
        };
        type PrepareForLeakDetectionRequest = {};
        type PrepareForLeakDetectionResponse = {};
        type ForciblyPurgeJavaScriptMemoryRequest = {};
        type ForciblyPurgeJavaScriptMemoryResponse = {};
        type SetPressureNotificationsSuppressedRequest = {
            suppressed: boolean;
        };
        type SetPressureNotificationsSuppressedResponse = {};
        type SimulatePressureNotificationRequest = {
            level: PressureLevel;
        };
        type SimulatePressureNotificationResponse = {};
        type StartSamplingRequest = {
            samplingInterval?: number;
            suppressRandomness?: boolean;
        };
        type StartSamplingResponse = {};
        type StopSamplingRequest = {};
        type StopSamplingResponse = {};
        type GetAllTimeSamplingProfileRequest = {};
        type GetAllTimeSamplingProfileResponse = {
            profile: SamplingProfile;
        };
        type GetBrowserSamplingProfileRequest = {};
        type GetBrowserSamplingProfileResponse = {
            profile: SamplingProfile;
        };
        type GetSamplingProfileRequest = {};
        type GetSamplingProfileResponse = {
            profile: SamplingProfile;
        };
    }
    namespace Network {
        /** Resource type as it was perceived by the rendering engine. */
        type ResourceType = 'Document' | 'Stylesheet' | 'Image' | 'Media' | 'Font' | 'Script' | 'TextTrack' | 'XHR' | 'Fetch' | 'EventSource' | 'WebSocket' | 'Manifest' | 'SignedExchange' | 'Ping' | 'CSPViolationReport' | 'Other';
        /** Unique loader identifier. */
        type LoaderId = string;
        /** Unique request identifier. */
        type RequestId = string;
        /** Unique intercepted request identifier. */
        type InterceptionId = string;
        /** Network level fetch failure reason. */
        type ErrorReason = 'Failed' | 'Aborted' | 'TimedOut' | 'AccessDenied' | 'ConnectionClosed' | 'ConnectionReset' | 'ConnectionRefused' | 'ConnectionAborted' | 'ConnectionFailed' | 'NameNotResolved' | 'InternetDisconnected' | 'AddressUnreachable' | 'BlockedByClient' | 'BlockedByResponse';
        /** UTC time in seconds, counted from January 1, 1970. */
        type TimeSinceEpoch = number;
        /** Monotonically increasing time in seconds since an arbitrary point in the past. */
        type MonotonicTime = number;
        /** Request / response headers as keys / values of JSON object. */
        type Headers = {
            [key: string]: any;
        };
        /** The underlying connection technology that the browser is supposedly using. */
        type ConnectionType = 'none' | 'cellular2g' | 'cellular3g' | 'cellular4g' | 'bluetooth' | 'ethernet' | 'wifi' | 'wimax' | 'other';
        /** Represents the cookie's 'SameSite' status: https://tools.ietf.org/html/draft-west-first-party-cookies */
        type CookieSameSite = 'Strict' | 'Lax' | 'Extended' | 'None';
        /** Timing information for the request. */
        type ResourceTiming = {
            requestTime: number;
            proxyStart: number;
            proxyEnd: number;
            dnsStart: number;
            dnsEnd: number;
            connectStart: number;
            connectEnd: number;
            sslStart: number;
            sslEnd: number;
            workerStart: number;
            workerReady: number;
            sendStart: number;
            sendEnd: number;
            pushStart: number;
            pushEnd: number;
            receiveHeadersEnd: number;
        };
        /** Loading priority of a resource request. */
        type ResourcePriority = 'VeryLow' | 'Low' | 'Medium' | 'High' | 'VeryHigh';
        /** HTTP request data. */
        type Request = {
            url: string;
            urlFragment?: string;
            method: string;
            headers: Headers;
            postData?: string;
            hasPostData?: boolean;
            mixedContentType?: Security.MixedContentType;
            initialPriority: ResourcePriority;
            referrerPolicy: 'unsafe-url' | 'no-referrer-when-downgrade' | 'no-referrer' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin';
            isLinkPreload?: boolean;
        };
        /** Details of a signed certificate timestamp (SCT). */
        type SignedCertificateTimestamp = {
            status: string;
            origin: string;
            logDescription: string;
            logId: string;
            timestamp: TimeSinceEpoch;
            hashAlgorithm: string;
            signatureAlgorithm: string;
            signatureData: string;
        };
        /** Security details about a request. */
        type SecurityDetails = {
            protocol: string;
            keyExchange: string;
            keyExchangeGroup?: string;
            cipher: string;
            mac?: string;
            certificateId: Security.CertificateId;
            subjectName: string;
            sanList: string[];
            issuer: string;
            validFrom: TimeSinceEpoch;
            validTo: TimeSinceEpoch;
            signedCertificateTimestampList: SignedCertificateTimestamp[];
            certificateTransparencyCompliance: CertificateTransparencyCompliance;
        };
        /** Whether the request complied with Certificate Transparency policy. */
        type CertificateTransparencyCompliance = 'unknown' | 'not-compliant' | 'compliant';
        /** The reason why request was blocked. */
        type BlockedReason = 'other' | 'csp' | 'mixed-content' | 'origin' | 'inspector' | 'subresource-filter' | 'content-type' | 'collapsed-by-client';
        /** HTTP response data. */
        type Response = {
            url: string;
            status: number;
            statusText: string;
            headers: Headers;
            headersText?: string;
            mimeType: string;
            requestHeaders?: Headers;
            requestHeadersText?: string;
            connectionReused: boolean;
            connectionId: number;
            remoteIPAddress?: string;
            remotePort?: number;
            fromDiskCache?: boolean;
            fromServiceWorker?: boolean;
            fromPrefetchCache?: boolean;
            encodedDataLength: number;
            timing?: ResourceTiming;
            protocol?: string;
            securityState: Security.SecurityState;
            securityDetails?: SecurityDetails;
        };
        /** WebSocket request data. */
        type WebSocketRequest = {
            headers: Headers;
        };
        /** WebSocket response data. */
        type WebSocketResponse = {
            status: number;
            statusText: string;
            headers: Headers;
            headersText?: string;
            requestHeaders?: Headers;
            requestHeadersText?: string;
        };
        /** WebSocket message data. This represents an entire WebSocket message, not just a fragmented frame as the name suggests. */
        type WebSocketFrame = {
            opcode: number;
            mask: boolean;
            payloadData: string;
        };
        /** Information about the cached resource. */
        type CachedResource = {
            url: string;
            type: ResourceType;
            response?: Response;
            bodySize: number;
        };
        /** Information about the request initiator. */
        type Initiator = {
            type: 'parser' | 'script' | 'preload' | 'SignedExchange' | 'other';
            stack?: Runtime.StackTrace;
            url?: string;
            lineNumber?: number;
        };
        /** Cookie object */
        type Cookie = {
            name: string;
            value: string;
            domain: string;
            path: string;
            expires: number;
            size: number;
            httpOnly: boolean;
            secure: boolean;
            session: boolean;
            sameSite?: CookieSameSite;
        };
        /** Cookie parameter object */
        type CookieParam = {
            name: string;
            value: string;
            url?: string;
            domain?: string;
            path?: string;
            secure?: boolean;
            httpOnly?: boolean;
            sameSite?: CookieSameSite;
            expires?: TimeSinceEpoch;
        };
        /** Authorization challenge for HTTP status code 401 or 407. */
        type AuthChallenge = {
            source?: 'Server' | 'Proxy';
            origin: string;
            scheme: string;
            realm: string;
        };
        /** Response to an AuthChallenge. */
        type AuthChallengeResponse = {
            response: 'Default' | 'CancelAuth' | 'ProvideCredentials';
            username?: string;
            password?: string;
        };
        /** Stages of the interception to begin intercepting. Request will intercept before the request is sent. Response will intercept after the response is received. */
        type InterceptionStage = 'Request' | 'HeadersReceived';
        /** Request pattern for interception. */
        type RequestPattern = {
            urlPattern?: string;
            resourceType?: ResourceType;
            interceptionStage?: InterceptionStage;
        };
        /** Information about a signed exchange signature. https://wicg.github.io/webpackage/draft-yasskin-httpbis-origin-signed-exchanges-impl.html#rfc.section.3.1 */
        type SignedExchangeSignature = {
            label: string;
            signature: string;
            integrity: string;
            certUrl?: string;
            certSha256?: string;
            validityUrl: string;
            date: number;
            expires: number;
            certificates?: string[];
        };
        /** Information about a signed exchange header. https://wicg.github.io/webpackage/draft-yasskin-httpbis-origin-signed-exchanges-impl.html#cbor-representation */
        type SignedExchangeHeader = {
            requestUrl: string;
            responseCode: number;
            responseHeaders: Headers;
            signatures: SignedExchangeSignature[];
            headerIntegrity: string;
        };
        /** Field type for a signed exchange related error. */
        type SignedExchangeErrorField = 'signatureSig' | 'signatureIntegrity' | 'signatureCertUrl' | 'signatureCertSha256' | 'signatureValidityUrl' | 'signatureTimestamps';
        /** Information about a signed exchange response. */
        type SignedExchangeError = {
            message: string;
            signatureIndex?: number;
            errorField?: SignedExchangeErrorField;
        };
        /** Information about a signed exchange response. */
        type SignedExchangeInfo = {
            outerResponse: Response;
            header?: SignedExchangeHeader;
            securityDetails?: SecurityDetails;
            errors?: SignedExchangeError[];
        };
        type DataReceivedEvent = {
            requestId: RequestId;
            timestamp: MonotonicTime;
            dataLength: number;
            encodedDataLength: number;
        };
        type EventSourceMessageReceivedEvent = {
            requestId: RequestId;
            timestamp: MonotonicTime;
            eventName: string;
            eventId: string;
            data: string;
        };
        type LoadingFailedEvent = {
            requestId: RequestId;
            timestamp: MonotonicTime;
            type: ResourceType;
            errorText: string;
            canceled?: boolean;
            blockedReason?: BlockedReason;
        };
        type LoadingFinishedEvent = {
            requestId: RequestId;
            timestamp: MonotonicTime;
            encodedDataLength: number;
            shouldReportCorbBlocking?: boolean;
        };
        type RequestInterceptedEvent = {
            interceptionId: InterceptionId;
            request: Request;
            frameId: Page.FrameId;
            resourceType: ResourceType;
            isNavigationRequest: boolean;
            isDownload?: boolean;
            redirectUrl?: string;
            authChallenge?: AuthChallenge;
            responseErrorReason?: ErrorReason;
            responseStatusCode?: number;
            responseHeaders?: Headers;
            requestId?: RequestId;
        };
        type RequestServedFromCacheEvent = {
            requestId: RequestId;
        };
        type RequestWillBeSentEvent = {
            requestId: RequestId;
            loaderId: LoaderId;
            documentURL: string;
            request: Request;
            timestamp: MonotonicTime;
            wallTime: TimeSinceEpoch;
            initiator: Initiator;
            redirectResponse?: Response;
            type?: ResourceType;
            frameId?: Page.FrameId;
            hasUserGesture?: boolean;
        };
        type ResourceChangedPriorityEvent = {
            requestId: RequestId;
            newPriority: ResourcePriority;
            timestamp: MonotonicTime;
        };
        type SignedExchangeReceivedEvent = {
            requestId: RequestId;
            info: SignedExchangeInfo;
        };
        type ResponseReceivedEvent = {
            requestId: RequestId;
            loaderId: LoaderId;
            timestamp: MonotonicTime;
            type: ResourceType;
            response: Response;
            frameId?: Page.FrameId;
        };
        type WebSocketClosedEvent = {
            requestId: RequestId;
            timestamp: MonotonicTime;
        };
        type WebSocketCreatedEvent = {
            requestId: RequestId;
            url: string;
            initiator?: Initiator;
        };
        type WebSocketFrameErrorEvent = {
            requestId: RequestId;
            timestamp: MonotonicTime;
            errorMessage: string;
        };
        type WebSocketFrameReceivedEvent = {
            requestId: RequestId;
            timestamp: MonotonicTime;
            response: WebSocketFrame;
        };
        type WebSocketFrameSentEvent = {
            requestId: RequestId;
            timestamp: MonotonicTime;
            response: WebSocketFrame;
        };
        type WebSocketHandshakeResponseReceivedEvent = {
            requestId: RequestId;
            timestamp: MonotonicTime;
            response: WebSocketResponse;
        };
        type WebSocketWillSendHandshakeRequestEvent = {
            requestId: RequestId;
            timestamp: MonotonicTime;
            wallTime: TimeSinceEpoch;
            request: WebSocketRequest;
        };
        type CanClearBrowserCacheRequest = {};
        type CanClearBrowserCacheResponse = {
            result: boolean;
        };
        type CanClearBrowserCookiesRequest = {};
        type CanClearBrowserCookiesResponse = {
            result: boolean;
        };
        type CanEmulateNetworkConditionsRequest = {};
        type CanEmulateNetworkConditionsResponse = {
            result: boolean;
        };
        type ClearBrowserCacheRequest = {};
        type ClearBrowserCacheResponse = {};
        type ClearBrowserCookiesRequest = {};
        type ClearBrowserCookiesResponse = {};
        type ContinueInterceptedRequestRequest = {
            interceptionId: InterceptionId;
            errorReason?: ErrorReason;
            rawResponse?: string;
            url?: string;
            method?: string;
            postData?: string;
            headers?: Headers;
            authChallengeResponse?: AuthChallengeResponse;
        };
        type ContinueInterceptedRequestResponse = {};
        type DeleteCookiesRequest = {
            name: string;
            url?: string;
            domain?: string;
            path?: string;
        };
        type DeleteCookiesResponse = {};
        type DisableRequest = {};
        type DisableResponse = {};
        type EmulateNetworkConditionsRequest = {
            offline: boolean;
            latency: number;
            downloadThroughput: number;
            uploadThroughput: number;
            connectionType?: ConnectionType;
        };
        type EmulateNetworkConditionsResponse = {};
        type EnableRequest = {
            maxTotalBufferSize?: number;
            maxResourceBufferSize?: number;
            maxPostDataSize?: number;
        };
        type EnableResponse = {};
        type GetAllCookiesRequest = {};
        type GetAllCookiesResponse = {
            cookies: Cookie[];
        };
        type GetCertificateRequest = {
            origin: string;
        };
        type GetCertificateResponse = {
            tableNames: string[];
        };
        type GetCookiesRequest = {
            urls?: string[];
        };
        type GetCookiesResponse = {
            cookies: Cookie[];
        };
        type GetResponseBodyRequest = {
            requestId: RequestId;
        };
        type GetResponseBodyResponse = {
            body: string;
            base64Encoded: boolean;
        };
        type GetRequestPostDataRequest = {
            requestId: RequestId;
        };
        type GetRequestPostDataResponse = {
            postData: string;
        };
        type GetResponseBodyForInterceptionRequest = {
            interceptionId: InterceptionId;
        };
        type GetResponseBodyForInterceptionResponse = {
            body: string;
            base64Encoded: boolean;
        };
        type TakeResponseBodyForInterceptionAsStreamRequest = {
            interceptionId: InterceptionId;
        };
        type TakeResponseBodyForInterceptionAsStreamResponse = {
            stream: IO.StreamHandle;
        };
        type ReplayXHRRequest = {
            requestId: RequestId;
        };
        type ReplayXHRResponse = {};
        type SearchInResponseBodyRequest = {
            requestId: RequestId;
            query: string;
            caseSensitive?: boolean;
            isRegex?: boolean;
        };
        type SearchInResponseBodyResponse = {
            result: Debugger.SearchMatch[];
        };
        type SetBlockedURLsRequest = {
            urls: string[];
        };
        type SetBlockedURLsResponse = {};
        type SetBypassServiceWorkerRequest = {
            bypass: boolean;
        };
        type SetBypassServiceWorkerResponse = {};
        type SetCacheDisabledRequest = {
            cacheDisabled: boolean;
        };
        type SetCacheDisabledResponse = {};
        type SetCookieRequest = {
            name: string;
            value: string;
            url?: string;
            domain?: string;
            path?: string;
            secure?: boolean;
            httpOnly?: boolean;
            sameSite?: CookieSameSite;
            expires?: TimeSinceEpoch;
        };
        type SetCookieResponse = {
            success: boolean;
        };
        type SetCookiesRequest = {
            cookies: CookieParam[];
        };
        type SetCookiesResponse = {};
        type SetDataSizeLimitsForTestRequest = {
            maxTotalSize: number;
            maxResourceSize: number;
        };
        type SetDataSizeLimitsForTestResponse = {};
        type SetExtraHTTPHeadersRequest = {
            headers: Headers;
        };
        type SetExtraHTTPHeadersResponse = {};
        type SetRequestInterceptionRequest = {
            patterns: RequestPattern[];
        };
        type SetRequestInterceptionResponse = {};
        type SetUserAgentOverrideRequest = {
            userAgent: string;
            acceptLanguage?: string;
            platform?: string;
        };
        type SetUserAgentOverrideResponse = {};
    }
    namespace Overlay {
        /** Configuration data for the highlighting of page elements. */
        type HighlightConfig = {
            showInfo?: boolean;
            showStyles?: boolean;
            showRulers?: boolean;
            showExtensionLines?: boolean;
            contentColor?: DOM.RGBA;
            paddingColor?: DOM.RGBA;
            borderColor?: DOM.RGBA;
            marginColor?: DOM.RGBA;
            eventTargetColor?: DOM.RGBA;
            shapeColor?: DOM.RGBA;
            shapeMarginColor?: DOM.RGBA;
            cssGridColor?: DOM.RGBA;
        };
        type InspectMode = 'searchForNode' | 'searchForUAShadowDOM' | 'captureAreaScreenshot' | 'showDistances' | 'none';
        type InspectNodeRequestedEvent = {
            backendNodeId: DOM.BackendNodeId;
        };
        type NodeHighlightRequestedEvent = {
            nodeId: DOM.NodeId;
        };
        type ScreenshotRequestedEvent = {
            viewport: Page.Viewport;
        };
        type InspectModeCanceledEvent = {
            [key: string]: any;
        };
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type GetHighlightObjectForTestRequest = {
            nodeId: DOM.NodeId;
            includeDistance?: boolean;
            includeStyle?: boolean;
        };
        type GetHighlightObjectForTestResponse = {
            highlight: {
                [key: string]: any;
            };
        };
        type HideHighlightRequest = {};
        type HideHighlightResponse = {};
        type HighlightFrameRequest = {
            frameId: Page.FrameId;
            contentColor?: DOM.RGBA;
            contentOutlineColor?: DOM.RGBA;
        };
        type HighlightFrameResponse = {};
        type HighlightNodeRequest = {
            highlightConfig: HighlightConfig;
            nodeId?: DOM.NodeId;
            backendNodeId?: DOM.BackendNodeId;
            objectId?: Runtime.RemoteObjectId;
            selector?: string;
        };
        type HighlightNodeResponse = {};
        type HighlightQuadRequest = {
            quad: DOM.Quad;
            color?: DOM.RGBA;
            outlineColor?: DOM.RGBA;
        };
        type HighlightQuadResponse = {};
        type HighlightRectRequest = {
            x: number;
            y: number;
            width: number;
            height: number;
            color?: DOM.RGBA;
            outlineColor?: DOM.RGBA;
        };
        type HighlightRectResponse = {};
        type SetInspectModeRequest = {
            mode: InspectMode;
            highlightConfig?: HighlightConfig;
        };
        type SetInspectModeResponse = {};
        type SetShowAdHighlightsRequest = {
            show: boolean;
        };
        type SetShowAdHighlightsResponse = {};
        type SetPausedInDebuggerMessageRequest = {
            message?: string;
        };
        type SetPausedInDebuggerMessageResponse = {};
        type SetShowDebugBordersRequest = {
            show: boolean;
        };
        type SetShowDebugBordersResponse = {};
        type SetShowFPSCounterRequest = {
            show: boolean;
        };
        type SetShowFPSCounterResponse = {};
        type SetShowPaintRectsRequest = {
            result: boolean;
        };
        type SetShowPaintRectsResponse = {};
        type SetShowLayoutShiftRegionsRequest = {
            result: boolean;
        };
        type SetShowLayoutShiftRegionsResponse = {};
        type SetShowScrollBottleneckRectsRequest = {
            show: boolean;
        };
        type SetShowScrollBottleneckRectsResponse = {};
        type SetShowHitTestBordersRequest = {
            show: boolean;
        };
        type SetShowHitTestBordersResponse = {};
        type SetShowViewportSizeOnResizeRequest = {
            show: boolean;
        };
        type SetShowViewportSizeOnResizeResponse = {};
    }
    namespace Page {
        /** Unique frame identifier. */
        type FrameId = string;
        /** Information about the Frame on the page. */
        type Frame = {
            id: string;
            parentId?: string;
            loaderId: Network.LoaderId;
            name?: string;
            url: string;
            urlFragment?: string;
            securityOrigin: string;
            mimeType: string;
            unreachableUrl?: string;
        };
        /** Information about the Resource on the page. */
        type FrameResource = {
            url: string;
            type: Network.ResourceType;
            mimeType: string;
            lastModified?: Network.TimeSinceEpoch;
            contentSize?: number;
            failed?: boolean;
            canceled?: boolean;
        };
        /** Information about the Frame hierarchy along with their cached resources. */
        type FrameResourceTree = {
            frame: Frame;
            childFrames?: FrameResourceTree[];
            resources: FrameResource[];
        };
        /** Information about the Frame hierarchy. */
        type FrameTree = {
            frame: Frame;
            childFrames?: FrameTree[];
        };
        /** Unique script identifier. */
        type ScriptIdentifier = string;
        /** Transition type. */
        type TransitionType = 'link' | 'typed' | 'address_bar' | 'auto_bookmark' | 'auto_subframe' | 'manual_subframe' | 'generated' | 'auto_toplevel' | 'form_submit' | 'reload' | 'keyword' | 'keyword_generated' | 'other';
        /** Navigation history entry. */
        type NavigationEntry = {
            id: number;
            url: string;
            userTypedURL: string;
            title: string;
            transitionType: TransitionType;
        };
        /** Screencast frame metadata. */
        type ScreencastFrameMetadata = {
            offsetTop: number;
            pageScaleFactor: number;
            deviceWidth: number;
            deviceHeight: number;
            scrollOffsetX: number;
            scrollOffsetY: number;
            timestamp?: Network.TimeSinceEpoch;
        };
        /** Javascript dialog type. */
        type DialogType = 'alert' | 'confirm' | 'prompt' | 'beforeunload';
        /** Error while paring app manifest. */
        type AppManifestError = {
            message: string;
            critical: number;
            line: number;
            column: number;
        };
        /** Layout viewport position and dimensions. */
        type LayoutViewport = {
            pageX: number;
            pageY: number;
            clientWidth: number;
            clientHeight: number;
        };
        /** Visual viewport position, dimensions, and scale. */
        type VisualViewport = {
            offsetX: number;
            offsetY: number;
            pageX: number;
            pageY: number;
            clientWidth: number;
            clientHeight: number;
            scale: number;
            zoom?: number;
        };
        /** Viewport for capturing screenshot. */
        type Viewport = {
            x: number;
            y: number;
            width: number;
            height: number;
            scale: number;
        };
        /** Generic font families collection. */
        type FontFamilies = {
            standard?: string;
            fixed?: string;
            serif?: string;
            sansSerif?: string;
            cursive?: string;
            fantasy?: string;
            pictograph?: string;
        };
        /** Default font sizes. */
        type FontSizes = {
            standard?: number;
            fixed?: number;
        };
        type ClientNavigationReason = 'formSubmissionGet' | 'formSubmissionPost' | 'httpHeaderRefresh' | 'scriptInitiated' | 'metaTagRefresh' | 'pageBlockInterstitial' | 'reload';
        type DomContentEventFiredEvent = {
            timestamp: Network.MonotonicTime;
        };
        type FileChooserOpenedEvent = {
            mode: 'selectSingle' | 'selectMultiple';
        };
        type FrameAttachedEvent = {
            frameId: FrameId;
            parentFrameId: FrameId;
            stack?: Runtime.StackTrace;
        };
        type FrameClearedScheduledNavigationEvent = {
            frameId: FrameId;
        };
        type FrameDetachedEvent = {
            frameId: FrameId;
        };
        type FrameNavigatedEvent = {
            frame: Frame;
        };
        type FrameResizedEvent = {
            [key: string]: any;
        };
        type FrameRequestedNavigationEvent = {
            frameId: FrameId;
            reason: ClientNavigationReason;
            url: string;
        };
        type FrameScheduledNavigationEvent = {
            frameId: FrameId;
            delay: number;
            reason: 'formSubmissionGet' | 'formSubmissionPost' | 'httpHeaderRefresh' | 'scriptInitiated' | 'metaTagRefresh' | 'pageBlockInterstitial' | 'reload';
            url: string;
        };
        type FrameStartedLoadingEvent = {
            frameId: FrameId;
        };
        type FrameStoppedLoadingEvent = {
            frameId: FrameId;
        };
        type DownloadWillBeginEvent = {
            frameId: FrameId;
            url: string;
        };
        type InterstitialHiddenEvent = {
            [key: string]: any;
        };
        type InterstitialShownEvent = {
            [key: string]: any;
        };
        type JavascriptDialogClosedEvent = {
            result: boolean;
            userInput: string;
        };
        type JavascriptDialogOpeningEvent = {
            url: string;
            message: string;
            type: DialogType;
            hasBrowserHandler: boolean;
            defaultPrompt?: string;
        };
        type LifecycleEventEvent = {
            frameId: FrameId;
            loaderId: Network.LoaderId;
            name: string;
            timestamp: Network.MonotonicTime;
        };
        type LoadEventFiredEvent = {
            timestamp: Network.MonotonicTime;
        };
        type NavigatedWithinDocumentEvent = {
            frameId: FrameId;
            url: string;
        };
        type ScreencastFrameEvent = {
            data: string;
            metadata: ScreencastFrameMetadata;
            sessionId: number;
        };
        type ScreencastVisibilityChangedEvent = {
            visible: boolean;
        };
        type WindowOpenEvent = {
            url: string;
            windowName: string;
            windowFeatures: string[];
            userGesture: boolean;
        };
        type CompilationCacheProducedEvent = {
            url: string;
            data: string;
        };
        type AddScriptToEvaluateOnLoadRequest = {
            scriptSource: string;
        };
        type AddScriptToEvaluateOnLoadResponse = {
            identifier: ScriptIdentifier;
        };
        type AddScriptToEvaluateOnNewDocumentRequest = {
            source: string;
            worldName?: string;
        };
        type AddScriptToEvaluateOnNewDocumentResponse = {
            identifier: ScriptIdentifier;
        };
        type BringToFrontRequest = {};
        type BringToFrontResponse = {};
        type CaptureScreenshotRequest = {
            format?: 'jpeg' | 'png';
            quality?: number;
            clip?: Viewport;
            fromSurface?: boolean;
        };
        type CaptureScreenshotResponse = {
            data: string;
        };
        type CaptureSnapshotRequest = {
            format?: 'mhtml';
        };
        type CaptureSnapshotResponse = {
            data: string;
        };
        type ClearDeviceMetricsOverrideRequest = {};
        type ClearDeviceMetricsOverrideResponse = {};
        type ClearDeviceOrientationOverrideRequest = {};
        type ClearDeviceOrientationOverrideResponse = {};
        type ClearGeolocationOverrideRequest = {};
        type ClearGeolocationOverrideResponse = {};
        type CreateIsolatedWorldRequest = {
            frameId: FrameId;
            worldName?: string;
            grantUniveralAccess?: boolean;
        };
        type CreateIsolatedWorldResponse = {
            executionContextId: Runtime.ExecutionContextId;
        };
        type DeleteCookieRequest = {
            cookieName: string;
            url: string;
        };
        type DeleteCookieResponse = {};
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type GetAppManifestRequest = {};
        type GetAppManifestResponse = {
            url: string;
            errors: AppManifestError[];
            data?: string;
        };
        type GetInstallabilityErrorsRequest = {};
        type GetInstallabilityErrorsResponse = {
            errors: string[];
        };
        type GetCookiesRequest = {};
        type GetCookiesResponse = {
            cookies: Network.Cookie[];
        };
        type GetFrameTreeRequest = {};
        type GetFrameTreeResponse = {
            frameTree: FrameTree;
        };
        type GetLayoutMetricsRequest = {};
        type GetLayoutMetricsResponse = {
            layoutViewport: LayoutViewport;
            visualViewport: VisualViewport;
            contentSize: DOM.Rect;
        };
        type GetNavigationHistoryRequest = {};
        type GetNavigationHistoryResponse = {
            currentIndex: number;
            entries: NavigationEntry[];
        };
        type ResetNavigationHistoryRequest = {};
        type ResetNavigationHistoryResponse = {};
        type GetResourceContentRequest = {
            frameId: FrameId;
            url: string;
        };
        type GetResourceContentResponse = {
            content: string;
            base64Encoded: boolean;
        };
        type GetResourceTreeRequest = {};
        type GetResourceTreeResponse = {
            frameTree: FrameResourceTree;
        };
        type HandleJavaScriptDialogRequest = {
            accept: boolean;
            promptText?: string;
        };
        type HandleJavaScriptDialogResponse = {};
        type NavigateRequest = {
            url: string;
            referrer?: string;
            transitionType?: TransitionType;
            frameId?: FrameId;
        };
        type NavigateResponse = {
            frameId: FrameId;
            loaderId?: Network.LoaderId;
            errorText?: string;
        };
        type NavigateToHistoryEntryRequest = {
            entryId: number;
        };
        type NavigateToHistoryEntryResponse = {};
        type PrintToPDFRequest = {
            landscape?: boolean;
            displayHeaderFooter?: boolean;
            printBackground?: boolean;
            scale?: number;
            paperWidth?: number;
            paperHeight?: number;
            marginTop?: number;
            marginBottom?: number;
            marginLeft?: number;
            marginRight?: number;
            pageRanges?: string;
            ignoreInvalidPageRanges?: boolean;
            headerTemplate?: string;
            footerTemplate?: string;
            preferCSSPageSize?: boolean;
            transferMode?: 'ReturnAsBase64' | 'ReturnAsStream';
        };
        type PrintToPDFResponse = {
            data: string;
            stream?: IO.StreamHandle;
        };
        type ReloadRequest = {
            ignoreCache?: boolean;
            scriptToEvaluateOnLoad?: string;
        };
        type ReloadResponse = {};
        type RemoveScriptToEvaluateOnLoadRequest = {
            identifier: ScriptIdentifier;
        };
        type RemoveScriptToEvaluateOnLoadResponse = {};
        type RemoveScriptToEvaluateOnNewDocumentRequest = {
            identifier: ScriptIdentifier;
        };
        type RemoveScriptToEvaluateOnNewDocumentResponse = {};
        type ScreencastFrameAckRequest = {
            sessionId: number;
        };
        type ScreencastFrameAckResponse = {};
        type SearchInResourceRequest = {
            frameId: FrameId;
            url: string;
            query: string;
            caseSensitive?: boolean;
            isRegex?: boolean;
        };
        type SearchInResourceResponse = {
            result: Debugger.SearchMatch[];
        };
        type SetAdBlockingEnabledRequest = {
            enabled: boolean;
        };
        type SetAdBlockingEnabledResponse = {};
        type SetBypassCSPRequest = {
            enabled: boolean;
        };
        type SetBypassCSPResponse = {};
        type SetDeviceMetricsOverrideRequest = {
            width: number;
            height: number;
            deviceScaleFactor: number;
            mobile: boolean;
            scale?: number;
            screenWidth?: number;
            screenHeight?: number;
            positionX?: number;
            positionY?: number;
            dontSetVisibleSize?: boolean;
            screenOrientation?: Emulation.ScreenOrientation;
            viewport?: Viewport;
        };
        type SetDeviceMetricsOverrideResponse = {};
        type SetDeviceOrientationOverrideRequest = {
            alpha: number;
            beta: number;
            gamma: number;
        };
        type SetDeviceOrientationOverrideResponse = {};
        type SetFontFamiliesRequest = {
            fontFamilies: FontFamilies;
        };
        type SetFontFamiliesResponse = {};
        type SetFontSizesRequest = {
            fontSizes: FontSizes;
        };
        type SetFontSizesResponse = {};
        type SetDocumentContentRequest = {
            frameId: FrameId;
            html: string;
        };
        type SetDocumentContentResponse = {};
        type SetDownloadBehaviorRequest = {
            behavior: 'deny' | 'allow' | 'default';
            downloadPath?: string;
        };
        type SetDownloadBehaviorResponse = {};
        type SetGeolocationOverrideRequest = {
            latitude?: number;
            longitude?: number;
            accuracy?: number;
        };
        type SetGeolocationOverrideResponse = {};
        type SetLifecycleEventsEnabledRequest = {
            enabled: boolean;
        };
        type SetLifecycleEventsEnabledResponse = {};
        type SetTouchEmulationEnabledRequest = {
            enabled: boolean;
            configuration?: 'mobile' | 'desktop';
        };
        type SetTouchEmulationEnabledResponse = {};
        type StartScreencastRequest = {
            format?: 'jpeg' | 'png';
            quality?: number;
            maxWidth?: number;
            maxHeight?: number;
            everyNthFrame?: number;
        };
        type StartScreencastResponse = {};
        type StopLoadingRequest = {};
        type StopLoadingResponse = {};
        type CrashRequest = {};
        type CrashResponse = {};
        type CloseRequest = {};
        type CloseResponse = {};
        type SetWebLifecycleStateRequest = {
            state: 'frozen' | 'active';
        };
        type SetWebLifecycleStateResponse = {};
        type StopScreencastRequest = {};
        type StopScreencastResponse = {};
        type SetProduceCompilationCacheRequest = {
            enabled: boolean;
        };
        type SetProduceCompilationCacheResponse = {};
        type AddCompilationCacheRequest = {
            url: string;
            data: string;
        };
        type AddCompilationCacheResponse = {};
        type ClearCompilationCacheRequest = {};
        type ClearCompilationCacheResponse = {};
        type GenerateTestReportRequest = {
            message: string;
            group?: string;
        };
        type GenerateTestReportResponse = {};
        type WaitForDebuggerRequest = {};
        type WaitForDebuggerResponse = {};
        type SetInterceptFileChooserDialogRequest = {
            enabled: boolean;
        };
        type SetInterceptFileChooserDialogResponse = {};
        type HandleFileChooserRequest = {
            action: 'accept' | 'cancel' | 'fallback';
            files?: string[];
        };
        type HandleFileChooserResponse = {};
    }
    namespace Performance {
        /** Run-time execution metric. */
        type Metric = {
            name: string;
            value: number;
        };
        type MetricsEvent = {
            metrics: Metric[];
            title: string;
        };
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type SetTimeDomainRequest = {
            timeDomain: 'timeTicks' | 'threadTicks';
        };
        type SetTimeDomainResponse = {};
        type GetMetricsRequest = {};
        type GetMetricsResponse = {
            metrics: Metric[];
        };
    }
    namespace Security {
        /** An internal certificate ID value. */
        type CertificateId = number;
        /** A description of mixed content (HTTP resources on HTTPS pages), as defined by https://www.w3.org/TR/mixed-content/#categories */
        type MixedContentType = 'blockable' | 'optionally-blockable' | 'none';
        /** The security level of a page or resource. */
        type SecurityState = 'unknown' | 'neutral' | 'insecure' | 'secure' | 'info';
        /** An explanation of an factor contributing to the security state. */
        type SecurityStateExplanation = {
            securityState: SecurityState;
            title: string;
            summary: string;
            description: string;
            mixedContentType: MixedContentType;
            certificate: string[];
            recommendations?: string[];
        };
        /** Information about insecure content on the page. */
        type InsecureContentStatus = {
            ranMixedContent: boolean;
            displayedMixedContent: boolean;
            containedMixedForm: boolean;
            ranContentWithCertErrors: boolean;
            displayedContentWithCertErrors: boolean;
            ranInsecureContentStyle: SecurityState;
            displayedInsecureContentStyle: SecurityState;
        };
        /** The action to take when a certificate error occurs. continue will continue processing the request and cancel will cancel the request. */
        type CertificateErrorAction = 'continue' | 'cancel';
        type CertificateErrorEvent = {
            eventId: number;
            errorType: string;
            requestURL: string;
        };
        type SecurityStateChangedEvent = {
            securityState: SecurityState;
            schemeIsCryptographic: boolean;
            explanations: SecurityStateExplanation[];
            insecureContentStatus: InsecureContentStatus;
            summary?: string;
        };
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type SetIgnoreCertificateErrorsRequest = {
            ignore: boolean;
        };
        type SetIgnoreCertificateErrorsResponse = {};
        type HandleCertificateErrorRequest = {
            eventId: number;
            action: CertificateErrorAction;
        };
        type HandleCertificateErrorResponse = {};
        type SetOverrideCertificateErrorsRequest = {
            override: boolean;
        };
        type SetOverrideCertificateErrorsResponse = {};
    }
    namespace ServiceWorker {
        type RegistrationID = string;
        /** ServiceWorker registration. */
        type ServiceWorkerRegistration = {
            registrationId: RegistrationID;
            scopeURL: string;
            isDeleted: boolean;
        };
        type ServiceWorkerVersionRunningStatus = 'stopped' | 'starting' | 'running' | 'stopping';
        type ServiceWorkerVersionStatus = 'new' | 'installing' | 'installed' | 'activating' | 'activated' | 'redundant';
        /** ServiceWorker version. */
        type ServiceWorkerVersion = {
            versionId: string;
            registrationId: RegistrationID;
            scriptURL: string;
            runningStatus: ServiceWorkerVersionRunningStatus;
            status: ServiceWorkerVersionStatus;
            scriptLastModified?: number;
            scriptResponseTime?: number;
            controlledClients?: Target.TargetID[];
            targetId?: Target.TargetID;
        };
        /** ServiceWorker error message. */
        type ServiceWorkerErrorMessage = {
            errorMessage: string;
            registrationId: RegistrationID;
            versionId: string;
            sourceURL: string;
            lineNumber: number;
            columnNumber: number;
        };
        type WorkerErrorReportedEvent = {
            errorMessage: ServiceWorkerErrorMessage;
        };
        type WorkerRegistrationUpdatedEvent = {
            registrations: ServiceWorkerRegistration[];
        };
        type WorkerVersionUpdatedEvent = {
            versions: ServiceWorkerVersion[];
        };
        type DeliverPushMessageRequest = {
            origin: string;
            registrationId: RegistrationID;
            data: string;
        };
        type DeliverPushMessageResponse = {};
        type DisableRequest = {};
        type DisableResponse = {};
        type DispatchSyncEventRequest = {
            origin: string;
            registrationId: RegistrationID;
            tag: string;
            lastChance: boolean;
        };
        type DispatchSyncEventResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type InspectWorkerRequest = {
            versionId: string;
        };
        type InspectWorkerResponse = {};
        type SetForceUpdateOnPageLoadRequest = {
            forceUpdateOnPageLoad: boolean;
        };
        type SetForceUpdateOnPageLoadResponse = {};
        type SkipWaitingRequest = {
            scopeURL: string;
        };
        type SkipWaitingResponse = {};
        type StartWorkerRequest = {
            scopeURL: string;
        };
        type StartWorkerResponse = {};
        type StopAllWorkersRequest = {};
        type StopAllWorkersResponse = {};
        type StopWorkerRequest = {
            versionId: string;
        };
        type StopWorkerResponse = {};
        type UnregisterRequest = {
            scopeURL: string;
        };
        type UnregisterResponse = {};
        type UpdateRegistrationRequest = {
            scopeURL: string;
        };
        type UpdateRegistrationResponse = {};
    }
    namespace Storage {
        /** Enum of possible storage types. */
        type StorageType = 'appcache' | 'cookies' | 'file_systems' | 'indexeddb' | 'local_storage' | 'shader_cache' | 'websql' | 'service_workers' | 'cache_storage' | 'all' | 'other';
        /** Usage for a storage type. */
        type UsageForType = {
            storageType: StorageType;
            usage: number;
        };
        type CacheStorageContentUpdatedEvent = {
            origin: string;
            cacheName: string;
        };
        type CacheStorageListUpdatedEvent = {
            origin: string;
        };
        type IndexedDBContentUpdatedEvent = {
            origin: string;
            databaseName: string;
            objectStoreName: string;
        };
        type IndexedDBListUpdatedEvent = {
            origin: string;
        };
        type ClearDataForOriginRequest = {
            origin: string;
            storageTypes: string;
        };
        type ClearDataForOriginResponse = {};
        type GetUsageAndQuotaRequest = {
            origin: string;
        };
        type GetUsageAndQuotaResponse = {
            usage: number;
            quota: number;
            usageBreakdown: UsageForType[];
        };
        type TrackCacheStorageForOriginRequest = {
            origin: string;
        };
        type TrackCacheStorageForOriginResponse = {};
        type TrackIndexedDBForOriginRequest = {
            origin: string;
        };
        type TrackIndexedDBForOriginResponse = {};
        type UntrackCacheStorageForOriginRequest = {
            origin: string;
        };
        type UntrackCacheStorageForOriginResponse = {};
        type UntrackIndexedDBForOriginRequest = {
            origin: string;
        };
        type UntrackIndexedDBForOriginResponse = {};
    }
    namespace SystemInfo {
        /** Describes a single graphics processor (GPU). */
        type GPUDevice = {
            vendorId: number;
            deviceId: number;
            vendorString: string;
            deviceString: string;
            driverVendor: string;
            driverVersion: string;
        };
        /** Describes the width and height dimensions of an entity. */
        type Size = {
            width: number;
            height: number;
        };
        /** Describes a supported video decoding profile with its associated minimum and maximum resolutions. */
        type VideoDecodeAcceleratorCapability = {
            profile: string;
            maxResolution: Size;
            minResolution: Size;
        };
        /** Describes a supported video encoding profile with its associated maximum resolution and maximum framerate. */
        type VideoEncodeAcceleratorCapability = {
            profile: string;
            maxResolution: Size;
            maxFramerateNumerator: number;
            maxFramerateDenominator: number;
        };
        /** YUV subsampling type of the pixels of a given image. */
        type SubsamplingFormat = 'yuv420' | 'yuv422' | 'yuv444';
        /** Describes a supported image decoding profile with its associated minimum and maximum resolutions and subsampling. */
        type ImageDecodeAcceleratorCapability = {
            imageType: string;
            maxDimensions: Size;
            minDimensions: Size;
            subsamplings: SubsamplingFormat[];
        };
        /** Provides information about the GPU(s) on the system. */
        type GPUInfo = {
            devices: GPUDevice[];
            auxAttributes?: {
                [key: string]: any;
            };
            featureStatus?: {
                [key: string]: any;
            };
            driverBugWorkarounds: string[];
            videoDecoding: VideoDecodeAcceleratorCapability[];
            videoEncoding: VideoEncodeAcceleratorCapability[];
            imageDecoding: ImageDecodeAcceleratorCapability[];
        };
        /** Represents process info. */
        type ProcessInfo = {
            type: string;
            id: number;
            cpuTime: number;
        };
        type GetInfoRequest = {};
        type GetInfoResponse = {
            gpu: GPUInfo;
            modelName: string;
            modelVersion: string;
            commandLine: string;
        };
        type GetProcessInfoRequest = {};
        type GetProcessInfoResponse = {
            processInfo: ProcessInfo[];
        };
    }
    namespace Target {
        type TargetID = string;
        /** Unique identifier of attached debugging session. */
        type SessionID = string;
        type BrowserContextID = string;
        type TargetInfo = {
            targetId: TargetID;
            type: string;
            title: string;
            url: string;
            attached: boolean;
            openerId?: TargetID;
            browserContextId?: BrowserContextID;
        };
        type RemoteLocation = {
            host: string;
            port: number;
        };
        type AttachedToTargetEvent = {
            sessionId: SessionID;
            targetInfo: TargetInfo;
            waitingForDebugger: boolean;
        };
        type DetachedFromTargetEvent = {
            sessionId: SessionID;
            targetId?: TargetID;
        };
        type ReceivedMessageFromTargetEvent = {
            sessionId: SessionID;
            message: string;
            targetId?: TargetID;
        };
        type TargetCreatedEvent = {
            targetInfo: TargetInfo;
        };
        type TargetDestroyedEvent = {
            targetId: TargetID;
        };
        type TargetCrashedEvent = {
            targetId: TargetID;
            status: string;
            errorCode: number;
        };
        type TargetInfoChangedEvent = {
            targetInfo: TargetInfo;
        };
        type ActivateTargetRequest = {
            targetId: TargetID;
        };
        type ActivateTargetResponse = {};
        type AttachToTargetRequest = {
            targetId: TargetID;
            flatten?: boolean;
        };
        type AttachToTargetResponse = {
            sessionId: SessionID;
        };
        type AttachToBrowserTargetRequest = {};
        type AttachToBrowserTargetResponse = {
            sessionId: SessionID;
        };
        type CloseTargetRequest = {
            targetId: TargetID;
        };
        type CloseTargetResponse = {
            success: boolean;
        };
        type ExposeDevToolsProtocolRequest = {
            targetId: TargetID;
            bindingName?: string;
        };
        type ExposeDevToolsProtocolResponse = {};
        type CreateBrowserContextRequest = {};
        type CreateBrowserContextResponse = {
            browserContextId: BrowserContextID;
        };
        type GetBrowserContextsRequest = {};
        type GetBrowserContextsResponse = {
            browserContextIds: BrowserContextID[];
        };
        type CreateTargetRequest = {
            url: string;
            width?: number;
            height?: number;
            browserContextId?: BrowserContextID;
            enableBeginFrameControl?: boolean;
            newWindow?: boolean;
            background?: boolean;
        };
        type CreateTargetResponse = {
            targetId: TargetID;
        };
        type DetachFromTargetRequest = {
            sessionId?: SessionID;
            targetId?: TargetID;
        };
        type DetachFromTargetResponse = {};
        type DisposeBrowserContextRequest = {
            browserContextId: BrowserContextID;
        };
        type DisposeBrowserContextResponse = {};
        type GetTargetInfoRequest = {
            targetId?: TargetID;
        };
        type GetTargetInfoResponse = {
            targetInfo: TargetInfo;
        };
        type GetTargetsRequest = {};
        type GetTargetsResponse = {
            targetInfos: TargetInfo[];
        };
        type SendMessageToTargetRequest = {
            message: string;
            sessionId?: SessionID;
            targetId?: TargetID;
        };
        type SendMessageToTargetResponse = {};
        type SetAutoAttachRequest = {
            autoAttach: boolean;
            waitForDebuggerOnStart: boolean;
            flatten?: boolean;
        };
        type SetAutoAttachResponse = {};
        type SetDiscoverTargetsRequest = {
            discover: boolean;
        };
        type SetDiscoverTargetsResponse = {};
        type SetRemoteLocationsRequest = {
            locations: RemoteLocation[];
        };
        type SetRemoteLocationsResponse = {};
    }
    namespace Tethering {
        type AcceptedEvent = {
            port: number;
            connectionId: string;
        };
        type BindRequest = {
            port: number;
        };
        type BindResponse = {};
        type UnbindRequest = {
            port: number;
        };
        type UnbindResponse = {};
    }
    namespace Tracing {
        /** Configuration for memory dump. Used only when "memory-infra" category is enabled. */
        type MemoryDumpConfig = {
            [key: string]: any;
        };
        type TraceConfig = {
            recordMode?: 'recordUntilFull' | 'recordContinuously' | 'recordAsMuchAsPossible' | 'echoToConsole';
            enableSampling?: boolean;
            enableSystrace?: boolean;
            enableArgumentFilter?: boolean;
            includedCategories?: string[];
            excludedCategories?: string[];
            syntheticDelays?: string[];
            memoryDumpConfig?: MemoryDumpConfig;
        };
        /** Data format of a trace. Can be either the legacy JSON format or the protocol buffer format. Note that the JSON format will be deprecated soon. */
        type StreamFormat = 'json' | 'proto';
        /** Compression type to use for traces returned via streams. */
        type StreamCompression = 'none' | 'gzip';
        type BufferUsageEvent = {
            percentFull?: number;
            eventCount?: number;
            value?: number;
        };
        type DataCollectedEvent = {
            value: {
                [key: string]: any;
            }[];
        };
        type TracingCompleteEvent = {
            dataLossOccurred: boolean;
            stream?: IO.StreamHandle;
            traceFormat?: StreamFormat;
            streamCompression?: StreamCompression;
        };
        type EndRequest = {};
        type EndResponse = {};
        type GetCategoriesRequest = {};
        type GetCategoriesResponse = {
            categories: string[];
        };
        type RecordClockSyncMarkerRequest = {
            syncId: string;
        };
        type RecordClockSyncMarkerResponse = {};
        type RequestMemoryDumpRequest = {};
        type RequestMemoryDumpResponse = {
            dumpGuid: string;
            success: boolean;
        };
        type StartRequest = {
            categories?: string;
            options?: string;
            bufferUsageReportingInterval?: number;
            transferMode?: 'ReportEvents' | 'ReturnAsStream';
            streamFormat?: StreamFormat;
            streamCompression?: StreamCompression;
            traceConfig?: TraceConfig;
        };
        type StartResponse = {};
    }
    namespace Fetch {
        /** Unique request identifier. */
        type RequestId = string;
        /** Stages of the request to handle. Request will intercept before the request is sent. Response will intercept after the response is received (but before response body is received. */
        type RequestStage = 'Request' | 'Response';
        type RequestPattern = {
            urlPattern?: string;
            resourceType?: Network.ResourceType;
            requestStage?: RequestStage;
        };
        /** Response HTTP header entry */
        type HeaderEntry = {
            name: string;
            value: string;
        };
        /** Authorization challenge for HTTP status code 401 or 407. */
        type AuthChallenge = {
            source?: 'Server' | 'Proxy';
            origin: string;
            scheme: string;
            realm: string;
        };
        /** Response to an AuthChallenge. */
        type AuthChallengeResponse = {
            response: 'Default' | 'CancelAuth' | 'ProvideCredentials';
            username?: string;
            password?: string;
        };
        type RequestPausedEvent = {
            requestId: RequestId;
            request: Network.Request;
            frameId: Page.FrameId;
            resourceType: Network.ResourceType;
            responseErrorReason?: Network.ErrorReason;
            responseStatusCode?: number;
            responseHeaders?: HeaderEntry[];
            networkId?: RequestId;
        };
        type AuthRequiredEvent = {
            requestId: RequestId;
            request: Network.Request;
            frameId: Page.FrameId;
            resourceType: Network.ResourceType;
            authChallenge: AuthChallenge;
        };
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {
            patterns?: RequestPattern[];
            handleAuthRequests?: boolean;
        };
        type EnableResponse = {};
        type FailRequestRequest = {
            requestId: RequestId;
            errorReason: Network.ErrorReason;
        };
        type FailRequestResponse = {};
        type FulfillRequestRequest = {
            requestId: RequestId;
            responseCode: number;
            responseHeaders: HeaderEntry[];
            body?: string;
            responsePhrase?: string;
        };
        type FulfillRequestResponse = {};
        type ContinueRequestRequest = {
            requestId: RequestId;
            url?: string;
            method?: string;
            postData?: string;
            headers?: HeaderEntry[];
        };
        type ContinueRequestResponse = {};
        type ContinueWithAuthRequest = {
            requestId: RequestId;
            authChallengeResponse: AuthChallengeResponse;
        };
        type ContinueWithAuthResponse = {};
        type GetResponseBodyRequest = {
            requestId: RequestId;
        };
        type GetResponseBodyResponse = {
            body: string;
            base64Encoded: boolean;
        };
        type TakeResponseBodyAsStreamRequest = {
            requestId: RequestId;
        };
        type TakeResponseBodyAsStreamResponse = {
            stream: IO.StreamHandle;
        };
    }
    namespace WebAudio {
        /** Context's UUID in string */
        type ContextId = string;
        /** Enum of BaseAudioContext types */
        type ContextType = 'realtime' | 'offline';
        /** Enum of AudioContextState from the spec */
        type ContextState = 'suspended' | 'running' | 'closed';
        /** Fields in AudioContext that change in real-time. */
        type ContextRealtimeData = {
            currentTime: number;
            renderCapacity: number;
            callbackIntervalMean: number;
            callbackIntervalVariance: number;
        };
        /** Protocol object for BaseAudioContext */
        type BaseAudioContext = {
            contextId: ContextId;
            contextType: ContextType;
            contextState: ContextState;
            realtimeData?: ContextRealtimeData;
            callbackBufferSize: number;
            maxOutputChannelCount: number;
            sampleRate: number;
        };
        type ContextCreatedEvent = {
            context: BaseAudioContext;
        };
        type ContextDestroyedEvent = {
            contextId: ContextId;
        };
        type ContextChangedEvent = {
            context: BaseAudioContext;
        };
        type EnableRequest = {};
        type EnableResponse = {};
        type DisableRequest = {};
        type DisableResponse = {};
        type GetRealtimeDataRequest = {
            contextId: ContextId;
        };
        type GetRealtimeDataResponse = {
            realtimeData: ContextRealtimeData;
        };
    }
    namespace WebAuthn {
        type AuthenticatorId = string;
        type AuthenticatorProtocol = 'u2f' | 'ctap2';
        type AuthenticatorTransport = 'usb' | 'nfc' | 'ble' | 'cable' | 'internal';
        type VirtualAuthenticatorOptions = {
            protocol: AuthenticatorProtocol;
            transport: AuthenticatorTransport;
            hasResidentKey: boolean;
            hasUserVerification: boolean;
            automaticPresenceSimulation?: boolean;
        };
        type Credential = {
            credentialId: string;
            rpIdHash: string;
            privateKey: string;
            signCount: number;
        };
        type EnableRequest = {};
        type EnableResponse = {};
        type DisableRequest = {};
        type DisableResponse = {};
        type AddVirtualAuthenticatorRequest = {
            options: VirtualAuthenticatorOptions;
        };
        type AddVirtualAuthenticatorResponse = {
            authenticatorId: AuthenticatorId;
        };
        type RemoveVirtualAuthenticatorRequest = {
            authenticatorId: AuthenticatorId;
        };
        type RemoveVirtualAuthenticatorResponse = {};
        type AddCredentialRequest = {
            authenticatorId: AuthenticatorId;
            credential: Credential;
        };
        type AddCredentialResponse = {};
        type GetCredentialsRequest = {
            authenticatorId: AuthenticatorId;
        };
        type GetCredentialsResponse = {
            credentials: Credential[];
        };
        type ClearCredentialsRequest = {
            authenticatorId: AuthenticatorId;
        };
        type ClearCredentialsResponse = {};
        type SetUserVerifiedRequest = {
            authenticatorId: AuthenticatorId;
            isUserVerified: boolean;
        };
        type SetUserVerifiedResponse = {};
    }
    namespace Console {
        /** Console message. */
        type ConsoleMessage = {
            source: 'xml' | 'javascript' | 'network' | 'console-api' | 'storage' | 'appcache' | 'rendering' | 'security' | 'other' | 'deprecation' | 'worker';
            level: 'log' | 'warning' | 'error' | 'debug' | 'info';
            text: string;
            url?: string;
            line?: number;
            column?: number;
        };
        type MessageAddedEvent = {
            message: ConsoleMessage;
        };
        type ClearMessagesRequest = {};
        type ClearMessagesResponse = {};
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
    }
    namespace Debugger {
        /** Breakpoint identifier. */
        type BreakpointId = string;
        /** Call frame identifier. */
        type CallFrameId = string;
        /** Location in the source code. */
        type Location = {
            scriptId: Runtime.ScriptId;
            lineNumber: number;
            columnNumber?: number;
        };
        /** Location in the source code. */
        type ScriptPosition = {
            lineNumber: number;
            columnNumber: number;
        };
        /** JavaScript call frame. Array of call frames form the call stack. */
        type CallFrame = {
            callFrameId: CallFrameId;
            functionName: string;
            functionLocation?: Location;
            location: Location;
            url: string;
            scopeChain: Scope[];
            this: Runtime.RemoteObject;
            returnValue?: Runtime.RemoteObject;
        };
        /** Scope description. */
        type Scope = {
            type: 'global' | 'local' | 'with' | 'closure' | 'catch' | 'block' | 'script' | 'eval' | 'module';
            object: Runtime.RemoteObject;
            name?: string;
            startLocation?: Location;
            endLocation?: Location;
        };
        /** Search match for resource. */
        type SearchMatch = {
            lineNumber: number;
            lineContent: string;
        };
        type BreakLocation = {
            scriptId: Runtime.ScriptId;
            lineNumber: number;
            columnNumber?: number;
            type?: 'debuggerStatement' | 'call' | 'return';
        };
        type BreakpointResolvedEvent = {
            breakpointId: BreakpointId;
            location: Location;
        };
        type PausedEvent = {
            callFrames: CallFrame[];
            reason: 'ambiguous' | 'assert' | 'debugCommand' | 'DOM' | 'EventListener' | 'exception' | 'instrumentation' | 'OOM' | 'other' | 'promiseRejection' | 'XHR';
            data?: {
                [key: string]: any;
            };
            hitBreakpoints?: string[];
            asyncStackTrace?: Runtime.StackTrace;
            asyncStackTraceId?: Runtime.StackTraceId;
            asyncCallStackTraceId?: Runtime.StackTraceId;
        };
        type ResumedEvent = {
            [key: string]: any;
        };
        type ScriptFailedToParseEvent = {
            scriptId: Runtime.ScriptId;
            url: string;
            startLine: number;
            startColumn: number;
            endLine: number;
            endColumn: number;
            executionContextId: Runtime.ExecutionContextId;
            hash: string;
            executionContextAuxData?: {
                [key: string]: any;
            };
            sourceMapURL?: string;
            hasSourceURL?: boolean;
            isModule?: boolean;
            length?: number;
            stackTrace?: Runtime.StackTrace;
        };
        type ScriptParsedEvent = {
            scriptId: Runtime.ScriptId;
            url: string;
            startLine: number;
            startColumn: number;
            endLine: number;
            endColumn: number;
            executionContextId: Runtime.ExecutionContextId;
            hash: string;
            executionContextAuxData?: {
                [key: string]: any;
            };
            isLiveEdit?: boolean;
            sourceMapURL?: string;
            hasSourceURL?: boolean;
            isModule?: boolean;
            length?: number;
            stackTrace?: Runtime.StackTrace;
        };
        type ContinueToLocationRequest = {
            location: Location;
            targetCallFrames?: 'any' | 'current';
        };
        type ContinueToLocationResponse = {};
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {
            maxScriptsCacheSize?: number;
        };
        type EnableResponse = {
            debuggerId: Runtime.UniqueDebuggerId;
        };
        type EvaluateOnCallFrameRequest = {
            callFrameId: CallFrameId;
            expression: string;
            objectGroup?: string;
            includeCommandLineAPI?: boolean;
            silent?: boolean;
            returnByValue?: boolean;
            generatePreview?: boolean;
            throwOnSideEffect?: boolean;
            timeout?: Runtime.TimeDelta;
        };
        type EvaluateOnCallFrameResponse = {
            result: Runtime.RemoteObject;
            exceptionDetails?: Runtime.ExceptionDetails;
        };
        type GetPossibleBreakpointsRequest = {
            start: Location;
            end?: Location;
            restrictToFunction?: boolean;
        };
        type GetPossibleBreakpointsResponse = {
            locations: BreakLocation[];
        };
        type GetScriptSourceRequest = {
            scriptId: Runtime.ScriptId;
        };
        type GetScriptSourceResponse = {
            scriptSource: string;
        };
        type GetStackTraceRequest = {
            stackTraceId: Runtime.StackTraceId;
        };
        type GetStackTraceResponse = {
            stackTrace: Runtime.StackTrace;
        };
        type PauseRequest = {};
        type PauseResponse = {};
        type PauseOnAsyncCallRequest = {
            parentStackTraceId: Runtime.StackTraceId;
        };
        type PauseOnAsyncCallResponse = {};
        type RemoveBreakpointRequest = {
            breakpointId: BreakpointId;
        };
        type RemoveBreakpointResponse = {};
        type RestartFrameRequest = {
            callFrameId: CallFrameId;
        };
        type RestartFrameResponse = {
            callFrames: CallFrame[];
            asyncStackTrace?: Runtime.StackTrace;
            asyncStackTraceId?: Runtime.StackTraceId;
        };
        type ResumeRequest = {};
        type ResumeResponse = {};
        type SearchInContentRequest = {
            scriptId: Runtime.ScriptId;
            query: string;
            caseSensitive?: boolean;
            isRegex?: boolean;
        };
        type SearchInContentResponse = {
            result: SearchMatch[];
        };
        type SetAsyncCallStackDepthRequest = {
            maxDepth: number;
        };
        type SetAsyncCallStackDepthResponse = {};
        type SetBlackboxPatternsRequest = {
            patterns: string[];
        };
        type SetBlackboxPatternsResponse = {};
        type SetBlackboxedRangesRequest = {
            scriptId: Runtime.ScriptId;
            positions: ScriptPosition[];
        };
        type SetBlackboxedRangesResponse = {};
        type SetBreakpointRequest = {
            location: Location;
            condition?: string;
        };
        type SetBreakpointResponse = {
            breakpointId: BreakpointId;
            actualLocation: Location;
        };
        type SetInstrumentationBreakpointRequest = {
            instrumentation: 'beforeScriptExecution' | 'beforeScriptWithSourceMapExecution';
        };
        type SetInstrumentationBreakpointResponse = {
            breakpointId: BreakpointId;
        };
        type SetBreakpointByUrlRequest = {
            lineNumber: number;
            url?: string;
            urlRegex?: string;
            scriptHash?: string;
            columnNumber?: number;
            condition?: string;
        };
        type SetBreakpointByUrlResponse = {
            breakpointId: BreakpointId;
            locations: Location[];
        };
        type SetBreakpointOnFunctionCallRequest = {
            objectId: Runtime.RemoteObjectId;
            condition?: string;
        };
        type SetBreakpointOnFunctionCallResponse = {
            breakpointId: BreakpointId;
        };
        type SetBreakpointsActiveRequest = {
            active: boolean;
        };
        type SetBreakpointsActiveResponse = {};
        type SetPauseOnExceptionsRequest = {
            state: 'none' | 'uncaught' | 'all';
        };
        type SetPauseOnExceptionsResponse = {};
        type SetReturnValueRequest = {
            newValue: Runtime.CallArgument;
        };
        type SetReturnValueResponse = {};
        type SetScriptSourceRequest = {
            scriptId: Runtime.ScriptId;
            scriptSource: string;
            dryRun?: boolean;
        };
        type SetScriptSourceResponse = {
            callFrames?: CallFrame[];
            stackChanged?: boolean;
            asyncStackTrace?: Runtime.StackTrace;
            asyncStackTraceId?: Runtime.StackTraceId;
            exceptionDetails?: Runtime.ExceptionDetails;
        };
        type SetSkipAllPausesRequest = {
            skip: boolean;
        };
        type SetSkipAllPausesResponse = {};
        type SetVariableValueRequest = {
            scopeNumber: number;
            variableName: string;
            newValue: Runtime.CallArgument;
            callFrameId: CallFrameId;
        };
        type SetVariableValueResponse = {};
        type StepIntoRequest = {
            breakOnAsyncCall?: boolean;
        };
        type StepIntoResponse = {};
        type StepOutRequest = {};
        type StepOutResponse = {};
        type StepOverRequest = {};
        type StepOverResponse = {};
    }
    namespace HeapProfiler {
        /** Heap snapshot object id. */
        type HeapSnapshotObjectId = string;
        /** Sampling Heap Profile node. Holds callsite information, allocation statistics and child nodes. */
        type SamplingHeapProfileNode = {
            callFrame: Runtime.CallFrame;
            selfSize: number;
            id: number;
            children: SamplingHeapProfileNode[];
        };
        /** A single sample from a sampling profile. */
        type SamplingHeapProfileSample = {
            size: number;
            nodeId: number;
            ordinal: number;
        };
        /** Sampling profile. */
        type SamplingHeapProfile = {
            head: SamplingHeapProfileNode;
            samples: SamplingHeapProfileSample[];
        };
        type AddHeapSnapshotChunkEvent = {
            chunk: string;
        };
        type HeapStatsUpdateEvent = {
            statsUpdate: number[];
        };
        type LastSeenObjectIdEvent = {
            lastSeenObjectId: number;
            timestamp: number;
        };
        type ReportHeapSnapshotProgressEvent = {
            done: number;
            total: number;
            finished?: boolean;
        };
        type ResetProfilesEvent = {
            [key: string]: any;
        };
        type AddInspectedHeapObjectRequest = {
            heapObjectId: HeapSnapshotObjectId;
        };
        type AddInspectedHeapObjectResponse = {};
        type CollectGarbageRequest = {};
        type CollectGarbageResponse = {};
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type GetHeapObjectIdRequest = {
            objectId: Runtime.RemoteObjectId;
        };
        type GetHeapObjectIdResponse = {
            heapSnapshotObjectId: HeapSnapshotObjectId;
        };
        type GetObjectByHeapObjectIdRequest = {
            objectId: HeapSnapshotObjectId;
            objectGroup?: string;
        };
        type GetObjectByHeapObjectIdResponse = {
            result: Runtime.RemoteObject;
        };
        type GetSamplingProfileRequest = {};
        type GetSamplingProfileResponse = {
            profile: SamplingHeapProfile;
        };
        type StartSamplingRequest = {
            samplingInterval?: number;
        };
        type StartSamplingResponse = {};
        type StartTrackingHeapObjectsRequest = {
            trackAllocations?: boolean;
        };
        type StartTrackingHeapObjectsResponse = {};
        type StopSamplingRequest = {};
        type StopSamplingResponse = {
            profile: SamplingHeapProfile;
        };
        type StopTrackingHeapObjectsRequest = {
            reportProgress?: boolean;
        };
        type StopTrackingHeapObjectsResponse = {};
        type TakeHeapSnapshotRequest = {
            reportProgress?: boolean;
        };
        type TakeHeapSnapshotResponse = {};
    }
    namespace Profiler {
        /** Profile node. Holds callsite information, execution statistics and child nodes. */
        type ProfileNode = {
            id: number;
            callFrame: Runtime.CallFrame;
            hitCount?: number;
            children?: number[];
            deoptReason?: string;
            positionTicks?: PositionTickInfo[];
        };
        /** Profile. */
        type Profile = {
            nodes: ProfileNode[];
            startTime: number;
            endTime: number;
            samples?: number[];
            timeDeltas?: number[];
        };
        /** Specifies a number of samples attributed to a certain source position. */
        type PositionTickInfo = {
            line: number;
            ticks: number;
        };
        /** Coverage data for a source range. */
        type CoverageRange = {
            startOffset: number;
            endOffset: number;
            count: number;
        };
        /** Coverage data for a JavaScript function. */
        type FunctionCoverage = {
            functionName: string;
            ranges: CoverageRange[];
            isBlockCoverage: boolean;
        };
        /** Coverage data for a JavaScript script. */
        type ScriptCoverage = {
            scriptId: Runtime.ScriptId;
            url: string;
            functions: FunctionCoverage[];
        };
        /** Describes a type collected during runtime. */
        type TypeObject = {
            name: string;
        };
        /** Source offset and types for a parameter or return value. */
        type TypeProfileEntry = {
            offset: number;
            types: TypeObject[];
        };
        /** Type profile data collected during runtime for a JavaScript script. */
        type ScriptTypeProfile = {
            scriptId: Runtime.ScriptId;
            url: string;
            entries: TypeProfileEntry[];
        };
        type ConsoleProfileFinishedEvent = {
            id: string;
            location: Debugger.Location;
            profile: Profile;
            title?: string;
        };
        type ConsoleProfileStartedEvent = {
            id: string;
            location: Debugger.Location;
            title?: string;
        };
        type DisableRequest = {};
        type DisableResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type GetBestEffortCoverageRequest = {};
        type GetBestEffortCoverageResponse = {
            result: ScriptCoverage[];
        };
        type SetSamplingIntervalRequest = {
            interval: number;
        };
        type SetSamplingIntervalResponse = {};
        type StartRequest = {};
        type StartResponse = {};
        type StartPreciseCoverageRequest = {
            callCount?: boolean;
            detailed?: boolean;
        };
        type StartPreciseCoverageResponse = {};
        type StartTypeProfileRequest = {};
        type StartTypeProfileResponse = {};
        type StopRequest = {};
        type StopResponse = {
            profile: Profile;
        };
        type StopPreciseCoverageRequest = {};
        type StopPreciseCoverageResponse = {};
        type StopTypeProfileRequest = {};
        type StopTypeProfileResponse = {};
        type TakePreciseCoverageRequest = {};
        type TakePreciseCoverageResponse = {
            result: ScriptCoverage[];
        };
        type TakeTypeProfileRequest = {};
        type TakeTypeProfileResponse = {
            result: ScriptTypeProfile[];
        };
    }
    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. */
        type RemoteObject = {
            type: 'object' | 'function' | 'undefined' | 'string' | 'number' | 'boolean' | 'symbol' | 'bigint';
            subtype?: 'array' | 'null' | 'node' | 'regexp' | 'date' | 'map' | 'set' | 'weakmap' | 'weakset' | 'iterator' | 'generator' | 'error' | 'proxy' | 'promise' | 'typedarray' | 'arraybuffer' | 'dataview';
            className?: string;
            value?: any;
            unserializableValue?: UnserializableValue;
            description?: string;
            objectId?: RemoteObjectId;
            preview?: ObjectPreview;
            customPreview?: CustomPreview;
        };
        type CustomPreview = {
            header: string;
            bodyGetterId?: RemoteObjectId;
        };
        /** Object containing abbreviated remote object value. */
        type ObjectPreview = {
            type: 'object' | 'function' | 'undefined' | 'string' | 'number' | 'boolean' | 'symbol' | 'bigint';
            subtype?: 'array' | 'null' | 'node' | 'regexp' | 'date' | 'map' | 'set' | 'weakmap' | 'weakset' | 'iterator' | 'generator' | 'error';
            description?: string;
            overflow: boolean;
            properties: PropertyPreview[];
            entries?: EntryPreview[];
        };
        type PropertyPreview = {
            name: string;
            type: 'object' | 'function' | 'undefined' | 'string' | 'number' | 'boolean' | 'symbol' | 'accessor' | 'bigint';
            value?: string;
            valuePreview?: ObjectPreview;
            subtype?: 'array' | 'null' | 'node' | 'regexp' | 'date' | 'map' | 'set' | 'weakmap' | 'weakset' | 'iterator' | 'generator' | 'error';
        };
        type EntryPreview = {
            key?: ObjectPreview;
            value: ObjectPreview;
        };
        /** Object property descriptor. */
        type PropertyDescriptor = {
            name: string;
            value?: RemoteObject;
            writable?: boolean;
            get?: RemoteObject;
            set?: RemoteObject;
            configurable: boolean;
            enumerable: boolean;
            wasThrown?: boolean;
            isOwn?: boolean;
            symbol?: RemoteObject;
        };
        /** Object internal property descriptor. This property isn't normally visible in JavaScript code. */
        type InternalPropertyDescriptor = {
            name: string;
            value?: RemoteObject;
        };
        /** Object private field descriptor. */
        type PrivatePropertyDescriptor = {
            name: string;
            value: RemoteObject;
        };
        /** Represents function call argument. Either remote object id `objectId`, primitive `value`, unserializable primitive value or neither of (for undefined) them should be specified. */
        type CallArgument = {
            value?: any;
            unserializableValue?: UnserializableValue;
            objectId?: RemoteObjectId;
        };
        /** Id of an execution context. */
        type ExecutionContextId = number;
        /** Description of an isolated world. */
        type ExecutionContextDescription = {
            id: ExecutionContextId;
            origin: string;
            name: string;
            auxData?: {
                [key: string]: any;
            };
        };
        /** Detailed information about exception (or error) that was thrown during script compilation or execution. */
        type ExceptionDetails = {
            exceptionId: number;
            text: string;
            lineNumber: number;
            columnNumber: number;
            scriptId?: ScriptId;
            url?: string;
            stackTrace?: StackTrace;
            exception?: RemoteObject;
            executionContextId?: ExecutionContextId;
        };
        /** Number of milliseconds since epoch. */
        type Timestamp = number;
        /** Number of milliseconds. */
        type TimeDelta = number;
        /** Stack entry for runtime errors and assertions. */
        type CallFrame = {
            functionName: string;
            scriptId: ScriptId;
            url: string;
            lineNumber: number;
            columnNumber: number;
        };
        /** Call frames for assertions or error messages. */
        type StackTrace = {
            description?: string;
            callFrames: CallFrame[];
            parent?: StackTrace;
            parentId?: StackTraceId;
        };
        /** Unique identifier of current debugger. */
        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. */
        type StackTraceId = {
            id: string;
            debuggerId?: UniqueDebuggerId;
        };
        type BindingCalledEvent = {
            name: string;
            payload: string;
            executionContextId: ExecutionContextId;
        };
        type ConsoleAPICalledEvent = {
            type: 'log' | 'debug' | 'info' | 'error' | 'warning' | 'dir' | 'dirxml' | 'table' | 'trace' | 'clear' | 'startGroup' | 'startGroupCollapsed' | 'endGroup' | 'assert' | 'profile' | 'profileEnd' | 'count' | 'timeEnd';
            args: RemoteObject[];
            executionContextId: ExecutionContextId;
            timestamp: Timestamp;
            stackTrace?: StackTrace;
            context?: string;
        };
        type ExceptionRevokedEvent = {
            reason: string;
            exceptionId: number;
        };
        type ExceptionThrownEvent = {
            timestamp: Timestamp;
            exceptionDetails: ExceptionDetails;
        };
        type ExecutionContextCreatedEvent = {
            context: ExecutionContextDescription;
        };
        type ExecutionContextDestroyedEvent = {
            executionContextId: ExecutionContextId;
        };
        type ExecutionContextsClearedEvent = {
            [key: string]: any;
        };
        type InspectRequestedEvent = {
            object: RemoteObject;
            hints: {
                [key: string]: any;
            };
        };
        type AwaitPromiseRequest = {
            promiseObjectId: RemoteObjectId;
            returnByValue?: boolean;
            generatePreview?: boolean;
        };
        type AwaitPromiseResponse = {
            result: RemoteObject;
            exceptionDetails?: ExceptionDetails;
        };
        type CallFunctionOnRequest = {
            functionDeclaration: string;
            objectId?: RemoteObjectId;
            arguments?: CallArgument[];
            silent?: boolean;
            returnByValue?: boolean;
            generatePreview?: boolean;
            userGesture?: boolean;
            awaitPromise?: boolean;
            executionContextId?: ExecutionContextId;
            objectGroup?: string;
        };
        type CallFunctionOnResponse = {
            result: RemoteObject;
            exceptionDetails?: ExceptionDetails;
        };
        type CompileScriptRequest = {
            expression: string;
            sourceURL: string;
            persistScript: boolean;
            executionContextId?: ExecutionContextId;
        };
        type CompileScriptResponse = {
            scriptId?: ScriptId;
            exceptionDetails?: ExceptionDetails;
        };
        type DisableRequest = {};
        type DisableResponse = {};
        type DiscardConsoleEntriesRequest = {};
        type DiscardConsoleEntriesResponse = {};
        type EnableRequest = {};
        type EnableResponse = {};
        type EvaluateRequest = {
            expression: string;
            objectGroup?: string;
            includeCommandLineAPI?: boolean;
            silent?: boolean;
            contextId?: ExecutionContextId;
            returnByValue?: boolean;
            generatePreview?: boolean;
            userGesture?: boolean;
            awaitPromise?: boolean;
            throwOnSideEffect?: boolean;
            timeout?: TimeDelta;
        };
        type EvaluateResponse = {
            result: RemoteObject;
            exceptionDetails?: ExceptionDetails;
        };
        type GetIsolateIdRequest = {};
        type GetIsolateIdResponse = {
            id: string;
        };
        type GetHeapUsageRequest = {};
        type GetHeapUsageResponse = {
            usedSize: number;
            totalSize: number;
        };
        type GetPropertiesRequest = {
            objectId: RemoteObjectId;
            ownProperties?: boolean;
            accessorPropertiesOnly?: boolean;
            generatePreview?: boolean;
        };
        type GetPropertiesResponse = {
            result: PropertyDescriptor[];
            internalProperties?: InternalPropertyDescriptor[];
            privateProperties?: PrivatePropertyDescriptor[];
            exceptionDetails?: ExceptionDetails;
        };
        type GlobalLexicalScopeNamesRequest = {
            executionContextId?: ExecutionContextId;
        };
        type GlobalLexicalScopeNamesResponse = {
            names: string[];
        };
        type QueryObjectsRequest = {
            prototypeObjectId: RemoteObjectId;
            objectGroup?: string;
        };
        type QueryObjectsResponse = {
            objects: RemoteObject;
        };
        type ReleaseObjectRequest = {
            objectId: RemoteObjectId;
        };
        type ReleaseObjectResponse = {};
        type ReleaseObjectGroupRequest = {
            objectGroup: string;
        };
        type ReleaseObjectGroupResponse = {};
        type RunIfWaitingForDebuggerRequest = {};
        type RunIfWaitingForDebuggerResponse = {};
        type RunScriptRequest = {
            scriptId: ScriptId;
            executionContextId?: ExecutionContextId;
            objectGroup?: string;
            silent?: boolean;
            includeCommandLineAPI?: boolean;
            returnByValue?: boolean;
            generatePreview?: boolean;
            awaitPromise?: boolean;
        };
        type RunScriptResponse = {
            result: RemoteObject;
            exceptionDetails?: ExceptionDetails;
        };
        type SetAsyncCallStackDepthRequest = {
            maxDepth: number;
        };
        type SetAsyncCallStackDepthResponse = {};
        type SetCustomObjectFormatterEnabledRequest = {
            enabled: boolean;
        };
        type SetCustomObjectFormatterEnabledResponse = {};
        type SetMaxCallStackSizeToCaptureRequest = {
            size: number;
        };
        type SetMaxCallStackSizeToCaptureResponse = {};
        type TerminateExecutionRequest = {};
        type TerminateExecutionResponse = {};
        type AddBindingRequest = {
            name: string;
            executionContextId?: ExecutionContextId;
        };
        type AddBindingResponse = {};
        type RemoveBindingRequest = {
            name: string;
        };
        type RemoveBindingResponse = {};
    }
    namespace Schema {
        /** Description of the protocol domain. */
        type Domain = {
            name: string;
            version: string;
        };
        type GetDomainsRequest = {};
        type GetDomainsResponse = {
            domains: Domain[];
        };
    }
    class Accessibility {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Disables the accessibility domain. */
        disable(request: Accessibility.DisableRequest): Promise<Accessibility.DisableResponse>;
        /** Enables the accessibility domain which causes `AXNodeId`s to remain consistent between method calls. This turns on accessibility for the page, which can impact performance until accessibility is disabled. */
        enable(request: Accessibility.EnableRequest): Promise<Accessibility.EnableResponse>;
        /** Fetches the accessibility node and partial accessibility tree for this DOM node, if it exists. */
        getPartialAXTree(request: Accessibility.GetPartialAXTreeRequest): Promise<Accessibility.GetPartialAXTreeResponse>;
        /** Fetches the entire accessibility tree */
        getFullAXTree(request: Accessibility.GetFullAXTreeRequest): Promise<Accessibility.GetFullAXTreeResponse>;
    }
    class Animation {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Disables animation domain notifications. */
        disable(request: Animation.DisableRequest): Promise<Animation.DisableResponse>;
        /** Enables animation domain notifications. */
        enable(request: Animation.EnableRequest): Promise<Animation.EnableResponse>;
        /** Returns the current time of the an animation. */
        getCurrentTime(request: Animation.GetCurrentTimeRequest): Promise<Animation.GetCurrentTimeResponse>;
        /** Gets the playback rate of the document timeline. */
        getPlaybackRate(request: Animation.GetPlaybackRateRequest): Promise<Animation.GetPlaybackRateResponse>;
        /** Releases a set of animations to no longer be manipulated. */
        releaseAnimations(request: Animation.ReleaseAnimationsRequest): Promise<Animation.ReleaseAnimationsResponse>;
        /** Gets the remote object of the Animation. */
        resolveAnimation(request: Animation.ResolveAnimationRequest): Promise<Animation.ResolveAnimationResponse>;
        /** Seek a set of animations to a particular time within each animation. */
        seekAnimations(request: Animation.SeekAnimationsRequest): Promise<Animation.SeekAnimationsResponse>;
        /** Sets the paused state of a set of animations. */
        setPaused(request: Animation.SetPausedRequest): Promise<Animation.SetPausedResponse>;
        /** Sets the playback rate of the document timeline. */
        setPlaybackRate(request: Animation.SetPlaybackRateRequest): Promise<Animation.SetPlaybackRateResponse>;
        /** Sets the timing of an animation node. */
        setTiming(request: Animation.SetTimingRequest): Promise<Animation.SetTimingResponse>;
        /** Event for when an animation has been cancelled. */
        on(event: 'animationCanceled', handler: EventHandler<Animation.AnimationCanceledEvent>): EventListener;
        /** Event for each animation that has been created. */
        on(event: 'animationCreated', handler: EventHandler<Animation.AnimationCreatedEvent>): EventListener;
        /** Event for animation that has been started. */
        on(event: 'animationStarted', handler: EventHandler<Animation.AnimationStartedEvent>): EventListener;
        /** Event for when an animation has been cancelled. */
        once(event: 'animationCanceled', handler: EventHandler<Animation.AnimationCanceledEvent>): EventListener;
        /** Event for each animation that has been created. */
        once(event: 'animationCreated', handler: EventHandler<Animation.AnimationCreatedEvent>): EventListener;
        /** Event for animation that has been started. */
        once(event: 'animationStarted', handler: EventHandler<Animation.AnimationStartedEvent>): EventListener;
    }
    class ApplicationCache {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Enables application cache domain notifications. */
        enable(request: ApplicationCache.EnableRequest): Promise<ApplicationCache.EnableResponse>;
        /** Returns relevant application cache data for the document in given frame. */
        getApplicationCacheForFrame(request: ApplicationCache.GetApplicationCacheForFrameRequest): Promise<ApplicationCache.GetApplicationCacheForFrameResponse>;
        /** Returns array of frame identifiers with manifest urls for each frame containing a document associated with some application cache. */
        getFramesWithManifests(request: ApplicationCache.GetFramesWithManifestsRequest): Promise<ApplicationCache.GetFramesWithManifestsResponse>;
        /** Returns manifest URL for document in the given frame. */
        getManifestForFrame(request: ApplicationCache.GetManifestForFrameRequest): Promise<ApplicationCache.GetManifestForFrameResponse>;
        on(event: 'applicationCacheStatusUpdated', handler: EventHandler<ApplicationCache.ApplicationCacheStatusUpdatedEvent>): EventListener;
        on(event: 'networkStateUpdated', handler: EventHandler<ApplicationCache.NetworkStateUpdatedEvent>): EventListener;
        once(event: 'applicationCacheStatusUpdated', handler: EventHandler<ApplicationCache.ApplicationCacheStatusUpdatedEvent>): EventListener;
        once(event: 'networkStateUpdated', handler: EventHandler<ApplicationCache.NetworkStateUpdatedEvent>): EventListener;
    }
    class Audits {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Returns the response body and size if it were re-encoded with the specified settings. Only applies to images. */
        getEncodedResponse(request: Audits.GetEncodedResponseRequest): Promise<Audits.GetEncodedResponseResponse>;
    }
    class BackgroundService {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Enables event updates for the service. */
        startObserving(request: BackgroundService.StartObservingRequest): Promise<BackgroundService.StartObservingResponse>;
        /** Disables event updates for the service. */
        stopObserving(request: BackgroundService.StopObservingRequest): Promise<BackgroundService.StopObservingResponse>;
        /** Set the recording state for the service. */
        setRecording(request: BackgroundService.SetRecordingRequest): Promise<BackgroundService.SetRecordingResponse>;
        /** Clears all stored data for the service. */
        clearEvents(request: BackgroundService.ClearEventsRequest): Promise<BackgroundService.ClearEventsResponse>;
        /** Called when the recording state for the service has been updated. */
        on(event: 'recordingStateChanged', handler: EventHandler<BackgroundService.RecordingStateChangedEvent>): EventListener;
        /** Called with all existing backgroundServiceEvents when enabled, and all new events afterwards if enabled and recording. */
        on(event: 'backgroundServiceEventReceived', handler: EventHandler<BackgroundService.BackgroundServiceEventReceivedEvent>): EventListener;
        /** Called when the recording state for the service has been updated. */
        once(event: 'recordingStateChanged', handler: EventHandler<BackgroundService.RecordingStateChangedEvent>): EventListener;
        /** Called with all existing backgroundServiceEvents when enabled, and all new events afterwards if enabled and recording. */
        once(event: 'backgroundServiceEventReceived', handler: EventHandler<BackgroundService.BackgroundServiceEventReceivedEvent>): EventListener;
    }
    class Browser {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Grant specific permissions to the given origin and reject all others. */
        grantPermissions(request: Browser.GrantPermissionsRequest): Promise<Browser.GrantPermissionsResponse>;
        /** Reset all permission management for all origins. */
        resetPermissions(request: Browser.ResetPermissionsRequest): Promise<Browser.ResetPermissionsResponse>;
        /** Close browser gracefully. */
        close(request: Browser.CloseRequest): Promise<Browser.CloseResponse>;
        /** Crashes browser on the main thread. */
        crash(request: Browser.CrashRequest): Promise<Browser.CrashResponse>;
        /** Crashes GPU process. */
        crashGpuProcess(request: Browser.CrashGpuProcessRequest): Promise<Browser.CrashGpuProcessResponse>;
        /** Returns version information. */
        getVersion(request: Browser.GetVersionRequest): Promise<Browser.GetVersionResponse>;
        /** Returns the command line switches for the browser process if, and only if --enable-automation is on the commandline. */
        getBrowserCommandLine(request: Browser.GetBrowserCommandLineRequest): Promise<Browser.GetBrowserCommandLineResponse>;
        /** Get Chrome histograms. */
        getHistograms(request: Browser.GetHistogramsRequest): Promise<Browser.GetHistogramsResponse>;
        /** Get a Chrome histogram by name. */
        getHistogram(request: Browser.GetHistogramRequest): Promise<Browser.GetHistogramResponse>;
        /** Get position and size of the browser window. */
        getWindowBounds(request: Browser.GetWindowBoundsRequest): Promise<Browser.GetWindowBoundsResponse>;
        /** Get the browser window that contains the devtools target. */
        getWindowForTarget(request: Browser.GetWindowForTargetRequest): Promise<Browser.GetWindowForTargetResponse>;
        /** Set position and/or size of the browser window. */
        setWindowBounds(request: Browser.SetWindowBoundsRequest): Promise<Browser.SetWindowBoundsResponse>;
        /** Set dock tile details, platform-specific. */
        setDockTile(request: Browser.SetDockTileRequest): Promise<Browser.SetDockTileResponse>;
    }
    class CSS {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Inserts a new rule with the given `ruleText` in a stylesheet with given `styleSheetId`, at the position specified by `location`. */
        addRule(request: CSS.AddRuleRequest): Promise<CSS.AddRuleResponse>;
        /** Returns all class names from specified stylesheet. */
        collectClassNames(request: CSS.CollectClassNamesRequest): Promise<CSS.CollectClassNamesResponse>;
        /** Creates a new special "via-inspector" stylesheet in the frame with given `frameId`. */
        createStyleSheet(request: CSS.CreateStyleSheetRequest): Promise<CSS.CreateStyleSheetResponse>;
        /** Disables the CSS agent for the given page. */
        disable(request: CSS.DisableRequest): Promise<CSS.DisableResponse>;
        /** Enables the CSS agent for the given page. Clients should not assume that the CSS agent has been enabled until the result of this command is received. */
        enable(request: CSS.EnableRequest): Promise<CSS.EnableResponse>;
        /** Ensures that the given node will have specified pseudo-classes whenever its style is computed by the browser. */
        forcePseudoState(request: CSS.ForcePseudoStateRequest): Promise<CSS.ForcePseudoStateResponse>;
        getBackgroundColors(request: CSS.GetBackgroundColorsRequest): Promise<CSS.GetBackgroundColorsResponse>;
        /** Returns the computed style for a DOM node identified by `nodeId`. */
        getComputedStyleForNode(request: CSS.GetComputedStyleForNodeRequest): Promise<CSS.GetComputedStyleForNodeResponse>;
        /** Returns the styles defined inline (explicitly in the "style" attribute and implicitly, using DOM attributes) for a DOM node identified by `nodeId`. */
        getInlineStylesForNode(request: CSS.GetInlineStylesForNodeRequest): Promise<CSS.GetInlineStylesForNodeResponse>;
        /** Returns requested styles for a DOM node identified by `nodeId`. */
        getMatchedStylesForNode(request: CSS.GetMatchedStylesForNodeRequest): Promise<CSS.GetMatchedStylesForNodeResponse>;
        /** Returns all media queries parsed by the rendering engine. */
        getMediaQueries(request: CSS.GetMediaQueriesRequest): Promise<CSS.GetMediaQueriesResponse>;
        /** Requests information about platform fonts which we used to render child TextNodes in the given node. */
        getPlatformFontsForNode(request: CSS.GetPlatformFontsForNodeRequest): Promise<CSS.GetPlatformFontsForNodeResponse>;
        /** Returns the current textual content for a stylesheet. */
        getStyleSheetText(request: CSS.GetStyleSheetTextRequest): Promise<CSS.GetStyleSheetTextResponse>;
        /** Find a rule with the given active property for the given node and set the new value for this property */
        setEffectivePropertyValueForNode(request: CSS.SetEffectivePropertyValueForNodeRequest): Promise<CSS.SetEffectivePropertyValueForNodeResponse>;
        /** Modifies the keyframe rule key text. */
        setKeyframeKey(request: CSS.SetKeyframeKeyRequest): Promise<CSS.SetKeyframeKeyResponse>;
        /** Modifies the rule selector. */
        setMediaText(request: CSS.SetMediaTextRequest): Promise<CSS.SetMediaTextResponse>;
        /** Modifies the rule selector. */
        setRuleSelector(request: CSS.SetRuleSelectorRequest): Promise<CSS.SetRuleSelectorResponse>;
        /** Sets the new stylesheet text. */
        setStyleSheetText(request: CSS.SetStyleSheetTextRequest): Promise<CSS.SetStyleSheetTextResponse>;
        /** Applies specified style edits one after another in the given order. */
        setStyleTexts(request: CSS.SetStyleTextsRequest): Promise<CSS.SetStyleTextsResponse>;
        /** Enables the selector recording. */
        startRuleUsageTracking(request: CSS.StartRuleUsageTrackingRequest): Promise<CSS.StartRuleUsageTrackingResponse>;
        /** Stop tracking rule usage and return the list of rules that were used since last call to `takeCoverageDelta` (or since start of coverage instrumentation) */
        stopRuleUsageTracking(request: CSS.StopRuleUsageTrackingRequest): Promise<CSS.StopRuleUsageTrackingResponse>;
        /** Obtain list of rules that became used since last call to this method (or since start of coverage instrumentation) */
        takeCoverageDelta(request: CSS.TakeCoverageDeltaRequest): Promise<CSS.TakeCoverageDeltaResponse>;
        /** Fires whenever a web font is updated.  A non-empty font parameter indicates a successfully loaded web font */
        on(event: 'fontsUpdated', handler: EventHandler<CSS.FontsUpdatedEvent>): EventListener;
        /** Fires whenever a MediaQuery result changes (for example, after a browser window has been resized.) The current implementation considers only viewport-dependent media features. */
        on(event: 'mediaQueryResultChanged', handler: EventHandler<CSS.MediaQueryResultChangedEvent>): EventListener;
        /** Fired whenever an active document stylesheet is added. */
        on(event: 'styleSheetAdded', handler: EventHandler<CSS.StyleSheetAddedEvent>): EventListener;
        /** Fired whenever a stylesheet is changed as a result of the client operation. */
        on(event: 'styleSheetChanged', handler: EventHandler<CSS.StyleSheetChangedEvent>): EventListener;
        /** Fired whenever an active document stylesheet is removed. */
        on(event: 'styleSheetRemoved', handler: EventHandler<CSS.StyleSheetRemovedEvent>): EventListener;
        /** Fires whenever a web font is updated.  A non-empty font parameter indicates a successfully loaded web font */
        once(event: 'fontsUpdated', handler: EventHandler<CSS.FontsUpdatedEvent>): EventListener;
        /** Fires whenever a MediaQuery result changes (for example, after a browser window has been resized.) The current implementation considers only viewport-dependent media features. */
        once(event: 'mediaQueryResultChanged', handler: EventHandler<CSS.MediaQueryResultChangedEvent>): EventListener;
        /** Fired whenever an active document stylesheet is added. */
        once(event: 'styleSheetAdded', handler: EventHandler<CSS.StyleSheetAddedEvent>): EventListener;
        /** Fired whenever a stylesheet is changed as a result of the client operation. */
        once(event: 'styleSheetChanged', handler: EventHandler<CSS.StyleSheetChangedEvent>): EventListener;
        /** Fired whenever an active document stylesheet is removed. */
        once(event: 'styleSheetRemoved', handler: EventHandler<CSS.StyleSheetRemovedEvent>): EventListener;
    }
    class CacheStorage {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Deletes a cache. */
        deleteCache(request: CacheStorage.DeleteCacheRequest): Promise<CacheStorage.DeleteCacheResponse>;
        /** Deletes a cache entry. */
        deleteEntry(request: CacheStorage.DeleteEntryRequest): Promise<CacheStorage.DeleteEntryResponse>;
        /** Requests cache names. */
        requestCacheNames(request: CacheStorage.RequestCacheNamesRequest): Promise<CacheStorage.RequestCacheNamesResponse>;
        /** Fetches cache entry. */
        requestCachedResponse(request: CacheStorage.RequestCachedResponseRequest): Promise<CacheStorage.RequestCachedResponseResponse>;
        /** Requests data from cache. */
        requestEntries(request: CacheStorage.RequestEntriesRequest): Promise<CacheStorage.RequestEntriesResponse>;
    }
    class Cast {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Starts observing for sinks that can be used for tab mirroring, and if set, sinks compatible with |presentationUrl| as well. When sinks are found, a |sinksUpdated| event is fired. Also starts observing for issue messages. When an issue is added or removed, an |issueUpdated| event is fired. */
        enable(request: Cast.EnableRequest): Promise<Cast.EnableResponse>;
        /** Stops observing for sinks and issues. */
        disable(request: Cast.DisableRequest): Promise<Cast.DisableResponse>;
        /** Sets a sink to be used when the web page requests the browser to choose a sink via Presentation API, Remote Playback API, or Cast SDK. */
        setSinkToUse(request: Cast.SetSinkToUseRequest): Promise<Cast.SetSinkToUseResponse>;
        /** Starts mirroring the tab to the sink. */
        startTabMirroring(request: Cast.StartTabMirroringRequest): Promise<Cast.StartTabMirroringResponse>;
        /** Stops the active Cast session on the sink. */
        stopCasting(request: Cast.StopCastingRequest): Promise<Cast.StopCastingResponse>;
        /** This is fired whenever the list of available sinks changes. A sink is a device or a software surface that you can cast to. */
        on(event: 'sinksUpdated', handler: EventHandler<Cast.SinksUpdatedEvent>): EventListener;
        /** This is fired whenever the outstanding issue/error message changes. |issueMessage| is empty if there is no issue. */
        on(event: 'issueUpdated', handler: EventHandler<Cast.IssueUpdatedEvent>): EventListener;
        /** This is fired whenever the list of available sinks changes. A sink is a device or a software surface that you can cast to. */
        once(event: 'sinksUpdated', handler: EventHandler<Cast.SinksUpdatedEvent>): EventListener;
        /** This is fired whenever the outstanding issue/error message changes. |issueMessage| is empty if there is no issue. */
        once(event: 'issueUpdated', handler: EventHandler<Cast.IssueUpdatedEvent>): EventListener;
    }
    class DOM {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Collects class names for the node with given id and all of it's child nodes. */
        collectClassNamesFromSubtree(request: DOM.CollectClassNamesFromSubtreeRequest): Promise<DOM.CollectClassNamesFromSubtreeResponse>;
        /** Creates a deep copy of the specified node and places it into the target container before the given anchor. */
        copyTo(request: DOM.CopyToRequest): Promise<DOM.CopyToResponse>;
        /** Describes node given its id, does not require domain to be enabled. Does not start tracking any objects, can be used for automation. */
        describeNode(request: DOM.DescribeNodeRequest): Promise<DOM.DescribeNodeResponse>;
        /** Disables DOM agent for the given page. */
        disable(request: DOM.DisableRequest): Promise<DOM.DisableResponse>;
        /** Discards search results from the session with the given id. `getSearchResults` should no longer be called for that search. */
        discardSearchResults(request: DOM.DiscardSearchResultsRequest): Promise<DOM.DiscardSearchResultsResponse>;
        /** Enables DOM agent for the given page. */
        enable(request: DOM.EnableRequest): Promise<DOM.EnableResponse>;
        /** Focuses the given element. */
        focus(request: DOM.FocusRequest): Promise<DOM.FocusResponse>;
        /** Returns attributes for the specified node. */
        getAttributes(request: DOM.GetAttributesRequest): Promise<DOM.GetAttributesResponse>;
        /** Returns boxes for the given node. */
        getBoxModel(request: DOM.GetBoxModelRequest): Promise<DOM.GetBoxModelResponse>;
        /** Returns quads that describe node position on the page. This method might return multiple quads for inline nodes. */
        getContentQuads(request: DOM.GetContentQuadsRequest): Promise<DOM.GetContentQuadsResponse>;
        /** Returns the root DOM node (and optionally the subtree) to the caller. */
        getDocument(request: DOM.GetDocumentRequest): Promise<DOM.GetDocumentResponse>;
        /** Returns the root DOM node (and optionally the subtree) to the caller. */
        getFlattenedDocument(request: DOM.GetFlattenedDocumentRequest): Promise<DOM.GetFlattenedDocumentResponse>;
        /** Returns node id at given location. Depending on whether DOM domain is enabled, nodeId is either returned or not. */
        getNodeForLocation(request: DOM.GetNodeForLocationRequest): Promise<DOM.GetNodeForLocationResponse>;
        /** Returns node's HTML markup. */
        getOuterHTML(request: DOM.GetOuterHTMLRequest): Promise<DOM.GetOuterHTMLResponse>;
        /** Returns the id of the nearest ancestor that is a relayout boundary. */
        getRelayoutBoundary(request: DOM.GetRelayoutBoundaryRequest): Promise<DOM.GetRelayoutBoundaryResponse>;
        /** Returns search results from given `fromIndex` to given `toIndex` from the search with the given identifier. */
        getSearchResults(request: DOM.GetSearchResultsRequest): Promise<DOM.GetSearchResultsResponse>;
        /** Hides any highlight. */
        hideHighlight(request: DOM.HideHighlightRequest): Promise<DOM.HideHighlightResponse>;
        /** Highlights DOM node. */
        highlightNode(request: DOM.HighlightNodeRequest): Promise<DOM.HighlightNodeResponse>;
        /** Highlights given rectangle. */
        highlightRect(request: DOM.HighlightRectRequest): Promise<DOM.HighlightRectResponse>;
        /** Marks last undoable state. */
        markUndoableState(request: DOM.MarkUndoableStateRequest): Promise<DOM.MarkUndoableStateResponse>;
        /** Moves node into the new container, places it before the given anchor. */
        moveTo(request: DOM.MoveToRequest): Promise<DOM.MoveToResponse>;
        /** Searches for a given string in the DOM tree. Use `getSearchResults` to access search results or `cancelSearch` to end this search session. */
        performSearch(request: DOM.PerformSearchRequest): Promise<DOM.PerformSearchResponse>;
        /** Requests that the node is sent to the caller given its path. // FIXME, use XPath */
        pushNodeByPathToFrontend(request: DOM.PushNodeByPathToFrontendRequest): Promise<DOM.PushNodeByPathToFrontendResponse>;
        /** Requests that a batch of nodes is sent to the caller given their backend node ids. */
        pushNodesByBackendIdsToFrontend(request: DOM.PushNodesByBackendIdsToFrontendRequest): Promise<DOM.PushNodesByBackendIdsToFrontendResponse>;
        /** Executes `querySelector` on a given node. */
        querySelector(request: DOM.QuerySelectorRequest): Promise<DOM.QuerySelectorResponse>;
        /** Executes `querySelectorAll` on a given node. */
        querySelectorAll(request: DOM.QuerySelectorAllRequest): Promise<DOM.QuerySelectorAllResponse>;
        /** Re-does the last undone action. */
        redo(request: DOM.RedoRequest): Promise<DOM.RedoResponse>;
        /** Removes attribute with given name from an element with given id. */
        removeAttribute(request: DOM.RemoveAttributeRequest): Promise<DOM.RemoveAttributeResponse>;
        /** Removes node with given id. */
        removeNode(request: DOM.RemoveNodeRequest): Promise<DOM.RemoveNodeResponse>;
        /** Requests that children of the node with given id are returned to the caller in form of `setChildNodes` events where not only immediate children are retrieved, but all children down to the specified depth. */
        requestChildNodes(request: DOM.RequestChildNodesRequest): Promise<DOM.RequestChildNodesResponse>;
        /** Requests that the node is sent to the caller given the JavaScript node object reference. All nodes that form the path from the node to the root are also sent to the client as a series of `setChildNodes` notifications. */
        requestNode(request: DOM.RequestNodeRequest): Promise<DOM.RequestNodeResponse>;
        /** Resolves the JavaScript node object for a given NodeId or BackendNodeId. */
        resolveNode(request: DOM.ResolveNodeRequest): Promise<DOM.ResolveNodeResponse>;
        /** Sets attribute for an element with given id. */
        setAttributeValue(request: DOM.SetAttributeValueRequest): Promise<DOM.SetAttributeValueResponse>;
        /** Sets attributes on element with given id. This method is useful when user edits some existing attribute value and types in several attribute name/value pairs. */
        setAttributesAsText(request: DOM.SetAttributesAsTextRequest): Promise<DOM.SetAttributesAsTextResponse>;
        /** Sets files for the given file input element. */
        setFileInputFiles(request: DOM.SetFileInputFilesRequest): Promise<DOM.SetFileInputFilesResponse>;
        /** Returns file information for the given File wrapper. */
        getFileInfo(request: DOM.GetFileInfoRequest): Promise<DOM.GetFileInfoResponse>;
        /** Enables console to refer to the node with given id via $x (see Command Line API for more details $x functions). */
        setInspectedNode(request: DOM.SetInspectedNodeRequest): Promise<DOM.SetInspectedNodeResponse>;
        /** Sets node name for a node with given id. */
        setNodeName(request: DOM.SetNodeNameRequest): Promise<DOM.SetNodeNameResponse>;
        /** Sets node value for a node with given id. */
        setNodeValue(request: DOM.SetNodeValueRequest): Promise<DOM.SetNodeValueResponse>;
        /** Sets node HTML markup, returns new node id. */
        setOuterHTML(request: DOM.SetOuterHTMLRequest): Promise<DOM.SetOuterHTMLResponse>;
        /** Undoes the last performed action. */
        undo(request: DOM.UndoRequest): Promise<DOM.UndoResponse>;
        /** Returns iframe node that owns iframe with the given domain. */
        getFrameOwner(request: DOM.GetFrameOwnerRequest): Promise<DOM.GetFrameOwnerResponse>;
        /** Fired when `Element`'s attribute is modified. */
        on(event: 'attributeModified', handler: EventHandler<DOM.AttributeModifiedEvent>): EventListener;
        /** Fired when `Element`'s attribute is removed. */
        on(event: 'attributeRemoved', handler: EventHandler<DOM.AttributeRemovedEvent>): EventListener;
        /** Mirrors `DOMCharacterDataModified` event. */
        on(event: 'characterDataModified', handler: EventHandler<DOM.CharacterDataModifiedEvent>): EventListener;
        /** Fired when `Container`'s child node count has changed. */
        on(event: 'childNodeCountUpdated', handler: EventHandler<DOM.ChildNodeCountUpdatedEvent>): EventListener;
        /** Mirrors `DOMNodeInserted` event. */
        on(event: 'childNodeInserted', handler: EventHandler<DOM.ChildNodeInsertedEvent>): EventListener;
        /** Mirrors `DOMNodeRemoved` event. */
        on(event: 'childNodeRemoved', handler: EventHandler<DOM.ChildNodeRemovedEvent>): EventListener;
        /** Called when distrubution is changed. */
        on(event: 'distributedNodesUpdated', handler: EventHandler<DOM.DistributedNodesUpdatedEvent>): EventListener;
        /** Fired when `Document` has been totally updated. Node ids are no longer valid. */
        on(event: 'documentUpdated', handler: EventHandler<DOM.DocumentUpdatedEvent>): EventListener;
        /** Fired when `Element`'s inline style is modified via a CSS property modification. */
        on(event: 'inlineStyleInvalidated', handler: EventHandler<DOM.InlineStyleInvalidatedEvent>): EventListener;
        /** Called when a pseudo element is added to an element. */
        on(event: 'pseudoElementAdded', handler: EventHandler<DOM.PseudoElementAddedEvent>): EventListener;
        /** Called when a pseudo element is removed from an element. */
        on(event: 'pseudoElementRemoved', handler: EventHandler<DOM.PseudoElementRemovedEvent>): EventListener;
        /** Fired when backend wants to provide client with the missing DOM structure. This happens upon most of the calls requesting node ids. */
        on(event: 'setChildNodes', handler: EventHandler<DOM.SetChildNodesEvent>): EventListener;
        /** Called when shadow root is popped from the element. */
        on(event: 'shadowRootPopped', handler: EventHandler<DOM.ShadowRootPoppedEvent>): EventListener;
        /** Called when shadow root is pushed into the element. */
        on(event: 'shadowRootPushed', handler: EventHandler<DOM.ShadowRootPushedEvent>): EventListener;
        /** Fired when `Element`'s attribute is modified. */
        once(event: 'attributeModified', handler: EventHandler<DOM.AttributeModifiedEvent>): EventListener;
        /** Fired when `Element`'s attribute is removed. */
        once(event: 'attributeRemoved', handler: EventHandler<DOM.AttributeRemovedEvent>): EventListener;
        /** Mirrors `DOMCharacterDataModified` event. */
        once(event: 'characterDataModified', handler: EventHandler<DOM.CharacterDataModifiedEvent>): EventListener;
        /** Fired when `Container`'s child node count has changed. */
        once(event: 'childNodeCountUpdated', handler: EventHandler<DOM.ChildNodeCountUpdatedEvent>): EventListener;
        /** Mirrors `DOMNodeInserted` event. */
        once(event: 'childNodeInserted', handler: EventHandler<DOM.ChildNodeInsertedEvent>): EventListener;
        /** Mirrors `DOMNodeRemoved` event. */
        once(event: 'childNodeRemoved', handler: EventHandler<DOM.ChildNodeRemovedEvent>): EventListener;
        /** Called when distrubution is changed. */
        once(event: 'distributedNodesUpdated', handler: EventHandler<DOM.DistributedNodesUpdatedEvent>): EventListener;
        /** Fired when `Document` has been totally updated. Node ids are no longer valid. */
        once(event: 'documentUpdated', handler: EventHandler<DOM.DocumentUpdatedEvent>): EventListener;
        /** Fired when `Element`'s inline style is modified via a CSS property modification. */
        once(event: 'inlineStyleInvalidated', handler: EventHandler<DOM.InlineStyleInvalidatedEvent>): EventListener;
        /** Called when a pseudo element is added to an element. */
        once(event: 'pseudoElementAdded', handler: EventHandler<DOM.PseudoElementAddedEvent>): EventListener;
        /** Called when a pseudo element is removed from an element. */
        once(event: 'pseudoElementRemoved', handler: EventHandler<DOM.PseudoElementRemovedEvent>): EventListener;
        /** Fired when backend wants to provide client with the missing DOM structure. This happens upon most of the calls requesting node ids. */
        once(event: 'setChildNodes', handler: EventHandler<DOM.SetChildNodesEvent>): EventListener;
        /** Called when shadow root is popped from the element. */
        once(event: 'shadowRootPopped', handler: EventHandler<DOM.ShadowRootPoppedEvent>): EventListener;
        /** Called when shadow root is pushed into the element. */
        once(event: 'shadowRootPushed', handler: EventHandler<DOM.ShadowRootPushedEvent>): EventListener;
    }
    class DOMDebugger {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Returns event listeners of the given object. */
        getEventListeners(request: DOMDebugger.GetEventListenersRequest): Promise<DOMDebugger.GetEventListenersResponse>;
        /** Removes DOM breakpoint that was set using `setDOMBreakpoint`. */
        removeDOMBreakpoint(request: DOMDebugger.RemoveDOMBreakpointRequest): Promise<DOMDebugger.RemoveDOMBreakpointResponse>;
        /** Removes breakpoint on particular DOM event. */
        removeEventListenerBreakpoint(request: DOMDebugger.RemoveEventListenerBreakpointRequest): Promise<DOMDebugger.RemoveEventListenerBreakpointResponse>;
        /** Removes breakpoint on particular native event. */
        removeInstrumentationBreakpoint(request: DOMDebugger.RemoveInstrumentationBreakpointRequest): Promise<DOMDebugger.RemoveInstrumentationBreakpointResponse>;
        /** Removes breakpoint from XMLHttpRequest. */
        removeXHRBreakpoint(request: DOMDebugger.RemoveXHRBreakpointRequest): Promise<DOMDebugger.RemoveXHRBreakpointResponse>;
        /** Sets breakpoint on particular operation with DOM. */
        setDOMBreakpoint(request: DOMDebugger.SetDOMBreakpointRequest): Promise<DOMDebugger.SetDOMBreakpointResponse>;
        /** Sets breakpoint on particular DOM event. */
        setEventListenerBreakpoint(request: DOMDebugger.SetEventListenerBreakpointRequest): Promise<DOMDebugger.SetEventListenerBreakpointResponse>;
        /** Sets breakpoint on particular native event. */
        setInstrumentationBreakpoint(request: DOMDebugger.SetInstrumentationBreakpointRequest): Promise<DOMDebugger.SetInstrumentationBreakpointResponse>;
        /** Sets breakpoint on XMLHttpRequest. */
        setXHRBreakpoint(request: DOMDebugger.SetXHRBreakpointRequest): Promise<DOMDebugger.SetXHRBreakpointResponse>;
    }
    class DOMSnapshot {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Disables DOM snapshot agent for the given page. */
        disable(request: DOMSnapshot.DisableRequest): Promise<DOMSnapshot.DisableResponse>;
        /** Enables DOM snapshot agent for the given page. */
        enable(request: DOMSnapshot.EnableRequest): Promise<DOMSnapshot.EnableResponse>;
        /** Returns a document snapshot, including the full DOM tree of the root node (including iframes, template contents, and imported documents) in a flattened array, as well as layout and white-listed computed style information for the nodes. Shadow DOM in the returned DOM tree is flattened. */
        getSnapshot(request: DOMSnapshot.GetSnapshotRequest): Promise<DOMSnapshot.GetSnapshotResponse>;
        /** Returns a document snapshot, including the full DOM tree of the root node (including iframes, template contents, and imported documents) in a flattened array, as well as layout and white-listed computed style information for the nodes. Shadow DOM in the returned DOM tree is flattened. */
        captureSnapshot(request: DOMSnapshot.CaptureSnapshotRequest): Promise<DOMSnapshot.CaptureSnapshotResponse>;
    }
    class DOMStorage {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        clear(request: DOMStorage.ClearRequest): Promise<DOMStorage.ClearResponse>;
        /** Disables storage tracking, prevents storage events from being sent to the client. */
        disable(request: DOMStorage.DisableRequest): Promise<DOMStorage.DisableResponse>;
        /** Enables storage tracking, storage events will now be delivered to the client. */
        enable(request: DOMStorage.EnableRequest): Promise<DOMStorage.EnableResponse>;
        getDOMStorageItems(request: DOMStorage.GetDOMStorageItemsRequest): Promise<DOMStorage.GetDOMStorageItemsResponse>;
        removeDOMStorageItem(request: DOMStorage.RemoveDOMStorageItemRequest): Promise<DOMStorage.RemoveDOMStorageItemResponse>;
        setDOMStorageItem(request: DOMStorage.SetDOMStorageItemRequest): Promise<DOMStorage.SetDOMStorageItemResponse>;
        on(event: 'domStorageItemAdded', handler: EventHandler<DOMStorage.DomStorageItemAddedEvent>): EventListener;
        on(event: 'domStorageItemRemoved', handler: EventHandler<DOMStorage.DomStorageItemRemovedEvent>): EventListener;
        on(event: 'domStorageItemUpdated', handler: EventHandler<DOMStorage.DomStorageItemUpdatedEvent>): EventListener;
        on(event: 'domStorageItemsCleared', handler: EventHandler<DOMStorage.DomStorageItemsClearedEvent>): EventListener;
        once(event: 'domStorageItemAdded', handler: EventHandler<DOMStorage.DomStorageItemAddedEvent>): EventListener;
        once(event: 'domStorageItemRemoved', handler: EventHandler<DOMStorage.DomStorageItemRemovedEvent>): EventListener;
        once(event: 'domStorageItemUpdated', handler: EventHandler<DOMStorage.DomStorageItemUpdatedEvent>): EventListener;
        once(event: 'domStorageItemsCleared', handler: EventHandler<DOMStorage.DomStorageItemsClearedEvent>): EventListener;
    }
    class Database {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Disables database tracking, prevents database events from being sent to the client. */
        disable(request: Database.DisableRequest): Promise<Database.DisableResponse>;
        /** Enables database tracking, database events will now be delivered to the client. */
        enable(request: Database.EnableRequest): Promise<Database.EnableResponse>;
        executeSQL(request: Database.ExecuteSQLRequest): Promise<Database.ExecuteSQLResponse>;
        getDatabaseTableNames(request: Database.GetDatabaseTableNamesRequest): Promise<Database.GetDatabaseTableNamesResponse>;
        on(event: 'addDatabase', handler: EventHandler<Database.AddDatabaseEvent>): EventListener;
        once(event: 'addDatabase', handler: EventHandler<Database.AddDatabaseEvent>): EventListener;
    }
    class DeviceOrientation {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Clears the overridden Device Orientation. */
        clearDeviceOrientationOverride(request: DeviceOrientation.ClearDeviceOrientationOverrideRequest): Promise<DeviceOrientation.ClearDeviceOrientationOverrideResponse>;
        /** Overrides the Device Orientation. */
        setDeviceOrientationOverride(request: DeviceOrientation.SetDeviceOrientationOverrideRequest): Promise<DeviceOrientation.SetDeviceOrientationOverrideResponse>;
    }
    class Emulation {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Tells whether emulation is supported. */
        canEmulate(request: Emulation.CanEmulateRequest): Promise<Emulation.CanEmulateResponse>;
        /** Clears the overriden device metrics. */
        clearDeviceMetricsOverride(request: Emulation.ClearDeviceMetricsOverrideRequest): Promise<Emulation.ClearDeviceMetricsOverrideResponse>;
        /** Clears the overriden Geolocation Position and Error. */
        clearGeolocationOverride(request: Emulation.ClearGeolocationOverrideRequest): Promise<Emulation.ClearGeolocationOverrideResponse>;
        /** Requests that page scale factor is reset to initial values. */
        resetPageScaleFactor(request: Emulation.ResetPageScaleFactorRequest): Promise<Emulation.ResetPageScaleFactorResponse>;
        /** Enables or disables simulating a focused and active page. */
        setFocusEmulationEnabled(request: Emulation.SetFocusEmulationEnabledRequest): Promise<Emulation.SetFocusEmulationEnabledResponse>;
        /** Enables CPU throttling to emulate slow CPUs. */
        setCPUThrottlingRate(request: Emulation.SetCPUThrottlingRateRequest): Promise<Emulation.SetCPUThrottlingRateResponse>;
        /** Sets or clears an override of the default background color of the frame. This override is used if the content does not specify one. */
        setDefaultBackgroundColorOverride(request: Emulation.SetDefaultBackgroundColorOverrideRequest): Promise<Emulation.SetDefaultBackgroundColorOverrideResponse>;
        /** Overrides the values of device screen dimensions (window.screen.width, window.screen.height, window.innerWidth, window.innerHeight, and "device-width"/"device-height"-related CSS media query results). */
        setDeviceMetricsOverride(request: Emulation.SetDeviceMetricsOverrideRequest): Promise<Emulation.SetDeviceMetricsOverrideResponse>;
        setScrollbarsHidden(request: Emulation.SetScrollbarsHiddenRequest): Promise<Emulation.SetScrollbarsHiddenResponse>;
        setDocumentCookieDisabled(request: Emulation.SetDocumentCookieDisabledRequest): Promise<Emulation.SetDocumentCookieDisabledResponse>;
        setEmitTouchEventsForMouse(request: Emulation.SetEmitTouchEventsForMouseRequest): Promise<Emulation.SetEmitTouchEventsForMouseResponse>;
        /** Emulates the given media for CSS media queries. */
        setEmulatedMedia(request: Emulation.SetEmulatedMediaRequest): Promise<Emulation.SetEmulatedMediaResponse>;
        /** Overrides the Geolocation Position or Error. Omitting any of the parameters emulates position unavailable. */
        setGeolocationOverride(request: Emulation.SetGeolocationOverrideRequest): Promise<Emulation.SetGeolocationOverrideResponse>;
        /** Overrides value returned by the javascript navigator object. */
        setNavigatorOverrides(request: Emulation.SetNavigatorOverridesRequest): Promise<Emulation.SetNavigatorOverridesResponse>;
        /** Sets a specified page scale factor. */
        setPageScaleFactor(request: Emulation.SetPageScaleFactorRequest): Promise<Emulation.SetPageScaleFactorResponse>;
        /** Switches script execution in the page. */
        setScriptExecutionDisabled(request: Emulation.SetScriptExecutionDisabledRequest): Promise<Emulation.SetScriptExecutionDisabledResponse>;
        /** Enables touch on platforms which do not support them. */
        setTouchEmulationEnabled(request: Emulation.SetTouchEmulationEnabledRequest): Promise<Emulation.SetTouchEmulationEnabledResponse>;
        /** Turns on virtual time for all frames (replacing real-time with a synthetic time source) and sets the current virtual time policy.  Note this supersedes any previous time budget. */
        setVirtualTimePolicy(request: Emulation.SetVirtualTimePolicyRequest): Promise<Emulation.SetVirtualTimePolicyResponse>;
        /** Overrides default host system timezone with the specified one. */
        setTimezoneOverride(request: Emulation.SetTimezoneOverrideRequest): Promise<Emulation.SetTimezoneOverrideResponse>;
        /** Resizes the frame/viewport of the page. Note that this does not affect the frame's container (e.g. browser window). Can be used to produce screenshots of the specified size. Not supported on Android. */
        setVisibleSize(request: Emulation.SetVisibleSizeRequest): Promise<Emulation.SetVisibleSizeResponse>;
        /** Allows overriding user agent with the given string. */
        setUserAgentOverride(request: Emulation.SetUserAgentOverrideRequest): Promise<Emulation.SetUserAgentOverrideResponse>;
        /** Notification sent after the virtual time budget for the current VirtualTimePolicy has run out. */
        on(event: 'virtualTimeBudgetExpired', handler: EventHandler<Emulation.VirtualTimeBudgetExpiredEvent>): EventListener;
        /** Notification sent after the virtual time budget for the current VirtualTimePolicy has run out. */
        once(event: 'virtualTimeBudgetExpired', handler: EventHandler<Emulation.VirtualTimeBudgetExpiredEvent>): EventListener;
    }
    class HeadlessExperimental {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Sends a BeginFrame to the target and returns when the frame was completed. Optionally captures a screenshot from the resulting frame. Requires that the target was created with enabled BeginFrameControl. Designed for use with --run-all-compositor-stages-before-draw, see also https://goo.gl/3zHXhB for more background. */
        beginFrame(request: HeadlessExperimental.BeginFrameRequest): Promise<HeadlessExperimental.BeginFrameResponse>;
        /** Disables headless events for the target. */
        disable(request: HeadlessExperimental.DisableRequest): Promise<HeadlessExperimental.DisableResponse>;
        /** Enables headless events for the target. */
        enable(request: HeadlessExperimental.EnableRequest): Promise<HeadlessExperimental.EnableResponse>;
        /** Issued when the target starts or stops needing BeginFrames. */
        on(event: 'needsBeginFramesChanged', handler: EventHandler<HeadlessExperimental.NeedsBeginFramesChangedEvent>): EventListener;
        /** Issued when the target starts or stops needing BeginFrames. */
        once(event: 'needsBeginFramesChanged', handler: EventHandler<HeadlessExperimental.NeedsBeginFramesChangedEvent>): EventListener;
    }
    class IO {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Close the stream, discard any temporary backing storage. */
        close(request: IO.CloseRequest): Promise<IO.CloseResponse>;
        /** Read a chunk of the stream */
        read(request: IO.ReadRequest): Promise<IO.ReadResponse>;
        /** Return UUID of Blob object specified by a remote object id. */
        resolveBlob(request: IO.ResolveBlobRequest): Promise<IO.ResolveBlobResponse>;
    }
    class IndexedDB {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Clears all entries from an object store. */
        clearObjectStore(request: IndexedDB.ClearObjectStoreRequest): Promise<IndexedDB.ClearObjectStoreResponse>;
        /** Deletes a database. */
        deleteDatabase(request: IndexedDB.DeleteDatabaseRequest): Promise<IndexedDB.DeleteDatabaseResponse>;
        /** Delete a range of entries from an object store */
        deleteObjectStoreEntries(request: IndexedDB.DeleteObjectStoreEntriesRequest): Promise<IndexedDB.DeleteObjectStoreEntriesResponse>;
        /** Disables events from backend. */
        disable(request: IndexedDB.DisableRequest): Promise<IndexedDB.DisableResponse>;
        /** Enables events from backend. */
        enable(request: IndexedDB.EnableRequest): Promise<IndexedDB.EnableResponse>;
        /** Requests data from object store or index. */
        requestData(request: IndexedDB.RequestDataRequest): Promise<IndexedDB.RequestDataResponse>;
        /** Gets metadata of an object store */
        getMetadata(request: IndexedDB.GetMetadataRequest): Promise<IndexedDB.GetMetadataResponse>;
        /** Requests database with given name in given frame. */
        requestDatabase(request: IndexedDB.RequestDatabaseRequest): Promise<IndexedDB.RequestDatabaseResponse>;
        /** Requests database names for given security origin. */
        requestDatabaseNames(request: IndexedDB.RequestDatabaseNamesRequest): Promise<IndexedDB.RequestDatabaseNamesResponse>;
    }
    class Input {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Dispatches a key event to the page. */
        dispatchKeyEvent(request: Input.DispatchKeyEventRequest): Promise<Input.DispatchKeyEventResponse>;
        /** This method emulates inserting text that doesn't come from a key press, for example an emoji keyboard or an IME. */
        insertText(request: Input.InsertTextRequest): Promise<Input.InsertTextResponse>;
        /** Dispatches a mouse event to the page. */
        dispatchMouseEvent(request: Input.DispatchMouseEventRequest): Promise<Input.DispatchMouseEventResponse>;
        /** Dispatches a touch event to the page. */
        dispatchTouchEvent(request: Input.DispatchTouchEventRequest): Promise<Input.DispatchTouchEventResponse>;
        /** Emulates touch event from the mouse event parameters. */
        emulateTouchFromMouseEvent(request: Input.EmulateTouchFromMouseEventRequest): Promise<Input.EmulateTouchFromMouseEventResponse>;
        /** Ignores input events (useful while auditing page). */
        setIgnoreInputEvents(request: Input.SetIgnoreInputEventsRequest): Promise<Input.SetIgnoreInputEventsResponse>;
        /** Synthesizes a pinch gesture over a time period by issuing appropriate touch events. */
        synthesizePinchGesture(request: Input.SynthesizePinchGestureRequest): Promise<Input.SynthesizePinchGestureResponse>;
        /** Synthesizes a scroll gesture over a time period by issuing appropriate touch events. */
        synthesizeScrollGesture(request: Input.SynthesizeScrollGestureRequest): Promise<Input.SynthesizeScrollGestureResponse>;
        /** Synthesizes a tap gesture over a time period by issuing appropriate touch events. */
        synthesizeTapGesture(request: Input.SynthesizeTapGestureRequest): Promise<Input.SynthesizeTapGestureResponse>;
    }
    class Inspector {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Disables inspector domain notifications. */
        disable(request: Inspector.DisableRequest): Promise<Inspector.DisableResponse>;
        /** Enables inspector domain notifications. */
        enable(request: Inspector.EnableRequest): Promise<Inspector.EnableResponse>;
        /** Fired when remote debugging connection is about to be terminated. Contains detach reason. */
        on(event: 'detached', handler: EventHandler<Inspector.DetachedEvent>): EventListener;
        /** Fired when debugging target has crashed */
        on(event: 'targetCrashed', handler: EventHandler<Inspector.TargetCrashedEvent>): EventListener;
        /** Fired when debugging target has reloaded after crash */
        on(event: 'targetReloadedAfterCrash', handler: EventHandler<Inspector.TargetReloadedAfterCrashEvent>): EventListener;
        /** Fired when remote debugging connection is about to be terminated. Contains detach reason. */
        once(event: 'detached', handler: EventHandler<Inspector.DetachedEvent>): EventListener;
        /** Fired when debugging target has crashed */
        once(event: 'targetCrashed', handler: EventHandler<Inspector.TargetCrashedEvent>): EventListener;
        /** Fired when debugging target has reloaded after crash */
        once(event: 'targetReloadedAfterCrash', handler: EventHandler<Inspector.TargetReloadedAfterCrashEvent>): EventListener;
    }
    class LayerTree {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Provides the reasons why the given layer was composited. */
        compositingReasons(request: LayerTree.CompositingReasonsRequest): Promise<LayerTree.CompositingReasonsResponse>;
        /** Disables compositing tree inspection. */
        disable(request: LayerTree.DisableRequest): Promise<LayerTree.DisableResponse>;
        /** Enables compositing tree inspection. */
        enable(request: LayerTree.EnableRequest): Promise<LayerTree.EnableResponse>;
        /** Returns the snapshot identifier. */
        loadSnapshot(request: LayerTree.LoadSnapshotRequest): Promise<LayerTree.LoadSnapshotResponse>;
        /** Returns the layer snapshot identifier. */
        makeSnapshot(request: LayerTree.MakeSnapshotRequest): Promise<LayerTree.MakeSnapshotResponse>;
        profileSnapshot(request: LayerTree.ProfileSnapshotRequest): Promise<LayerTree.ProfileSnapshotResponse>;
        /** Releases layer snapshot captured by the back-end. */
        releaseSnapshot(request: LayerTree.ReleaseSnapshotRequest): Promise<LayerTree.ReleaseSnapshotResponse>;
        /** Replays the layer snapshot and returns the resulting bitmap. */
        replaySnapshot(request: LayerTree.ReplaySnapshotRequest): Promise<LayerTree.ReplaySnapshotResponse>;
        /** Replays the layer snapshot and returns canvas log. */
        snapshotCommandLog(request: LayerTree.SnapshotCommandLogRequest): Promise<LayerTree.SnapshotCommandLogResponse>;
        on(event: 'layerPainted', handler: EventHandler<LayerTree.LayerPaintedEvent>): EventListener;
        on(event: 'layerTreeDidChange', handler: EventHandler<LayerTree.LayerTreeDidChangeEvent>): EventListener;
        once(event: 'layerPainted', handler: EventHandler<LayerTree.LayerPaintedEvent>): EventListener;
        once(event: 'layerTreeDidChange', handler: EventHandler<LayerTree.LayerTreeDidChangeEvent>): EventListener;
    }
    class Log {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Clears the log. */
        clear(request: Log.ClearRequest): Promise<Log.ClearResponse>;
        /** Disables log domain, prevents further log entries from being reported to the client. */
        disable(request: Log.DisableRequest): Promise<Log.DisableResponse>;
        /** Enables log domain, sends the entries collected so far to the client by means of the `entryAdded` notification. */
        enable(request: Log.EnableRequest): Promise<Log.EnableResponse>;
        /** start violation reporting. */
        startViolationsReport(request: Log.StartViolationsReportRequest): Promise<Log.StartViolationsReportResponse>;
        /** Stop violation reporting. */
        stopViolationsReport(request: Log.StopViolationsReportRequest): Promise<Log.StopViolationsReportResponse>;
        /** Issued when new message was logged. */
        on(event: 'entryAdded', handler: EventHandler<Log.EntryAddedEvent>): EventListener;
        /** Issued when new message was logged. */
        once(event: 'entryAdded', handler: EventHandler<Log.EntryAddedEvent>): EventListener;
    }
    class Memory {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        getDOMCounters(request: Memory.GetDOMCountersRequest): Promise<Memory.GetDOMCountersResponse>;
        prepareForLeakDetection(request: Memory.PrepareForLeakDetectionRequest): Promise<Memory.PrepareForLeakDetectionResponse>;
        /** Simulate OomIntervention by purging V8 memory. */
        forciblyPurgeJavaScriptMemory(request: Memory.ForciblyPurgeJavaScriptMemoryRequest): Promise<Memory.ForciblyPurgeJavaScriptMemoryResponse>;
        /** Enable/disable suppressing memory pressure notifications in all processes. */
        setPressureNotificationsSuppressed(request: Memory.SetPressureNotificationsSuppressedRequest): Promise<Memory.SetPressureNotificationsSuppressedResponse>;
        /** Simulate a memory pressure notification in all processes. */
        simulatePressureNotification(request: Memory.SimulatePressureNotificationRequest): Promise<Memory.SimulatePressureNotificationResponse>;
        /** Start collecting native memory profile. */
        startSampling(request: Memory.StartSamplingRequest): Promise<Memory.StartSamplingResponse>;
        /** Stop collecting native memory profile. */
        stopSampling(request: Memory.StopSamplingRequest): Promise<Memory.StopSamplingResponse>;
        /** Retrieve native memory allocations profile collected since renderer process startup. */
        getAllTimeSamplingProfile(request: Memory.GetAllTimeSamplingProfileRequest): Promise<Memory.GetAllTimeSamplingProfileResponse>;
        /** Retrieve native memory allocations profile collected since browser process startup. */
        getBrowserSamplingProfile(request: Memory.GetBrowserSamplingProfileRequest): Promise<Memory.GetBrowserSamplingProfileResponse>;
        /** Retrieve native memory allocations profile collected since last `startSampling` call. */
        getSamplingProfile(request: Memory.GetSamplingProfileRequest): Promise<Memory.GetSamplingProfileResponse>;
    }
    class Network {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Tells whether clearing browser cache is supported. */
        canClearBrowserCache(request: Network.CanClearBrowserCacheRequest): Promise<Network.CanClearBrowserCacheResponse>;
        /** Tells whether clearing browser cookies is supported. */
        canClearBrowserCookies(request: Network.CanClearBrowserCookiesRequest): Promise<Network.CanClearBrowserCookiesResponse>;
        /** Tells whether emulation of network conditions is supported. */
        canEmulateNetworkConditions(request: Network.CanEmulateNetworkConditionsRequest): Promise<Network.CanEmulateNetworkConditionsResponse>;
        /** Clears browser cache. */
        clearBrowserCache(request: Network.ClearBrowserCacheRequest): Promise<Network.ClearBrowserCacheResponse>;
        /** Clears browser cookies. */
        clearBrowserCookies(request: Network.ClearBrowserCookiesRequest): Promise<Network.ClearBrowserCookiesResponse>;
        /** Response to Network.requestIntercepted which either modifies the request to continue with any modifications, or blocks it, or completes it with the provided response bytes. If a network fetch occurs as a result which encounters a redirect an additional Network.requestIntercepted event will be sent with the same InterceptionId. Deprecated, use Fetch.continueRequest, Fetch.fulfillRequest and Fetch.failRequest instead. */
        continueInterceptedRequest(request: Network.ContinueInterceptedRequestRequest): Promise<Network.ContinueInterceptedRequestResponse>;
        /** Deletes browser cookies with matching name and url or domain/path pair. */
        deleteCookies(request: Network.DeleteCookiesRequest): Promise<Network.DeleteCookiesResponse>;
        /** Disables network tracking, prevents network events from being sent to the client. */
        disable(request: Network.DisableRequest): Promise<Network.DisableResponse>;
        /** Activates emulation of network conditions. */
        emulateNetworkConditions(request: Network.EmulateNetworkConditionsRequest): Promise<Network.EmulateNetworkConditionsResponse>;
        /** Enables network tracking, network events will now be delivered to the client. */
        enable(request: Network.EnableRequest): Promise<Network.EnableResponse>;
        /** Returns all browser cookies. Depending on the backend support, will return detailed cookie information in the `cookies` field. */
        getAllCookies(request: Network.GetAllCookiesRequest): Promise<Network.GetAllCookiesResponse>;
        /** Returns the DER-encoded certificate. */
        getCertificate(request: Network.GetCertificateRequest): Promise<Network.GetCertificateResponse>;
        /** Returns all browser cookies for the current URL. Depending on the backend support, will return detailed cookie information in the `cookies` field. */
        getCookies(request: Network.GetCookiesRequest): Promise<Network.GetCookiesResponse>;
        /** Returns content served for the given request. */
        getResponseBody(request: Network.GetResponseBodyRequest): Promise<Network.GetResponseBodyResponse>;
        /** Returns post data sent with the request. Returns an error when no data was sent with the request. */
        getRequestPostData(request: Network.GetRequestPostDataRequest): Promise<Network.GetRequestPostDataResponse>;
        /** Returns content served for the given currently intercepted request. */
        getResponseBodyForInterception(request: Network.GetResponseBodyForInterceptionRequest): Promise<Network.GetResponseBodyForInterceptionResponse>;
        /** Returns a handle to the stream representing the response body. Note that after this command, the intercepted request can't be continued as is -- you either need to cancel it or to provide the response body. The stream only supports sequential read, IO.read will fail if the position is specified. */
        takeResponseBodyForInterceptionAsStream(request: Network.TakeResponseBodyForInterceptionAsStreamRequest): Promise<Network.TakeResponseBodyForInterceptionAsStreamResponse>;
        /** This method sends a new XMLHttpRequest which is identical to the original one. The following parameters should be identical: method, url, async, request body, extra headers, withCredentials attribute, user, password. */
        replayXHR(request: Network.ReplayXHRRequest): Promise<Network.ReplayXHRResponse>;
        /** Searches for given string in response content. */
        searchInResponseBody(request: Network.SearchInResponseBodyRequest): Promise<Network.SearchInResponseBodyResponse>;
        /** Blocks URLs from loading. */
        setBlockedURLs(request: Network.SetBlockedURLsRequest): Promise<Network.SetBlockedURLsResponse>;
        /** Toggles ignoring of service worker for each request. */
        setBypassServiceWorker(request: Network.SetBypassServiceWorkerRequest): Promise<Network.SetBypassServiceWorkerResponse>;
        /** Toggles ignoring cache for each request. If `true`, cache will not be used. */
        setCacheDisabled(request: Network.SetCacheDisabledRequest): Promise<Network.SetCacheDisabledResponse>;
        /** Sets a cookie with the given cookie data; may overwrite equivalent cookies if they exist. */
        setCookie(request: Network.SetCookieRequest): Promise<Network.SetCookieResponse>;
        /** Sets given cookies. */
        setCookies(request: Network.SetCookiesRequest): Promise<Network.SetCookiesResponse>;
        /** For testing. */
        setDataSizeLimitsForTest(request: Network.SetDataSizeLimitsForTestRequest): Promise<Network.SetDataSizeLimitsForTestResponse>;
        /** Specifies whether to always send extra HTTP headers with the requests from this page. */
        setExtraHTTPHeaders(request: Network.SetExtraHTTPHeadersRequest): Promise<Network.SetExtraHTTPHeadersResponse>;
        /** Sets the requests to intercept that match the provided patterns and optionally resource types. Deprecated, please use Fetch.enable instead. */
        setRequestInterception(request: Network.SetRequestInterceptionRequest): Promise<Network.SetRequestInterceptionResponse>;
        /** Allows overriding user agent with the given string. */
        setUserAgentOverride(request: Network.SetUserAgentOverrideRequest): Promise<Network.SetUserAgentOverrideResponse>;
        /** Fired when data chunk was received over the network. */
        on(event: 'dataReceived', handler: EventHandler<Network.DataReceivedEvent>): EventListener;
        /** Fired when EventSource message is received. */
        on(event: 'eventSourceMessageReceived', handler: EventHandler<Network.EventSourceMessageReceivedEvent>): EventListener;
        /** Fired when HTTP request has failed to load. */
        on(event: 'loadingFailed', handler: EventHandler<Network.LoadingFailedEvent>): EventListener;
        /** Fired when HTTP request has finished loading. */
        on(event: 'loadingFinished', handler: EventHandler<Network.LoadingFinishedEvent>): EventListener;
        /** Details of an intercepted HTTP request, which must be either allowed, blocked, modified or mocked. Deprecated, use Fetch.requestPaused instead. */
        on(event: 'requestIntercepted', handler: EventHandler<Network.RequestInterceptedEvent>): EventListener;
        /** Fired if request ended up loading from cache. */
        on(event: 'requestServedFromCache', handler: EventHandler<Network.RequestServedFromCacheEvent>): EventListener;
        /** Fired when page is about to send HTTP request. */
        on(event: 'requestWillBeSent', handler: EventHandler<Network.RequestWillBeSentEvent>): EventListener;
        /** Fired when resource loading priority is changed */
        on(event: 'resourceChangedPriority', handler: EventHandler<Network.ResourceChangedPriorityEvent>): EventListener;
        /** Fired when a signed exchange was received over the network */
        on(event: 'signedExchangeReceived', handler: EventHandler<Network.SignedExchangeReceivedEvent>): EventListener;
        /** Fired when HTTP response is available. */
        on(event: 'responseReceived', handler: EventHandler<Network.ResponseReceivedEvent>): EventListener;
        /** Fired when WebSocket is closed. */
        on(event: 'webSocketClosed', handler: EventHandler<Network.WebSocketClosedEvent>): EventListener;
        /** Fired upon WebSocket creation. */
        on(event: 'webSocketCreated', handler: EventHandler<Network.WebSocketCreatedEvent>): EventListener;
        /** Fired when WebSocket message error occurs. */
        on(event: 'webSocketFrameError', handler: EventHandler<Network.WebSocketFrameErrorEvent>): EventListener;
        /** Fired when WebSocket message is received. */
        on(event: 'webSocketFrameReceived', handler: EventHandler<Network.WebSocketFrameReceivedEvent>): EventListener;
        /** Fired when WebSocket message is sent. */
        on(event: 'webSocketFrameSent', handler: EventHandler<Network.WebSocketFrameSentEvent>): EventListener;
        /** Fired when WebSocket handshake response becomes available. */
        on(event: 'webSocketHandshakeResponseReceived', handler: EventHandler<Network.WebSocketHandshakeResponseReceivedEvent>): EventListener;
        /** Fired when WebSocket is about to initiate handshake. */
        on(event: 'webSocketWillSendHandshakeRequest', handler: EventHandler<Network.WebSocketWillSendHandshakeRequestEvent>): EventListener;
        /** Fired when data chunk was received over the network. */
        once(event: 'dataReceived', handler: EventHandler<Network.DataReceivedEvent>): EventListener;
        /** Fired when EventSource message is received. */
        once(event: 'eventSourceMessageReceived', handler: EventHandler<Network.EventSourceMessageReceivedEvent>): EventListener;
        /** Fired when HTTP request has failed to load. */
        once(event: 'loadingFailed', handler: EventHandler<Network.LoadingFailedEvent>): EventListener;
        /** Fired when HTTP request has finished loading. */
        once(event: 'loadingFinished', handler: EventHandler<Network.LoadingFinishedEvent>): EventListener;
        /** Details of an intercepted HTTP request, which must be either allowed, blocked, modified or mocked. Deprecated, use Fetch.requestPaused instead. */
        once(event: 'requestIntercepted', handler: EventHandler<Network.RequestInterceptedEvent>): EventListener;
        /** Fired if request ended up loading from cache. */
        once(event: 'requestServedFromCache', handler: EventHandler<Network.RequestServedFromCacheEvent>): EventListener;
        /** Fired when page is about to send HTTP request. */
        once(event: 'requestWillBeSent', handler: EventHandler<Network.RequestWillBeSentEvent>): EventListener;
        /** Fired when resource loading priority is changed */
        once(event: 'resourceChangedPriority', handler: EventHandler<Network.ResourceChangedPriorityEvent>): EventListener;
        /** Fired when a signed exchange was received over the network */
        once(event: 'signedExchangeReceived', handler: EventHandler<Network.SignedExchangeReceivedEvent>): EventListener;
        /** Fired when HTTP response is available. */
        once(event: 'responseReceived', handler: EventHandler<Network.ResponseReceivedEvent>): EventListener;
        /** Fired when WebSocket is closed. */
        once(event: 'webSocketClosed', handler: EventHandler<Network.WebSocketClosedEvent>): EventListener;
        /** Fired upon WebSocket creation. */
        once(event: 'webSocketCreated', handler: EventHandler<Network.WebSocketCreatedEvent>): EventListener;
        /** Fired when WebSocket message error occurs. */
        once(event: 'webSocketFrameError', handler: EventHandler<Network.WebSocketFrameErrorEvent>): EventListener;
        /** Fired when WebSocket message is received. */
        once(event: 'webSocketFrameReceived', handler: EventHandler<Network.WebSocketFrameReceivedEvent>): EventListener;
        /** Fired when WebSocket message is sent. */
        once(event: 'webSocketFrameSent', handler: EventHandler<Network.WebSocketFrameSentEvent>): EventListener;
        /** Fired when WebSocket handshake response becomes available. */
        once(event: 'webSocketHandshakeResponseReceived', handler: EventHandler<Network.WebSocketHandshakeResponseReceivedEvent>): EventListener;
        /** Fired when WebSocket is about to initiate handshake. */
        once(event: 'webSocketWillSendHandshakeRequest', handler: EventHandler<Network.WebSocketWillSendHandshakeRequestEvent>): EventListener;
    }
    class Overlay {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Disables domain notifications. */
        disable(request: Overlay.DisableRequest): Promise<Overlay.DisableResponse>;
        /** Enables domain notifications. */
        enable(request: Overlay.EnableRequest): Promise<Overlay.EnableResponse>;
        /** For testing. */
        getHighlightObjectForTest(request: Overlay.GetHighlightObjectForTestRequest): Promise<Overlay.GetHighlightObjectForTestResponse>;
        /** Hides any highlight. */
        hideHighlight(request: Overlay.HideHighlightRequest): Promise<Overlay.HideHighlightResponse>;
        /** Highlights owner element of the frame with given id. */
        highlightFrame(request: Overlay.HighlightFrameRequest): Promise<Overlay.HighlightFrameResponse>;
        /** Highlights DOM node with given id or with the given JavaScript object wrapper. Either nodeId or objectId must be specified. */
        highlightNode(request: Overlay.HighlightNodeRequest): Promise<Overlay.HighlightNodeResponse>;
        /** Highlights given quad. Coordinates are absolute with respect to the main frame viewport. */
        highlightQuad(request: Overlay.HighlightQuadRequest): Promise<Overlay.HighlightQuadResponse>;
        /** Highlights given rectangle. Coordinates are absolute with respect to the main frame viewport. */
        highlightRect(request: Overlay.HighlightRectRequest): Promise<Overlay.HighlightRectResponse>;
        /** Enters the 'inspect' mode. In this mode, elements that user is hovering over are highlighted. Backend then generates 'inspectNodeRequested' event upon element selection. */
        setInspectMode(request: Overlay.SetInspectModeRequest): Promise<Overlay.SetInspectModeResponse>;
        /** Highlights owner element of all frames detected to be ads. */
        setShowAdHighlights(request: Overlay.SetShowAdHighlightsRequest): Promise<Overlay.SetShowAdHighlightsResponse>;
        setPausedInDebuggerMessage(request: Overlay.SetPausedInDebuggerMessageRequest): Promise<Overlay.SetPausedInDebuggerMessageResponse>;
        /** Requests that backend shows debug borders on layers */
        setShowDebugBorders(request: Overlay.SetShowDebugBordersRequest): Promise<Overlay.SetShowDebugBordersResponse>;
        /** Requests that backend shows the FPS counter */
        setShowFPSCounter(request: Overlay.SetShowFPSCounterRequest): Promise<Overlay.SetShowFPSCounterResponse>;
        /** Requests that backend shows paint rectangles */
        setShowPaintRects(request: Overlay.SetShowPaintRectsRequest): Promise<Overlay.SetShowPaintRectsResponse>;
        /** Requests that backend shows layout shift regions */
        setShowLayoutShiftRegions(request: Overlay.SetShowLayoutShiftRegionsRequest): Promise<Overlay.SetShowLayoutShiftRegionsResponse>;
        /** Requests that backend shows scroll bottleneck rects */
        setShowScrollBottleneckRects(request: Overlay.SetShowScrollBottleneckRectsRequest): Promise<Overlay.SetShowScrollBottleneckRectsResponse>;
        /** Requests that backend shows hit-test borders on layers */
        setShowHitTestBorders(request: Overlay.SetShowHitTestBordersRequest): Promise<Overlay.SetShowHitTestBordersResponse>;
        /** Paints viewport size upon main frame resize. */
        setShowViewportSizeOnResize(request: Overlay.SetShowViewportSizeOnResizeRequest): Promise<Overlay.SetShowViewportSizeOnResizeResponse>;
        /** Fired when the node should be inspected. This happens after call to `setInspectMode` or when user manually inspects an element. */
        on(event: 'inspectNodeRequested', handler: EventHandler<Overlay.InspectNodeRequestedEvent>): EventListener;
        /** Fired when the node should be highlighted. This happens after call to `setInspectMode`. */
        on(event: 'nodeHighlightRequested', handler: EventHandler<Overlay.NodeHighlightRequestedEvent>): EventListener;
        /** Fired when user asks to capture screenshot of some area on the page. */
        on(event: 'screenshotRequested', handler: EventHandler<Overlay.ScreenshotRequestedEvent>): EventListener;
        /** Fired when user cancels the inspect mode. */
        on(event: 'inspectModeCanceled', handler: EventHandler<Overlay.InspectModeCanceledEvent>): EventListener;
        /** Fired when the node should be inspected. This happens after call to `setInspectMode` or when user manually inspects an element. */
        once(event: 'inspectNodeRequested', handler: EventHandler<Overlay.InspectNodeRequestedEvent>): EventListener;
        /** Fired when the node should be highlighted. This happens after call to `setInspectMode`. */
        once(event: 'nodeHighlightRequested', handler: EventHandler<Overlay.NodeHighlightRequestedEvent>): EventListener;
        /** Fired when user asks to capture screenshot of some area on the page. */
        once(event: 'screenshotRequested', handler: EventHandler<Overlay.ScreenshotRequestedEvent>): EventListener;
        /** Fired when user cancels the inspect mode. */
        once(event: 'inspectModeCanceled', handler: EventHandler<Overlay.InspectModeCanceledEvent>): EventListener;
    }
    class Page {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Deprecated, please use addScriptToEvaluateOnNewDocument instead. */
        addScriptToEvaluateOnLoad(request: Page.AddScriptToEvaluateOnLoadRequest): Promise<Page.AddScriptToEvaluateOnLoadResponse>;
        /** Evaluates given script in every frame upon creation (before loading frame's scripts). */
        addScriptToEvaluateOnNewDocument(request: Page.AddScriptToEvaluateOnNewDocumentRequest): Promise<Page.AddScriptToEvaluateOnNewDocumentResponse>;
        /** Brings page to front (activates tab). */
        bringToFront(request: Page.BringToFrontRequest): Promise<Page.BringToFrontResponse>;
        /** Capture page screenshot. */
        captureScreenshot(request: Page.CaptureScreenshotRequest): Promise<Page.CaptureScreenshotResponse>;
        /** Returns a snapshot of the page as a string. For MHTML format, the serialization includes iframes, shadow DOM, external resources, and element-inline styles. */
        captureSnapshot(request: Page.CaptureSnapshotRequest): Promise<Page.CaptureSnapshotResponse>;
        /** Clears the overriden device metrics. */
        clearDeviceMetricsOverride(request: Page.ClearDeviceMetricsOverrideRequest): Promise<Page.ClearDeviceMetricsOverrideResponse>;
        /** Clears the overridden Device Orientation. */
        clearDeviceOrientationOverride(request: Page.ClearDeviceOrientationOverrideRequest): Promise<Page.ClearDeviceOrientationOverrideResponse>;
        /** Clears the overriden Geolocation Position and Error. */
        clearGeolocationOverride(request: Page.ClearGeolocationOverrideRequest): Promise<Page.ClearGeolocationOverrideResponse>;
        /** Creates an isolated world for the given frame. */
        createIsolatedWorld(request: Page.CreateIsolatedWorldRequest): Promise<Page.CreateIsolatedWorldResponse>;
        /** Deletes browser cookie with given name, domain and path. */
        deleteCookie(request: Page.DeleteCookieRequest): Promise<Page.DeleteCookieResponse>;
        /** Disables page domain notifications. */
        disable(request: Page.DisableRequest): Promise<Page.DisableResponse>;
        /** Enables page domain notifications. */
        enable(request: Page.EnableRequest): Promise<Page.EnableResponse>;
        getAppManifest(request: Page.GetAppManifestRequest): Promise<Page.GetAppManifestResponse>;
        getInstallabilityErrors(request: Page.GetInstallabilityErrorsRequest): Promise<Page.GetInstallabilityErrorsResponse>;
        /** Returns all browser cookies. Depending on the backend support, will return detailed cookie information in the `cookies` field. */
        getCookies(request: Page.GetCookiesRequest): Promise<Page.GetCookiesResponse>;
        /** Returns present frame tree structure. */
        getFrameTree(request: Page.GetFrameTreeRequest): Promise<Page.GetFrameTreeResponse>;
        /** Returns metrics relating to the layouting of the page, such as viewport bounds/scale. */
        getLayoutMetrics(request: Page.GetLayoutMetricsRequest): Promise<Page.GetLayoutMetricsResponse>;
        /** Returns navigation history for the current page. */
        getNavigationHistory(request: Page.GetNavigationHistoryRequest): Promise<Page.GetNavigationHistoryResponse>;
        /** Resets navigation history for the current page. */
        resetNavigationHistory(request: Page.ResetNavigationHistoryRequest): Promise<Page.ResetNavigationHistoryResponse>;
        /** Returns content of the given resource. */
        getResourceContent(request: Page.GetResourceContentRequest): Promise<Page.GetResourceContentResponse>;
        /** Returns present frame / resource tree structure. */
        getResourceTree(request: Page.GetResourceTreeRequest): Promise<Page.GetResourceTreeResponse>;
        /** Accepts or dismisses a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload). */
        handleJavaScriptDialog(request: Page.HandleJavaScriptDialogRequest): Promise<Page.HandleJavaScriptDialogResponse>;
        /** Navigates current page to the given URL. */
        navigate(request: Page.NavigateRequest): Promise<Page.NavigateResponse>;
        /** Navigates current page to the given history entry. */
        navigateToHistoryEntry(request: Page.NavigateToHistoryEntryRequest): Promise<Page.NavigateToHistoryEntryResponse>;
        /** Print page as PDF. */
        printToPDF(request: Page.PrintToPDFRequest): Promise<Page.PrintToPDFResponse>;
        /** Reloads given page optionally ignoring the cache. */
        reload(request: Page.ReloadRequest): Promise<Page.ReloadResponse>;
        /** Deprecated, please use removeScriptToEvaluateOnNewDocument instead. */
        removeScriptToEvaluateOnLoad(request: Page.RemoveScriptToEvaluateOnLoadRequest): Promise<Page.RemoveScriptToEvaluateOnLoadResponse>;
        /** Removes given script from the list. */
        removeScriptToEvaluateOnNewDocument(request: Page.RemoveScriptToEvaluateOnNewDocumentRequest): Promise<Page.RemoveScriptToEvaluateOnNewDocumentResponse>;
        /** Acknowledges that a screencast frame has been received by the frontend. */
        screencastFrameAck(request: Page.ScreencastFrameAckRequest): Promise<Page.ScreencastFrameAckResponse>;
        /** Searches for given string in resource content. */
        searchInResource(request: Page.SearchInResourceRequest): Promise<Page.SearchInResourceResponse>;
        /** Enable Chrome's experimental ad filter on all sites. */
        setAdBlockingEnabled(request: Page.SetAdBlockingEnabledRequest): Promise<Page.SetAdBlockingEnabledResponse>;
        /** Enable page Content Security Policy by-passing. */
        setBypassCSP(request: Page.SetBypassCSPRequest): Promise<Page.SetBypassCSPResponse>;
        /** Overrides the values of device screen dimensions (window.screen.width, window.screen.height, window.innerWidth, window.innerHeight, and "device-width"/"device-height"-related CSS media query results). */
        setDeviceMetricsOverride(request: Page.SetDeviceMetricsOverrideRequest): Promise<Page.SetDeviceMetricsOverrideResponse>;
        /** Overrides the Device Orientation. */
        setDeviceOrientationOverride(request: Page.SetDeviceOrientationOverrideRequest): Promise<Page.SetDeviceOrientationOverrideResponse>;
        /** Set generic font families. */
        setFontFamilies(request: Page.SetFontFamiliesRequest): Promise<Page.SetFontFamiliesResponse>;
        /** Set default font sizes. */
        setFontSizes(request: Page.SetFontSizesRequest): Promise<Page.SetFontSizesResponse>;
        /** Sets given markup as the document's HTML. */
        setDocumentContent(request: Page.SetDocumentContentRequest): Promise<Page.SetDocumentContentResponse>;
        /** Set the behavior when downloading a file. */
        setDownloadBehavior(request: Page.SetDownloadBehaviorRequest): Promise<Page.SetDownloadBehaviorResponse>;
        /** Overrides the Geolocation Position or Error. Omitting any of the parameters emulates position unavailable. */
        setGeolocationOverride(request: Page.SetGeolocationOverrideRequest): Promise<Page.SetGeolocationOverrideResponse>;
        /** Controls whether page will emit lifecycle events. */
        setLifecycleEventsEnabled(request: Page.SetLifecycleEventsEnabledRequest): Promise<Page.SetLifecycleEventsEnabledResponse>;
        /** Toggles mouse event-based touch event emulation. */
        setTouchEmulationEnabled(request: Page.SetTouchEmulationEnabledRequest): Promise<Page.SetTouchEmulationEnabledResponse>;
        /** Starts sending each frame using the `screencastFrame` event. */
        startScreencast(request: Page.StartScreencastRequest): Promise<Page.StartScreencastResponse>;
        /** Force the page stop all navigations and pending resource fetches. */
        stopLoading(request: Page.StopLoadingRequest): Promise<Page.StopLoadingResponse>;
        /** Crashes renderer on the IO thread, generates minidumps. */
        crash(request: Page.CrashRequest): Promise<Page.CrashResponse>;
        /** Tries to close page, running its beforeunload hooks, if any. */
        close(request: Page.CloseRequest): Promise<Page.CloseResponse>;
        /** Tries to update the web lifecycle state of the page. It will transition the page to the given state according to: https://github.com/WICG/web-lifecycle/ */
        setWebLifecycleState(request: Page.SetWebLifecycleStateRequest): Promise<Page.SetWebLifecycleStateResponse>;
        /** Stops sending each frame in the `screencastFrame`. */
        stopScreencast(request: Page.StopScreencastRequest): Promise<Page.StopScreencastResponse>;
        /** Forces compilation cache to be generated for every subresource script. */
        setProduceCompilationCache(request: Page.SetProduceCompilationCacheRequest): Promise<Page.SetProduceCompilationCacheResponse>;
        /** Seeds compilation cache for given url. Compilation cache does not survive cross-process navigation. */
        addCompilationCache(request: Page.AddCompilationCacheRequest): Promise<Page.AddCompilationCacheResponse>;
        /** Clears seeded compilation cache. */
        clearCompilationCache(request: Page.ClearCompilationCacheRequest): Promise<Page.ClearCompilationCacheResponse>;
        /** Generates a report for testing. */
        generateTestReport(request: Page.GenerateTestReportRequest): Promise<Page.GenerateTestReportResponse>;
        /** Pauses page execution. Can be resumed using generic Runtime.runIfWaitingForDebugger. */
        waitForDebugger(request: Page.WaitForDebuggerRequest): Promise<Page.WaitForDebuggerResponse>;
        /** Intercept file chooser requests and transfer control to protocol clients. When file chooser interception is enabled, native file chooser dialog is not shown. Instead, a protocol event `Page.fileChooserOpened` is emitted. File chooser can be handled with `page.handleFileChooser` command. */
        setInterceptFileChooserDialog(request: Page.SetInterceptFileChooserDialogRequest): Promise<Page.SetInterceptFileChooserDialogResponse>;
        /** Accepts or cancels an intercepted file chooser dialog. */
        handleFileChooser(request: Page.HandleFileChooserRequest): Promise<Page.HandleFileChooserResponse>;
        on(event: 'domContentEventFired', handler: EventHandler<Page.DomContentEventFiredEvent>): EventListener;
        /** Emitted only when `page.interceptFileChooser` is enabled. */
        on(event: 'fileChooserOpened', handler: EventHandler<Page.FileChooserOpenedEvent>): EventListener;
        /** Fired when frame has been attached to its parent. */
        on(event: 'frameAttached', handler: EventHandler<Page.FrameAttachedEvent>): EventListener;
        /** Fired when frame no longer has a scheduled navigation. */
        on(event: 'frameClearedScheduledNavigation', handler: EventHandler<Page.FrameClearedScheduledNavigationEvent>): EventListener;
        /** Fired when frame has been detached from its parent. */
        on(event: 'frameDetached', handler: EventHandler<Page.FrameDetachedEvent>): EventListener;
        /** Fired once navigation of the frame has completed. Frame is now associated with the new loader. */
        on(event: 'frameNavigated', handler: EventHandler<Page.FrameNavigatedEvent>): EventListener;
        on(event: 'frameResized', handler: EventHandler<Page.FrameResizedEvent>): EventListener;
        /** Fired when a renderer-initiated navigation is requested. Navigation may still be cancelled after the event is issued. */
        on(event: 'frameRequestedNavigation', handler: EventHandler<Page.FrameRequestedNavigationEvent>): EventListener;
        /** Fired when frame schedules a potential navigation. */
        on(event: 'frameScheduledNavigation', handler: EventHandler<Page.FrameScheduledNavigationEvent>): EventListener;
        /** Fired when frame has started loading. */
        on(event: 'frameStartedLoading', handler: EventHandler<Page.FrameStartedLoadingEvent>): EventListener;
        /** Fired when frame has stopped loading. */
        on(event: 'frameStoppedLoading', handler: EventHandler<Page.FrameStoppedLoadingEvent>): EventListener;
        /** Fired when page is about to start a download. */
        on(event: 'downloadWillBegin', handler: EventHandler<Page.DownloadWillBeginEvent>): EventListener;
        /** Fired when interstitial page was hidden */
        on(event: 'interstitialHidden', handler: EventHandler<Page.InterstitialHiddenEvent>): EventListener;
        /** Fired when interstitial page was shown */
        on(event: 'interstitialShown', handler: EventHandler<Page.InterstitialShownEvent>): EventListener;
        /** Fired when a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload) has been closed. */
        on(event: 'javascriptDialogClosed', handler: EventHandler<Page.JavascriptDialogClosedEvent>): EventListener;
        /** Fired when a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload) is about to open. */
        on(event: 'javascriptDialogOpening', handler: EventHandler<Page.JavascriptDialogOpeningEvent>): EventListener;
        /** Fired for top level page lifecycle events such as navigation, load, paint, etc. */
        on(event: 'lifecycleEvent', handler: EventHandler<Page.LifecycleEventEvent>): EventListener;
        on(event: 'loadEventFired', handler: EventHandler<Page.LoadEventFiredEvent>): EventListener;
        /** Fired when same-document navigation happens, e.g. due to history API usage or anchor navigation. */
        on(event: 'navigatedWithinDocument', handler: EventHandler<Page.NavigatedWithinDocumentEvent>): EventListener;
        /** Compressed image data requested by the `startScreencast`. */
        on(event: 'screencastFrame', handler: EventHandler<Page.ScreencastFrameEvent>): EventListener;
        /** Fired when the page with currently enabled screencast was shown or hidden `. */
        on(event: 'screencastVisibilityChanged', handler: EventHandler<Page.ScreencastVisibilityChangedEvent>): EventListener;
        /** Fired when a new window is going to be opened, via window.open(), link click, form submission, etc. */
        on(event: 'windowOpen', handler: EventHandler<Page.WindowOpenEvent>): EventListener;
        /** Issued for every compilation cache generated. Is only available if Page.setGenerateCompilationCache is enabled. */
        on(event: 'compilationCacheProduced', handler: EventHandler<Page.CompilationCacheProducedEvent>): EventListener;
        once(event: 'domContentEventFired', handler: EventHandler<Page.DomContentEventFiredEvent>): EventListener;
        /** Emitted only when `page.interceptFileChooser` is enabled. */
        once(event: 'fileChooserOpened', handler: EventHandler<Page.FileChooserOpenedEvent>): EventListener;
        /** Fired when frame has been attached to its parent. */
        once(event: 'frameAttached', handler: EventHandler<Page.FrameAttachedEvent>): EventListener;
        /** Fired when frame no longer has a scheduled navigation. */
        once(event: 'frameClearedScheduledNavigation', handler: EventHandler<Page.FrameClearedScheduledNavigationEvent>): EventListener;
        /** Fired when frame has been detached from its parent. */
        once(event: 'frameDetached', handler: EventHandler<Page.FrameDetachedEvent>): EventListener;
        /** Fired once navigation of the frame has completed. Frame is now associated with the new loader. */
        once(event: 'frameNavigated', handler: EventHandler<Page.FrameNavigatedEvent>): EventListener;
        once(event: 'frameResized', handler: EventHandler<Page.FrameResizedEvent>): EventListener;
        /** Fired when a renderer-initiated navigation is requested. Navigation may still be cancelled after the event is issued. */
        once(event: 'frameRequestedNavigation', handler: EventHandler<Page.FrameRequestedNavigationEvent>): EventListener;
        /** Fired when frame schedules a potential navigation. */
        once(event: 'frameScheduledNavigation', handler: EventHandler<Page.FrameScheduledNavigationEvent>): EventListener;
        /** Fired when frame has started loading. */
        once(event: 'frameStartedLoading', handler: EventHandler<Page.FrameStartedLoadingEvent>): EventListener;
        /** Fired when frame has stopped loading. */
        once(event: 'frameStoppedLoading', handler: EventHandler<Page.FrameStoppedLoadingEvent>): EventListener;
        /** Fired when page is about to start a download. */
        once(event: 'downloadWillBegin', handler: EventHandler<Page.DownloadWillBeginEvent>): EventListener;
        /** Fired when interstitial page was hidden */
        once(event: 'interstitialHidden', handler: EventHandler<Page.InterstitialHiddenEvent>): EventListener;
        /** Fired when interstitial page was shown */
        once(event: 'interstitialShown', handler: EventHandler<Page.InterstitialShownEvent>): EventListener;
        /** Fired when a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload) has been closed. */
        once(event: 'javascriptDialogClosed', handler: EventHandler<Page.JavascriptDialogClosedEvent>): EventListener;
        /** Fired when a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload) is about to open. */
        once(event: 'javascriptDialogOpening', handler: EventHandler<Page.JavascriptDialogOpeningEvent>): EventListener;
        /** Fired for top level page lifecycle events such as navigation, load, paint, etc. */
        once(event: 'lifecycleEvent', handler: EventHandler<Page.LifecycleEventEvent>): EventListener;
        once(event: 'loadEventFired', handler: EventHandler<Page.LoadEventFiredEvent>): EventListener;
        /** Fired when same-document navigation happens, e.g. due to history API usage or anchor navigation. */
        once(event: 'navigatedWithinDocument', handler: EventHandler<Page.NavigatedWithinDocumentEvent>): EventListener;
        /** Compressed image data requested by the `startScreencast`. */
        once(event: 'screencastFrame', handler: EventHandler<Page.ScreencastFrameEvent>): EventListener;
        /** Fired when the page with currently enabled screencast was shown or hidden `. */
        once(event: 'screencastVisibilityChanged', handler: EventHandler<Page.ScreencastVisibilityChangedEvent>): EventListener;
        /** Fired when a new window is going to be opened, via window.open(), link click, form submission, etc. */
        once(event: 'windowOpen', handler: EventHandler<Page.WindowOpenEvent>): EventListener;
        /** Issued for every compilation cache generated. Is only available if Page.setGenerateCompilationCache is enabled. */
        once(event: 'compilationCacheProduced', handler: EventHandler<Page.CompilationCacheProducedEvent>): EventListener;
    }
    class Performance {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Disable collecting and reporting metrics. */
        disable(request: Performance.DisableRequest): Promise<Performance.DisableResponse>;
        /** Enable collecting and reporting metrics. */
        enable(request: Performance.EnableRequest): Promise<Performance.EnableResponse>;
        /** Sets time domain to use for collecting and reporting duration metrics. Note that this must be called before enabling metrics collection. Calling this method while metrics collection is enabled returns an error. */
        setTimeDomain(request: Performance.SetTimeDomainRequest): Promise<Performance.SetTimeDomainResponse>;
        /** Retrieve current values of run-time metrics. */
        getMetrics(request: Performance.GetMetricsRequest): Promise<Performance.GetMetricsResponse>;
        /** Current values of the metrics. */
        on(event: 'metrics', handler: EventHandler<Performance.MetricsEvent>): EventListener;
        /** Current values of the metrics. */
        once(event: 'metrics', handler: EventHandler<Performance.MetricsEvent>): EventListener;
    }
    class Security {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Disables tracking security state changes. */
        disable(request: Security.DisableRequest): Promise<Security.DisableResponse>;
        /** Enables tracking security state changes. */
        enable(request: Security.EnableRequest): Promise<Security.EnableResponse>;
        /** Enable/disable whether all certificate errors should be ignored. */
        setIgnoreCertificateErrors(request: Security.SetIgnoreCertificateErrorsRequest): Promise<Security.SetIgnoreCertificateErrorsResponse>;
        /** Handles a certificate error that fired a certificateError event. */
        handleCertificateError(request: Security.HandleCertificateErrorRequest): Promise<Security.HandleCertificateErrorResponse>;
        /** Enable/disable overriding certificate errors. If enabled, all certificate error events need to be handled by the DevTools client and should be answered with `handleCertificateError` commands. */
        setOverrideCertificateErrors(request: Security.SetOverrideCertificateErrorsRequest): Promise<Security.SetOverrideCertificateErrorsResponse>;
        /** There is a certificate error. If overriding certificate errors is enabled, then it should be handled with the `handleCertificateError` command. Note: this event does not fire if the certificate error has been allowed internally. Only one client per target should override certificate errors at the same time. */
        on(event: 'certificateError', handler: EventHandler<Security.CertificateErrorEvent>): EventListener;
        /** The security state of the page changed. */
        on(event: 'securityStateChanged', handler: EventHandler<Security.SecurityStateChangedEvent>): EventListener;
        /** There is a certificate error. If overriding certificate errors is enabled, then it should be handled with the `handleCertificateError` command. Note: this event does not fire if the certificate error has been allowed internally. Only one client per target should override certificate errors at the same time. */
        once(event: 'certificateError', handler: EventHandler<Security.CertificateErrorEvent>): EventListener;
        /** The security state of the page changed. */
        once(event: 'securityStateChanged', handler: EventHandler<Security.SecurityStateChangedEvent>): EventListener;
    }
    class ServiceWorker {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        deliverPushMessage(request: ServiceWorker.DeliverPushMessageRequest): Promise<ServiceWorker.DeliverPushMessageResponse>;
        disable(request: ServiceWorker.DisableRequest): Promise<ServiceWorker.DisableResponse>;
        dispatchSyncEvent(request: ServiceWorker.DispatchSyncEventRequest): Promise<ServiceWorker.DispatchSyncEventResponse>;
        enable(request: ServiceWorker.EnableRequest): Promise<ServiceWorker.EnableResponse>;
        inspectWorker(request: ServiceWorker.InspectWorkerRequest): Promise<ServiceWorker.InspectWorkerResponse>;
        setForceUpdateOnPageLoad(request: ServiceWorker.SetForceUpdateOnPageLoadRequest): Promise<ServiceWorker.SetForceUpdateOnPageLoadResponse>;
        skipWaiting(request: ServiceWorker.SkipWaitingRequest): Promise<ServiceWorker.SkipWaitingResponse>;
        startWorker(request: ServiceWorker.StartWorkerRequest): Promise<ServiceWorker.StartWorkerResponse>;
        stopAllWorkers(request: ServiceWorker.StopAllWorkersRequest): Promise<ServiceWorker.StopAllWorkersResponse>;
        stopWorker(request: ServiceWorker.StopWorkerRequest): Promise<ServiceWorker.StopWorkerResponse>;
        unregister(request: ServiceWorker.UnregisterRequest): Promise<ServiceWorker.UnregisterResponse>;
        updateRegistration(request: ServiceWorker.UpdateRegistrationRequest): Promise<ServiceWorker.UpdateRegistrationResponse>;
        on(event: 'workerErrorReported', handler: EventHandler<ServiceWorker.WorkerErrorReportedEvent>): EventListener;
        on(event: 'workerRegistrationUpdated', handler: EventHandler<ServiceWorker.WorkerRegistrationUpdatedEvent>): EventListener;
        on(event: 'workerVersionUpdated', handler: EventHandler<ServiceWorker.WorkerVersionUpdatedEvent>): EventListener;
        once(event: 'workerErrorReported', handler: EventHandler<ServiceWorker.WorkerErrorReportedEvent>): EventListener;
        once(event: 'workerRegistrationUpdated', handler: EventHandler<ServiceWorker.WorkerRegistrationUpdatedEvent>): EventListener;
        once(event: 'workerVersionUpdated', handler: EventHandler<ServiceWorker.WorkerVersionUpdatedEvent>): EventListener;
    }
    class Storage {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Clears storage for origin. */
        clearDataForOrigin(request: Storage.ClearDataForOriginRequest): Promise<Storage.ClearDataForOriginResponse>;
        /** Returns usage and quota in bytes. */
        getUsageAndQuota(request: Storage.GetUsageAndQuotaRequest): Promise<Storage.GetUsageAndQuotaResponse>;
        /** Registers origin to be notified when an update occurs to its cache storage list. */
        trackCacheStorageForOrigin(request: Storage.TrackCacheStorageForOriginRequest): Promise<Storage.TrackCacheStorageForOriginResponse>;
        /** Registers origin to be notified when an update occurs to its IndexedDB. */
        trackIndexedDBForOrigin(request: Storage.TrackIndexedDBForOriginRequest): Promise<Storage.TrackIndexedDBForOriginResponse>;
        /** Unregisters origin from receiving notifications for cache storage. */
        untrackCacheStorageForOrigin(request: Storage.UntrackCacheStorageForOriginRequest): Promise<Storage.UntrackCacheStorageForOriginResponse>;
        /** Unregisters origin from receiving notifications for IndexedDB. */
        untrackIndexedDBForOrigin(request: Storage.UntrackIndexedDBForOriginRequest): Promise<Storage.UntrackIndexedDBForOriginResponse>;
        /** A cache's contents have been modified. */
        on(event: 'cacheStorageContentUpdated', handler: EventHandler<Storage.CacheStorageContentUpdatedEvent>): EventListener;
        /** A cache has been added/deleted. */
        on(event: 'cacheStorageListUpdated', handler: EventHandler<Storage.CacheStorageListUpdatedEvent>): EventListener;
        /** The origin's IndexedDB object store has been modified. */
        on(event: 'indexedDBContentUpdated', handler: EventHandler<Storage.IndexedDBContentUpdatedEvent>): EventListener;
        /** The origin's IndexedDB database list has been modified. */
        on(event: 'indexedDBListUpdated', handler: EventHandler<Storage.IndexedDBListUpdatedEvent>): EventListener;
        /** A cache's contents have been modified. */
        once(event: 'cacheStorageContentUpdated', handler: EventHandler<Storage.CacheStorageContentUpdatedEvent>): EventListener;
        /** A cache has been added/deleted. */
        once(event: 'cacheStorageListUpdated', handler: EventHandler<Storage.CacheStorageListUpdatedEvent>): EventListener;
        /** The origin's IndexedDB object store has been modified. */
        once(event: 'indexedDBContentUpdated', handler: EventHandler<Storage.IndexedDBContentUpdatedEvent>): EventListener;
        /** The origin's IndexedDB database list has been modified. */
        once(event: 'indexedDBListUpdated', handler: EventHandler<Storage.IndexedDBListUpdatedEvent>): EventListener;
    }
    class SystemInfo {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Returns information about the system. */
        getInfo(request: SystemInfo.GetInfoRequest): Promise<SystemInfo.GetInfoResponse>;
        /** Returns information about all running processes. */
        getProcessInfo(request: SystemInfo.GetProcessInfoRequest): Promise<SystemInfo.GetProcessInfoResponse>;
    }
    class Target {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Activates (focuses) the target. */
        activateTarget(request: Target.ActivateTargetRequest): Promise<Target.ActivateTargetResponse>;
        /** Attaches to the target with given id. */
        attachToTarget(request: Target.AttachToTargetRequest): Promise<Target.AttachToTargetResponse>;
        /** Attaches to the browser target, only uses flat sessionId mode. */
        attachToBrowserTarget(request: Target.AttachToBrowserTargetRequest): Promise<Target.AttachToBrowserTargetResponse>;
        /** Closes the target. If the target is a page that gets closed too. */
        closeTarget(request: Target.CloseTargetRequest): Promise<Target.CloseTargetResponse>;
        /** Inject object to the target's main frame that provides a communication channel with browser target.  Injected object will be available as `window[bindingName]`.  The object has the follwing API: - `binding.send(json)` - a method to send messages over the remote debugging protocol - `binding.onmessage = json => handleMessage(json)` - a callback that will be called for the protocol notifications and command responses. */
        exposeDevToolsProtocol(request: Target.ExposeDevToolsProtocolRequest): Promise<Target.ExposeDevToolsProtocolResponse>;
        /** Creates a new empty BrowserContext. Similar to an incognito profile but you can have more than one. */
        createBrowserContext(request: Target.CreateBrowserContextRequest): Promise<Target.CreateBrowserContextResponse>;
        /** Returns all browser contexts created with `Target.createBrowserContext` method. */
        getBrowserContexts(request: Target.GetBrowserContextsRequest): Promise<Target.GetBrowserContextsResponse>;
        /** Creates a new page. */
        createTarget(request: Target.CreateTargetRequest): Promise<Target.CreateTargetResponse>;
        /** Detaches session with given id. */
        detachFromTarget(request: Target.DetachFromTargetRequest): Promise<Target.DetachFromTargetResponse>;
        /** Deletes a BrowserContext. All the belonging pages will be closed without calling their beforeunload hooks. */
        disposeBrowserContext(request: Target.DisposeBrowserContextRequest): Promise<Target.DisposeBrowserContextResponse>;
        /** Returns information about a target. */
        getTargetInfo(request: Target.GetTargetInfoRequest): Promise<Target.GetTargetInfoResponse>;
        /** Retrieves a list of available targets. */
        getTargets(request: Target.GetTargetsRequest): Promise<Target.GetTargetsResponse>;
        /** Sends protocol message over session with given id. */
        sendMessageToTarget(request: Target.SendMessageToTargetRequest): Promise<Target.SendMessageToTargetResponse>;
        /** Controls whether to automatically attach to new targets which are considered to be related to this one. When turned on, attaches to all existing related targets as well. When turned off, automatically detaches from all currently attached targets. */
        setAutoAttach(request: Target.SetAutoAttachRequest): Promise<Target.SetAutoAttachResponse>;
        /** Controls whether to discover available targets and notify via `targetCreated/targetInfoChanged/targetDestroyed` events. */
        setDiscoverTargets(request: Target.SetDiscoverTargetsRequest): Promise<Target.SetDiscoverTargetsResponse>;
        /** Enables target discovery for the specified locations, when `setDiscoverTargets` was set to `true`. */
        setRemoteLocations(request: Target.SetRemoteLocationsRequest): Promise<Target.SetRemoteLocationsResponse>;
        /** Issued when attached to target because of auto-attach or `attachToTarget` command. */
        on(event: 'attachedToTarget', handler: EventHandler<Target.AttachedToTargetEvent>): EventListener;
        /** Issued when detached from target for any reason (including `detachFromTarget` command). Can be issued multiple times per target if multiple sessions have been attached to it. */
        on(event: 'detachedFromTarget', handler: EventHandler<Target.DetachedFromTargetEvent>): EventListener;
        /** Notifies about a new protocol message received from the session (as reported in `attachedToTarget` event). */
        on(event: 'receivedMessageFromTarget', handler: EventHandler<Target.ReceivedMessageFromTargetEvent>): EventListener;
        /** Issued when a possible inspection target is created. */
        on(event: 'targetCreated', handler: EventHandler<Target.TargetCreatedEvent>): EventListener;
        /** Issued when a target is destroyed. */
        on(event: 'targetDestroyed', handler: EventHandler<Target.TargetDestroyedEvent>): EventListener;
        /** Issued when a target has crashed. */
        on(event: 'targetCrashed', handler: EventHandler<Target.TargetCrashedEvent>): EventListener;
        /** Issued when some information about a target has changed. This only happens between `targetCreated` and `targetDestroyed`. */
        on(event: 'targetInfoChanged', handler: EventHandler<Target.TargetInfoChangedEvent>): EventListener;
        /** Issued when attached to target because of auto-attach or `attachToTarget` command. */
        once(event: 'attachedToTarget', handler: EventHandler<Target.AttachedToTargetEvent>): EventListener;
        /** Issued when detached from target for any reason (including `detachFromTarget` command). Can be issued multiple times per target if multiple sessions have been attached to it. */
        once(event: 'detachedFromTarget', handler: EventHandler<Target.DetachedFromTargetEvent>): EventListener;
        /** Notifies about a new protocol message received from the session (as reported in `attachedToTarget` event). */
        once(event: 'receivedMessageFromTarget', handler: EventHandler<Target.ReceivedMessageFromTargetEvent>): EventListener;
        /** Issued when a possible inspection target is created. */
        once(event: 'targetCreated', handler: EventHandler<Target.TargetCreatedEvent>): EventListener;
        /** Issued when a target is destroyed. */
        once(event: 'targetDestroyed', handler: EventHandler<Target.TargetDestroyedEvent>): EventListener;
        /** Issued when a target has crashed. */
        once(event: 'targetCrashed', handler: EventHandler<Target.TargetCrashedEvent>): EventListener;
        /** Issued when some information about a target has changed. This only happens between `targetCreated` and `targetDestroyed`. */
        once(event: 'targetInfoChanged', handler: EventHandler<Target.TargetInfoChangedEvent>): EventListener;
    }
    class Tethering {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Request browser port binding. */
        bind(request: Tethering.BindRequest): Promise<Tethering.BindResponse>;
        /** Request browser port unbinding. */
        unbind(request: Tethering.UnbindRequest): Promise<Tethering.UnbindResponse>;
        /** Informs that port was successfully bound and got a specified connection id. */
        on(event: 'accepted', handler: EventHandler<Tethering.AcceptedEvent>): EventListener;
        /** Informs that port was successfully bound and got a specified connection id. */
        once(event: 'accepted', handler: EventHandler<Tethering.AcceptedEvent>): EventListener;
    }
    class Tracing {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Stop trace events collection. */
        end(request: Tracing.EndRequest): Promise<Tracing.EndResponse>;
        /** Gets supported tracing categories. */
        getCategories(request: Tracing.GetCategoriesRequest): Promise<Tracing.GetCategoriesResponse>;
        /** Record a clock sync marker in the trace. */
        recordClockSyncMarker(request: Tracing.RecordClockSyncMarkerRequest): Promise<Tracing.RecordClockSyncMarkerResponse>;
        /** Request a global memory dump. */
        requestMemoryDump(request: Tracing.RequestMemoryDumpRequest): Promise<Tracing.RequestMemoryDumpResponse>;
        /** Start trace events collection. */
        start(request: Tracing.StartRequest): Promise<Tracing.StartResponse>;
        on(event: 'bufferUsage', handler: EventHandler<Tracing.BufferUsageEvent>): EventListener;
        /** Contains an bucket of collected trace events. When tracing is stopped collected events will be send as a sequence of dataCollected events followed by tracingComplete event. */
        on(event: 'dataCollected', handler: EventHandler<Tracing.DataCollectedEvent>): EventListener;
        /** Signals that tracing is stopped and there is no trace buffers pending flush, all data were delivered via dataCollected events. */
        on(event: 'tracingComplete', handler: EventHandler<Tracing.TracingCompleteEvent>): EventListener;
        once(event: 'bufferUsage', handler: EventHandler<Tracing.BufferUsageEvent>): EventListener;
        /** Contains an bucket of collected trace events. When tracing is stopped collected events will be send as a sequence of dataCollected events followed by tracingComplete event. */
        once(event: 'dataCollected', handler: EventHandler<Tracing.DataCollectedEvent>): EventListener;
        /** Signals that tracing is stopped and there is no trace buffers pending flush, all data were delivered via dataCollected events. */
        once(event: 'tracingComplete', handler: EventHandler<Tracing.TracingCompleteEvent>): EventListener;
    }
    class Fetch {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Disables the fetch domain. */
        disable(request: Fetch.DisableRequest): Promise<Fetch.DisableResponse>;
        /** Enables issuing of requestPaused events. A request will be paused until client calls one of failRequest, fulfillRequest or continueRequest/continueWithAuth. */
        enable(request: Fetch.EnableRequest): Promise<Fetch.EnableResponse>;
        /** Causes the request to fail with specified reason. */
        failRequest(request: Fetch.FailRequestRequest): Promise<Fetch.FailRequestResponse>;
        /** Provides response to the request. */
        fulfillRequest(request: Fetch.FulfillRequestRequest): Promise<Fetch.FulfillRequestResponse>;
        /** Continues the request, optionally modifying some of its parameters. */
        continueRequest(request: Fetch.ContinueRequestRequest): Promise<Fetch.ContinueRequestResponse>;
        /** Continues a request supplying authChallengeResponse following authRequired event. */
        continueWithAuth(request: Fetch.ContinueWithAuthRequest): Promise<Fetch.ContinueWithAuthResponse>;
        /** Causes the body of the response to be received from the server and returned as a single string. May only be issued for a request that is paused in the Response stage and is mutually exclusive with takeResponseBodyForInterceptionAsStream. Calling other methods that affect the request or disabling fetch domain before body is received results in an undefined behavior. */
        getResponseBody(request: Fetch.GetResponseBodyRequest): Promise<Fetch.GetResponseBodyResponse>;
        /** Returns a handle to the stream representing the response body. The request must be paused in the HeadersReceived stage. Note that after this command the request can't be continued as is -- client either needs to cancel it or to provide the response body. The stream only supports sequential read, IO.read will fail if the position is specified. This method is mutually exclusive with getResponseBody. Calling other methods that affect the request or disabling fetch domain before body is received results in an undefined behavior. */
        takeResponseBodyAsStream(request: Fetch.TakeResponseBodyAsStreamRequest): Promise<Fetch.TakeResponseBodyAsStreamResponse>;
        /** Issued when the domain is enabled and the request URL matches the specified filter. The request is paused until the client responds with one of continueRequest, failRequest or fulfillRequest. The stage of the request can be determined by presence of responseErrorReason and responseStatusCode -- the request is at the response stage if either of these fields is present and in the request stage otherwise. */
        on(event: 'requestPaused', handler: EventHandler<Fetch.RequestPausedEvent>): EventListener;
        /** Issued when the domain is enabled with handleAuthRequests set to true. The request is paused until client responds with continueWithAuth. */
        on(event: 'authRequired', handler: EventHandler<Fetch.AuthRequiredEvent>): EventListener;
        /** Issued when the domain is enabled and the request URL matches the specified filter. The request is paused until the client responds with one of continueRequest, failRequest or fulfillRequest. The stage of the request can be determined by presence of responseErrorReason and responseStatusCode -- the request is at the response stage if either of these fields is present and in the request stage otherwise. */
        once(event: 'requestPaused', handler: EventHandler<Fetch.RequestPausedEvent>): EventListener;
        /** Issued when the domain is enabled with handleAuthRequests set to true. The request is paused until client responds with continueWithAuth. */
        once(event: 'authRequired', handler: EventHandler<Fetch.AuthRequiredEvent>): EventListener;
    }
    class WebAudio {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Enables the WebAudio domain and starts sending context lifetime events. */
        enable(request: WebAudio.EnableRequest): Promise<WebAudio.EnableResponse>;
        /** Disables the WebAudio domain. */
        disable(request: WebAudio.DisableRequest): Promise<WebAudio.DisableResponse>;
        /** Fetch the realtime data from the registered contexts. */
        getRealtimeData(request: WebAudio.GetRealtimeDataRequest): Promise<WebAudio.GetRealtimeDataResponse>;
        /** Notifies that a new BaseAudioContext has been created. */
        on(event: 'contextCreated', handler: EventHandler<WebAudio.ContextCreatedEvent>): EventListener;
        /** Notifies that existing BaseAudioContext has been destroyed. */
        on(event: 'contextDestroyed', handler: EventHandler<WebAudio.ContextDestroyedEvent>): EventListener;
        /** Notifies that existing BaseAudioContext has changed some properties (id stays the same).. */
        on(event: 'contextChanged', handler: EventHandler<WebAudio.ContextChangedEvent>): EventListener;
        /** Notifies that a new BaseAudioContext has been created. */
        once(event: 'contextCreated', handler: EventHandler<WebAudio.ContextCreatedEvent>): EventListener;
        /** Notifies that existing BaseAudioContext has been destroyed. */
        once(event: 'contextDestroyed', handler: EventHandler<WebAudio.ContextDestroyedEvent>): EventListener;
        /** Notifies that existing BaseAudioContext has changed some properties (id stays the same).. */
        once(event: 'contextChanged', handler: EventHandler<WebAudio.ContextChangedEvent>): EventListener;
    }
    class WebAuthn {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Enable the WebAuthn domain and start intercepting credential storage and retrieval with a virtual authenticator. */
        enable(request: WebAuthn.EnableRequest): Promise<WebAuthn.EnableResponse>;
        /** Disable the WebAuthn domain. */
        disable(request: WebAuthn.DisableRequest): Promise<WebAuthn.DisableResponse>;
        /** Creates and adds a virtual authenticator. */
        addVirtualAuthenticator(request: WebAuthn.AddVirtualAuthenticatorRequest): Promise<WebAuthn.AddVirtualAuthenticatorResponse>;
        /** Removes the given authenticator. */
        removeVirtualAuthenticator(request: WebAuthn.RemoveVirtualAuthenticatorRequest): Promise<WebAuthn.RemoveVirtualAuthenticatorResponse>;
        /** Adds the credential to the specified authenticator. */
        addCredential(request: WebAuthn.AddCredentialRequest): Promise<WebAuthn.AddCredentialResponse>;
        /** Returns all the credentials stored in the given virtual authenticator. */
        getCredentials(request: WebAuthn.GetCredentialsRequest): Promise<WebAuthn.GetCredentialsResponse>;
        /** Clears all the credentials from the specified device. */
        clearCredentials(request: WebAuthn.ClearCredentialsRequest): Promise<WebAuthn.ClearCredentialsResponse>;
        /** Sets whether User Verification succeeds or fails for an authenticator. The default is true. */
        setUserVerified(request: WebAuthn.SetUserVerifiedRequest): Promise<WebAuthn.SetUserVerifiedResponse>;
    }
    class Console {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Does nothing. */
        clearMessages(request: Console.ClearMessagesRequest): Promise<Console.ClearMessagesResponse>;
        /** Disables console domain, prevents further console messages from being reported to the client. */
        disable(request: Console.DisableRequest): Promise<Console.DisableResponse>;
        /** Enables console domain, sends the messages collected so far to the client by means of the `messageAdded` notification. */
        enable(request: Console.EnableRequest): Promise<Console.EnableResponse>;
        /** Issued when new console message is added. */
        on(event: 'messageAdded', handler: EventHandler<Console.MessageAddedEvent>): EventListener;
        /** Issued when new console message is added. */
        once(event: 'messageAdded', handler: EventHandler<Console.MessageAddedEvent>): EventListener;
    }
    class Debugger {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Continues execution until specific location is reached. */
        continueToLocation(request: Debugger.ContinueToLocationRequest): Promise<Debugger.ContinueToLocationResponse>;
        /** Disables debugger for given page. */
        disable(request: Debugger.DisableRequest): Promise<Debugger.DisableResponse>;
        /** Enables debugger for the given page. Clients should not assume that the debugging has been enabled until the result for this command is received. */
        enable(request: Debugger.EnableRequest): Promise<Debugger.EnableResponse>;
        /** Evaluates expression on a given call frame. */
        evaluateOnCallFrame(request: Debugger.EvaluateOnCallFrameRequest): Promise<Debugger.EvaluateOnCallFrameResponse>;
        /** Returns possible locations for breakpoint. scriptId in start and end range locations should be the same. */
        getPossibleBreakpoints(request: Debugger.GetPossibleBreakpointsRequest): Promise<Debugger.GetPossibleBreakpointsResponse>;
        /** Returns source for the script with given id. */
        getScriptSource(request: Debugger.GetScriptSourceRequest): Promise<Debugger.GetScriptSourceResponse>;
        /** Returns stack trace with given `stackTraceId`. */
        getStackTrace(request: Debugger.GetStackTraceRequest): Promise<Debugger.GetStackTraceResponse>;
        /** Stops on the next JavaScript statement. */
        pause(request: Debugger.PauseRequest): Promise<Debugger.PauseResponse>;
        pauseOnAsyncCall(request: Debugger.PauseOnAsyncCallRequest): Promise<Debugger.PauseOnAsyncCallResponse>;
        /** Removes JavaScript breakpoint. */
        removeBreakpoint(request: Debugger.RemoveBreakpointRequest): Promise<Debugger.RemoveBreakpointResponse>;
        /** Restarts particular call frame from the beginning. */
        restartFrame(request: Debugger.RestartFrameRequest): Promise<Debugger.RestartFrameResponse>;
        /** Resumes JavaScript execution. */
        resume(request: Debugger.ResumeRequest): Promise<Debugger.ResumeResponse>;
        /** Searches for given string in script content. */
        searchInContent(request: Debugger.SearchInContentRequest): Promise<Debugger.SearchInContentResponse>;
        /** Enables or disables async call stacks tracking. */
        setAsyncCallStackDepth(request: Debugger.SetAsyncCallStackDepthRequest): Promise<Debugger.SetAsyncCallStackDepthResponse>;
        /** Replace previous blackbox patterns with passed ones. Forces backend to skip stepping/pausing in scripts with url matching one of the patterns. VM will try to leave blackboxed script by performing 'step in' several times, finally resorting to 'step out' if unsuccessful. */
        setBlackboxPatterns(request: Debugger.SetBlackboxPatternsRequest): Promise<Debugger.SetBlackboxPatternsResponse>;
        /** 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. */
        setBlackboxedRanges(request: Debugger.SetBlackboxedRangesRequest): Promise<Debugger.SetBlackboxedRangesResponse>;
        /** Sets JavaScript breakpoint at a given location. */
        setBreakpoint(request: Debugger.SetBreakpointRequest): Promise<Debugger.SetBreakpointResponse>;
        /** Sets instrumentation breakpoint. */
        setInstrumentationBreakpoint(request: Debugger.SetInstrumentationBreakpointRequest): Promise<Debugger.SetInstrumentationBreakpointResponse>;
        /** 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. */
        setBreakpointByUrl(request: Debugger.SetBreakpointByUrlRequest): Promise<Debugger.SetBreakpointByUrlResponse>;
        /** Sets JavaScript breakpoint before each call to the given function. If another function was created from the same source as a given one, calling it will also trigger the breakpoint. */
        setBreakpointOnFunctionCall(request: Debugger.SetBreakpointOnFunctionCallRequest): Promise<Debugger.SetBreakpointOnFunctionCallResponse>;
        /** Activates / deactivates all breakpoints on the page. */
        setBreakpointsActive(request: Debugger.SetBreakpointsActiveRequest): Promise<Debugger.SetBreakpointsActiveResponse>;
        /** 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`. */
        setPauseOnExceptions(request: Debugger.SetPauseOnExceptionsRequest): Promise<Debugger.SetPauseOnExceptionsResponse>;
        /** Changes return value in top frame. Available only at return break position. */
        setReturnValue(request: Debugger.SetReturnValueRequest): Promise<Debugger.SetReturnValueResponse>;
        /** Edits JavaScript source live. */
        setScriptSource(request: Debugger.SetScriptSourceRequest): Promise<Debugger.SetScriptSourceResponse>;
        /** Makes page not interrupt on any pauses (breakpoint, exception, dom exception etc). */
        setSkipAllPauses(request: Debugger.SetSkipAllPausesRequest): Promise<Debugger.SetSkipAllPausesResponse>;
        /** Changes value of variable in a callframe. Object-based scopes are not supported and must be mutated manually. */
        setVariableValue(request: Debugger.SetVariableValueRequest): Promise<Debugger.SetVariableValueResponse>;
        /** Steps into the function call. */
        stepInto(request: Debugger.StepIntoRequest): Promise<Debugger.StepIntoResponse>;
        /** Steps out of the function call. */
        stepOut(request: Debugger.StepOutRequest): Promise<Debugger.StepOutResponse>;
        /** Steps over the statement. */
        stepOver(request: Debugger.StepOverRequest): Promise<Debugger.StepOverResponse>;
        /** Fired when breakpoint is resolved to an actual script and location. */
        on(event: 'breakpointResolved', handler: EventHandler<Debugger.BreakpointResolvedEvent>): EventListener;
        /** Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria. */
        on(event: 'paused', handler: EventHandler<Debugger.PausedEvent>): EventListener;
        /** Fired when the virtual machine resumed execution. */
        on(event: 'resumed', handler: EventHandler<Debugger.ResumedEvent>): EventListener;
        /** Fired when virtual machine fails to parse the script. */
        on(event: 'scriptFailedToParse', handler: EventHandler<Debugger.ScriptFailedToParseEvent>): EventListener;
        /** Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger. */
        on(event: 'scriptParsed', handler: EventHandler<Debugger.ScriptParsedEvent>): EventListener;
        /** Fired when breakpoint is resolved to an actual script and location. */
        once(event: 'breakpointResolved', handler: EventHandler<Debugger.BreakpointResolvedEvent>): EventListener;
        /** Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria. */
        once(event: 'paused', handler: EventHandler<Debugger.PausedEvent>): EventListener;
        /** Fired when the virtual machine resumed execution. */
        once(event: 'resumed', handler: EventHandler<Debugger.ResumedEvent>): EventListener;
        /** Fired when virtual machine fails to parse the script. */
        once(event: 'scriptFailedToParse', handler: EventHandler<Debugger.ScriptFailedToParseEvent>): EventListener;
        /** Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger. */
        once(event: 'scriptParsed', handler: EventHandler<Debugger.ScriptParsedEvent>): EventListener;
    }
    class HeapProfiler {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Enables console to refer to the node with given id via $x (see Command Line API for more details $x functions). */
        addInspectedHeapObject(request: HeapProfiler.AddInspectedHeapObjectRequest): Promise<HeapProfiler.AddInspectedHeapObjectResponse>;
        collectGarbage(request: HeapProfiler.CollectGarbageRequest): Promise<HeapProfiler.CollectGarbageResponse>;
        disable(request: HeapProfiler.DisableRequest): Promise<HeapProfiler.DisableResponse>;
        enable(request: HeapProfiler.EnableRequest): Promise<HeapProfiler.EnableResponse>;
        getHeapObjectId(request: HeapProfiler.GetHeapObjectIdRequest): Promise<HeapProfiler.GetHeapObjectIdResponse>;
        getObjectByHeapObjectId(request: HeapProfiler.GetObjectByHeapObjectIdRequest): Promise<HeapProfiler.GetObjectByHeapObjectIdResponse>;
        getSamplingProfile(request: HeapProfiler.GetSamplingProfileRequest): Promise<HeapProfiler.GetSamplingProfileResponse>;
        startSampling(request: HeapProfiler.StartSamplingRequest): Promise<HeapProfiler.StartSamplingResponse>;
        startTrackingHeapObjects(request: HeapProfiler.StartTrackingHeapObjectsRequest): Promise<HeapProfiler.StartTrackingHeapObjectsResponse>;
        stopSampling(request: HeapProfiler.StopSamplingRequest): Promise<HeapProfiler.StopSamplingResponse>;
        stopTrackingHeapObjects(request: HeapProfiler.StopTrackingHeapObjectsRequest): Promise<HeapProfiler.StopTrackingHeapObjectsResponse>;
        takeHeapSnapshot(request: HeapProfiler.TakeHeapSnapshotRequest): Promise<HeapProfiler.TakeHeapSnapshotResponse>;
        on(event: 'addHeapSnapshotChunk', handler: EventHandler<HeapProfiler.AddHeapSnapshotChunkEvent>): EventListener;
        /** If heap objects tracking has been started then backend may send update for one or more fragments */
        on(event: 'heapStatsUpdate', handler: EventHandler<HeapProfiler.HeapStatsUpdateEvent>): EventListener;
        /** 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: 'lastSeenObjectId', handler: EventHandler<HeapProfiler.LastSeenObjectIdEvent>): EventListener;
        on(event: 'reportHeapSnapshotProgress', handler: EventHandler<HeapProfiler.ReportHeapSnapshotProgressEvent>): EventListener;
        on(event: 'resetProfiles', handler: EventHandler<HeapProfiler.ResetProfilesEvent>): EventListener;
        once(event: 'addHeapSnapshotChunk', handler: EventHandler<HeapProfiler.AddHeapSnapshotChunkEvent>): EventListener;
        /** If heap objects tracking has been started then backend may send update for one or more fragments */
        once(event: 'heapStatsUpdate', handler: EventHandler<HeapProfiler.HeapStatsUpdateEvent>): EventListener;
        /** 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: 'lastSeenObjectId', handler: EventHandler<HeapProfiler.LastSeenObjectIdEvent>): EventListener;
        once(event: 'reportHeapSnapshotProgress', handler: EventHandler<HeapProfiler.ReportHeapSnapshotProgressEvent>): EventListener;
        once(event: 'resetProfiles', handler: EventHandler<HeapProfiler.ResetProfilesEvent>): EventListener;
    }
    class Profiler {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        disable(request: Profiler.DisableRequest): Promise<Profiler.DisableResponse>;
        enable(request: Profiler.EnableRequest): Promise<Profiler.EnableResponse>;
        /** Collect coverage data for the current isolate. The coverage data may be incomplete due to garbage collection. */
        getBestEffortCoverage(request: Profiler.GetBestEffortCoverageRequest): Promise<Profiler.GetBestEffortCoverageResponse>;
        /** Changes CPU profiler sampling interval. Must be called before CPU profiles recording started. */
        setSamplingInterval(request: Profiler.SetSamplingIntervalRequest): Promise<Profiler.SetSamplingIntervalResponse>;
        start(request: Profiler.StartRequest): Promise<Profiler.StartResponse>;
        /** Enable precise code coverage. Coverage data for JavaScript executed before enabling precise code coverage may be incomplete. Enabling prevents running optimized code and resets execution counters. */
        startPreciseCoverage(request: Profiler.StartPreciseCoverageRequest): Promise<Profiler.StartPreciseCoverageResponse>;
        /** Enable type profile. */
        startTypeProfile(request: Profiler.StartTypeProfileRequest): Promise<Profiler.StartTypeProfileResponse>;
        stop(request: Profiler.StopRequest): Promise<Profiler.StopResponse>;
        /** Disable precise code coverage. Disabling releases unnecessary execution count records and allows executing optimized code. */
        stopPreciseCoverage(request: Profiler.StopPreciseCoverageRequest): Promise<Profiler.StopPreciseCoverageResponse>;
        /** Disable type profile. Disabling releases type profile data collected so far. */
        stopTypeProfile(request: Profiler.StopTypeProfileRequest): Promise<Profiler.StopTypeProfileResponse>;
        /** Collect coverage data for the current isolate, and resets execution counters. Precise code coverage needs to have started. */
        takePreciseCoverage(request: Profiler.TakePreciseCoverageRequest): Promise<Profiler.TakePreciseCoverageResponse>;
        /** Collect type profile. */
        takeTypeProfile(request: Profiler.TakeTypeProfileRequest): Promise<Profiler.TakeTypeProfileResponse>;
        on(event: 'consoleProfileFinished', handler: EventHandler<Profiler.ConsoleProfileFinishedEvent>): EventListener;
        /** Sent when new profile recording is started using console.profile() call. */
        on(event: 'consoleProfileStarted', handler: EventHandler<Profiler.ConsoleProfileStartedEvent>): EventListener;
        once(event: 'consoleProfileFinished', handler: EventHandler<Profiler.ConsoleProfileFinishedEvent>): EventListener;
        /** Sent when new profile recording is started using console.profile() call. */
        once(event: 'consoleProfileStarted', handler: EventHandler<Profiler.ConsoleProfileStartedEvent>): EventListener;
    }
    class Runtime {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Add handler to promise with given promise object id. */
        awaitPromise(request: Runtime.AwaitPromiseRequest): Promise<Runtime.AwaitPromiseResponse>;
        /** Calls function with given declaration on the given object. Object group of the result is inherited from the target object. */
        callFunctionOn(request: Runtime.CallFunctionOnRequest): Promise<Runtime.CallFunctionOnResponse>;
        /** Compiles expression. */
        compileScript(request: Runtime.CompileScriptRequest): Promise<Runtime.CompileScriptResponse>;
        /** Disables reporting of execution contexts creation. */
        disable(request: Runtime.DisableRequest): Promise<Runtime.DisableResponse>;
        /** Discards collected exceptions and console API calls. */
        discardConsoleEntries(request: Runtime.DiscardConsoleEntriesRequest): Promise<Runtime.DiscardConsoleEntriesResponse>;
        /** Enables reporting of execution contexts creation by means of `executionContextCreated` event. When the reporting gets enabled the event will be sent immediately for each existing execution context. */
        enable(request: Runtime.EnableRequest): Promise<Runtime.EnableResponse>;
        /** Evaluates expression on global object. */
        evaluate(request: Runtime.EvaluateRequest): Promise<Runtime.EvaluateResponse>;
        /** Returns the isolate id. */
        getIsolateId(request: Runtime.GetIsolateIdRequest): Promise<Runtime.GetIsolateIdResponse>;
        /** Returns the JavaScript heap usage. It is the total usage of the corresponding isolate not scoped to a particular Runtime. */
        getHeapUsage(request: Runtime.GetHeapUsageRequest): Promise<Runtime.GetHeapUsageResponse>;
        /** Returns properties of a given object. Object group of the result is inherited from the target object. */
        getProperties(request: Runtime.GetPropertiesRequest): Promise<Runtime.GetPropertiesResponse>;
        /** Returns all let, const and class variables from global scope. */
        globalLexicalScopeNames(request: Runtime.GlobalLexicalScopeNamesRequest): Promise<Runtime.GlobalLexicalScopeNamesResponse>;
        queryObjects(request: Runtime.QueryObjectsRequest): Promise<Runtime.QueryObjectsResponse>;
        /** Releases remote object with given id. */
        releaseObject(request: Runtime.ReleaseObjectRequest): Promise<Runtime.ReleaseObjectResponse>;
        /** Releases all remote objects that belong to a given group. */
        releaseObjectGroup(request: Runtime.ReleaseObjectGroupRequest): Promise<Runtime.ReleaseObjectGroupResponse>;
        /** Tells inspected instance to run if it was waiting for debugger to attach. */
        runIfWaitingForDebugger(request: Runtime.RunIfWaitingForDebuggerRequest): Promise<Runtime.RunIfWaitingForDebuggerResponse>;
        /** Runs script with given id in a given context. */
        runScript(request: Runtime.RunScriptRequest): Promise<Runtime.RunScriptResponse>;
        /** Enables or disables async call stacks tracking. */
        setAsyncCallStackDepth(request: Runtime.SetAsyncCallStackDepthRequest): Promise<Runtime.SetAsyncCallStackDepthResponse>;
        setCustomObjectFormatterEnabled(request: Runtime.SetCustomObjectFormatterEnabledRequest): Promise<Runtime.SetCustomObjectFormatterEnabledResponse>;
        setMaxCallStackSizeToCapture(request: Runtime.SetMaxCallStackSizeToCaptureRequest): Promise<Runtime.SetMaxCallStackSizeToCaptureResponse>;
        /** Terminate current or next JavaScript execution. Will cancel the termination when the outer-most script execution ends. */
        terminateExecution(request: Runtime.TerminateExecutionRequest): Promise<Runtime.TerminateExecutionResponse>;
        /** If executionContextId is empty, adds binding with the given name on the global objects of all inspected contexts, including those created later, bindings survive reloads. If executionContextId is specified, adds binding only on global object of given execution context. Binding function takes exactly one argument, this argument should be string, in case of any other input, function throws an exception. Each binding function call produces Runtime.bindingCalled notification. */
        addBinding(request: Runtime.AddBindingRequest): Promise<Runtime.AddBindingResponse>;
        /** This method does not remove binding function from global object but unsubscribes current runtime agent from Runtime.bindingCalled notifications. */
        removeBinding(request: Runtime.RemoveBindingRequest): Promise<Runtime.RemoveBindingResponse>;
        /** Notification is issued every time when binding is called. */
        on(event: 'bindingCalled', handler: EventHandler<Runtime.BindingCalledEvent>): EventListener;
        /** Issued when console API was called. */
        on(event: 'consoleAPICalled', handler: EventHandler<Runtime.ConsoleAPICalledEvent>): EventListener;
        /** Issued when unhandled exception was revoked. */
        on(event: 'exceptionRevoked', handler: EventHandler<Runtime.ExceptionRevokedEvent>): EventListener;
        /** Issued when exception was thrown and unhandled. */
        on(event: 'exceptionThrown', handler: EventHandler<Runtime.ExceptionThrownEvent>): EventListener;
        /** Issued when new execution context is created. */
        on(event: 'executionContextCreated', handler: EventHandler<Runtime.ExecutionContextCreatedEvent>): EventListener;
        /** Issued when execution context is destroyed. */
        on(event: 'executionContextDestroyed', handler: EventHandler<Runtime.ExecutionContextDestroyedEvent>): EventListener;
        /** Issued when all executionContexts were cleared in browser */
        on(event: 'executionContextsCleared', handler: EventHandler<Runtime.ExecutionContextsClearedEvent>): EventListener;
        /** Issued when object should be inspected (for example, as a result of inspect() command line API call). */
        on(event: 'inspectRequested', handler: EventHandler<Runtime.InspectRequestedEvent>): EventListener;
        /** Notification is issued every time when binding is called. */
        once(event: 'bindingCalled', handler: EventHandler<Runtime.BindingCalledEvent>): EventListener;
        /** Issued when console API was called. */
        once(event: 'consoleAPICalled', handler: EventHandler<Runtime.ConsoleAPICalledEvent>): EventListener;
        /** Issued when unhandled exception was revoked. */
        once(event: 'exceptionRevoked', handler: EventHandler<Runtime.ExceptionRevokedEvent>): EventListener;
        /** Issued when exception was thrown and unhandled. */
        once(event: 'exceptionThrown', handler: EventHandler<Runtime.ExceptionThrownEvent>): EventListener;
        /** Issued when new execution context is created. */
        once(event: 'executionContextCreated', handler: EventHandler<Runtime.ExecutionContextCreatedEvent>): EventListener;
        /** Issued when execution context is destroyed. */
        once(event: 'executionContextDestroyed', handler: EventHandler<Runtime.ExecutionContextDestroyedEvent>): EventListener;
        /** Issued when all executionContexts were cleared in browser */
        once(event: 'executionContextsCleared', handler: EventHandler<Runtime.ExecutionContextsClearedEvent>): EventListener;
        /** Issued when object should be inspected (for example, as a result of inspect() command line API call). */
        once(event: 'inspectRequested', handler: EventHandler<Runtime.InspectRequestedEvent>): EventListener;
    }
    class Schema {
        private readonly adapter;
        private readonly events;
        constructor(adapter: DevToolsAdapter);
        /** Returns supported domains. */
        getDomains(request: Schema.GetDomainsRequest): Promise<Schema.GetDomainsResponse>;
    }
    class DevTools {
        private readonly adapter;
        readonly Accessibility: Accessibility;
        readonly Animation: Animation;
        readonly ApplicationCache: ApplicationCache;
        readonly Audits: Audits;
        readonly BackgroundService: BackgroundService;
        readonly Browser: Browser;
        readonly CSS: CSS;
        readonly CacheStorage: CacheStorage;
        readonly Cast: Cast;
        readonly DOM: DOM;
        readonly DOMDebugger: DOMDebugger;
        readonly DOMSnapshot: DOMSnapshot;
        readonly DOMStorage: DOMStorage;
        readonly Database: Database;
        readonly DeviceOrientation: DeviceOrientation;
        readonly Emulation: Emulation;
        readonly HeadlessExperimental: HeadlessExperimental;
        readonly IO: IO;
        readonly IndexedDB: IndexedDB;
        readonly Input: Input;
        readonly Inspector: Inspector;
        readonly LayerTree: LayerTree;
        readonly Log: Log;
        readonly Memory: Memory;
        readonly Network: Network;
        readonly Overlay: Overlay;
        readonly Page: Page;
        readonly Performance: Performance;
        readonly Security: Security;
        readonly ServiceWorker: ServiceWorker;
        readonly Storage: Storage;
        readonly SystemInfo: SystemInfo;
        readonly Target: Target;
        readonly Tethering: Tethering;
        readonly Tracing: Tracing;
        readonly Fetch: Fetch;
        readonly WebAudio: WebAudio;
        readonly WebAuthn: WebAuthn;
        readonly Console: Console;
        readonly Debugger: Debugger;
        readonly HeapProfiler: HeapProfiler;
        readonly Profiler: Profiler;
        readonly Runtime: Runtime;
        readonly Schema: Schema;
        constructor(adapter: DevToolsAdapter);
    }
}