devtools-tracing 1.2.0 → 1.2.2

package/dist/lib/front_end/models/trace/lantern/simulation/TCPConnection.d.ts

@@ -0,0 +1,47 @@
+import type { ConnectionTiming } from './SimulationTimingMap.js';
+interface DownloadOptions {
+    dnsResolutionTime?: number;
+    timeAlreadyElapsed?: number;
+    maximumTimeToElapse?: number;
+}
+interface DownloadResults {
+    roundTrips: number;
+    timeElapsed: number;
+    bytesDownloaded: number;
+    extraBytesDownloaded: number;
+    congestionWindow: number;
+    connectionTiming: ConnectionTiming;
+}
+declare class TCPConnection {
+    warmed: boolean;
+    ssl: boolean;
+    h2: boolean;
+    rtt: number;
+    throughput: number;
+    serverLatency: number;
+    _congestionWindow: number;
+    h2OverflowBytesDownloaded: number;
+    constructor(rtt: number, throughput: number, serverLatency?: number, ssl?: boolean, h2?: boolean);
+    static maximumSaturatedConnections(rtt: number, availableThroughput: number): number;
+    computeMaximumCongestionWindowInSegments(): number;
+    setThroughput(throughput: number): void;
+    setCongestionWindow(congestion: number): void;
+    setWarmed(warmed: boolean): void;
+    isH2(): boolean;
+    get congestionWindow(): number;
+    /**
+     * Sets the number of excess bytes that are available to this connection on future downloads, only
+     * applies to H2 connections.
+     */
+    setH2OverflowBytesDownloaded(bytes: number): void;
+    clone(): TCPConnection;
+    /**
+     * Simulates a network download of a particular number of bytes over an optional maximum amount of time
+     * and returns information about the ending state.
+     *
+     * See https://hpbn.co/building-blocks-of-tcp/#three-way-handshake and
+     *  https://hpbn.co/transport-layer-security-tls/#tls-handshake for details.
+     */
+    simulateDownloadUntil(bytesToDownload: number, options?: DownloadOptions): DownloadResults;
+}
+export { TCPConnection };

package/dist/lib/front_end/models/trace/lantern/simulation/simulation.d.ts

@@ -0,0 +1,6 @@
+export * from './ConnectionPool.js';
+export * from './Constants.js';
+export * from './DNSCache.js';
+export * from './SimulationTimingMap.js';
+export * from './Simulator.js';
+export * from './TCPConnection.js';

package/dist/lib/front_end/models/trace/lantern/types/Lantern.d.ts

