devtools-tracing 1.2.1 → 1.2.2

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

@@ -0,0 +1,21 @@
+import * as Formatter from '../../models/formatter/formatter.js';
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+import type { Script } from './Script.js';
+type ScopeTreeNode = Formatter.FormatterWorkerPool.ScopeTreeNode;
+type Text = TextUtils.Text.Text;
+/**
+ * Computes and caches the scope tree for `script`.
+ *
+ * We use {@link Script} as a key to uniquely identify scripts.
+ * {@link Script} boils down to "target" + "script ID". This
+ * duplicates work in case of identical script running on multiple targets
+ * (e.g. workers).
+ *
+ * We also return a {@link TextUtils.Text.Text} instance. The scope tree uses offsets
+ * and the text allows conversion from/to line/column numbers.
+ */
+export declare function scopeTreeForScript(script: Script): Promise<{
+    scopeTree: ScopeTreeNode;
+    text: Text;
+} | null>;
+export {};

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

@@ -0,0 +1,69 @@
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import type * as Protocol from '../../generated/protocol.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export declare const enum ScreenshotMode {
+    FROM_VIEWPORT = "fromViewport",
+    FROM_CLIP = "fromClip",
+    FULLPAGE = "fullpage"
+}
+type ScreencastFrameCallback = ((arg0: Protocol.binary, arg1: Protocol.Page.ScreencastFrameMetadata) => void);
+type ScreencastVisibilityChangedCallback = ((arg0: boolean) => void);
+/**
+ * Manages concurrent screencast requests by queuing and prioritizing.
+ *
+ * When startScreencast is invoked:
+ * - If a screencast is currently active, the existing screencast's parameters and callbacks are
+ * saved in the #screencastOperations array.
+ * - The active screencast is then stopped.
+ * - A new screencast is initiated using the parameters and callbacks from the current startScreencast call.
+ *
+ * When stopScreencast is invoked:
+ * - The currently active screencast is stopped.
+ * - The #screencastOperations is checked for interrupted screencast operations.
+ * - If any operations are found, the latest one is started
+ * using its saved parameters and callbacks.
+ *
+ * This ensures that:
+ * - Only one screencast is active at a time.
+ * - Interrupted screencasts are resumed after the current screencast is stopped.
+ * This ensures animation previews, which use screencasting, don't disrupt ongoing remote debugging sessions. Without this mechanism, stopping a preview screencast would terminate the debugging screencast, freezing the ScreencastView.
+ **/
+export declare class ScreenCaptureModel extends SDKModel<void> implements ProtocolProxyApi.PageDispatcher {
+    #private;
+    constructor(target: Target);
+    startScreencast(format: Protocol.Page.StartScreencastRequestFormat, quality: number, maxWidth: number | undefined, maxHeight: number | undefined, everyNthFrame: number | undefined, onFrame: ScreencastFrameCallback, onVisibilityChanged: ScreencastVisibilityChangedCallback): Promise<number>;
+    stopScreencast(id: number): void;
+    captureScreenshot(format: Protocol.Page.CaptureScreenshotRequestFormat, quality: number, mode: ScreenshotMode, clip?: Protocol.Page.Viewport): Promise<string | null>;
+    screencastFrame({ data, metadata, sessionId }: Protocol.Page.ScreencastFrameEvent): void;
+    screencastVisibilityChanged({ visible }: Protocol.Page.ScreencastVisibilityChangedEvent): void;
+    backForwardCacheNotUsed(_params: Protocol.Page.BackForwardCacheNotUsedEvent): void;
+    domContentEventFired(_params: Protocol.Page.DomContentEventFiredEvent): void;
+    loadEventFired(_params: Protocol.Page.LoadEventFiredEvent): void;
+    lifecycleEvent(_params: Protocol.Page.LifecycleEventEvent): void;
+    navigatedWithinDocument(_params: Protocol.Page.NavigatedWithinDocumentEvent): void;
+    frameAttached(_params: Protocol.Page.FrameAttachedEvent): void;
+    frameNavigated(_params: Protocol.Page.FrameNavigatedEvent): void;
+    documentOpened(_params: Protocol.Page.DocumentOpenedEvent): void;
+    frameDetached(_params: Protocol.Page.FrameDetachedEvent): void;
+    frameStartedLoading(_params: Protocol.Page.FrameStartedLoadingEvent): void;
+    frameStoppedLoading(_params: Protocol.Page.FrameStoppedLoadingEvent): void;
+    frameRequestedNavigation(_params: Protocol.Page.FrameRequestedNavigationEvent): void;
+    frameStartedNavigating(_params: Protocol.Page.FrameStartedNavigatingEvent): void;
+    frameSubtreeWillBeDetached(_params: Protocol.Page.FrameSubtreeWillBeDetachedEvent): void;
+    frameScheduledNavigation(_params: Protocol.Page.FrameScheduledNavigationEvent): void;
+    frameClearedScheduledNavigation(_params: Protocol.Page.FrameClearedScheduledNavigationEvent): void;
+    frameResized(): void;
+    javascriptDialogOpening(_params: Protocol.Page.JavascriptDialogOpeningEvent): void;
+    javascriptDialogClosed(_params: Protocol.Page.JavascriptDialogClosedEvent): void;
+    interstitialShown(): void;
+    interstitialHidden(): void;
+    windowOpen(_params: Protocol.Page.WindowOpenEvent): void;
+    fileChooserOpened(_params: Protocol.Page.FileChooserOpenedEvent): void;
+    compilationCacheProduced(_params: Protocol.Page.CompilationCacheProducedEvent): void;
+    downloadWillBegin(_params: Protocol.Page.DownloadWillBeginEvent): void;
+    downloadProgress(): void;
+    prefetchStatusUpdated(_params: Protocol.Preload.PrefetchStatusUpdatedEvent): void;
+    prerenderStatusUpdated(_params: Protocol.Preload.PrerenderStatusUpdatedEvent): void;
+}
+export {};

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

