devtools-tracing 1.2.0 → 1.2.2

package/dist/lib/front_end/core/sdk/NetworkRequest.d.ts

@@ -0,0 +1,424 @@
+import * as Protocol from '../../generated/protocol.js';
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+import * as Common from '../common/common.js';
+import * as Platform from '../platform/platform.js';
+import { Attribute, type Cookie } from './Cookie.js';
+import { ServerTiming } from './ServerTiming.js';
+export declare class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements TextUtils.ContentProvider.StreamingContentProvider {
+    #private;
+    statusCode: number;
+    statusText: string;
+    requestMethod: string;
+    requestTime: number;
+    protocol: string;
+    alternateProtocolUsage: Protocol.Network.AlternateProtocolUsage | undefined;
+    mixedContentType: Protocol.Security.MixedContentType;
+    connectionId: string;
+    connectionReused: boolean;
+    hasNetworkData: boolean;
+    localizedFailDescription: string | null;
+    responseReceivedPromise?: Promise<void>;
+    responseReceivedPromiseResolve?: () => void;
+    directSocketInfo?: DirectSocketInfo;
+    constructor(requestId: string, backendRequestId: Protocol.Network.RequestId | undefined, url: Platform.DevToolsPath.UrlString, documentURL: Platform.DevToolsPath.UrlString, frameId: Protocol.Page.FrameId | null, loaderId: Protocol.Network.LoaderId | null, initiator: Protocol.Network.Initiator | null, hasUserGesture?: boolean);
+    static create(backendRequestId: Protocol.Network.RequestId, url: Platform.DevToolsPath.UrlString, documentURL: Platform.DevToolsPath.UrlString, frameId: Protocol.Page.FrameId | null, loaderId: Protocol.Network.LoaderId | null, initiator: Protocol.Network.Initiator | null, hasUserGesture?: boolean): NetworkRequest;
+    static createForSocket(backendRequestId: Protocol.Network.RequestId, requestURL: Platform.DevToolsPath.UrlString, initiator?: Protocol.Network.Initiator): NetworkRequest;
+    static createWithoutBackendRequest(requestId: string, url: Platform.DevToolsPath.UrlString, documentURL: Platform.DevToolsPath.UrlString, initiator: Protocol.Network.Initiator | null): NetworkRequest;
+    identityCompare(other: NetworkRequest): number;
+    requestId(): string;
+    backendRequestId(): Protocol.Network.RequestId | undefined;
+    url(): Platform.DevToolsPath.UrlString;
+    isBlobRequest(): boolean;
+    setUrl(x: Platform.DevToolsPath.UrlString): void;
+    get documentURL(): Platform.DevToolsPath.UrlString;
+    get parsedURL(): Common.ParsedURL.ParsedURL;
+    get frameId(): Protocol.Page.FrameId | null;
+    get loaderId(): Protocol.Network.LoaderId | null;
+    get appliedNetworkConditionsId(): string | undefined;
+    setRemoteAddress(ip: string, port: number): void;
+    remoteAddress(): string;
+    remoteAddressSpace(): Protocol.Network.IPAddressSpace;
+    /**
+     * The cache #name of the CacheStorage from where the response is served via
+     * the ServiceWorker.
+     */
+    getResponseCacheStorageCacheName(): string | undefined;
+    setResponseCacheStorageCacheName(x: string): void;
+    serviceWorkerResponseSource(): Protocol.Network.ServiceWorkerResponseSource | undefined;
+    setServiceWorkerResponseSource(serviceWorkerResponseSource: Protocol.Network.ServiceWorkerResponseSource): void;
+    setReferrerPolicy(referrerPolicy: Protocol.Network.RequestReferrerPolicy): void;
+    referrerPolicy(): Protocol.Network.RequestReferrerPolicy | null;
+    securityState(): Protocol.Security.SecurityState;
+    setSecurityState(securityState: Protocol.Security.SecurityState): void;
+    securityDetails(): Protocol.Network.SecurityDetails | null;
+    securityOrigin(): string;
+    setSecurityDetails(securityDetails: Protocol.Network.SecurityDetails): void;
+    get startTime(): number;
+    setIssueTime(monotonicTime: number, wallTime: number): void;
+    issueTime(): number;
+    pseudoWallTime(monotonicTime: number): number;
+    get responseReceivedTime(): number;
+    set responseReceivedTime(x: number);
+    /**
+     * The time at which the returned response was generated. For cached
+     * responses, this is the last time the cache entry was validated.
+     */
+    getResponseRetrievalTime(): Date | undefined;
+    setResponseRetrievalTime(x: Date): void;
+    get endTime(): number;
+    set endTime(x: number);
+    get duration(): number;
+    get latency(): number;
+    get resourceSize(): number;
+    set resourceSize(x: number);
+    get transferSize(): number;
+    increaseTransferSize(x: number): void;
+    setTransferSize(x: number): void;
+    get finished(): boolean;
+    set finished(x: boolean);
+    get failed(): boolean;
+    set failed(x: boolean);
+    get canceled(): boolean;
+    set canceled(x: boolean);
+    get preserved(): boolean;
+    set preserved(x: boolean);
+    blockedReason(): Protocol.Network.BlockedReason | undefined;
+    setBlockedReason(reason: Protocol.Network.BlockedReason): void;
+    setRenderBlockingBehavior(renderBlocking: Protocol.Network.RenderBlockingBehavior): void;
+    renderBlockingBehavior(): Protocol.Network.RenderBlockingBehavior | undefined;
+    corsErrorStatus(): Protocol.Network.CorsErrorStatus | undefined;
+    setCorsErrorStatus(corsErrorStatus: Protocol.Network.CorsErrorStatus): void;
+    wasBlocked(): boolean;
+    cached(): boolean;
+    cachedInMemory(): boolean;
+    fromPrefetchCache(): boolean;
+    setFromMemoryCache(): void;
+    get fromDiskCache(): boolean | undefined;
+    setFromDiskCache(): void;
+    setFromPrefetchCache(): void;
+    fromEarlyHints(): boolean;
+    setFromEarlyHints(): void;
+    /**
+     * Returns true if the request was intercepted by a service worker and it
+     * provided its own response.
+     */
+    get fetchedViaServiceWorker(): boolean;
+    set fetchedViaServiceWorker(x: boolean);
+    get serviceWorkerRouterInfo(): Protocol.Network.ServiceWorkerRouterInfo | undefined;
+    set serviceWorkerRouterInfo(x: Protocol.Network.ServiceWorkerRouterInfo);
+    /**
+     * Returns true if the request was matched to a route when using the
+     * ServiceWorker static routing API.
+     */
+    hasMatchingServiceWorkerRouter(): boolean;
+    /**
+     * Returns true if the request was sent by a service worker.
+     */
+    initiatedByServiceWorker(): boolean;
+    get timing(): Protocol.Network.ResourceTiming | undefined;
+    set timing(timingInfo: Protocol.Network.ResourceTiming | undefined);
+    private setConnectTimingFromExtraInfo;
+    get mimeType(): string;
+    set mimeType(x: string);
+    get displayName(): string;
+    name(): string;
+    path(): string;
+    private parseNameAndPathFromURL;
+    get folder(): string;
+    get pathname(): string;
+    resourceType(): Common.ResourceType.ResourceType;
+    setResourceType(resourceType: Common.ResourceType.ResourceType): void;
+    get domain(): string;
+    get scheme(): string;
+    getInferredStatusText(): string;
+    redirectSource(): NetworkRequest | null;
+    setRedirectSource(originatingRequest: NetworkRequest | null): void;
+    preflightRequest(): NetworkRequest | null;
+    setPreflightRequest(preflightRequest: NetworkRequest | null): void;
+    preflightInitiatorRequest(): NetworkRequest | null;
+    setPreflightInitiatorRequest(preflightInitiatorRequest: NetworkRequest | null): void;
+    isPreflightRequest(): boolean;
+    redirectDestination(): NetworkRequest | null;
+    setRedirectDestination(redirectDestination: NetworkRequest | null): void;
+    requestHeaders(): NameValue[];
+    setRequestHeaders(headers: NameValue[]): void;
+    requestHeadersText(): string | undefined;
+    setRequestHeadersText(text: string): void;
+    requestHeaderValue(headerName: string): string | undefined;
+    requestFormData(): Promise<string | null>;
+    setRequestFormData(hasData: boolean, data: string | null): void;
+    private filteredProtocolName;
+    requestHttpVersion(): string;
+    get responseHeaders(): NameValue[];
+    set responseHeaders(x: NameValue[]);
+    get earlyHintsHeaders(): NameValue[];
+    set earlyHintsHeaders(x: NameValue[]);
+    get originalResponseHeaders(): Protocol.Fetch.HeaderEntry[];
+    set originalResponseHeaders(headers: Protocol.Fetch.HeaderEntry[]);
+    get setCookieHeaders(): Protocol.Fetch.HeaderEntry[];
+    set setCookieHeaders(headers: Protocol.Fetch.HeaderEntry[]);
+    get responseHeadersText(): string;
+    set responseHeadersText(x: string);
+    get sortedResponseHeaders(): NameValue[];
+    get sortedOriginalResponseHeaders(): NameValue[];
+    get overrideTypes(): OverrideType[];
+    get hasOverriddenContent(): boolean;
+    set hasOverriddenContent(value: boolean);
+    hasOverriddenHeaders(): boolean;
+    responseHeaderValue(headerName: string): string | undefined;
+    wasIntercepted(): boolean;
+    setWasIntercepted(wasIntercepted: boolean): void;
+    setEarlyHintsHeaders(headers: NameValue[]): void;
+    get responseCookies(): Cookie[];
+    set responseCookies(responseCookies: Cookie[]);
+    responseLastModified(): string | undefined;
+    allCookiesIncludingBlockedOnes(): Cookie[];
+    get serverTimings(): ServerTiming[] | null;
+    queryString(): string | null;
+    get queryParameters(): NameValue[] | null;
+    private parseFormParameters;
+    formParameters(): Promise<NameValue[] | null>;
+    responseHttpVersion(): string;
+    private parseParameters;
+    /**
+     * Parses multipart/form-data; boundary=boundaryString request bodies -
+     * --boundaryString
+     * Content-Disposition: form-data; #name="field-#name"; filename="r.gif"
+     * Content-Type: application/octet-stream
+     *
+     * optionalValue
+     * --boundaryString
+     * Content-Disposition: form-data; #name="field-#name-2"
+     *
+     * optionalValue2
+     * --boundaryString--
+     */
+    private parseMultipartFormDataParameters;
+    private computeHeaderValue;
+    requestContentData(): Promise<TextUtils.ContentData.ContentDataOrError>;
+    setContentDataProvider(dataProvider: () => Promise<TextUtils.ContentData.ContentDataOrError>): void;
+    requestStreamingContent(): Promise<TextUtils.StreamingContentData.StreamingContentDataOrError>;
+    contentURL(): Platform.DevToolsPath.UrlString;
+    contentType(): Common.ResourceType.ResourceType;
+    searchInContent(query: string, caseSensitive: boolean, isRegex: boolean): Promise<TextUtils.ContentProvider.SearchMatch[]>;
+    requestContentType(): string | undefined;
+    requestContentEncoding(): string | undefined;
+    hasErrorStatusCode(): boolean;
+    setInitialPriority(priority: Protocol.Network.ResourcePriority): void;
+    initialPriority(): Protocol.Network.ResourcePriority | null;
+    setPriority(priority: Protocol.Network.ResourcePriority): void;
+    priority(): Protocol.Network.ResourcePriority | null;
+    setSignedExchangeInfo(info: Protocol.Network.SignedExchangeInfo): void;
+    signedExchangeInfo(): Protocol.Network.SignedExchangeInfo | null;
+    populateImageSource(image: HTMLImageElement): Promise<void>;
+    initiator(): Protocol.Network.Initiator | null;
+    hasUserGesture(): boolean | null;
+    frames(): WebSocketFrame[];
+    addProtocolFrameError(errorMessage: string, time: number): void;
+    addProtocolFrame(response: Protocol.Network.WebSocketFrame, time: number, sent: boolean): void;
+    addFrame(frame: WebSocketFrame): void;
+    directSocketChunks(): DirectSocketChunk[];
+    addDirectSocketChunk(chunk: DirectSocketChunk): void;
+    eventSourceMessages(): readonly EventSourceMessage[];
+    addEventSourceMessage(time: number, eventName: string, eventId: string, data: string): void;
+    markAsRedirect(redirectCount: number): void;
+    isRedirect(): boolean;
+    setRequestIdForTest(requestId: Protocol.Network.RequestId): void;
+    charset(): string | null;
+    setCharset(charset: string): void;
+    addExtraRequestInfo(extraRequestInfo: ExtraRequestInfo): void;
+    setAppliedNetworkConditions(appliedNetworkConditionsId: string): void;
+    getDeviceBoundSessionUsages(): Protocol.Network.DeviceBoundSessionWithUsage[];
+    hasExtraRequestInfo(): boolean;
+    blockedRequestCookies(): BlockedCookieWithReason[];
+    setIncludedRequestCookies(includedRequestCookies: IncludedCookieWithReason[]): void;
+    includedRequestCookies(): IncludedCookieWithReason[];
+    hasRequestCookies(): boolean;
+    siteHasCookieInOtherPartition(): boolean;
+    static parseStatusTextFromResponseHeadersText(responseHeadersText: string): string;
+    addExtraResponseInfo(extraResponseInfo: ExtraResponseInfo): void;
+    hasExtraResponseInfo(): boolean;
+    blockedResponseCookies(): BlockedSetCookieWithReason[];
+    exemptedResponseCookies(): ExemptedSetCookieWithReason[];
+    nonBlockedResponseCookies(): Cookie[];
+    responseCookiesPartitionKey(): Protocol.Network.CookiePartitionKey | null;
+    responseCookiesPartitionKeyOpaque(): boolean | null;
+    redirectSourceSignedExchangeInfoHasNoErrors(): boolean;
+    clientSecurityState(): Protocol.Network.ClientSecurityState | undefined;
+    setTrustTokenParams(trustTokenParams: Protocol.Network.TrustTokenParams): void;
+    trustTokenParams(): Protocol.Network.TrustTokenParams | undefined;
+    setTrustTokenOperationDoneEvent(doneEvent: Protocol.Network.TrustTokenOperationDoneEvent): void;
+    trustTokenOperationDoneEvent(): Protocol.Network.TrustTokenOperationDoneEvent | undefined;
+    setIsSameSite(isSameSite: boolean): void;
+    isSameSite(): boolean | null;
+    setIsAdRelated(isAdRelated: boolean): void;
+    isAdRelated(): boolean;
+    getAssociatedData(key: string): object | null;
+    setAssociatedData(key: string, data: object): void;
+    deleteAssociatedData(key: string): void;
+    hasThirdPartyCookiePhaseoutIssue(): boolean;
+    addDataReceivedEvent({ timestamp, dataLength, encodedDataLength, data, }: Protocol.Network.DataReceivedEvent): void;
+    waitForResponseReceived(): Promise<void>;
+}
+export declare enum Events {
+    FINISHED_LOADING = "FinishedLoading",
+    TIMING_CHANGED = "TimingChanged",
+    REMOTE_ADDRESS_CHANGED = "RemoteAddressChanged",
+    REQUEST_HEADERS_CHANGED = "RequestHeadersChanged",
+    RESPONSE_HEADERS_CHANGED = "ResponseHeadersChanged",
+    WEBSOCKET_FRAME_ADDED = "WebsocketFrameAdded",
+    DIRECTSOCKET_CHUNK_ADDED = "DirectsocketChunkAdded",
+    EVENT_SOURCE_MESSAGE_ADDED = "EventSourceMessageAdded",
+    TRUST_TOKEN_RESULT_ADDED = "TrustTokenResultAdded"
+}
+export interface EventTypes {
+    [Events.FINISHED_LOADING]: NetworkRequest;
+    [Events.TIMING_CHANGED]: NetworkRequest;
+    [Events.REMOTE_ADDRESS_CHANGED]: NetworkRequest;
+    [Events.REQUEST_HEADERS_CHANGED]: void;
+    [Events.RESPONSE_HEADERS_CHANGED]: void;
+    [Events.WEBSOCKET_FRAME_ADDED]: WebSocketFrame;
+    [Events.DIRECTSOCKET_CHUNK_ADDED]: DirectSocketChunk;
+    [Events.DIRECTSOCKET_CHUNK_ADDED]: DirectSocketChunk;
+    [Events.EVENT_SOURCE_MESSAGE_ADDED]: EventSourceMessage;
+    [Events.TRUST_TOKEN_RESULT_ADDED]: void;
+}
+export declare const enum InitiatorType {
+    OTHER = "other",
+    PARSER = "parser",
+    REDIRECT = "redirect",
+    SCRIPT = "script",
+    PRELOAD = "preload",
+    SIGNED_EXCHANGE = "signedExchange",
+    PREFLIGHT = "preflight"
+}
+export declare enum WebSocketFrameType {
+    Send = "send",
+    Receive = "receive",
+    Error = "error"
+}
+export declare const cookieExemptionReasonToUiString: (exemptionReason: Protocol.Network.CookieExemptionReason) => string;
+export declare const cookieBlockedReasonToUiString: (blockedReason: Protocol.Network.CookieBlockedReason) => string;
+export declare const setCookieBlockedReasonToUiString: (blockedReason: Protocol.Network.SetCookieBlockedReason) => string;
+export declare const cookieBlockedReasonToAttribute: (blockedReason: Protocol.Network.CookieBlockedReason) => Attribute | null;
+export declare const setCookieBlockedReasonToAttribute: (blockedReason: Protocol.Network.SetCookieBlockedReason) => Attribute | null;
+export interface NameValue {
+    name: string;
+    value: string;
+}
+export interface WebSocketFrame {
+    type: WebSocketFrameType;
+    time: number;
+    text: string;
+    opCode: number;
+    mask: boolean;
+}
+export interface BlockedSetCookieWithReason {
+    blockedReasons: Protocol.Network.SetCookieBlockedReason[];
+    cookieLine: string;
+    cookie: Cookie | null;
+}
+export interface BlockedCookieWithReason {
+    cookie: Cookie;
+    blockedReasons: Protocol.Network.CookieBlockedReason[];
+}
+export interface IncludedCookieWithReason {
+    cookie: Cookie;
+    exemptionReason?: Protocol.Network.CookieExemptionReason;
+}
+export interface ExemptedSetCookieWithReason {
+    cookie: Cookie;
+    cookieLine: string;
+    exemptionReason: Protocol.Network.CookieExemptionReason;
+}
+export interface EventSourceMessage {
+    time: number;
+    eventName: string;
+    eventId: string;
+    data: string;
+}
+export interface ExtraRequestInfo {
+    blockedRequestCookies: Array<{
+        blockedReasons: Protocol.Network.CookieBlockedReason[];
+        cookie: Cookie;
+    }>;
+    requestHeaders: NameValue[];
+    includedRequestCookies: IncludedCookieWithReason[];
+    deviceBoundSessionUsages?: Protocol.Network.DeviceBoundSessionWithUsage[];
+    clientSecurityState?: Protocol.Network.ClientSecurityState;
+    connectTiming: Protocol.Network.ConnectTiming;
+    siteHasCookieInOtherPartition?: boolean;
+    appliedNetworkConditionsId?: string;
+}
+export interface ExtraResponseInfo {
+    blockedResponseCookies: Array<{
+        blockedReasons: Protocol.Network.SetCookieBlockedReason[];
+        cookieLine: string;
+        cookie: Cookie | null;
+    }>;
+    responseHeaders: NameValue[];
+    responseHeadersText?: string;
+    resourceIPAddressSpace: Protocol.Network.IPAddressSpace;
+    statusCode: number | undefined;
+    cookiePartitionKey?: Protocol.Network.CookiePartitionKey;
+    cookiePartitionKeyOpaque: boolean | undefined;
+    exemptedResponseCookies: Array<{
+        cookie: Cookie;
+        cookieLine: string;
+        exemptionReason: Protocol.Network.CookieExemptionReason;
+    }> | undefined;
+}
+export interface EarlyHintsInfo {
+    responseHeaders: NameValue[];
+}
+export type OverrideType = 'content' | 'headers';
+export declare enum DirectSocketType {
+    TCP = 1,
+    UDP_BOUND = 2,
+    UDP_CONNECTED = 3
+}
+export declare enum DirectSocketStatus {
+    OPENING = 1,
+    OPEN = 2,
+    CLOSED = 3,
+    ABORTED = 4
+}
+export interface DirectSocketCreateOptions {
+    remoteAddr?: string;
+    remotePort?: number;
+    localAddr?: string;
+    localPort?: number;
+    noDelay?: boolean;
+    keepAliveDelay?: number;
+    sendBufferSize?: number;
+    receiveBufferSize?: number;
+    dnsQueryType?: Protocol.Network.DirectSocketDnsQueryType;
+    multicastLoopback?: boolean;
+    multicastTimeToLive?: number;
+    multicastAllowAddressSharing?: boolean;
+}
+export interface DirectSocketOpenInfo {
+    remoteAddr?: string;
+    remotePort?: number;
+    localAddr?: string;
+    localPort?: number;
+}
+export interface DirectSocketInfo {
+    type: DirectSocketType;
+    status: DirectSocketStatus;
+    errorMessage?: string;
+    createOptions: DirectSocketCreateOptions;
+    openInfo?: DirectSocketOpenInfo;
+    joinedMulticastGroups?: Set<string>;
+}
+export interface DirectSocketChunk {
+    data: string;
+    type: DirectSocketChunkType;
+    timestamp: number;
+    remoteAddress?: string;
+    remotePort?: number;
+}
+export declare enum DirectSocketChunkType {
+    SEND = "send",
+    RECEIVE = "receive"
+}