@@ -0,0 +1,196 @@
+import type * as Protocol from '../../../../generated/protocol.js';
+export declare const NetworkRequestTypes: {
+    readonly XHR: "XHR";
+    readonly Fetch: "Fetch";
+    readonly EventSource: "EventSource";
+    readonly Script: "Script";
+    readonly Stylesheet: "Stylesheet";
+    readonly Image: "Image";
+    readonly Media: "Media";
+    readonly Font: "Font";
+    readonly Document: "Document";
+    readonly TextTrack: "TextTrack";
+    readonly WebSocket: "WebSocket";
+    readonly Other: "Other";
+    readonly Manifest: "Manifest";
+    readonly SignedExchange: "SignedExchange";
+    readonly Ping: "Ping";
+    readonly Preflight: "Preflight";
+    readonly CSPViolationReport: "CSPViolationReport";
+    readonly Prefetch: "Prefetch";
+    readonly FedCM: "FedCM";
+};
+export interface TraceEvent {
+    name: string;
+    args: {
+        name?: string;
+        data?: {
+            frame?: string;
+            readyState?: number;
+            stackTrace?: Array<{
+                url: string;
+            }>;
+            url?: string;
+        };
+    };
+    pid: number;
+    tid: number;
+    /** Timestamp of the event in microseconds. */
+    ts: number;
+    dur: number;
+}
+export interface Trace {
+    traceEvents: TraceEvent[];
+}
+export type ResourcePriority = ('VeryLow' | 'Low' | 'Medium' | 'High' | 'VeryHigh');
+export type ResourceType = keyof typeof NetworkRequestTypes;
+type InitiatorType = ('parser' | 'script' | 'preload' | 'SignedExchange' | 'preflight' | 'FedCM' | 'other');
+export type ResourceTiming = Protocol.Network.ResourceTiming;
+export interface CallStack {
+    callFrames: Array<{
+        scriptId: string;
+        url: string;
+        lineNumber: number;
+        columnNumber: number;
+        functionName: string;
+    }>;
+    parent?: CallStack;
+}
+export interface ParsedURL {
+    /**
+     * Equivalent to a `new URL(url).protocol` BUT w/o the trailing colon (:)
+     */
+    scheme: string;
+    /**
+     * Equivalent to a `new URL(url).hostname`
+     */
+    host: string;
+    securityOrigin: string;
+}
+export type AnyNetworkObject = any;
+export interface NetworkRequest<T = AnyNetworkObject> {
+    requestId: string;
+    connectionId: number;
+    connectionReused: boolean;
+    url: string;
+    protocol: string;
+    parsedURL: ParsedURL;
+    documentURL: string;
+    /** When the renderer process initially discovers a network request, in milliseconds. */
+    rendererStartTime: number;
+    /**
+     * When the network service is about to handle a request, ie. just before going to the
+     * HTTP cache or going to the network for DNS/connection setup, in milliseconds.
+     */
+    networkRequestTime: number;
+    /**
+     * When the last byte of the response headers is received, in milliseconds.
+     * Equal to networkRequestTime if no data is received over the
+     * network (ex: cached requests or data urls).
+     */
+    responseHeadersEndTime: number;
+    /** When the last byte of the response body is received, in milliseconds. */
+    networkEndTime: number;
+    transferSize: number;
+    resourceSize: number;
+    fromDiskCache: boolean;
+    fromMemoryCache: boolean;
+    isLinkPreload: boolean;
+    finished: boolean;
+    failed: boolean;
+    statusCode: number;
+    /** The network request that redirected to this one */
+    redirectSource?: NetworkRequest<T>;
+    /** The network request that this one redirected to */
+    redirectDestination?: NetworkRequest<T>;
+    initiator: {
+        type: InitiatorType;
+        url?: string;
+        stack?: CallStack;
+    };
+    initiatorRequest?: NetworkRequest<T>;
+    /** The chain of network requests that redirected to this one */
+    redirects?: NetworkRequest[] | undefined;
+    timing?: Protocol.Network.ResourceTiming;
+    resourceType?: ResourceType;
+    mimeType: string;
+    priority: ResourcePriority;
+    frameId: string | undefined;
+    fromWorker: boolean;
+    /**
+     * Optional value for how long the server took to respond to this request, in ms.
+     * When not provided, the server response time is derived from the timing object.
+     */
+    serverResponseTime?: number;
+    /**
+     * Implementation-specific canonical data structure that this Lantern NetworkRequest
+     * was derived from.
+     * Users of Lantern create a NetworkRequest matching this interface,
+     * but can store the source-of-truth for their network model in this property.
+     * This is then accessible as a read-only property on NetworkNode.
+     */
+    rawRequest?: T;
+}
+export declare namespace Simulation {
+    interface URL {
+        /** URL of the initially requested URL */
+        requestedUrl?: string;
+        /** URL of the last document request */
+        mainDocumentUrl?: string;
+    }
+    /** Simulation settings that control the amount of network & cpu throttling in the run. */
+    interface ThrottlingSettings {
+        /** The round trip time in milliseconds. */
+        rttMs?: number;
+        /** The network throughput in kilobits per second. */
+        throughputKbps?: number;
+        /** The network request latency in milliseconds. */
+        requestLatencyMs?: number;
+        /** The network download throughput in kilobits per second. */
+        downloadThroughputKbps?: number;
+        /** The network upload throughput in kilobits per second. */
+        uploadThroughputKbps?: number;
+        /** The amount of slowdown applied to the cpu (1/<cpuSlowdownMultiplier>). */
+        cpuSlowdownMultiplier?: number;
+    }
+    interface PrecomputedLanternData {
+        additionalRttByOrigin: Record<string, number>;
+        serverResponseTimeByOrigin: Record<string, number>;
+    }
+    interface Settings {
+        networkAnalysis: {
+            rtt: number;
+            additionalRttByOrigin: Map<string, number>;
+            serverResponseTimeByOrigin: Map<string, number>;
+            throughput: number;
+        };
+        /** The method used to throttle the network. */
+        throttlingMethod: 'devtools' | 'simulate' | 'provided';
+        /** The throttling config settings. */
+        throttling?: Required<ThrottlingSettings>;
+        /** Precomputed lantern estimates to use instead of observed analysis. */
+        precomputedLanternData?: PrecomputedLanternData | null;
+    }
+    interface Options {
+        rtt?: number;
+        throughput?: number;
+        observedThroughput: number;
+        maximumConcurrentRequests?: number;
+        cpuSlowdownMultiplier?: number;
+        layoutTaskMultiplier?: number;
+        additionalRttByOrigin?: Map<string, number>;
+        serverResponseTimeByOrigin?: Map<string, number>;
+    }
+    interface ProcessedNavigation {
+        timestamps: {
+            firstContentfulPaint: number;
+            largestContentfulPaint?: number;
+        };
+    }
+    interface NodeTiming {
+        startTime: number;
+        endTime: number;
+        duration: number;
+    }
+}
+export {};