@@ -0,0 +1,125 @@
+import * as Platform from '../../core/platform/platform.js';
+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 { type DebuggerModel, Location } from './DebuggerModel.js';
+import type { FrameAssociated } from './FrameAssociated.js';
+import type { PageResourceLoadInitiator } from './PageResourceLoader.js';
+import type { ExecutionContext } from './RuntimeModel.js';
+import type { DebugId, SourceMap } from './SourceMap.js';
+import type { Target } from './Target.js';
+export declare class Script implements TextUtils.ContentProvider.ContentProvider, FrameAssociated {
+    #private;
+    debuggerModel: DebuggerModel;
+    scriptId: Protocol.Runtime.ScriptId;
+    /**
+     * The URL of the script. When `hasSourceURL` is true, this value comes from a `//# sourceURL=` directive. Otherwise,
+     * it's the original `src` URL from which the script was loaded.
+     */
+    sourceURL: Platform.DevToolsPath.UrlString;
+    lineOffset: number;
+    columnOffset: number;
+    endLine: number;
+    endColumn: number;
+    executionContextId: number;
+    hash: string;
+    sourceMapURL?: string;
+    debugSymbols: Protocol.Debugger.DebugSymbols | null;
+    hasSourceURL: boolean;
+    contentLength: number;
+    originStackTrace: Protocol.Runtime.StackTrace | null;
+    readonly isModule: boolean | null;
+    readonly buildId: string | null;
+    constructor(debuggerModel: DebuggerModel, scriptId: Protocol.Runtime.ScriptId, sourceURL: Platform.DevToolsPath.UrlString, startLine: number, startColumn: number, endLine: number, endColumn: number, executionContextId: number, hash: string, isContentScript: boolean, isLiveEdit: boolean, sourceMapURL: string | undefined, hasSourceURL: boolean, length: number, isModule: boolean | null, originStackTrace: Protocol.Runtime.StackTrace | null, codeOffset: number | null, scriptLanguage: string | null, debugSymbols: Protocol.Debugger.DebugSymbols | null, embedderName: Platform.DevToolsPath.UrlString | null, buildId: string | null);
+    embedderName(): Platform.DevToolsPath.UrlString | null;
+    target(): Target;
+    private static trimSourceURLComment;
+    isContentScript(): boolean;
+    codeOffset(): number | null;
+    isJavaScript(): boolean;
+    isWasm(): boolean;
+    scriptLanguage(): string | null;
+    executionContext(): ExecutionContext | null;
+    isLiveEdit(): boolean;
+    contentURL(): Platform.DevToolsPath.UrlString;
+    contentType(): Common.ResourceType.ResourceType;
+    private loadTextContent;
+    private loadWasmContent;
+    requestContentData(): Promise<TextUtils.ContentData.ContentDataOrError>;
+    getWasmBytecode(): Promise<ArrayBuffer>;
+    originalContentProvider(): TextUtils.ContentProvider.ContentProvider;
+    searchInContent(query: string, caseSensitive: boolean, isRegex: boolean): Promise<TextUtils.ContentProvider.SearchMatch[]>;
+    private appendSourceURLCommentIfNeeded;
+    editSource(newSource: string): Promise<{
+        changed: boolean;
+        status: Protocol.Debugger.SetScriptSourceResponseStatus;
+        exceptionDetails?: Protocol.Runtime.ExceptionDetails;
+    }>;
+    rawLocation(lineNumber: number, columnNumber: number): Location | null;
+    isInlineScript(): boolean;
+    isAnonymousScript(): boolean;
+    setBlackboxedRanges(positions: Protocol.Debugger.ScriptPosition[]): Promise<boolean>;
+    containsLocation(lineNumber: number, columnNumber: number): boolean;
+    get frameId(): Protocol.Page.FrameId;
+    /**
+     * @returns true, iff this script originates from a breakpoint/logpoint condition
+     */
+    get isBreakpointCondition(): boolean;
+    /**
+     * @returns the currently attached source map for this Script or `undefined` if there is none or it
+     * hasn't loaded yet.
+     */
+    sourceMap(): SourceMap | undefined;
+    createPageResourceLoadInitiator(): PageResourceLoadInitiator;
+    debugId(): DebugId | null;
+    /**
+     * Translates the `rawLocation` from line and column number in terms of what V8 understands
+     * to a script relative location. Specifically this means that for inline `<script>`'s
+     * without a `//# sourceURL=` annotation, the line and column offset of the script
+     * content is subtracted to make the location within the script independent of the
+     * location of the `<script>` tag within the surrounding document.
+     *
+     * @param rawLocation the raw location in terms of what V8 understands.
+     * @returns the script relative line and column number for the {@link rawLocation}.
+     */
+    rawLocationToRelativeLocation(rawLocation: {
+        lineNumber: number;
+        columnNumber: number;
+    }): {
+        lineNumber: number;
+        columnNumber: number;
+    };
+    rawLocationToRelativeLocation(rawLocation: {
+        lineNumber: number;
+        columnNumber: number | undefined;
+    }): {
+        lineNumber: number;
+        columnNumber: number | undefined;
+    };
+    /**
+     * Translates the `relativeLocation` from script relative line and column number to
+     * the raw location in terms of what V8 understands. Specifically this means that for
+     * inline `<script>`'s without a `//# sourceURL=` annotation, the line and column offset
+     * of the script content is added to make the location relative to the start of the
+     * surrounding document.
+     *
+     * @param relativeLocation the script relative location.
+     * @returns the raw location in terms of what V8 understands for the {@link relativeLocation}.
+     */
+    relativeLocationToRawLocation(relativeLocation: {
+        lineNumber: number;
+        columnNumber: number;
+    }): {
+        lineNumber: number;
+        columnNumber: number;
+    };
+    relativeLocationToRawLocation(relativeLocation: {
+        lineNumber: number;
+        columnNumber: number | undefined;
+    }): {
+        lineNumber: number;
+        columnNumber: number | undefined;
+    };
+}
+export declare const sourceURLRegex: RegExp;
+export declare function disassembleWasm(content: string): Promise<TextUtils.WasmDisassembly.WasmDisassembly>;

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