package/dist/lib/front_end/core/sdk/OverlayColorGenerator.d.ts

@@ -0,0 +1,14 @@
+import * as Common from '../common/common.js';
+/**
+ * Used to cycle through a list of predetermined #colors for the overlays.
+ * This helps users differentiate between overlays when several are shown at the
+ * same time.
+ */
+export declare class OverlayColorGenerator {
+    #private;
+    constructor();
+    /**
+     * Generate the next color in the spectrum
+     */
+    next(): Common.Color.Color;
+}

package/dist/lib/front_end/core/sdk/OverlayModel.d.ts

@@ -0,0 +1,161 @@
+import type * as Platform from '../../core/platform/platform.js';
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import * as Protocol from '../../generated/protocol.js';
+import type { CSSModel } from './CSSModel.js';
+import { DeferredDOMNode, DOMModel, type DOMNode } from './DOMModel.js';
+import type { RemoteObject } from './RemoteObject.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export interface HighlightColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export interface HighlightRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: HighlightColor;
+    outlineColor: HighlightColor;
+}
+export interface Hinge {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    contentColor: HighlightColor;
+    outlineColor: HighlightColor;
+}
+export declare const enum EmulatedOSType {
+    WINDOWS = "Windows",
+    MAC = "Mac",
+    LINUX = "Linux"
+}
+export declare class OverlayModel extends SDKModel<EventTypes> implements ProtocolProxyApi.OverlayDispatcher {
+    #private;
+    overlayAgent: ProtocolProxyApi.OverlayApi;
+    constructor(target: Target);
+    static highlightObjectAsDOMNode(object: RemoteObject): void;
+    static hideDOMNodeHighlight(): void;
+    static muteHighlight(): Promise<void[]>;
+    static unmuteHighlight(): Promise<void[]>;
+    static highlightRect(rect: HighlightRect): void;
+    static clearHighlight(): void;
+    getDOMModel(): DOMModel;
+    highlightRect({ x, y, width, height, color, outlineColor }: HighlightRect): Promise<Protocol.ProtocolResponseWithError>;
+    clearHighlight(): Promise<Protocol.ProtocolResponseWithError>;
+    private wireAgentToSettings;
+    suspendModel(): Promise<void>;
+    resumeModel(): Promise<void>;
+    setShowViewportSizeOnResize(show: boolean): void;
+    private updatePausedInDebuggerMessage;
+    setHighlighter(highlighter: Highlighter | null): void;
+    setInspectMode(mode: Protocol.Overlay.InspectMode, showDetailedTooltip?: boolean | undefined): Promise<void>;
+    inspectModeEnabled(): boolean;
+    highlightInOverlay(data: HighlightData, mode?: string, showInfo?: boolean): void;
+    highlightInOverlayForTwoSeconds(data: HighlightData): void;
+    highlightGridInPersistentOverlay(nodeId: Protocol.DOM.NodeId): void;
+    isHighlightedGridInPersistentOverlay(nodeId: Protocol.DOM.NodeId): boolean;
+    hideGridInPersistentOverlay(nodeId: Protocol.DOM.NodeId): void;
+    highlightScrollSnapInPersistentOverlay(nodeId: Protocol.DOM.NodeId): void;
+    isHighlightedScrollSnapInPersistentOverlay(nodeId: Protocol.DOM.NodeId): boolean;
+    hideScrollSnapInPersistentOverlay(nodeId: Protocol.DOM.NodeId): void;
+    highlightFlexContainerInPersistentOverlay(nodeId: Protocol.DOM.NodeId): void;
+    isHighlightedFlexContainerInPersistentOverlay(nodeId: Protocol.DOM.NodeId): boolean;
+    hideFlexContainerInPersistentOverlay(nodeId: Protocol.DOM.NodeId): void;
+    highlightContainerQueryInPersistentOverlay(nodeId: Protocol.DOM.NodeId): void;
+    isHighlightedContainerQueryInPersistentOverlay(nodeId: Protocol.DOM.NodeId): boolean;
+    hideContainerQueryInPersistentOverlay(nodeId: Protocol.DOM.NodeId): void;
+    highlightSourceOrderInOverlay(node: DOMNode): void;
+    colorOfGridInPersistentOverlay(nodeId: Protocol.DOM.NodeId): string | null;
+    setColorOfGridInPersistentOverlay(nodeId: Protocol.DOM.NodeId, colorStr: string): void;
+    colorOfFlexInPersistentOverlay(nodeId: Protocol.DOM.NodeId): string | null;
+    setColorOfFlexInPersistentOverlay(nodeId: Protocol.DOM.NodeId, colorStr: string): void;
+    hideSourceOrderInOverlay(): void;
+    setSourceOrderActive(isActive: boolean): void;
+    private delayedHideHighlight;
+    highlightFrame(frameId: Protocol.Page.FrameId): void;
+    showHingeForDualScreen(hinge: Hinge | null): void;
+    setWindowControlsPlatform(selectedPlatform: EmulatedOSType): void;
+    setWindowControlsThemeColor(themeColor: string): void;
+    getWindowControlsConfig(): Protocol.Overlay.WindowControlsOverlayConfig;
+    toggleWindowControlsToolbar(show: boolean): Promise<void>;
+    private buildHighlightConfig;
+    nodeHighlightRequested({ nodeId }: Protocol.Overlay.NodeHighlightRequestedEvent): void;
+    static setInspectNodeHandler(handler: (arg0: DOMNode) => Promise<void>): void;
+    inspectNodeRequested({ backendNodeId }: Protocol.Overlay.InspectNodeRequestedEvent): void;
+    screenshotRequested({ viewport }: Protocol.Overlay.ScreenshotRequestedEvent): void;
+    inspectModeCanceled(): void;
+    static inspectNodeHandler: ((node: DOMNode) => Promise<void>) | null;
+    getOverlayAgent(): ProtocolProxyApi.OverlayApi;
+    hasStyleSheetText(url: Platform.DevToolsPath.UrlString): Promise<boolean>;
+    inspectPanelShowRequested({ backendNodeId }: Protocol.Overlay.InspectPanelShowRequestedEvent): void;
+    inspectedElementWindowRestored({ backendNodeId }: Protocol.Overlay.InspectedElementWindowRestoredEvent): void;
+}
+export declare class WindowControls {
+    #private;
+    constructor(cssModel: CSSModel);
+    get selectedPlatform(): string;
+    set selectedPlatform(osType: EmulatedOSType);
+    get themeColor(): string;
+    set themeColor(color: string);
+    get config(): Protocol.Overlay.WindowControlsOverlayConfig;
+    initializeStyleSheetText(url: Platform.DevToolsPath.UrlString): Promise<boolean>;
+    toggleEmulatedOverlay(showOverlay: boolean): Promise<void>;
+    transformStyleSheetforTesting(x: number, y: number, width: number, height: number, originalStyleSheet: string | undefined): string | undefined;
+}
+export declare const enum Events {
+    INSPECT_MODE_WILL_BE_TOGGLED = "InspectModeWillBeToggled",
+    EXITED_INSPECT_MODE = "InspectModeExited",
+    HIGHLIGHT_NODE_REQUESTED = "HighlightNodeRequested",
+    SCREENSHOT_REQUESTED = "ScreenshotRequested",
+    PERSISTENT_GRID_OVERLAY_STATE_CHANGED = "PersistentGridOverlayStateChanged",
+    PERSISTENT_FLEX_CONTAINER_OVERLAY_STATE_CHANGED = "PersistentFlexContainerOverlayStateChanged",
+    PERSISTENT_SCROLL_SNAP_OVERLAY_STATE_CHANGED = "PersistentScrollSnapOverlayStateChanged",
+    PERSISTENT_CONTAINER_QUERY_OVERLAY_STATE_CHANGED = "PersistentContainerQueryOverlayStateChanged",
+    INSPECT_PANEL_SHOW_REQUESTED = "InspectPanelShowRequested",
+    INSPECTED_ELEMENT_WINDOW_RESTORED = "InspectedElementWindowRestored"
+}
+export interface ChangedNodeId {
+    nodeId: number;
+    enabled: boolean;
+}
+export interface EventTypes {
+    [Events.INSPECT_MODE_WILL_BE_TOGGLED]: OverlayModel;
+    [Events.EXITED_INSPECT_MODE]: void;
+    [Events.HIGHLIGHT_NODE_REQUESTED]: DOMNode;
+    [Events.SCREENSHOT_REQUESTED]: Protocol.Page.Viewport;
+    [Events.PERSISTENT_GRID_OVERLAY_STATE_CHANGED]: ChangedNodeId;
+    [Events.PERSISTENT_FLEX_CONTAINER_OVERLAY_STATE_CHANGED]: ChangedNodeId;
+    [Events.PERSISTENT_SCROLL_SNAP_OVERLAY_STATE_CHANGED]: ChangedNodeId;
+    [Events.PERSISTENT_CONTAINER_QUERY_OVERLAY_STATE_CHANGED]: ChangedNodeId;
+    [Events.INSPECT_PANEL_SHOW_REQUESTED]: number;
+    [Events.INSPECTED_ELEMENT_WINDOW_RESTORED]: number;
+}
+export interface Highlighter {
+    highlightInOverlay(data: HighlightData, config: Protocol.Overlay.HighlightConfig): void;
+    setInspectMode(mode: Protocol.Overlay.InspectMode, config: Protocol.Overlay.HighlightConfig): Promise<void>;
+    highlightFrame(frameId: Protocol.Page.FrameId): void;
+}
+export declare class SourceOrderHighlighter {
+    #private;
+    constructor(model: OverlayModel);
+    highlightSourceOrderInOverlay(node: DOMNode, sourceOrderConfig: Protocol.Overlay.SourceOrderConfig): void;
+    hideSourceOrderHighlight(): void;
+}
+export interface HighlightNodeData {
+    node: DOMNode;
+    selectorList?: string;
+}
+export interface HighlightDeferredNode {
+    deferredNode: DeferredDOMNode;
+}
+export interface HighlightObjectData {
+    object: RemoteObject;
+    selectorList?: string;
+}
+export type HighlightData = HighlightNodeData | HighlightDeferredNode | HighlightObjectData | {
+    clear: boolean;
+};