package/dist/lib/front_end/models/trace/lantern/types/types.d.ts

@@ -0,0 +1 @@
+export * from './Lantern.js';

package/dist/lib/front_end/models/trace/trace.d.ts

@@ -0,0 +1,14 @@
+import * as EntityMapper from './EntityMapper.js';
+import * as EventsSerializer from './EventsSerializer.js';
+import * as Extras from './extras/extras.js';
+import * as Handlers from './handlers/handlers.js';
+import * as Helpers from './helpers/helpers.js';
+import * as Insights from './insights/insights.js';
+import * as Lantern from './lantern/lantern.js';
+import * as LanternComputationData from './LanternComputationData.js';
+import * as TraceModel from './ModelImpl.js';
+import * as Name from './Name.js';
+import * as Processor from './Processor.js';
+import * as Styles from './Styles.js';
+import * as Types from './types/types.js';
+export { EntityMapper, EventsSerializer, Extras, Handlers, Helpers, Insights, Lantern, LanternComputationData, Name, Processor, Styles, TraceModel, Types, };

package/dist/lib/front_end/models/trace/types/Configuration.d.ts

@@ -0,0 +1,87 @@
+import type * as Platform from '../../../core/platform/platform.js';
+import type * as SDK from '../../../core/sdk/sdk.js';
+import type * as Protocol from '../../../generated/protocol.js';
+import type * as Lantern from '../lantern/lantern.js';
+import type * as File from './File.js';
+import type { Milli } from './Timing.js';
+export interface Configuration {
+    /**
+     * Show all events: disable the default filtering which hides and excludes some events.
+     */
+    showAllEvents: boolean;
+    /**
+     * Extra detail for RPP developers (eg Trace Event json in Summary, and individual JS Sample events)
+     */
+    debugMode: boolean;
+    /**
+     * How many invalidation events will be stored for a layout (or similar) event.
+     * On large sites with a lot of DOM there can be thousands of invalidations
+     * associated with any given event. It is not useful to show the user 1000s of
+     * invalidations in the UI, but it is also expensive for us to hold onto them
+     * all, and it helps prevents OOM issues when running in NodeJS
+     * [https://github.com/GoogleChrome/lighthouse/issues/16111].
+     * Therefore, instead, we store only the latest 20 per event. We do also store
+     * the total count, so we can show that, but we'll only ever hold on to the
+     * last 20 invalidations (in DESC trace order - so the latest 20 in the trace file)
+     *
+     * If you set this to 0, we will skip the Invalidations processing entirely.
+     * 0 effectively disables the InvalidationsHandler and it will not even
+     * attempt to gather or track invalidations.
+     */
+    maxInvalidationEventsPerEvent: number;
+    /**
+     * Determines if the AnimationFramesHandler should be enabled. Currently in
+     * DevTools we do not use it, so we disable it by default to avoid work that
+     * we do not use. If you disable it, you will still see `data.AnimationFrames`
+     * from the model, but the contents will be empty.
+     */
+    enableAnimationsFrameHandler: boolean;
+}
+export declare const defaults: () => Configuration;
+/**
+ * Generates a key that can be used to represent this config in a cache. This is
+ * used mainly in tests, where we want to avoid re-parsing a file if we have
+ * already processed it with the same configuration.
+ */
+export declare function configToCacheKey(config: Configuration): string;
+export interface ParseOptions {
+    showAllEvents?: boolean;
+    /**
+     * If the trace was just recorded on the current page, rather than an imported file.
+     * TODO(paulirish): Maybe remove. This is currently unused by the Processor and Handlers
+     * @default false
+     */
+    isFreshRecording?: boolean;
+    /**
+     * If the trace is a CPU Profile rather than a Chrome tracing trace.
+     * @default false
+     */
+    isCPUProfile?: boolean;
+    metadata?: File.MetaData;
+    resolveSourceMap?: (params: ResolveSourceMapParams) => Promise<SDK.SourceMap.SourceMap | null>;
+    logger?: {
+        start: (id: string) => void;
+        end: (id: string) => void;
+    };
+    lanternSettings?: Omit<Lantern.Types.Simulation.Settings, 'networkAnalysis'>;
+    /**
+     * Used when an Insight needs to format a time to string as part of its
+     * output. By default we use the i18n.TimeUtilities in DevTools but this
+     * enables it to be overridden, which is useful if you are consuming the trace
+     * engine outside of DevTools.
+     */
+    insightTimeFormatters?: InsightTimeFormatters;
+}
+export interface InsightTimeFormatters {
+    milli: (x: Milli) => string;
+}
+export interface ResolveSourceMapParams {
+    scriptId: string;
+    scriptUrl: Platform.DevToolsPath.UrlString;
+    /** The url as resolved by any sourceUrl comment. */
+    sourceUrl: Platform.DevToolsPath.UrlString;
+    sourceMapUrl: Platform.DevToolsPath.UrlString;
+    frame: Protocol.Page.FrameId;
+    /** Set only if the raw source map was found on the provided metadata. Never set for source maps from data urls. */
+    cachedRawSourceMap?: SDK.SourceMap.SourceMapV3;
+}