@@ -0,0 +1,23 @@
+import { SDKModel } from './SDKModel.js';
+export declare class SecurityOriginManager extends SDKModel<EventTypes> {
+    #private;
+    updateSecurityOrigins(securityOrigins: Set<string>): void;
+    securityOrigins(): string[];
+    mainSecurityOrigin(): string;
+    unreachableMainSecurityOrigin(): string | null;
+    setMainSecurityOrigin(securityOrigin: string, unreachableSecurityOrigin: string): void;
+}
+export declare enum Events {
+    SecurityOriginAdded = "SecurityOriginAdded",
+    SecurityOriginRemoved = "SecurityOriginRemoved",
+    MainSecurityOriginChanged = "MainSecurityOriginChanged"
+}
+export interface MainSecurityOriginChangedEvent {
+    mainSecurityOrigin: string;
+    unreachableMainSecurityOrigin: string | null;
+}
+export interface EventTypes {
+    [Events.SecurityOriginAdded]: string;
+    [Events.SecurityOriginRemoved]: string;
+    [Events.MainSecurityOriginChanged]: MainSecurityOriginChangedEvent;
+}

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

@@ -0,0 +1,18 @@
+import { type EventSourceMessage, type NetworkRequest } from './NetworkRequest.js';
+/**
+ * Server sent events only arrive via CDP (Explicit Network.eventSourceMessageReceived) when
+ * the page uses "EventSource" in the code.
+ *
+ * If the page manually uses 'fetch' or XHR we have to do the protocol parsing
+ * ourselves.
+ *
+ * `ServerSentEvents` is a small helper class that manages this distinction for a specific
+ * request, stores the event data and sends out "EventSourceMessageAdded" events for a request.
+ */
+export declare class ServerSentEvents {
+    #private;
+    constructor(request: NetworkRequest, parseFromStreamedData: boolean);
+    get eventSourceMessages(): readonly EventSourceMessage[];
+    /** Forwarded Network.eventSourceMessage received */
+    onProtocolEventSourceMessageReceived(eventName: string, data: string, eventId: string, time: number): void;
+}

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

