@nativescript/core 9.0.11-next.2 → 9.0.11

package/debugger/InspectorBackendCommands.d.ts

@@ -0,0 +1,1056 @@
+export declare function DomainDispatcher(domain: string): ClassDecorator;
+export declare namespace HeapDomain {
+    type HeapSnapshotData = string;
+    interface GarbageCollection {
+        type: any;
+        startTime: number;
+        endTime: number;
+    }
+    interface GetPreviewMethodArguments {
+        heapObjectId: number;
+    }
+    interface GetRemoteObjectMethodArguments {
+        heapObjectId: number;
+        objectGroup?: string;
+    }
+    interface HeapDomainDispatcher {
+        enable(): void;
+        disable(): void;
+        gc(): void;
+        snapshot(): {
+            timestamp: number;
+            snapshotData: HeapSnapshotData;
+        };
+        startTracking(): void;
+        stopTracking(): void;
+        getPreview(params: GetPreviewMethodArguments): {
+            string?: string;
+            functionDetails?: DebuggerDomain.FunctionDetails;
+            preview?: RuntimeDomain.ObjectPreview;
+        };
+        getRemoteObject(params: GetRemoteObjectMethodArguments): {
+            result: RuntimeDomain.RemoteObject;
+        };
+    }
+    class HeapFrontend {
+        garbageCollected(collection: GarbageCollection): void;
+        trackingStart(timestamp: number, snapshotData: HeapSnapshotData): void;
+        trackingComplete(timestamp: number, snapshotData: HeapSnapshotData): void;
+    }
+}
+export declare namespace DebuggerDomain {
+    type BreakpointId = string;
+    type BreakpointActionIdentifier = number;
+    type ScriptId = string;
+    type CallFrameId = string;
+    interface Location {
+        scriptId: ScriptId;
+        lineNumber: number;
+        columnNumber?: number;
+    }
+    interface BreakpointAction {
+        type: any;
+        data?: string;
+        id?: BreakpointActionIdentifier;
+    }
+    interface BreakpointOptions {
+        condition?: string;
+        actions?: BreakpointAction[];
+        autoContinue?: boolean;
+        ignoreCount?: number;
+    }
+    interface FunctionDetails {
+        location: Location;
+        name?: string;
+        displayName?: string;
+        scopeChain?: Scope[];
+    }
+    interface CallFrame {
+        callFrameId: CallFrameId;
+        functionName: string;
+        location: Location;
+        scopeChain: Scope[];
+        this: RuntimeDomain.RemoteObject;
+        isTailDeleted: boolean;
+    }
+    interface Scope {
+        object: RuntimeDomain.RemoteObject;
+        type: any;
+        name?: string;
+        location?: Location;
+        empty?: boolean;
+    }
+    interface ProbeSample {
+        probeId: BreakpointActionIdentifier;
+        sampleId: number;
+        batchId: number;
+        timestamp: number;
+        payload: RuntimeDomain.RemoteObject;
+    }
+    interface AssertPauseReason {
+        message?: string;
+    }
+    interface BreakpointPauseReason {
+        breakpointId: string;
+    }
+    interface CSPViolationPauseReason {
+        directive: string;
+    }
+    interface SetBreakpointsActiveMethodArguments {
+        active: boolean;
+    }
+    interface SetBreakpointByUrlMethodArguments {
+        lineNumber: number;
+        url?: string;
+        urlRegex?: string;
+        columnNumber?: number;
+        options?: BreakpointOptions;
+    }
+    interface SetBreakpointMethodArguments {
+        location: Location;
+        options?: BreakpointOptions;
+    }
+    interface RemoveBreakpointMethodArguments {
+        breakpointId: BreakpointId;
+    }
+    interface ContinueToLocationMethodArguments {
+        location: Location;
+    }
+    interface SearchInContentMethodArguments {
+        scriptId: ScriptId;
+        query: string;
+        caseSensitive?: boolean;
+        isRegex?: boolean;
+    }
+    interface GetScriptSourceMethodArguments {
+        scriptId: ScriptId;
+    }
+    interface SetScriptSourceMethodArguments {
+        scriptUrl: string;
+        scriptSource: string;
+    }
+    interface GetFunctionDetailsMethodArguments {
+        functionId: RuntimeDomain.RemoteObjectId;
+    }
+    interface SetPauseOnExceptionsMethodArguments {
+        state: any;
+    }
+    interface SetPauseOnAssertionsMethodArguments {
+        enabled: boolean;
+    }
+    interface EvaluateOnCallFrameMethodArguments {
+        callFrameId: CallFrameId;
+        expression: string;
+        objectGroup?: string;
+        includeCommandLineAPI?: boolean;
+        doNotPauseOnExceptionsAndMuteConsole?: boolean;
+        returnByValue?: boolean;
+        generatePreview?: boolean;
+        saveResult?: boolean;
+    }
+    interface SetOverlayMessageMethodArguments {
+        message?: string;
+    }
+    interface DebuggerDomainDispatcher {
+        enable(): void;
+        disable(): void;
+        setBreakpointsActive(params: SetBreakpointsActiveMethodArguments): void;
+        setBreakpointByUrl(params: SetBreakpointByUrlMethodArguments): {
+            breakpointId: BreakpointId;
+            locations: Location[];
+        };
+        setBreakpoint(params: SetBreakpointMethodArguments): {
+            breakpointId: BreakpointId;
+            actualLocation: Location;
+        };
+        removeBreakpoint(params: RemoveBreakpointMethodArguments): void;
+        continueToLocation(params: ContinueToLocationMethodArguments): void;
+        stepOver(): void;
+        stepInto(): void;
+        stepOut(): void;
+        pause(): void;
+        resume(): void;
+        searchInContent(params: SearchInContentMethodArguments): {
+            result: GenericTypesDomain.SearchMatch[];
+        };
+        getScriptSource(params: GetScriptSourceMethodArguments): {
+            scriptSource: string;
+        };
+        setScriptSource(params: SetScriptSourceMethodArguments): void;
+        getFunctionDetails(params: GetFunctionDetailsMethodArguments): {
+            details: FunctionDetails;
+        };
+        setPauseOnExceptions(params: SetPauseOnExceptionsMethodArguments): void;
+        setPauseOnAssertions(params: SetPauseOnAssertionsMethodArguments): void;
+        evaluateOnCallFrame(params: EvaluateOnCallFrameMethodArguments): {
+            result: RuntimeDomain.RemoteObject;
+            wasThrown?: boolean;
+            savedResultIndex?: number;
+        };
+        setOverlayMessage(params: SetOverlayMessageMethodArguments): void;
+    }
+    class DebuggerFrontend {
+        globalObjectCleared(): void;
+        scriptParsed(scriptId: ScriptId, url: string, startLine: number, startColumn: number, endLine: number, endColumn: number, isContentScript?: boolean, sourceURL?: string, sourceMapURL?: string): void;
+        scriptFailedToParse(url: string, scriptSource: string, startLine: number, errorLine: number, errorMessage: string): void;
+        breakpointResolved(breakpointId: BreakpointId, location: Location): void;
+        paused(callFrames: CallFrame[], reason: any, data?: Object): void;
+        resumed(): void;
+        didSampleProbe(sample: ProbeSample): void;
+        playBreakpointActionSound(breakpointActionId: BreakpointActionIdentifier): void;
+    }
+}
+export declare namespace RuntimeDomain {
+    type RemoteObjectId = string;
+    type ExecutionContextId = number;
+    interface RemoteObject {
+        type: any;
+        subtype?: any;
+        className?: string;
+        value?: any;
+        description?: string;
+        objectId?: RemoteObjectId;
+        size?: number;
+        classPrototype?: RemoteObject;
+        preview?: ObjectPreview;
+    }
+    interface ObjectPreview {
+        type: any;
+        subtype?: any;
+        description?: string;
+        lossless: boolean;
+        overflow?: boolean;
+        properties?: PropertyPreview[];
+        entries?: EntryPreview[];
+        size?: number;
+    }
+    interface PropertyPreview {
+        name: string;
+        type: any;
+        subtype?: any;
+        value?: string;
+        valuePreview?: ObjectPreview;
+        internal?: boolean;
+    }
+    interface EntryPreview {
+        key?: ObjectPreview;
+        value: ObjectPreview;
+    }
+    interface CollectionEntry {
+        key?: RemoteObject;
+        value: RemoteObject;
+    }
+    interface PropertyDescriptor {
+        name: string;
+        value?: RemoteObject;
+        writable?: boolean;
+        get?: RemoteObject;
+        set?: RemoteObject;
+        configurable: boolean;
+        enumerable: boolean;
+        wasThrown?: boolean;
+        isOwn?: boolean;
+        symbol?: RemoteObject;
+        nativeGetter?: boolean;
+    }
+    interface InternalPropertyDescriptor {
+        name: string;
+        value?: RemoteObject;
+    }
+    interface CallArgument {
+        value?: any;
+        objectId?: RemoteObjectId;
+    }
+    interface ExecutionContextDescription {
+        id: ExecutionContextId;
+        isPageContext: boolean;
+        name: string;
+        frameId: NetworkDomain.FrameId;
+    }
+    interface ErrorRange {
+        startOffset: number;
+        endOffset: number;
+    }
+    interface StructureDescription {
+        fields?: string[];
+        optionalFields?: string[];
+        constructorName?: string;
+        prototypeStructure?: StructureDescription;
+        isImprecise?: boolean;
+    }
+    interface TypeSet {
+        isFunction: boolean;
+        isUndefined: boolean;
+        isNull: boolean;
+        isBoolean: boolean;
+        isInteger: boolean;
+        isNumber: boolean;
+        isString: boolean;
+        isObject: boolean;
+        isSymbol: boolean;
+    }
+    interface TypeDescription {
+        isValid: boolean;
+        leastCommonAncestor?: string;
+        typeSet?: TypeSet;
+        structures?: StructureDescription[];
+        isTruncated?: boolean;
+    }
+    interface TypeLocation {
+        typeInformationDescriptor: number;
+        sourceID: string;
+        divot: number;
+    }
+    interface BasicBlock {
+        startOffset: number;
+        endOffset: number;
+        hasExecuted: boolean;
+        executionCount: number;
+    }
+    const enum SyntaxErrorType {
+        None = 0,
+        Irrecoverable = 1,
+        UnterminatedLiteral = 2,
+        Recoverable = 3
+    }
+    interface ParseMethodArguments {
+        source: string;
+    }
+    interface EvaluateMethodArguments {
+        expression: string;
+        objectGroup?: string;
+        includeCommandLineAPI?: boolean;
+        doNotPauseOnExceptionsAndMuteConsole?: boolean;
+        contextId?: ExecutionContextId;
+        returnByValue?: boolean;
+        generatePreview?: boolean;
+        saveResult?: boolean;
+    }
+    interface CallFunctionOnMethodArguments {
+        objectId: RemoteObjectId;
+        functionDeclaration: string;
+        arguments?: CallArgument[];
+        doNotPauseOnExceptionsAndMuteConsole?: boolean;
+        returnByValue?: boolean;
+        generatePreview?: boolean;
+    }
+    interface GetPropertiesMethodArguments {
+        objectId: RemoteObjectId;
+        ownProperties?: boolean;
+        generatePreview?: boolean;
+    }
+    interface GetDisplayablePropertiesMethodArguments {
+        objectId: RemoteObjectId;
+        generatePreview?: boolean;
+    }
+    interface GetCollectionEntriesMethodArguments {
+        objectId: RemoteObjectId;
+        objectGroup?: string;
+        startIndex?: number;
+        numberToFetch?: number;
+    }
+    interface SaveResultMethodArguments {
+        value: CallArgument;
+        contextId?: ExecutionContextId;
+    }
+    interface ReleaseObjectMethodArguments {
+        objectId: RemoteObjectId;
+    }
+    interface ReleaseObjectGroupMethodArguments {
+        objectGroup: string;
+    }
+    interface GetRuntimeTypesForVariablesAtOffsetsMethodArguments {
+        locations: TypeLocation[];
+    }
+    interface GetBasicBlocksMethodArguments {
+        sourceID: string;
+    }
+    interface RuntimeDomainDispatcher {
+        parse(params: ParseMethodArguments): {
+            result: SyntaxErrorType;
+            message?: string;
+            range?: ErrorRange;
+        };
+        evaluate(params: EvaluateMethodArguments): {
+            result: RemoteObject;
+            wasThrown?: boolean;
+            savedResultIndex?: number;
+        };
+        callFunctionOn(params: CallFunctionOnMethodArguments): {
+            result: RemoteObject;
+            wasThrown?: boolean;
+        };
+        getProperties(params: GetPropertiesMethodArguments): {
+            result: PropertyDescriptor[];
+            internalProperties?: InternalPropertyDescriptor[];
+        };
+        getDisplayableProperties(params: GetDisplayablePropertiesMethodArguments): {
+            properties: PropertyDescriptor[];
+            internalProperties?: InternalPropertyDescriptor[];
+        };
+        getCollectionEntries(params: GetCollectionEntriesMethodArguments): {
+            entries: CollectionEntry[];
+        };
+        saveResult(params: SaveResultMethodArguments): {
+            savedResultIndex?: number;
+        };
+        releaseObject(params: ReleaseObjectMethodArguments): void;
+        releaseObjectGroup(params: ReleaseObjectGroupMethodArguments): void;
+        enable(): void;
+        disable(): void;
+        getRuntimeTypesForVariablesAtOffsets(params: GetRuntimeTypesForVariablesAtOffsetsMethodArguments): {
+            types: TypeDescription[];
+        };
+        enableTypeProfiler(): void;
+        disableTypeProfiler(): void;
+        enableControlFlowProfiler(): void;
+        disableControlFlowProfiler(): void;
+        getBasicBlocks(params: GetBasicBlocksMethodArguments): {
+            basicBlocks: BasicBlock[];
+        };
+    }
+    class RuntimeFrontend {
+        executionContextCreated(context: ExecutionContextDescription): void;
+    }
+}
+export declare namespace ConsoleDomain {
+    interface ConsoleMessage {
+        source: any;
+        level: any;
+        text: string;
+        type?: any;
+        url?: string;
+        line?: number;
+        column?: number;
+        repeatCount?: number;
+        parameters?: RuntimeDomain.RemoteObject[];
+        stackTrace?: CallFrame[];
+        networkRequestId?: NetworkDomain.RequestId;
+    }
+    interface CallFrame {
+        functionName: string;
+        url: string;
+        scriptId: DebuggerDomain.ScriptId;
+        lineNumber: number;
+        columnNumber: number;
+    }
+    interface SetMonitoringXHREnabledMethodArguments {
+        enabled: boolean;
+    }
+    interface AddInspectedNodeMethodArguments {
+        nodeId: DOMDomain.NodeId;
+    }
+    interface ConsoleDomainDispatcher {
+        enable(): void;
+        disable(): void;
+        clearMessages(): void;
+        setMonitoringXHREnabled(params: SetMonitoringXHREnabledMethodArguments): void;
+        addInspectedNode(params: AddInspectedNodeMethodArguments): void;
+    }
+    class ConsoleFrontend {
+        messageAdded(message: ConsoleMessage): void;
+        messageRepeatCountUpdated(count: number): void;
+        messagesCleared(): void;
+        heapSnapshot(timestamp: number, snapshotData: HeapDomain.HeapSnapshotData, title?: string): void;
+    }
+}
+export declare namespace GenericTypesDomain {
+    interface SearchMatch {
+        lineNumber: number;
+        lineContent: string;
+    }
+}
+export declare namespace PageDomain {
+    type ScriptIdentifier = string;
+    interface Frame {
+        id: string;
+        parentId?: string;
+        loaderId: NetworkDomain.LoaderId;
+        name?: string;
+        url: string;
+        securityOrigin: string;
+        mimeType: string;
+    }
+    interface FrameResource {
+        url: string;
+        type: ResourceType;
+        mimeType: string;
+        failed?: boolean;
+        canceled?: boolean;
+        sourceMapURL?: string;
+    }
+    interface FrameResourceTree {
+        frame: Frame;
+        childFrames?: FrameResourceTree[];
+        resources: FrameResource[];
+    }
+    interface SearchResult {
+        url: string;
+        frameId: NetworkDomain.FrameId;
+        matchesCount: number;
+        requestId?: NetworkDomain.RequestId;
+    }
+    interface Cookie {
+        name: string;
+        value: string;
+        domain: string;
+        path: string;
+        expires: number;
+        size: number;
+        httpOnly: boolean;
+        secure: boolean;
+        session: boolean;
+    }
+    const enum ResourceType {
+        Document = 0,
+        Stylesheet = 1,
+        Image = 2,
+        Font = 3,
+        Script = 4,
+        XHR = 5,
+        WebSocket = 6,
+        Other = 7
+    }
+    const enum CoordinateSystem {
+        Viewport = 0,
+        Page = 1
+    }
+    interface AddScriptToEvaluateOnLoadMethodArguments {
+        scriptSource: string;
+    }
+    interface RemoveScriptToEvaluateOnLoadMethodArguments {
+        identifier: ScriptIdentifier;
+    }
+    interface ReloadMethodArguments {
+        ignoreCache?: boolean;
+        scriptToEvaluateOnLoad?: string;
+    }
+    interface NavigateMethodArguments {
+        url: string;
+    }
+    interface DeleteCookieMethodArguments {
+        cookieName: string;
+        url: string;
+    }
+    interface GetResourceContentMethodArguments {
+        frameId: NetworkDomain.FrameId;
+        url: string;
+    }
+    interface SearchInResourceMethodArguments {
+        frameId: NetworkDomain.FrameId;
+        url: string;
+        query: string;
+        caseSensitive?: boolean;
+        isRegex?: boolean;
+        requestId?: NetworkDomain.RequestId;
+    }
+    interface SearchInResourcesMethodArguments {
+        text: string;
+        caseSensitive?: boolean;
+        isRegex?: boolean;
+    }
+    interface SetDocumentContentMethodArguments {
+        frameId: NetworkDomain.FrameId;
+        html: string;
+    }
+    interface SetShowPaintRectsMethodArguments {
+        result: boolean;
+    }
+    interface SetScriptExecutionDisabledMethodArguments {
+        value: boolean;
+    }
+    interface SetTouchEmulationEnabledMethodArguments {
+        enabled: boolean;
+    }
+    interface SetEmulatedMediaMethodArguments {
+        media: string;
+    }
+    interface SetCompositingBordersVisibleMethodArguments {
+        visible: boolean;
+    }
+    interface SnapshotNodeMethodArguments {
+        nodeId: DOMDomain.NodeId;
+    }
+    interface SnapshotRectMethodArguments {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        coordinateSystem: CoordinateSystem;
+    }
+    interface HandleJavaScriptDialogMethodArguments {
+        accept: boolean;
+        promptText?: string;
+    }
+    interface PageDomainDispatcher {
+        enable(): void;
+        disable(): void;
+        addScriptToEvaluateOnLoad(params: AddScriptToEvaluateOnLoadMethodArguments): {
+            identifier: ScriptIdentifier;
+        };
+        removeScriptToEvaluateOnLoad(params: RemoveScriptToEvaluateOnLoadMethodArguments): void;
+        reload(params: ReloadMethodArguments): void;
+        navigate(params: NavigateMethodArguments): void;
+        getCookies(): {
+            cookies: Cookie[];
+        };
+        deleteCookie(params: DeleteCookieMethodArguments): void;
+        getResourceTree(): {
+            frameTree: FrameResourceTree;
+        };
+        getResourceContent(params: GetResourceContentMethodArguments): {
+            content: string;
+            base64Encoded: boolean;
+        };
+        searchInResource(params: SearchInResourceMethodArguments): {
+            result: GenericTypesDomain.SearchMatch[];
+        };
+        searchInResources(params: SearchInResourcesMethodArguments): {
+            result: SearchResult[];
+        };
+        setDocumentContent(params: SetDocumentContentMethodArguments): void;
+        setShowPaintRects(params: SetShowPaintRectsMethodArguments): void;
+        getScriptExecutionStatus(): {
+            result: any;
+        };
+        setScriptExecutionDisabled(params: SetScriptExecutionDisabledMethodArguments): void;
+        setTouchEmulationEnabled(params: SetTouchEmulationEnabledMethodArguments): void;
+        setEmulatedMedia(params: SetEmulatedMediaMethodArguments): void;
+        getCompositingBordersVisible(): {
+            result: boolean;
+        };
+        setCompositingBordersVisible(params: SetCompositingBordersVisibleMethodArguments): void;
+        snapshotNode(params: SnapshotNodeMethodArguments): {
+            dataURL: string;
+        };
+        snapshotRect(params: SnapshotRectMethodArguments): {
+            dataURL: string;
+        };
+        handleJavaScriptDialog(params: HandleJavaScriptDialogMethodArguments): void;
+        archive(): {
+            data: string;
+        };
+    }
+    class PageFrontend {
+        domContentEventFired(timestamp: number): void;
+        loadEventFired(timestamp: number): void;
+        frameNavigated(frame: Frame): void;
+        frameDetached(frameId: NetworkDomain.FrameId): void;
+        frameStartedLoading(frameId: NetworkDomain.FrameId): void;
+        frameStoppedLoading(frameId: NetworkDomain.FrameId): void;
+        frameScheduledNavigation(frameId: NetworkDomain.FrameId, delay: number): void;
+        frameClearedScheduledNavigation(frameId: NetworkDomain.FrameId): void;
+        javascriptDialogOpening(message: string): void;
+        javascriptDialogClosed(): void;
+        scriptsEnabled(isEnabled: boolean): void;
+    }
+}
+export declare namespace NetworkDomain {
+    type LoaderId = string;
+    type FrameId = string;
+    type RequestId = string;
+    type Timestamp = number;
+    interface Headers {
+    }
+    interface ResourceTiming {
+        startTime: number;
+        domainLookupStart: number;
+        domainLookupEnd: number;
+        connectStart: number;
+        connectEnd: number;
+        secureConnectionStart: number;
+        requestStart: number;
+        responseStart: number;
+    }
+    interface Request {
+        url: string;
+        method: string;
+        headers: Headers;
+        postData?: string;
+    }
+    interface Response {
+        url: string;
+        status: number;
+        statusText: string;
+        headers: Headers;
+        headersText?: string;
+        mimeType: string;
+        requestHeaders?: Headers;
+        requestHeadersText?: string;
+        fromDiskCache?: boolean;
+        timing?: ResourceTiming;
+    }
+    interface WebSocketRequest {
+        headers: Headers;
+    }
+    interface WebSocketResponse {
+        status: number;
+        statusText: string;
+        headers: Headers;
+    }
+    interface WebSocketFrame {
+        opcode: number;
+        mask: boolean;
+        payloadData: string;
+    }
+    interface CachedResource {
+        url: string;
+        type: PageDomain.ResourceType;
+        response?: Response;
+        bodySize: number;
+        sourceMapURL?: string;
+    }
+    interface Initiator {
+        type: any;
+        stackTrace?: ConsoleDomain.CallFrame[];
+        url?: string;
+        lineNumber?: number;
+    }
+    interface SetExtraHTTPHeadersMethodArguments {
+        headers: Headers;
+    }
+    interface GetResponseBodyMethodArguments {
+        requestId: RequestId;
+    }
+    interface SetCacheDisabledMethodArguments {
+        cacheDisabled: boolean;
+    }
+    interface LoadResourceMethodArguments {
+        frameId: FrameId;
+        url: string;
+    }
+    interface NetworkDomainDispatcher {
+        enable(): void;
+        disable(): void;
+        setExtraHTTPHeaders(params: SetExtraHTTPHeadersMethodArguments): void;
+        getResponseBody(params: GetResponseBodyMethodArguments): {
+            body: string;
+            base64Encoded: boolean;
+        };
+        setCacheDisabled(params: SetCacheDisabledMethodArguments): void;
+        loadResource(params: LoadResourceMethodArguments): {
+            content: string;
+            mimeType: string;
+            status: number;
+        };
+    }
+    class NetworkFrontend {
+        requestWillBeSent(requestId: RequestId, frameId: FrameId, loaderId: LoaderId, documentURL: string, request: Request, timestamp: Timestamp, initiator: Initiator, redirectResponse?: Response, type?: PageDomain.ResourceType): void;
+        requestServedFromCache(requestId: RequestId): void;
+        responseReceived(requestId: RequestId, frameId: FrameId, loaderId: LoaderId, timestamp: Timestamp, type: PageDomain.ResourceType, response: Response): void;
+        dataReceived(requestId: RequestId, timestamp: Timestamp, dataLength: number, encodedDataLength: number): void;
+        loadingFinished(requestId: RequestId, timestamp: Timestamp, sourceMapURL?: string): void;
+        loadingFailed(requestId: RequestId, timestamp: Timestamp, errorText: string, canceled?: boolean): void;
+        requestServedFromMemoryCache(requestId: RequestId, frameId: FrameId, loaderId: LoaderId, documentURL: string, timestamp: Timestamp, initiator: Initiator, resource: CachedResource): void;
+        webSocketWillSendHandshakeRequest(requestId: RequestId, timestamp: Timestamp, request: WebSocketRequest): void;
+        webSocketHandshakeResponseReceived(requestId: RequestId, timestamp: Timestamp, response: WebSocketResponse): void;
+        webSocketCreated(requestId: RequestId, url: string): void;
+        webSocketClosed(requestId: RequestId, timestamp: Timestamp): void;
+        webSocketFrameReceived(requestId: RequestId, timestamp: Timestamp, response: WebSocketFrame): void;
+        webSocketFrameError(requestId: RequestId, timestamp: Timestamp, errorMessage: string): void;
+        webSocketFrameSent(requestId: RequestId, timestamp: Timestamp, response: WebSocketFrame): void;
+    }
+}
+export declare namespace DOMDomain {
+    type NodeId = number;
+    type BackendNodeId = number;
+    interface Node {
+        nodeId: NodeId;
+        nodeType: number;
+        nodeName: string;
+        localName: string;
+        nodeValue: string;
+        childNodeCount?: number;
+        children?: Node[];
+        attributes?: string[];
+        documentURL?: string;
+        baseURL?: string;
+        publicId?: string;
+        systemId?: string;
+        xmlVersion?: string;
+        name?: string;
+        value?: string;
+        pseudoType?: PseudoType;
+        shadowRootType?: ShadowRootType;
+        frameId?: NetworkDomain.FrameId;
+        contentDocument?: Node;
+        shadowRoots?: Node[];
+        templateContent?: Node;
+        pseudoElements?: Node[];
+        role?: string;
+        contentSecurityPolicyHash?: string;
+    }
+    interface RGBAColor {
+        r: number;
+        g: number;
+        b: number;
+        a?: number;
+    }
+    interface HighlightConfig {
+        showInfo?: boolean;
+        contentColor?: RGBAColor;
+        paddingColor?: RGBAColor;
+        borderColor?: RGBAColor;
+        marginColor?: RGBAColor;
+    }
+    const enum PseudoType {
+        Before = 0,
+        After = 1
+    }
+    const enum ShadowRootType {
+        UserAgent = 0,
+        Open = 1,
+        Closed = 2
+    }
+    const enum LiveRegionRelevant {
+        Additions = 0,
+        Removals = 1,
+        Text = 2
+    }
+    interface RemoveNodeMethodArguments {
+        nodeId: NodeId;
+    }
+    interface SetAttributeValueMethodArguments {
+        nodeId: NodeId;
+        name: string;
+        value: string;
+    }
+    interface SetAttributesAsTextMethodArguments {
+        nodeId: NodeId;
+        text: string;
+        name?: string;
+    }
+    interface RemoveAttributeMethodArguments {
+        nodeId: NodeId;
+        name: string;
+    }
+    interface PerformSearchMethodArguments {
+        query: string;
+        nodeIds?: NodeId[];
+    }
+    interface GetSearchResultsMethodArguments {
+        searchId: string;
+        fromIndex: number;
+        toIndex: number;
+    }
+    interface DiscardSearchResultsMethodArguments {
+        searchId: string;
+    }
+    interface HighlightNodeMethodArguments {
+        highlightConfig: HighlightConfig;
+        nodeId?: NodeId;
+        objectId?: RuntimeDomain.RemoteObjectId;
+    }
+    interface ResolveNodeMethodArguments {
+        nodeId: NodeId;
+        objectGroup?: string;
+    }
+    interface DOMDomainDispatcher {
+        enable(): void;
+        disable(): void;
+        getDocument(): {
+            root: Node;
+        };
+        removeNode(params: RemoveNodeMethodArguments): void;
+        setAttributeValue(params: SetAttributeValueMethodArguments): void;
+        setAttributesAsText(params: SetAttributesAsTextMethodArguments): void;
+        removeAttribute(params: RemoveAttributeMethodArguments): void;
+        performSearch(params: PerformSearchMethodArguments): {
+            searchId: string;
+            resultCount: number;
+        };
+        getSearchResults(params: GetSearchResultsMethodArguments): {
+            nodeIds: NodeId[];
+        };
+        discardSearchResults(params: DiscardSearchResultsMethodArguments): void;
+        highlightNode(params: HighlightNodeMethodArguments): void;
+        hideHighlight(): void;
+        resolveNode(params: ResolveNodeMethodArguments): {
+            object: RuntimeDomain.RemoteObject;
+        };
+    }
+    class DOMFrontend {
+        documentUpdated(): void;
+        setChildNodes(parentId: NodeId, nodes: Node[]): void;
+        attributeModified(nodeId: NodeId, name: string, value: string): void;
+        attributeRemoved(nodeId: NodeId, name: string): void;
+        inlineStyleInvalidated(nodeIds: NodeId[]): void;
+        characterDataModified(nodeId: NodeId, characterData: string): void;
+        childNodeCountUpdated(nodeId: NodeId, childNodeCount: number): void;
+        childNodeInserted(parentNodeId: NodeId, previousNodeId: NodeId, node: Node): void;
+        childNodeRemoved(parentNodeId: NodeId, nodeId: NodeId): void;
+        shadowRootPushed(hostId: NodeId, root: Node): void;
+        shadowRootPopped(hostId: NodeId, rootId: NodeId): void;
+        pseudoElementAdded(parentId: NodeId, pseudoElement: Node): void;
+        pseudoElementRemoved(parentId: NodeId, pseudoElementId: NodeId): void;
+    }
+}
+export declare namespace CSSDomain {
+    type StyleSheetId = string;
+    interface PseudoElementMatches {
+        pseudoType: DOMDomain.PseudoType;
+        matches: RuleMatch[];
+    }
+    interface InheritedStyleEntry {
+        inlineStyle?: CSSStyle;
+        matchedCSSRules: RuleMatch[];
+    }
+    interface RuleMatch {
+        rule: CSSRule;
+        matchingSelectors: number[];
+    }
+    interface Value {
+        text: string;
+        range?: SourceRange;
+    }
+    interface SelectorList {
+        selectors: Value[];
+        text: string;
+    }
+    interface CSSStyleSheetHeader {
+        styleSheetId: StyleSheetId;
+        frameId: string;
+        sourceURL: string;
+        sourceMapURL?: string;
+        origin: StyleSheetOrigin;
+        title: string;
+        ownerNode?: DOMDomain.BackendNodeId;
+        disabled: boolean;
+        hasSourceURL?: boolean;
+        isInline: boolean;
+        startLine: number;
+        startColumn: number;
+    }
+    interface CSSRule {
+        styleSheetId?: StyleSheetId;
+        selectorList: SelectorList;
+        origin: StyleSheetOrigin;
+        style: CSSStyle;
+        media?: CSSMedia[];
+    }
+    interface SourceRange {
+        startLine: number;
+        startColumn: number;
+        endLine: number;
+        endColumn: number;
+    }
+    interface ShorthandEntry {
+        name: string;
+        value: string;
+        important?: boolean;
+    }
+    interface CSSComputedStyleProperty {
+        name: string;
+        value: string;
+    }
+    interface CSSStyle {
+        styleSheetId?: StyleSheetId;
+        cssProperties: CSSProperty[];
+        shorthandEntries: ShorthandEntry[];
+        cssText?: string;
+        range?: SourceRange;
+    }
+    interface CSSProperty {
+        name: string;
+        value: string;
+        important?: boolean;
+        implicit?: boolean;
+        text?: string;
+        parsedOk?: boolean;
+        disabled?: boolean;
+        range?: SourceRange;
+    }
+    interface CSSMedia {
+        text: string;
+        source: any;
+        sourceURL?: string;
+        range?: SourceRange;
+        styleSheetId?: StyleSheetId;
+        mediaList?: MediaQuery[];
+    }
+    interface MediaQuery {
+        expressions: MediaQueryExpression[];
+        active: boolean;
+    }
+    interface MediaQueryExpression {
+        value: number;
+        unit: string;
+        feature: string;
+        valueRange?: SourceRange;
+        computedLength?: number;
+    }
+    interface PlatformFontUsage {
+        familyName: string;
+        isCustomFont: boolean;
+        glyphCount: number;
+    }
+    interface CSSKeyframesRule {
+        animationName: Value;
+        keyframes: CSSKeyframeRule[];
+    }
+    interface CSSKeyframeRule {
+        styleSheetId?: StyleSheetId;
+        origin: StyleSheetOrigin;
+        keyText: Value;
+        style: CSSStyle;
+    }
+    interface StyleDeclarationEdit {
+        styleSheetId: StyleSheetId;
+        range: SourceRange;
+        text: string;
+    }
+    const enum StyleSheetOrigin {
+        Injected = 0,
+        UserAgent = 1,
+        Inspector = 2,
+        Regular = 3
+    }
+    interface GetMatchedStylesForNodeMethodArguments {
+        nodeId: DOMDomain.NodeId;
+    }
+    interface GetInlineStylesForNodeMethodArguments {
+        nodeId: DOMDomain.NodeId;
+    }
+    interface GetComputedStyleForNodeMethodArguments {
+        nodeId: DOMDomain.NodeId;
+    }
+    interface GetPlatformFontsForNodeMethodArguments {
+        nodeId: DOMDomain.NodeId;
+    }
+    interface GetStyleSheetTextMethodArguments {
+        styleSheetId: StyleSheetId;
+    }
+    interface CSSDomainDispatcher {
+        enable(): void;
+        disable(): void;
+        getMatchedStylesForNode(params: GetMatchedStylesForNodeMethodArguments): {
+            inlineStyle?: CSSStyle;
+            attributesStyle?: CSSStyle;
+            matchedCSSRules?: RuleMatch[];
+            pseudoElements?: PseudoElementMatches[];
+            inherited?: InheritedStyleEntry[];
+            cssKeyframesRules?: CSSKeyframesRule[];
+        };
+        getInlineStylesForNode(params: GetInlineStylesForNodeMethodArguments): {
+            inlineStyle?: CSSStyle;
+            attributesStyle?: CSSStyle;
+        };
+        getComputedStyleForNode(params: GetComputedStyleForNodeMethodArguments): {
+            computedStyle: CSSComputedStyleProperty[];
+        };
+        getPlatformFontsForNode(params: GetPlatformFontsForNodeMethodArguments): {
+            fonts: PlatformFontUsage[];
+        };
+        getStyleSheetText(params: GetStyleSheetTextMethodArguments): {
+            text: string;
+        };
+    }
+    class CSSFrontend {
+        mediaQueryResultChanged(): void;
+        fontsUpdated(): void;
+        styleSheetChanged(styleSheetId: StyleSheetId): void;
+        styleSheetAdded(header: CSSStyleSheetHeader): void;
+        styleSheetRemoved(styleSheetId: StyleSheetId): void;
+        layoutEditorChange(styleSheetId: StyleSheetId, changeRange: SourceRange): void;
+    }
+}