package/dist/lib/front_end/models/trace/types/Extensions.d.ts

@@ -0,0 +1,77 @@
+import type * as Platform from '../../../core/platform/platform.js';
+import type { ConsoleTimeStamp, Event, PerformanceMark, PerformanceMeasureBegin, Phase, SyntheticBased } from './TraceEvents.js';
+export type ExtensionEntryType = 'track-entry' | 'marker';
+export declare const extensionPalette: readonly ["primary", "primary-light", "primary-dark", "secondary", "secondary-light", "secondary-dark", "tertiary", "tertiary-light", "tertiary-dark", "error", "warning"];
+export type ExtensionColorFromPalette = typeof extensionPalette[number];
+/**
+ * Represents any valid value that can be produced by JSON.parse()
+ * without a reviver.
+ */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export interface DevToolsObjBase {
+    color?: ExtensionColorFromPalette;
+    /**
+     * We document to users that we support only string values here, but because
+     * this is coming from user code the values could be anything, so we ensure we
+     * deal with bad data by typing this as unknown.
+     */
+    properties?: Array<[string, JsonValue]>;
+    tooltipText?: string;
+}
+export type DevToolsObj = DevToolsObjEntry | DevToolsObjMarker;
+export interface ExtensionTrackEntryPayloadDeeplink {
+    url: Platform.DevToolsPath.UrlString;
+    description: string;
+}
+export interface DevToolsObjEntry extends DevToolsObjBase {
+    dataType?: 'track-entry';
+    track: string;
+    trackGroup?: string;
+    userDetail?: JsonValue;
+}
+export interface DevToolsObjMarker extends DevToolsObjBase {
+    dataType: 'marker';
+}
+/**
+ * Synthetic events created for extension tracks.
+ */
+export interface SyntheticExtensionTrackEntry extends SyntheticBased<Phase.COMPLETE, PerformanceMeasureBegin | PerformanceMark | ConsoleTimeStamp> {
+    devtoolsObj: DevToolsObjEntry;
+    userDetail: JsonValue | null;
+}
+/**
+ * Synthetic events created for extension marks.
+ */
+export interface SyntheticExtensionMarker extends SyntheticBased<Phase.INSTANT, PerformanceMark> {
+    devtoolsObj: DevToolsObjMarker;
+    userDetail: JsonValue | null;
+}
+export type SyntheticExtensionEntry = SyntheticExtensionTrackEntry | SyntheticExtensionMarker;
+/** Returns true if this is a devtoolsObj for a marker */
+export declare function isExtensionPayloadMarker(payload: {
+    dataType?: string;
+}): payload is DevToolsObjMarker;
+/** Returns true if this is a devtoolsObj for an entry (non-instant) */
+export declare function isExtensionEntryObj(payload: {
+    track?: string;
+    dataType?: string;
+}): payload is DevToolsObjEntry;
+/** Returns true if this is a devtoolsObj for a console.timeStamp */
+export declare function isConsoleTimestampPayloadTrackEntry(payload: {
+    description?: string;
+    url?: string;
+}): payload is ExtensionTrackEntryPayloadDeeplink;
+export declare function isValidExtensionPayload(payload: {
+    track?: string;
+    dataType?: string;
+    description?: string;
+    url?: string;
+}): payload is DevToolsObj | ExtensionTrackEntryPayloadDeeplink;
+export declare function isSyntheticExtensionEntry(entry: Event): entry is SyntheticExtensionEntry;
+export interface ExtensionTrackData {
+    name: string;
+    isTrackGroup: boolean;
+    entriesByTrack: Record<string, SyntheticExtensionTrackEntry[]>;
+}