@@ -0,0 +1,18 @@
+import type * as Protocol from '../../generated/protocol.js';
+/**
+ * Implements Server-Sent-Events protocl parsing as described by
+ * https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream
+ *
+ * Webpages can use SSE over fetch/XHR and not go through EventSource. DevTools
+ * only receives the raw binary data in this case, which means we have to decode
+ * and parse the event stream ourselves here.
+ *
+ * Implementation mostly ported over from blink
+ * third_party/blink/renderer/modules/eventsource/event_source_parser.cc.
+ */
+export declare class ServerSentEventsParser {
+    #private;
+    constructor(callback: (eventType: string, data: string, eventId: string) => void, encodingLabel?: string);
+    addBase64Chunk(raw: Protocol.binary): Promise<void>;
+    addTextChunk(chunk: string): void;
+}

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

@@ -0,0 +1,24 @@
+import type { NameValue } from './NetworkRequest.js';
+/**
+ * Represents an authored single server timing metric. https://w3c.github.io/server-timing/#the-server-timing-header-field
+ */
+export interface ServerTimingMetric {
+    /** The name of the metric, a single token */
+    name: string;
+    /** A human-readable description of the metric. */
+    desc?: string;
+    /** The duration; milliseconds is recommended. https://w3c.github.io/server-timing/#duration-attribute. */
+    dur?: number;
+}
+export declare const cloudflarePrefix = "(cf) ";
+export declare const cloudinaryPrefix = "(cld) ";
+export declare class ServerTiming {
+    metric: string;
+    value: number | null;
+    description: string | null;
+    constructor(metric: string, value: number | null, description: string | null);
+    static parseHeaders(headers: NameValue[]): ServerTiming[] | null;
+    static createFromHeaderValue(valueString: string): ServerTimingMetric[];
+    static getParserForParameter(paramName: string): ((arg0: ServerTimingMetric, arg1: string | null) => void) | null;
+    static showWarning(msg: string): void;
+}

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

@@ -0,0 +1,79 @@
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import type * as Protocol from '../../generated/protocol.js';
+import type * as Platform from '../platform/platform.js';
+import type { NameValue } from './NetworkRequest.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export declare class ServiceWorkerCacheModel extends SDKModel<EventTypes> implements ProtocolProxyApi.StorageDispatcher {
+    #private;
+    readonly cacheAgent: ProtocolProxyApi.CacheStorageApi;
+    /**
+     * Invariant: This #model can only be constructed on a ServiceWorker target.
+     */
+    constructor(target: Target);
+    enable(): void;
+    clearForStorageKey(storageKey: string): void;
+    refreshCacheNames(): void;
+    deleteCache(cache: Cache): Promise<void>;
+    deleteCacheEntry(cache: Cache, request: string): Promise<void>;
+    loadCacheData(cache: Cache, skipCount: number, pageSize: number, pathFilter: string, callback: (arg0: Protocol.CacheStorage.DataEntry[], arg1: number) => void): void;
+    loadAllCacheData(cache: Cache, pathFilter: string, callback: (arg0: Protocol.CacheStorage.DataEntry[], arg1: number) => void): void;
+    caches(): Cache[];
+    dispose(): void;
+    private addStorageBucket;
+    private removeStorageBucket;
+    private loadCacheNames;
+    private updateCacheNames;
+    private storageBucketAdded;
+    private storageBucketRemoved;
+    private cacheAdded;
+    private cacheRemoved;
+    private requestEntries;
+    private requestAllEntries;
+    cacheStorageListUpdated({ bucketId }: Protocol.Storage.CacheStorageListUpdatedEvent): void;
+    cacheStorageContentUpdated({ bucketId, cacheName }: Protocol.Storage.CacheStorageContentUpdatedEvent): void;
+    attributionReportingTriggerRegistered(_event: Protocol.Storage.AttributionReportingTriggerRegisteredEvent): void;
+    indexedDBListUpdated(_event: Protocol.Storage.IndexedDBListUpdatedEvent): void;
+    indexedDBContentUpdated(_event: Protocol.Storage.IndexedDBContentUpdatedEvent): void;
+    interestGroupAuctionEventOccurred(_event: Protocol.Storage.InterestGroupAuctionEventOccurredEvent): void;
+    interestGroupAccessed(_event: Protocol.Storage.InterestGroupAccessedEvent): void;
+    interestGroupAuctionNetworkRequestCreated(_event: Protocol.Storage.InterestGroupAuctionNetworkRequestCreatedEvent): void;
+    sharedStorageAccessed(_event: Protocol.Storage.SharedStorageAccessedEvent): void;
+    sharedStorageWorkletOperationExecutionFinished(_event: Protocol.Storage.SharedStorageWorkletOperationExecutionFinishedEvent): void;
+    storageBucketCreatedOrUpdated(_event: Protocol.Storage.StorageBucketCreatedOrUpdatedEvent): void;
+    storageBucketDeleted(_event: Protocol.Storage.StorageBucketDeletedEvent): void;
+    setThrottlerSchedulesAsSoonAsPossibleForTest(): void;
+    attributionReportingSourceRegistered(_event: Protocol.Storage.AttributionReportingSourceRegisteredEvent): void;
+    attributionReportingReportSent(_event: Protocol.Storage.AttributionReportingReportSentEvent): void;
+    attributionReportingVerboseDebugReportSent(_event: Protocol.Storage.AttributionReportingVerboseDebugReportSentEvent): void;
+}
+export declare const enum Events {
+    CACHE_ADDED = "CacheAdded",
+    CACHE_REMOVED = "CacheRemoved",
+    CACHE_STORAGE_CONTENT_UPDATED = "CacheStorageContentUpdated"
+}
+export interface CacheEvent {
+    model: ServiceWorkerCacheModel;
+    cache: Cache;
+}
+export interface CacheStorageContentUpdatedEvent {
+    storageBucket: Protocol.Storage.StorageBucket;
+    cacheName: string;
+}
+export interface EventTypes {
+    [Events.CACHE_ADDED]: CacheEvent;
+    [Events.CACHE_REMOVED]: CacheEvent;
+    [Events.CACHE_STORAGE_CONTENT_UPDATED]: CacheStorageContentUpdatedEvent;
+}
+export declare class Cache {
+    #private;
+    storageKey: string;
+    storageBucket: Protocol.Storage.StorageBucket;
+    cacheName: string;
+    cacheId: Protocol.CacheStorage.CacheId;
+    constructor(model: ServiceWorkerCacheModel, storageBucket: Protocol.Storage.StorageBucket, cacheName: string, cacheId: Protocol.CacheStorage.CacheId);
+    inBucket(storageBucket: Protocol.Storage.StorageBucket): boolean;
+    equals(cache: Cache): boolean;
+    toString(): string;
+    requestCachedResponse(url: Platform.DevToolsPath.UrlString, requestHeaders: NameValue[]): Promise<Protocol.CacheStorage.CachedResponse | null>;
+}

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