package/dist/lib/front_end/models/trace/types/File.d.ts

@@ -0,0 +1,197 @@
+import type * as SDK from '../../../core/sdk/sdk.js';
+import type * as Protocol from '../../../generated/protocol.js';
+import type * as CrUXManager from '../../../models/crux-manager/crux-manager.js';
+import type { TraceWindowMicro } from './Timing.js';
+import type { Event, LegacyTimelineFrame, ProcessID, SampleIndex, ThreadID } from './TraceEvents.js';
+export interface TraceFile {
+    traceEvents: readonly Event[];
+    metadata: MetaData;
+}
+export interface Breadcrumb {
+    window: TraceWindowMicro;
+    child: Breadcrumb | null;
+}
+export declare const enum DataOrigin {
+    CPU_PROFILE = "CPUProfile",
+    TRACE_EVENTS = "TraceEvents"
+}
+/**
+ * The Entries link can have 3 stated:
+ *  1. The Link creation is not started yet, meaning only the button that needs to be clicked to start creating the link is visible.
+ *  2. Pending to event - the creation is started, but the entry that the link points to has not been chosen yet
+ *  3. Link connected - final state, both entries present
+ */
+export declare const enum EntriesLinkState {
+    CREATION_NOT_STARTED = "creation_not_started",
+    PENDING_TO_EVENT = "pending_to_event",
+    CONNECTED = "connected"
+}
+export declare const enum EventKeyType {
+    RAW_EVENT = "r",
+    SYNTHETIC_EVENT = "s",
+    PROFILE_CALL = "p",
+    LEGACY_TIMELINE_FRAME = "l"
+}
+/**
+ * Represents an object that is saved in the file when user created annotations in the timeline.
+ *
+ * Expected to add more annotations.
+ */
+export interface SerializedAnnotations {
+    entryLabels: EntryLabelAnnotationSerialized[];
+    labelledTimeRanges: TimeRangeAnnotationSerialized[];
+    linksBetweenEntries: EntriesLinkAnnotationSerialized[];
+}
+/**
+ * Represents an object that is used to store the Entry Label annotation that is created when a user creates a label for an entry in the timeline.
+ */
+export interface EntryLabelAnnotation {
+    type: 'ENTRY_LABEL';
+    entry: Event | LegacyTimelineFrame;
+    label: string;
+}
+/**
+ * Represents an object that is used to store the Labelled Time Range Annotation that is created when a user creates a Time Range Selection in the timeline.
+ */
+export interface TimeRangeAnnotation {
+    type: 'TIME_RANGE';
+    label: string;
+    bounds: TraceWindowMicro;
+}
+export interface EntriesLinkAnnotation {
+    type: 'ENTRIES_LINK';
+    state: EntriesLinkState;
+    entryFrom: Event;
+    entryTo?: Event;
+}
+/**
+ * Represents an object that is saved in the file when a user creates a label for an entry in the timeline.
+ */
+export interface EntryLabelAnnotationSerialized {
+    entry: SerializableKey;
+    label: string;
+}
+/**
+ * Represents an object that is saved in the file when a user creates a time range with a label in the timeline.
+ */
+export interface TimeRangeAnnotationSerialized {
+    bounds: TraceWindowMicro;
+    label: string;
+}
+/**
+ * Represents an object that is saved in the file when a user creates a link between entries in the timeline.
+ */
+export interface EntriesLinkAnnotationSerialized {
+    entryFrom: SerializableKey;
+    entryTo: SerializableKey;
+}
+/**
+ * `Annotation` are the user-created annotations that are saved into the metadata.
+ * Those annotations are rendered on the timeline by `Overlays.ts`
+ *
+ * TODO: Implement other OverlayAnnotations (annotated time ranges, links between entries).
+ * TODO: Save/load overlay annotations to/from the trace file.
+ */
+export type Annotation = EntryLabelAnnotation | TimeRangeAnnotation | EntriesLinkAnnotation;
+export declare function isTimeRangeAnnotation(annotation: Annotation): annotation is TimeRangeAnnotation;
+export declare function isEntryLabelAnnotation(annotation: Annotation): annotation is EntryLabelAnnotation;
+export declare function isEntriesLinkAnnotation(annotation: Annotation): annotation is EntriesLinkAnnotation;
+/**
+ * Serializable keys are created for trace events to be able to save
+ * references to timeline events in a trace file. These keys enable
+ * user modifications that can be saved. See go/cpq:event-data-json for
+ * more details on the key format.
+ **/
+export type RawEventKey = `${EventKeyType.RAW_EVENT}-${number}`;
+export type SyntheticEventKey = `${EventKeyType.SYNTHETIC_EVENT}-${number}`;
+export type ProfileCallKey = `${EventKeyType.PROFILE_CALL}-${ProcessID}-${ThreadID}-${SampleIndex}-${Protocol.integer}`;
+export type LegacyTimelineFrameKey = `${EventKeyType.LEGACY_TIMELINE_FRAME}-${number}`;
+export type SerializableKey = RawEventKey | ProfileCallKey | SyntheticEventKey | LegacyTimelineFrameKey;
+/** Serializable keys values objects contain data that maps the keys to original Trace Events **/
+export interface RawEventKeyValues {
+    type: EventKeyType.RAW_EVENT;
+    rawIndex: number;
+}
+export interface SyntheticEventKeyValues {
+    type: EventKeyType.SYNTHETIC_EVENT;
+    rawIndex: number;
+}
+export interface ProfileCallKeyValues {
+    type: EventKeyType.PROFILE_CALL;
+    processID: ProcessID;
+    threadID: ThreadID;
+    sampleIndex: SampleIndex;
+    protocol: Protocol.integer;
+}
+export interface LegacyTimelineFrameKeyValues {
+    type: EventKeyType.LEGACY_TIMELINE_FRAME;
+    rawIndex: number;
+}
+export type SerializableKeyValues = RawEventKeyValues | ProfileCallKeyValues | SyntheticEventKeyValues | LegacyTimelineFrameKeyValues;
+export interface Modifications {
+    entriesModifications: {
+        hiddenEntries: SerializableKey[];
+        expandableEntries: SerializableKey[];
+    };
+    initialBreadcrumb: Breadcrumb;
+    annotations: SerializedAnnotations;
+}
+/**
+ * IMPORTANT: this is the same as PerfUI.FlameChart.PersistedGroupConfig
+ * However, the PerfUI code should not depend on the model/trace, and similarly
+ * this model cannot depend on that code, so we duplicate it.
+ **/
+export interface TrackVisualConfig {
+    hidden: boolean;
+    expanded: boolean;
+    originalIndex: number;
+    visualIndex: number;
+    trackName: string;
+}
+/**
+ * Stores the visual config if the user has modified it. Split into "main" and
+ * "network" so we can pass the relevant config into the right data provider.
+ * NOTE: as of August 2025 (M141) we currently do not export this in new
+ * traces, or use it if an existing trace is imported with it.
+ */
+export interface PersistedTraceVisualConfig {
+    main: TrackVisualConfig[] | null;
+    network: TrackVisualConfig[] | null;
+}
+/**
+ * Trace metadata that we persist to the file. This will allow us to
+ * store specifics for the trace, e.g., which tracks should be visible
+ * on load.
+ */
+export interface MetaData {
+    source?: 'DevTools';
+    startTime?: string;
+    emulatedDeviceTitle?: string;
+    networkThrottling?: string;
+    networkThrottlingConditions?: Omit<SDK.NetworkManager.Conditions, 'title'>;
+    cpuThrottling?: number;
+    dataOrigin?: DataOrigin;
+    enhancedTraceVersion?: number;
+    modifications?: Modifications;
+    cruxFieldData?: CrUXManager.PageResult[];
+    /** Currently only stores JS maps, not CSS. This never stores data url source maps. */
+    sourceMaps?: MetadataSourceMap[];
+    /** Currently only stores HTML and CSS resources. */
+    resources?: MetadataResource[];
+    visualTrackConfig?: PersistedTraceVisualConfig;
+    hostDPR?: number;
+}
+export interface MetadataSourceMap {
+    url: string;
+    /** If not defined, then this was a data url. */
+    sourceMapUrl?: string;
+    sourceMap: SDK.SourceMap.SourceMapV3;
+}
+export interface MetadataResource {
+    url: string;
+    frame: string;
+    content: string;
+    mimeType: string;
+}
+export type Contents = TraceFile | Event[];
+export declare function traceEventKeyToValues(key: SerializableKey): SerializableKeyValues;