@@ -0,0 +1,130 @@
+import * as Protocol from '../../generated/protocol.js';
+import * as Common from '../common/common.js';
+import type * as Platform from '../platform/platform.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export declare class ServiceWorkerManager extends SDKModel<EventTypes> {
+    #private;
+    constructor(target: Target);
+    enable(): Promise<void>;
+    disable(): Promise<void>;
+    registrations(): Map<string, ServiceWorkerRegistration>;
+    findVersion(versionId: string): ServiceWorkerVersion | null;
+    deleteRegistration(registrationId: string): void;
+    updateRegistration(registrationId: string): Promise<void>;
+    deliverPushMessage(registrationId: Protocol.ServiceWorker.RegistrationID, data: string): Promise<void>;
+    dispatchSyncEvent(registrationId: Protocol.ServiceWorker.RegistrationID, tag: string, lastChance: boolean): Promise<void>;
+    dispatchPeriodicSyncEvent(registrationId: Protocol.ServiceWorker.RegistrationID, tag: string): Promise<void>;
+    private unregister;
+    startWorker(scopeURL: string): Promise<void>;
+    skipWaiting(scopeURL: string): Promise<void>;
+    stopWorker(versionId: string): Promise<void>;
+    workerRegistrationUpdated(registrations: Protocol.ServiceWorker.ServiceWorkerRegistration[]): void;
+    workerVersionUpdated(versions: Protocol.ServiceWorker.ServiceWorkerVersion[]): void;
+    workerErrorReported(payload: Protocol.ServiceWorker.ServiceWorkerErrorMessage): void;
+    private forceUpdateSettingChanged;
+}
+export declare const enum Events {
+    REGISTRATION_UPDATED = "RegistrationUpdated",
+    REGISTRATION_ERROR_ADDED = "RegistrationErrorAdded",
+    REGISTRATION_DELETED = "RegistrationDeleted"
+}
+export interface RegistrationErrorAddedEvent {
+    registration: ServiceWorkerRegistration;
+    error: Protocol.ServiceWorker.ServiceWorkerErrorMessage;
+}
+export interface EventTypes {
+    [Events.REGISTRATION_UPDATED]: ServiceWorkerRegistration;
+    [Events.REGISTRATION_ERROR_ADDED]: RegistrationErrorAddedEvent;
+    [Events.REGISTRATION_DELETED]: ServiceWorkerRegistration;
+}
+/**
+ * For every version, we keep a history of ServiceWorkerVersionState. Every time
+ * a version is updated we will add a new state at the head of the history chain.
+ * This history tells us information such as what the current state is, or when
+ * the version becomes installed.
+ */
+export declare class ServiceWorkerVersionState {
+    runningStatus: Protocol.ServiceWorker.ServiceWorkerVersionRunningStatus;
+    status: Protocol.ServiceWorker.ServiceWorkerVersionStatus;
+    lastUpdatedTimestamp: number;
+    previousState: ServiceWorkerVersionState | null;
+    constructor(runningStatus: Protocol.ServiceWorker.ServiceWorkerVersionRunningStatus, status: Protocol.ServiceWorker.ServiceWorkerVersionStatus, previousState: ServiceWorkerVersionState | null, timestamp: number);
+}
+export declare class ServiceWorkerRouterRule {
+    condition: string;
+    source: string;
+    id: number;
+    constructor(condition: string, source: string, id: number);
+}
+export declare class ServiceWorkerVersion {
+    id: string;
+    scriptURL: Platform.DevToolsPath.UrlString;
+    parsedURL: Common.ParsedURL.ParsedURL;
+    securityOrigin: string;
+    scriptLastModified: number | undefined;
+    scriptResponseTime: number | undefined;
+    controlledClients: Protocol.Target.TargetID[];
+    targetId: string | null;
+    routerRules: ServiceWorkerRouterRule[] | null;
+    currentState: ServiceWorkerVersionState;
+    registration: ServiceWorkerRegistration;
+    constructor(registration: ServiceWorkerRegistration, payload: Protocol.ServiceWorker.ServiceWorkerVersion);
+    update(payload: Protocol.ServiceWorker.ServiceWorkerVersion): void;
+    isStartable(): boolean;
+    isStoppedAndRedundant(): boolean;
+    isStopped(): boolean;
+    isStarting(): boolean;
+    isRunning(): boolean;
+    isStopping(): boolean;
+    isNew(): boolean;
+    isInstalling(): boolean;
+    isInstalled(): boolean;
+    isActivating(): boolean;
+    isActivated(): boolean;
+    isRedundant(): boolean;
+    get status(): Protocol.ServiceWorker.ServiceWorkerVersionStatus;
+    get runningStatus(): Protocol.ServiceWorker.ServiceWorkerVersionRunningStatus;
+    mode(): string;
+    private parseJSONRules;
+}
+export declare namespace ServiceWorkerVersion {
+    const RunningStatus: {
+        running: any;
+        starting: any;
+        stopped: any;
+        stopping: any;
+    };
+    const Status: {
+        activated: any;
+        activating: any;
+        installed: any;
+        installing: any;
+        new: any;
+        redundant: any;
+    };
+    const enum Modes {
+        INSTALLING = "installing",
+        WAITING = "waiting",
+        ACTIVE = "active",
+        REDUNDANT = "redundant"
+    }
+}
+export declare class ServiceWorkerRegistration {
+    #private;
+    id: Protocol.ServiceWorker.RegistrationID;
+    scopeURL: Platform.DevToolsPath.UrlString;
+    securityOrigin: Platform.DevToolsPath.UrlString;
+    isDeleted: boolean;
+    versions: Map<string, ServiceWorkerVersion>;
+    deleting: boolean;
+    errors: Protocol.ServiceWorker.ServiceWorkerErrorMessage[];
+    constructor(payload: Protocol.ServiceWorker.ServiceWorkerRegistration);
+    update(payload: Protocol.ServiceWorker.ServiceWorkerRegistration): void;
+    fingerprint(): symbol;
+    versionsByMode(): Map<string, ServiceWorkerVersion>;
+    updateVersion(payload: Protocol.ServiceWorker.ServiceWorkerVersion): ServiceWorkerVersion;
+    isRedundant(): boolean;
+    shouldBeRemoved(): boolean;
+    canBeRemoved(): boolean;
+}