@paulirish/trace_engine 0.0.32 → 0.0.33

package/models/trace/types/TraceEvents.d.ts

@@ -1,5 +1,5 @@
 import type * as Protocol from '../../../generated/protocol.js';
-import { type MicroSeconds, type MilliSeconds, type Seconds } from './Timing.js';
+import type { MicroSeconds, MilliSeconds, Seconds, TraceWindowMicroSeconds } from './Timing.js';
 export declare const enum Phase {
     BEGIN = "B",
     END = "E",
@@ -27,15 +27,15 @@ export declare const enum Phase {
     CLOCK_SYNC = "c"
 }
 export declare function isNestableAsyncPhase(phase: Phase): boolean;
-export declare function isAsyncPhase(phase: Phase): boolean;
+export declare function isPhaseAsync(phase: Phase): boolean;
 export declare function isFlowPhase(phase: Phase): boolean;
-export declare const enum TraceEventScope {
+export declare const enum Scope {
     THREAD = "t",
     PROCESS = "p",
     GLOBAL = "g"
 }
-export interface TraceEventData {
-    args?: TraceEventArgs;
+export interface Event {
+    args?: Args;
     cat: string;
     name: string;
     ph: Phase;
@@ -46,16 +46,17 @@ export interface TraceEventData {
     tdur?: MicroSeconds;
     dur?: MicroSeconds;
 }
-export interface TraceEventArgs {
-    data?: TraceEventArgsData;
+export interface Args {
+    data?: ArgsData;
+    stackTrace?: CallFrame[];
 }
-export interface TraceEventArgsData {
-    stackTrace?: TraceEventCallFrame[];
+export interface ArgsData {
+    stackTrace?: CallFrame[];
     url?: string;
     navigationId?: string;
     frame?: string;
 }
-export interface TraceEventCallFrame {
+export interface CallFrame {
     codeType?: string;
     functionName: string;
     scriptId: number | string;
@@ -63,7 +64,7 @@ export interface TraceEventCallFrame {
     lineNumber: number;
     url: string;
 }
-export declare function objectIsTraceEventCallFrame(object: {}): object is TraceEventCallFrame;
+export declare function objectIsCallFrame(object: {}): object is CallFrame;
 export interface TraceFrame {
     frame: string;
     name: string;
@@ -73,62 +74,62 @@ export interface TraceFrame {
     isOutermostMainFrame?: boolean;
     isInPrimaryMainFrame?: boolean;
 }
-export interface TraceEventSample extends TraceEventData {
+export interface Sample extends Event {
     ph: Phase.SAMPLE;
 }
 /**
  * A fake trace event created to support CDP.Profiler.Profiles in the
  * trace engine.
  */
-export interface SyntheticCpuProfile extends TraceEventInstant, SyntheticBasedEvent<Phase.INSTANT> {
+export interface SyntheticCpuProfile extends Instant, SyntheticBased<Phase.INSTANT> {
     name: 'CpuProfile';
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+    args: Args & {
+        data: ArgsData & {
             cpuProfile: Protocol.Profiler.Profile;
         };
     };
 }
-export interface TraceEventProfile extends TraceEventSample {
+export interface Profile extends Sample {
     name: 'Profile';
     id: ProfileID;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+    args: Args & {
+        data: ArgsData & {
             startTime: MicroSeconds;
         };
     };
 }
-export interface TraceEventProfileChunk extends TraceEventSample {
+export interface ProfileChunk extends Sample {
     name: 'ProfileChunk';
     id: ProfileID;
-    args: TraceEventArgs & {
-        data?: TraceEventArgsData & {
-            cpuProfile?: TraceEventPartialProfile;
+    args: Args & {
+        data?: ArgsData & {
+            cpuProfile?: PartialProfile;
             timeDeltas?: MicroSeconds[];
             lines?: MicroSeconds[];
         };
     };
 }
-export interface TraceEventPartialProfile {
-    nodes?: TraceEventPartialNode[];
+export interface PartialProfile {
+    nodes?: PartialNode[];
     samples: CallFrameID[];
 }
-export interface TraceEventPartialNode {
-    callFrame: TraceEventCallFrame;
+export interface PartialNode {
+    callFrame: CallFrame;
     id: CallFrameID;
     parent?: CallFrameID;
 }
-export interface TraceEventComplete extends TraceEventData {
+export interface Complete extends Event {
     ph: Phase.COMPLETE;
     dur: MicroSeconds;
 }
-export interface TraceEventRunTask extends TraceEventComplete {
-    name: KnownEventName.RunTask;
+export interface RunTask extends Complete {
+    name: Name.RUN_TASK;
 }
-export declare function isTraceEventRunTask(event: TraceEventData): event is TraceEventRunTask;
-export interface TraceEventFireIdleCallback extends TraceEventComplete {
-    name: KnownEventName.FireIdleCallback;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export declare function isRunTask(event: Event): event is RunTask;
+export interface FireIdleCallback extends Complete {
+    name: Name.FIRE_IDLE_CALLBACK;
+    args: Args & {
+        data: ArgsData & {
             allottedMilliseconds: MilliSeconds;
             frame: string;
             id: number;
@@ -136,33 +137,33 @@ export interface TraceEventFireIdleCallback extends TraceEventComplete {
         };
     };
 }
-export interface TraceEventSchedulePostMessage extends TraceEventInstant {
-    name: KnownEventName.SchedulePostMessage;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export interface SchedulePostMessage extends Instant {
+    name: Name.SCHEDULE_POST_MESSAGE;
+    args: Args & {
+        data: ArgsData & {
             traceId: string;
         };
     };
 }
-export interface TraceEventHandlePostMessage extends TraceEventComplete {
-    name: KnownEventName.HandlePostMessage;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export interface HandlePostMessage extends Complete {
+    name: Name.HANDLE_POST_MESSAGE;
+    args: Args & {
+        data: ArgsData & {
             traceId: string;
         };
     };
 }
-export interface TraceEventDispatch extends TraceEventComplete {
+export interface Dispatch extends Complete {
     name: 'EventDispatch';
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+    args: Args & {
+        data: ArgsData & {
             type: string;
         };
     };
 }
-export interface TraceEventParseHTML extends TraceEventComplete {
+export interface ParseHTML extends Complete {
     name: 'ParseHTML';
-    args: TraceEventArgs & {
+    args: Args & {
         beginData: {
             frame: string;
             startLine: number;
@@ -173,10 +174,10 @@ export interface TraceEventParseHTML extends TraceEventComplete {
         };
     };
 }
-export interface TraceEventBegin extends TraceEventData {
+export interface Begin extends Event {
     ph: Phase.BEGIN;
 }
-export interface TraceEventEnd extends TraceEventData {
+export interface End extends Event {
     ph: Phase.END;
 }
 /**
@@ -186,14 +187,14 @@ export interface TraceEventEnd extends TraceEventData {
  * complete event that comprises the data of both from the beginning in
  * the RendererHandler.
  */
-export type SyntheticCompleteEvent = TraceEventComplete;
-export interface TraceEventEventTiming extends TraceEventData {
+export type SyntheticComplete = Complete;
+export interface EventTiming extends Event {
     ph: Phase.ASYNC_NESTABLE_START | Phase.ASYNC_NESTABLE_END;
-    name: KnownEventName.EventTiming;
+    name: Name.EVENT_TIMING;
     id: string;
-    args: TraceEventArgs & {
+    args: Args & {
         frame: string;
-        data?: TraceEventArgsData & {
+        data?: ArgsData & {
             cancelable: boolean;
             duration: MilliSeconds;
             processingEnd: MilliSeconds;
@@ -204,16 +205,16 @@ export interface TraceEventEventTiming extends TraceEventData {
         };
     };
 }
-export interface TraceEventEventTimingBegin extends TraceEventEventTiming {
+export interface EventTimingBegin extends EventTiming {
     ph: Phase.ASYNC_NESTABLE_START;
 }
-export interface TraceEventEventTimingEnd extends TraceEventEventTiming {
+export interface EventTimingEnd extends EventTiming {
     ph: Phase.ASYNC_NESTABLE_END;
 }
-export interface TraceEventGPUTask extends TraceEventComplete {
+export interface GPUTask extends Complete {
     name: 'GPUTask';
-    args: TraceEventArgs & {
-        data?: TraceEventArgsData & {
+    args: Args & {
+        data?: ArgsData & {
             renderer_pid: ProcessID;
             used_bytes: number;
         };
@@ -246,14 +247,20 @@ interface SyntheticArgsData {
     ssl: MicroSeconds;
     stalled: MicroSeconds;
     totalTime: MicroSeconds;
+    /** Server response time (receiveHeadersEnd - sendEnd) */
     waiting: MicroSeconds;
 }
-export interface SyntheticNetworkRequest extends TraceEventComplete, SyntheticBasedEvent<Phase.COMPLETE> {
-    rawSourceEvent: TraceEventData;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export interface SyntheticNetworkRequest extends Complete, SyntheticBased<Phase.COMPLETE> {
+    rawSourceEvent: ResourceSendRequest;
+    args: Args & {
+        data: ArgsData & {
             syntheticData: SyntheticArgsData;
+            /** Size of the resource after decompression (if applicable). */
             decodedBodyLength: number;
+            /**
+             * Size of the resource over the network. Includes size of headers and
+             * anything else in the HTTP response packet.
+             */
             encodedDataLength: number;
             frame: string;
             fromServiceWorker: boolean;
@@ -289,7 +296,8 @@ export interface SyntheticNetworkRequest extends TraceEventComplete, SyntheticBa
             connectionReused: boolean;
             initiator?: Initiator;
             requestMethod?: string;
-            timing?: TraceEventResourceReceiveResponseTimingData;
+            timing?: ResourceReceiveResponseTimingData;
+            syntheticServerTimings?: SyntheticServerTiming[];
         };
     };
     cat: 'loading';
@@ -302,57 +310,57 @@ export interface SyntheticNetworkRequest extends TraceEventComplete, SyntheticBa
     pid: ProcessID;
     tid: ThreadID;
 }
-export interface SyntheticWebSocketConnectionEvent extends TraceEventComplete, SyntheticBasedEvent<Phase.COMPLETE> {
-    rawSourceEvent: TraceEventData;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export interface SyntheticWebSocketConnection extends Complete, SyntheticBased<Phase.COMPLETE> {
+    rawSourceEvent: Event;
+    args: Args & {
+        data: ArgsData & {
             identifier: number;
             priority: Protocol.Network.ResourcePriority;
             url: string;
         };
     };
     cat: string;
-    name: 'SyntheticWebSocketConnectionEvent';
+    name: 'SyntheticWebSocketConnection';
     ph: Phase.COMPLETE;
     dur: MicroSeconds;
     ts: MicroSeconds;
     pid: ProcessID;
     tid: ThreadID;
-    s: TraceEventScope;
+    s: Scope;
 }
 export declare const enum AuctionWorkletType {
     BIDDER = "bidder",
     SELLER = "seller",
     UNKNOWN = "unknown"
 }
-export interface SyntheticAuctionWorkletEvent extends TraceEventInstant, SyntheticBasedEvent<Phase.INSTANT> {
-    rawSourceEvent: TraceEventData;
-    name: 'SyntheticAuctionWorkletEvent';
+export interface SyntheticAuctionWorklet extends Instant, SyntheticBased<Phase.INSTANT> {
+    rawSourceEvent: Event;
+    name: 'SyntheticAuctionWorklet';
     pid: ProcessID;
     host: string;
     target: string;
     type: AuctionWorkletType;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
-            utilityThread: TraceEventThreadName;
-            v8HelperThread: TraceEventThreadName;
+    args: Args & {
+        data: ArgsData & {
+            utilityThread: ThreadName;
+            v8HelperThread: ThreadName;
         } & ({
-            runningInProcessEvent: TraceEventAuctionWorkletRunningInProcess;
-            doneWithProcessEvent: TraceEventAuctionWorkletDoneWithProcess;
+            runningInProcessEvent: AuctionWorkletRunningInProcess;
+            doneWithProcessEvent: AuctionWorkletDoneWithProcess;
         } | {
-            runningInProcessEvent?: TraceEventAuctionWorkletRunningInProcess;
-            doneWithProcessEvent: TraceEventAuctionWorkletDoneWithProcess;
+            runningInProcessEvent?: AuctionWorkletRunningInProcess;
+            doneWithProcessEvent: AuctionWorkletDoneWithProcess;
         } | {
-            doneWithProcessEvent?: TraceEventAuctionWorkletDoneWithProcess;
-            runningInProcessEvent: TraceEventAuctionWorkletRunningInProcess;
+            doneWithProcessEvent?: AuctionWorkletDoneWithProcess;
+            runningInProcessEvent: AuctionWorkletRunningInProcess;
         });
     };
 }
-export interface TraceEventAuctionWorkletRunningInProcess extends TraceEventData {
+export interface AuctionWorkletRunningInProcess extends Event {
     name: 'AuctionWorkletRunningInProcess';
     ph: Phase.INSTANT;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+    args: Args & {
+        data: ArgsData & {
             host: string;
             pid: ProcessID;
             target: string;
@@ -360,11 +368,11 @@ export interface TraceEventAuctionWorkletRunningInProcess extends TraceEventData
         };
     };
 }
-export interface TraceEventAuctionWorkletDoneWithProcess extends TraceEventData {
+export interface AuctionWorkletDoneWithProcess extends Event {
     name: 'AuctionWorkletDoneWithProcess';
     ph: Phase.INSTANT;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+    args: Args & {
+        data: ArgsData & {
             host: string;
             pid: ProcessID;
             target: string;
@@ -372,39 +380,39 @@ export interface TraceEventAuctionWorkletDoneWithProcess extends TraceEventData
         };
     };
 }
-export declare function isTraceEventAuctionWorkletRunningInProcess(event: TraceEventData): event is TraceEventAuctionWorkletRunningInProcess;
-export declare function isTraceEventAuctionWorkletDoneWithProcess(event: TraceEventData): event is TraceEventAuctionWorkletDoneWithProcess;
-export interface TraceEventScreenshot extends TraceEventData {
+export declare function isAuctionWorkletRunningInProcess(event: Event): event is AuctionWorkletRunningInProcess;
+export declare function isAuctionWorkletDoneWithProcess(event: Event): event is AuctionWorkletDoneWithProcess;
+export interface Screenshot extends Event {
     /**
      * @deprecated This value is incorrect. Use ScreenshotHandler.getPresentationTimestamp()
      */
     ts: MicroSeconds;
     /** The id is the frame sequence number in hex */
     id: string;
-    args: TraceEventArgs & {
+    args: Args & {
         snapshot: string;
     };
-    name: KnownEventName.Screenshot;
+    name: Name.SCREENSHOT;
     cat: 'disabled-by-default-devtools.screenshot';
     ph: Phase.OBJECT_SNAPSHOT;
 }
-export declare function isTraceEventScreenshot(event: TraceEventData): event is TraceEventScreenshot;
-export interface SyntheticScreenshot extends TraceEventData, SyntheticBasedEvent {
-    rawSourceEvent: TraceEventScreenshot;
+export declare function isScreenshot(event: Event): event is Screenshot;
+export interface SyntheticScreenshot extends Event, SyntheticBased {
+    rawSourceEvent: Screenshot;
     /** This is the correct presentation timestamp. */
     ts: MicroSeconds;
-    args: TraceEventArgs & {
+    args: Args & {
         dataUri: string;
     };
-    name: KnownEventName.Screenshot;
+    name: Name.SCREENSHOT;
     cat: 'disabled-by-default-devtools.screenshot';
     ph: Phase.OBJECT_SNAPSHOT;
 }
-export interface TraceEventAnimation extends TraceEventData {
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export interface Animation extends Event {
+    args: Args & {
+        data: ArgsData & {
             nodeName?: string;
-            nodeId?: number;
+            nodeId?: Protocol.DOM.BackendNodeId;
             displayName?: string;
             id?: string;
             name?: string;
@@ -419,29 +427,29 @@ export interface TraceEventAnimation extends TraceEventData {
     };
     ph: Phase.ASYNC_NESTABLE_START | Phase.ASYNC_NESTABLE_END | Phase.ASYNC_NESTABLE_INSTANT;
 }
-export interface TraceEventMetadata extends TraceEventData {
+export interface Metadata extends Event {
     ph: Phase.METADATA;
-    args: TraceEventArgs & {
+    args: Args & {
         name?: string;
         uptime?: string;
     };
 }
-export interface TraceEventThreadName extends TraceEventMetadata {
-    name: KnownEventName.ThreadName;
-    args: TraceEventArgs & {
+export interface ThreadName extends Metadata {
+    name: Name.THREAD_NAME;
+    args: Args & {
         name?: string;
     };
 }
-export interface TraceEventProcessName extends TraceEventMetadata {
+export interface ProcessName extends Metadata {
     name: 'process_name';
 }
-export interface TraceEventMark extends TraceEventData {
+export interface Mark extends Event {
     ph: Phase.MARK;
 }
-export interface TraceEventNavigationStart extends TraceEventMark {
+export interface NavigationStart extends Mark {
     name: 'navigationStart';
-    args: TraceEventArgs & {
-        data?: TraceEventArgsData & {
+    args: Args & {
+        data?: ArgsData & {
             documentLoaderURL: string;
             isLoadingMainFrame: boolean;
             isOutermostMainFrame?: boolean;
@@ -454,36 +462,36 @@ export interface TraceEventNavigationStart extends TraceEventMark {
         frame: string;
     };
 }
-export interface TraceEventFirstContentfulPaint extends TraceEventMark {
-    name: KnownEventName.MarkFCP;
-    args: TraceEventArgs & {
+export interface FirstContentfulPaint extends Mark {
+    name: Name.MARK_FCP;
+    args: Args & {
         frame: string;
-        data?: TraceEventArgsData & {
+        data?: ArgsData & {
             navigationId: string;
         };
     };
 }
-export interface TraceEventFirstPaint extends TraceEventMark {
+export interface FirstPaint extends Mark {
     name: 'firstPaint';
-    args: TraceEventArgs & {
+    args: Args & {
         frame: string;
-        data?: TraceEventArgsData & {
+        data?: ArgsData & {
             navigationId: string;
         };
     };
 }
-export type PageLoadEvent = TraceEventFirstContentfulPaint | TraceEventMarkDOMContent | TraceEventInteractiveTime | TraceEventLargestContentfulPaintCandidate | TraceEventLayoutShift | TraceEventFirstPaint | TraceEventMarkLoad | TraceEventNavigationStart;
+export type PageLoadEvent = FirstContentfulPaint | MarkDOMContent | InteractiveTime | LargestContentfulPaintCandidate | LayoutShift | FirstPaint | MarkLoad | NavigationStart;
 export declare const MarkerName: readonly ["MarkDOMContent", "MarkLoad", "firstPaint", "firstContentfulPaint", "largestContentfulPaint::Candidate"];
-export interface MarkerEvent extends TraceEventData {
+export interface MarkerEvent extends Event {
     name: typeof MarkerName[number];
 }
-export declare function isTraceEventMarkerEvent(event: TraceEventData): event is MarkerEvent;
-export declare function eventIsPageLoadEvent(event: TraceEventData): event is PageLoadEvent;
-export interface TraceEventLargestContentfulPaintCandidate extends TraceEventMark {
-    name: KnownEventName.MarkLCPCandidate;
-    args: TraceEventArgs & {
+export declare function isMarkerEvent(event: Event): event is MarkerEvent;
+export declare function eventIsPageLoadEvent(event: Event): event is PageLoadEvent;
+export interface LargestContentfulPaintCandidate extends Mark {
+    name: Name.MARK_LCP_CANDIDATE;
+    args: Args & {
         frame: string;
-        data?: TraceEventArgsData & {
+        data?: ArgsData & {
             candidateIndex: number;
             isOutermostMainFrame: boolean;
             isMainFrame: boolean;
@@ -494,44 +502,44 @@ export interface TraceEventLargestContentfulPaintCandidate extends TraceEventMar
         };
     };
 }
-export interface TraceEventLargestImagePaintCandidate extends TraceEventMark {
+export interface LargestImagePaintCandidate extends Mark {
     name: 'LargestImagePaint::Candidate';
-    args: TraceEventArgs & {
+    args: Args & {
         frame: string;
-        data?: TraceEventArgsData & {
+        data?: ArgsData & {
             candidateIndex: number;
             imageUrl: string;
             DOMNodeId: Protocol.DOM.BackendNodeId;
         };
     };
 }
-export interface TraceEventLargestTextPaintCandidate extends TraceEventMark {
+export interface LargestTextPaintCandidate extends Mark {
     name: 'LargestTextPaint::Candidate';
-    args: TraceEventArgs & {
+    args: Args & {
         frame: string;
-        data?: TraceEventArgsData & {
+        data?: ArgsData & {
             candidateIndex: number;
             DOMNodeId: Protocol.DOM.BackendNodeId;
         };
     };
 }
-export interface TraceEventInteractiveTime extends TraceEventMark {
+export interface InteractiveTime extends Mark {
     name: 'InteractiveTime';
-    args: TraceEventArgs & {
+    args: Args & {
         args: {
             total_blocking_time_ms: number;
         };
         frame: string;
     };
 }
-export interface TraceEventInstant extends TraceEventData {
+export interface Instant extends Event {
     ph: Phase.INSTANT;
-    s: TraceEventScope;
+    s: Scope;
 }
-export interface TraceEventUpdateCounters extends TraceEventInstant {
+export interface UpdateCounters extends Instant {
     name: 'UpdateCounters';
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+    args: Args & {
+        data: ArgsData & {
             documents: number;
             jsEventListeners: number;
             jsHeapSizeUsed: number;
@@ -540,21 +548,21 @@ export interface TraceEventUpdateCounters extends TraceEventInstant {
         };
     };
 }
-export type TraceEventRendererEvent = TraceEventInstant | TraceEventComplete;
-export interface TraceEventTracingStartedInBrowser extends TraceEventInstant {
-    name: KnownEventName.TracingStartedInBrowser;
-    args: TraceEventArgs & {
-        data?: TraceEventArgsData & {
+export type RendererEvent = Instant | Complete;
+export interface TracingStartedInBrowser extends Instant {
+    name: Name.TRACING_STARTED_IN_BROWSER;
+    args: Args & {
+        data?: ArgsData & {
             frameTreeNodeId: number;
             frames?: TraceFrame[];
             persistentIds: boolean;
         };
     };
 }
-export interface TraceEventTracingSessionIdForWorker extends TraceEventInstant {
+export interface TracingSessionIdForWorker extends Instant {
     name: 'TracingSessionIdForWorker';
-    args: TraceEventArgs & {
-        data?: TraceEventArgsData & {
+    args: Args & {
+        data?: ArgsData & {
             url: string;
             workerId: WorkerId;
             workerThreadId: ThreadID;
@@ -562,25 +570,27 @@ export interface TraceEventTracingSessionIdForWorker extends TraceEventInstant {
         };
     };
 }
-export declare function isTraceEventTracingSessionIdForWorker(event: TraceEventData): event is TraceEventTracingSessionIdForWorker;
-export interface TraceEventFrameCommittedInBrowser extends TraceEventInstant {
+export declare function isTracingSessionIdForWorker(event: Event): event is TracingSessionIdForWorker;
+export interface FrameCommittedInBrowser extends Instant {
     name: 'FrameCommittedInBrowser';
-    args: TraceEventArgs & {
-        data?: TraceEventArgsData & TraceFrame;
+    args: Args & {
+        data?: ArgsData & TraceFrame;
     };
 }
-export interface TraceEventMainFrameViewport extends TraceEventInstant {
+export interface MainFrameViewport extends Instant {
     name: 'PaintTimingVisualizer::Viewport';
     args: {
-        data: TraceEventArgsData & {
+        data: ArgsData & {
             viewport_rect: number[];
+            /** Device Pixel Ratio. Added in m128 */
+            dpr: number;
         };
     };
 }
-export interface TraceEventCommitLoad extends TraceEventInstant {
+export interface CommitLoad extends Instant {
     name: 'CommitLoad';
-    args: TraceEventArgs & {
-        data?: TraceEventArgsData & {
+    args: Args & {
+        data?: ArgsData & {
             frame: string;
             isMainFrame: boolean;
             name: string;
@@ -591,10 +601,10 @@ export interface TraceEventCommitLoad extends TraceEventInstant {
         };
     };
 }
-export interface TraceEventMarkDOMContent extends TraceEventInstant {
+export interface MarkDOMContent extends Instant {
     name: 'MarkDOMContent';
-    args: TraceEventArgs & {
-        data?: TraceEventArgsData & {
+    args: Args & {
+        data?: ArgsData & {
             frame: string;
             isMainFrame: boolean;
             isOutermostMainFrame?: boolean;
@@ -602,10 +612,10 @@ export interface TraceEventMarkDOMContent extends TraceEventInstant {
         };
     };
 }
-export interface TraceEventMarkLoad extends TraceEventInstant {
+export interface MarkLoad extends Instant {
     name: 'MarkLoad';
-    args: TraceEventArgs & {
-        data?: TraceEventArgsData & {
+    args: Args & {
+        data?: ArgsData & {
             frame: string;
             isMainFrame: boolean;
             page: string;
@@ -613,7 +623,7 @@ export interface TraceEventMarkLoad extends TraceEventInstant {
         };
     };
 }
-export interface TraceEventAsync extends TraceEventData {
+export interface Async extends Event {
     ph: Phase.ASYNC_NESTABLE_START | Phase.ASYNC_NESTABLE_INSTANT | Phase.ASYNC_NESTABLE_END | Phase.ASYNC_STEP_INTO | Phase.ASYNC_BEGIN | Phase.ASYNC_END | Phase.ASYNC_STEP_PAST;
 }
 export type TraceRect = [number, number, number, number];
@@ -622,7 +632,7 @@ export type TraceImpactedNode = {
     node_id: Protocol.DOM.BackendNodeId;
     old_rect: TraceRect;
 };
-type LayoutShiftData = TraceEventArgsData & {
+type LayoutShiftData = ArgsData & {
     cumulative_score: number;
     frame_max_distance: number;
     had_recent_input: boolean;
@@ -630,13 +640,16 @@ type LayoutShiftData = TraceEventArgsData & {
     is_main_frame: boolean;
     overall_max_distance: number;
     region_rects: TraceRect[];
+    /** @deprecated This value will incorrectly overreport for shifts within an iframe. */
     score: number;
+    /** This is the preferred "score", used for CLS. If `is_main_frame` is true, `score` and `weighted_score_delta` will be equal. But if the shift is from an iframe, `weighted_score_delta` will be appropriately reduced to account for the viewport size of that iframe. https://wicg.github.io/layout-instability/#subframe-weighting-factor and b/275509162 */
     weighted_score_delta: number;
+    navigationId?: string;
 };
-export interface TraceEventLayoutShift extends TraceEventInstant {
+export interface LayoutShift extends Instant {
     name: 'LayoutShift';
     normalized?: boolean;
-    args: TraceEventArgs & {
+    args: Args & {
         frame: string;
         data?: LayoutShiftData;
     };
@@ -646,24 +659,58 @@ interface LayoutShiftSessionWindowData {
     id: number;
 }
 export interface LayoutShiftParsedData {
-    screenshotSource?: string;
+    /** screenshot taken before and after this shift. Before *should* always exist, but after might not at the end of a trace. */
+    screenshots: {
+        before: SyntheticScreenshot | null;
+        after: SyntheticScreenshot | null;
+    };
     timeFromNavigation?: MicroSeconds;
     cumulativeWeightedScoreInWindow: number;
     sessionWindowData: LayoutShiftSessionWindowData;
 }
-export interface SyntheticLayoutShift extends TraceEventLayoutShift, SyntheticBasedEvent<Phase.INSTANT> {
+export interface SyntheticLayoutShift extends LayoutShift, SyntheticBased<Phase.INSTANT> {
     name: 'LayoutShift';
-    rawSourceEvent: TraceEventLayoutShift;
-    args: TraceEventArgs & {
+    rawSourceEvent: LayoutShift;
+    args: Args & {
         frame: string;
         data?: LayoutShiftData & {
-            rawEvent: TraceEventLayoutShift;
+            rawEvent: LayoutShift;
         };
     };
     parsedData: LayoutShiftParsedData;
 }
+export declare const NO_NAVIGATION = "NO_NAVIGATION";
+/**
+ * This maybe be a navigation id string from Chromium, or `NO_NAVIGATION`, which represents the
+ * portion of the trace for which we don't have any navigation event for (as it happeneded prior
+ * to the trace start).
+ */
+export type NavigationId = string | typeof NO_NAVIGATION;
+/**
+ * This is a synthetic Layout shift cluster. Not based on a raw event as there's no concept
+ * of this as a trace event.
+ */
+export interface SyntheticLayoutShiftCluster {
+    name: 'SyntheticLayoutShiftCluster';
+    clusterWindow: TraceWindowMicroSeconds;
+    clusterCumulativeScore: number;
+    events: SyntheticLayoutShift[];
+    scoreWindows: {
+        good: TraceWindowMicroSeconds;
+        needsImprovement?: TraceWindowMicroSeconds;
+        bad?: TraceWindowMicroSeconds;
+    };
+    navigationId?: NavigationId;
+    worstShiftEvent?: Event;
+    ts: MicroSeconds;
+    dur: MicroSeconds;
+    cat: '';
+    ph: Phase.COMPLETE;
+    pid: ProcessID;
+    tid: ThreadID;
+}
 export type FetchPriorityHint = 'low' | 'high' | 'auto';
-export type RenderBlocking = 'blocking' | 'non_blocking' | 'in_body_parser_blocking' | 'potentially_blocking';
+export type RenderBlocking = 'blocking' | 'non_blocking' | 'in_body_parser_blocking' | 'potentially_blocking' | 'dynamically_injected_non_blocking';
 export interface Initiator {
     type: Protocol.Network.InitiatorType;
     fetchType: string;
@@ -671,16 +718,18 @@ export interface Initiator {
     lineNumber?: number;
     url?: string;
 }
-export interface TraceEventResourceSendRequest extends TraceEventInstant {
+export interface ResourceSendRequest extends Instant {
     name: 'ResourceSendRequest';
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+    args: Args & {
+        data: ArgsData & {
             frame: string;
             requestId: string;
             url: string;
             priority: Protocol.Network.ResourcePriority;
-            resourceType: Protocol.Network.ResourceType;
-            fetchPriorityHint: FetchPriorityHint;
+            /** Added Feb 2024. https://crrev.com/c/5277583 */
+            resourceType?: Protocol.Network.ResourceType;
+            /** Added Feb 2024. https://crrev.com/c/5297615 */
+            fetchPriorityHint?: FetchPriorityHint;
             requestMethod?: string;
             renderBlocking?: RenderBlocking;
             initiator?: Initiator;
@@ -688,27 +737,27 @@ export interface TraceEventResourceSendRequest extends TraceEventInstant {
         };
     };
 }
-export interface TraceEventResourceChangePriority extends TraceEventInstant {
+export interface ResourceChangePriority extends Instant {
     name: 'ResourceChangePriority';
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+    args: Args & {
+        data: ArgsData & {
             requestId: string;
             priority: Protocol.Network.ResourcePriority;
         };
     };
 }
-export interface TraceEventResourceWillSendRequest extends TraceEventInstant {
+export interface ResourceWillSendRequest extends Instant {
     name: 'ResourceWillSendRequest';
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+    args: Args & {
+        data: ArgsData & {
             requestId: string;
         };
     };
 }
-export interface TraceEventResourceFinish extends TraceEventInstant {
+export interface ResourceFinish extends Instant {
     name: 'ResourceFinish';
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+    args: Args & {
+        data: ArgsData & {
             decodedBodyLength: number;
             didFail: boolean;
             encodedDataLength: number;
@@ -717,17 +766,17 @@ export interface TraceEventResourceFinish extends TraceEventInstant {
         };
     };
 }
-export interface TraceEventResourceReceivedData extends TraceEventInstant {
+export interface ResourceReceivedData extends Instant {
     name: 'ResourceReceivedData';
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+    args: Args & {
+        data: ArgsData & {
             encodedDataLength: number;
             frame: string;
             requestId: string;
         };
     };
 }
-interface TraceEventResourceReceiveResponseTimingData {
+interface ResourceReceiveResponseTimingData {
     connectEnd: MilliSeconds;
     connectStart: MilliSeconds;
     dnsEnd: MilliSeconds;
@@ -746,10 +795,10 @@ interface TraceEventResourceReceiveResponseTimingData {
     workerReady: MilliSeconds;
     workerStart: MilliSeconds;
 }
-export interface TraceEventResourceReceiveResponse extends TraceEventInstant {
+export interface ResourceReceiveResponse extends Instant {
     name: 'ResourceReceiveResponse';
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+    args: Args & {
+        data: ArgsData & {
             /**
              * This is the protocol used to resolve the request.
              *
@@ -766,7 +815,7 @@ export interface TraceEventResourceReceiveResponse extends TraceEventInstant {
             requestId: string;
             responseTime: MilliSeconds;
             statusCode: number;
-            timing: TraceEventResourceReceiveResponseTimingData;
+            timing?: ResourceReceiveResponseTimingData;
             connectionId: number;
             connectionReused: boolean;
             headers?: Array<{
@@ -776,10 +825,10 @@ export interface TraceEventResourceReceiveResponse extends TraceEventInstant {
         };
     };
 }
-export interface TraceEventResourceMarkAsCached extends TraceEventInstant {
+export interface ResourceMarkAsCached extends Instant {
     name: 'ResourceMarkAsCached';
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+    args: Args & {
+        data: ArgsData & {
             requestId: string;
         };
     };
@@ -794,10 +843,10 @@ export declare const enum LayoutInvalidationReason {
     FONTS_CHANGED = "Fonts changed",
     UNKNOWN = "Unknown"
 }
-export interface TraceEventLayoutInvalidationTracking extends TraceEventInstant {
-    name: KnownEventName.LayoutInvalidationTracking;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export interface LayoutInvalidationTracking extends Instant {
+    name: Name.LAYOUT_INVALIDATION_TRACKING;
+    args: Args & {
+        data: ArgsData & {
             frame: string;
             nodeId: Protocol.DOM.BackendNodeId;
             reason: LayoutInvalidationReason;
@@ -805,10 +854,10 @@ export interface TraceEventLayoutInvalidationTracking extends TraceEventInstant
         };
     };
 }
-export interface TraceEventScheduleStyleInvalidationTracking extends TraceEventInstant {
-    name: KnownEventName.ScheduleStyleInvalidationTracking;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export interface ScheduleStyleInvalidationTracking extends Instant {
+    name: Name.SCHEDULE_STYLE_INVALIDATION_TRACKING;
+    args: Args & {
+        data: ArgsData & {
             frame: string;
             nodeId: Protocol.DOM.BackendNodeId;
             invalidationSet?: string;
@@ -818,18 +867,18 @@ export interface TraceEventScheduleStyleInvalidationTracking extends TraceEventI
             changedAttribute?: string;
             changedId?: string;
             nodeName?: string;
-            stackTrace?: TraceEventCallFrame[];
+            stackTrace?: CallFrame[];
         };
     };
 }
-export declare function isTraceEventScheduleStyleInvalidationTracking(event: TraceEventData): event is TraceEventScheduleStyleInvalidationTracking;
+export declare function isScheduleStyleInvalidationTracking(event: Event): event is ScheduleStyleInvalidationTracking;
 export declare const enum StyleRecalcInvalidationReason {
     ANIMATION = "Animation"
 }
-export interface TraceEventStyleRecalcInvalidationTracking extends TraceEventInstant {
-    name: KnownEventName.StyleRecalcInvalidationTracking;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export interface StyleRecalcInvalidationTracking extends Instant {
+    name: Name.STYLE_RECALC_INVALIDATION_TRACKING;
+    args: Args & {
+        data: ArgsData & {
             frame: string;
             nodeId: Protocol.DOM.BackendNodeId;
             reason: StyleRecalcInvalidationReason;
@@ -839,11 +888,11 @@ export interface TraceEventStyleRecalcInvalidationTracking extends TraceEventIns
         };
     };
 }
-export declare function isTraceEventStyleRecalcInvalidationTracking(event: TraceEventData): event is TraceEventStyleRecalcInvalidationTracking;
-export interface TraceEventStyleInvalidatorInvalidationTracking extends TraceEventInstant {
-    name: KnownEventName.StyleInvalidatorInvalidationTracking;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export declare function isStyleRecalcInvalidationTracking(event: Event): event is StyleRecalcInvalidationTracking;
+export interface StyleInvalidatorInvalidationTracking extends Instant {
+    name: Name.STYLE_INVALIDATOR_INVALIDATION_TRACKING;
+    args: Args & {
+        data: ArgsData & {
             frame: string;
             nodeId: Protocol.DOM.BackendNodeId;
             reason: string;
@@ -857,36 +906,47 @@ export interface TraceEventStyleInvalidatorInvalidationTracking extends TraceEve
         };
     };
 }
-export declare function isTraceEventStyleInvalidatorInvalidationTracking(event: TraceEventData): event is TraceEventStyleInvalidatorInvalidationTracking;
-export interface TraceEventBeginCommitCompositorFrame extends TraceEventInstant {
-    name: KnownEventName.BeginCommitCompositorFrame;
-    args: TraceEventArgs & {
+export declare function isStyleInvalidatorInvalidationTracking(event: Event): event is StyleInvalidatorInvalidationTracking;
+export interface BeginCommitCompositorFrame extends Instant {
+    name: Name.BEGIN_COMMIT_COMPOSITOR_FRAME;
+    args: Args & {
         frame: string;
         is_mobile_optimized: boolean;
     };
 }
-export declare function isTraceEventBeginCommitCompositorFrame(event: TraceEventData): event is TraceEventBeginCommitCompositorFrame;
-export interface TraceEventScheduleStyleRecalculation extends TraceEventInstant {
-    name: KnownEventName.ScheduleStyleRecalculation;
-    args: TraceEventArgs & {
+export declare function isBeginCommitCompositorFrame(event: Event): event is BeginCommitCompositorFrame;
+export interface ParseMetaViewport extends Instant {
+    name: Name.PARSE_META_VIEWPORT;
+    args: Args & {
+        data: {
+            node_id: Protocol.DOM.BackendNodeId;
+            content: string;
+            frame?: string;
+        };
+    };
+}
+export declare function isParseMetaViewport(event: Event): event is ParseMetaViewport;
+export interface ScheduleStyleRecalculation extends Instant {
+    name: Name.SCHEDULE_STYLE_RECALCULATION;
+    args: Args & {
         data: {
             frame: string;
         };
     };
 }
-export declare function isTraceEventScheduleStyleRecalculation(event: TraceEventData): event is TraceEventScheduleStyleRecalculation;
-export interface TraceEventRenderFrameImplCreateChildFrame extends TraceEventData {
-    name: KnownEventName.RenderFrameImplCreateChildFrame;
-    args: TraceEventArgs & {
+export declare function isScheduleStyleRecalculation(event: Event): event is ScheduleStyleRecalculation;
+export interface RenderFrameImplCreateChildFrame extends Event {
+    name: Name.RENDER_FRAME_IMPL_CREATE_CHILD_FRAME;
+    args: Args & {
         child_frame_token: string;
         frame_token: string;
     };
 }
-export declare function isTraceEventRenderFrameImplCreateChildFrame(event: TraceEventData): event is TraceEventRenderFrameImplCreateChildFrame;
-export interface TraceEventPrePaint extends TraceEventComplete {
+export declare function isRenderFrameImplCreateChildFrame(event: Event): event is RenderFrameImplCreateChildFrame;
+export interface PrePaint extends Complete {
     name: 'PrePaint';
 }
-export interface TraceEventPairableAsync extends TraceEventData {
+export interface PairableAsync extends Event {
     ph: Phase.ASYNC_NESTABLE_START | Phase.ASYNC_NESTABLE_END | Phase.ASYNC_NESTABLE_INSTANT;
     id2?: {
         local?: string;
@@ -894,16 +954,16 @@ export interface TraceEventPairableAsync extends TraceEventData {
     };
     id?: string;
 }
-export interface TraceEventPairableAsyncBegin extends TraceEventPairableAsync {
+export interface PairableAsyncBegin extends PairableAsync {
     ph: Phase.ASYNC_NESTABLE_START;
 }
-export interface TraceEventPairableAsyncInstant extends TraceEventPairableAsync {
+export interface PairableAsyncInstant extends PairableAsync {
     ph: Phase.ASYNC_NESTABLE_INSTANT;
 }
-export interface TraceEventPairableAsyncEnd extends TraceEventPairableAsync {
+export interface PairableAsyncEnd extends PairableAsync {
     ph: Phase.ASYNC_NESTABLE_END;
 }
-export interface TraceEventUserTiming extends TraceEventData {
+export interface UserTiming extends Event {
     id2?: {
         local?: string;
         global?: string;
@@ -911,91 +971,57 @@ export interface TraceEventUserTiming extends TraceEventData {
     id?: string;
     cat: 'blink.user_timing';
 }
-export type TraceEventPairableUserTiming = TraceEventUserTiming & TraceEventPairableAsync;
-export interface TraceEventPerformanceMeasureBegin extends TraceEventPairableUserTiming {
-    args: TraceEventArgs & {
+export interface DomLoading extends UserTiming {
+    name: Name.DOM_LOADING;
+    args: Args & {
+        frame?: string;
+    };
+}
+export interface BeginRemoteFontLoad extends UserTiming {
+    name: Name.BEGIN_REMOTE_FONT_LOAD;
+    args: Args & {
+        display: string;
+        id: number;
+    };
+}
+export type PairableUserTiming = UserTiming & PairableAsync;
+export interface PerformanceMeasureBegin extends PairableUserTiming {
+    args: Args & {
         detail?: string;
+        stackTrace?: CallFrame[];
     };
     ph: Phase.ASYNC_NESTABLE_START;
 }
-export type TraceEventPerformanceMeasureEnd = TraceEventPairableUserTiming & TraceEventPairableAsyncEnd;
-export type TraceEventPerformanceMeasure = TraceEventPerformanceMeasureBegin | TraceEventPerformanceMeasureEnd;
-export interface TraceEventPerformanceMark extends TraceEventUserTiming {
-    args: TraceEventArgs & {
-        data?: TraceEventArgsData & {
+export type PerformanceMeasureEnd = PairableUserTiming & PairableAsyncEnd;
+export type PerformanceMeasure = PerformanceMeasureBegin | PerformanceMeasureEnd;
+export interface PerformanceMark extends UserTiming {
+    args: Args & {
+        data?: ArgsData & {
             detail?: string;
+            stackTrace?: CallFrame[];
         };
     };
     ph: Phase.INSTANT | Phase.MARK | Phase.ASYNC_NESTABLE_INSTANT;
 }
-export interface TraceEventConsoleTimeBegin extends TraceEventPairableAsyncBegin {
+export interface ConsoleTimeBegin extends PairableAsyncBegin {
     cat: 'blink.console';
 }
-export interface TraceEventConsoleTimeEnd extends TraceEventPairableAsyncEnd {
+export interface ConsoleTimeEnd extends PairableAsyncEnd {
     cat: 'blink.console';
 }
-export type TraceEventConsoleTime = TraceEventConsoleTimeBegin | TraceEventConsoleTimeEnd;
-export interface TraceEventTimeStamp extends TraceEventData {
+export type ConsoleTime = ConsoleTimeBegin | ConsoleTimeEnd;
+export interface TimeStamp extends Event {
     cat: 'devtools.timeline';
     name: 'TimeStamp';
     ph: Phase.INSTANT;
     id: string;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+    args: Args & {
+        data: ArgsData & {
             frame: string;
             message: string;
         };
     };
 }
-export interface TraceEventTargetRundown extends TraceEventData {
-    cat: 'disabled-by-default-devtools.target-rundown';
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
-            frame: string;
-            frameType: string;
-            url: string;
-            isolate: string;
-            v8context: string;
-            origin: string;
-            scriptId: number;
-            isDefault?: boolean;
-            contextType?: string;
-        };
-    };
-}
-export declare function isTraceEventTargetRundown(traceEventData: TraceEventData): traceEventData is TraceEventTargetRundown;
-export interface TraceEventScriptRundown extends TraceEventData {
-    cat: 'disabled-by-default-devtools.v8-source-rundown';
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
-            isolate: string;
-            executionContextId: number;
-            scriptId: number;
-            startLine: number;
-            startColumn: number;
-            endLine: number;
-            endColumn: number;
-            url: string;
-            hash: string;
-            isModule: boolean;
-            hasSourceUrl: boolean;
-            sourceMapUrl?: string;
-        };
-    };
-}
-export declare function isTraceEventScriptRundown(traceEventData: TraceEventData): traceEventData is TraceEventScriptRundown;
-export interface TraceEventScriptRundownSource extends TraceEventData {
-    cat: 'disabled-by-default-devtools.v8-source-rundown-sources';
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
-            isolate: string;
-            scriptId: number;
-            length?: number;
-            sourceText?: string;
-        };
-    };
-}
-export declare function isTraceEventScriptRundownSource(traceEventData: TraceEventData): traceEventData is TraceEventScriptRundownSource;
 /** ChromeFrameReporter args for PipelineReporter event.
     Matching proto: https://source.chromium.org/chromium/chromium/src/+/main:third_party/perfetto/protos/perfetto/trace/track_event/chrome_frame_reporter.proto
  */
@@ -1074,24 +1100,24 @@ declare const enum FrameType {
     FORKED = "FORKED",
     BACKFILL = "BACKFILL"
 }
-export interface TraceEventPipelineReporter extends TraceEventData {
+export interface PipelineReporter extends Event {
     id2?: {
         local?: string;
     };
     ph: Phase.ASYNC_NESTABLE_START | Phase.ASYNC_NESTABLE_END;
-    args: TraceEventArgs & {
+    args: Args & {
         chrome_frame_reporter: ChromeFrameReporter;
     };
 }
-export declare function isTraceEventPipelineReporter(event: TraceEventData): event is TraceEventPipelineReporter;
-export interface SyntheticBasedEvent<Ph extends Phase = Phase> extends TraceEventData {
+export declare function isPipelineReporter(event: Event): event is PipelineReporter;
+export interface SyntheticBased<Ph extends Phase = Phase> extends Event {
     ph: Ph;
-    rawSourceEvent: TraceEventData;
+    rawSourceEvent: Event;
     _tag: 'SyntheticEntryTag';
 }
-export declare function isSyntheticBasedEvent(event: TraceEventData): event is SyntheticBasedEvent;
-export interface SyntheticEventPair<T extends TraceEventPairableAsync = TraceEventPairableAsync> extends SyntheticBasedEvent {
-    rawSourceEvent: TraceEventData;
+export declare function isSyntheticBased(event: Event): event is SyntheticBased;
+export interface SyntheticEventPair<T extends PairableAsync = PairableAsync> extends SyntheticBased {
+    rawSourceEvent: Event;
     name: T['name'];
     cat: T['cat'];
     id?: string;
@@ -1100,19 +1126,19 @@ export interface SyntheticEventPair<T extends TraceEventPairableAsync = TraceEve
         global?: string;
     };
     dur: MicroSeconds;
-    args: TraceEventArgs & {
+    args: Args & {
         data: {
-            beginEvent: T & TraceEventPairableAsyncBegin;
-            endEvent: T & TraceEventPairableAsyncEnd;
-            instantEvents?: Array<T & TraceEventPairableAsyncInstant>;
+            beginEvent: T & PairableAsyncBegin;
+            endEvent: T & PairableAsyncEnd;
+            instantEvents?: Array<T & PairableAsyncInstant>;
         };
     };
 }
-export type SyntheticPipelineReporterPair = SyntheticEventPair<TraceEventPipelineReporter>;
-export type SyntheticUserTimingPair = SyntheticEventPair<TraceEventPerformanceMeasure>;
-export type SyntheticConsoleTimingPair = SyntheticEventPair<TraceEventConsoleTime>;
-export type SyntheticAnimationPair = SyntheticEventPair<TraceEventAnimation>;
-export interface SyntheticInteractionPair extends SyntheticEventPair<TraceEventEventTiming> {
+export type SyntheticPipelineReporterPair = SyntheticEventPair<PipelineReporter>;
+export type SyntheticUserTimingPair = SyntheticEventPair<PerformanceMeasure>;
+export type SyntheticConsoleTimingPair = SyntheticEventPair<ConsoleTime>;
+export type SyntheticAnimationPair = SyntheticEventPair<Animation>;
+export interface SyntheticInteractionPair extends SyntheticEventPair<EventTiming> {
     interactionId: number;
     type: string;
     ts: MicroSeconds;
@@ -1135,97 +1161,116 @@ export interface SyntheticInteractionPair extends SyntheticEventPair<TraceEventE
  * point in time that the sample was created, we also have to store the ID of
  * the Node that points to the function call that this profile call represents.
  */
-export interface SyntheticProfileCall extends TraceEventData {
+export interface SyntheticProfileCall extends Event {
     callFrame: Protocol.Runtime.CallFrame;
     nodeId: Protocol.integer;
     sampleIndex: number;
     profileId: ProfileID;
 }
+/**
+ * A synthetic event created from the Server-Timing header of network
+ * request. In order to create these synthetic events, the corresponding
+ * metric (timing) in the header must contain a "start" param, which
+ * corresponds to the timestamp of the metric in the server. The
+ * ServerTimingsHandler implements a heuristic to estimate the offset
+ * between the client clock and the server clock so that the server
+ * timestamp can be translated to the tracing clock.
+ */
+export interface SyntheticServerTiming<T extends Phase = Phase.COMPLETE> extends SyntheticBased<T> {
+    rawSourceEvent: ResourceSendRequest;
+    cat: 'devtools.server-timing';
+    args: Args & {
+        data: ArgsData & {
+            desc?: string;
+            origin: string;
+        };
+    };
+}
 /**
  * A JS Sample reflects a single sample from the V8 CPU Profile
  */
-export interface SyntheticJSSample extends TraceEventData {
-    name: KnownEventName.JSSample;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export interface SyntheticJSSample extends Event {
+    name: Name.JS_SAMPLE;
+    args: Args & {
+        data: ArgsData & {
             stackTrace: Protocol.Runtime.CallFrame[];
         };
     };
     ph: Phase.INSTANT;
 }
-export declare function isSyntheticInteractionEvent(event: TraceEventData): event is SyntheticInteractionPair;
-export interface TraceEventDrawFrame extends TraceEventInstant {
-    name: KnownEventName.DrawFrame;
-    args: TraceEventArgs & {
+export declare function isSyntheticInteraction(event: Event): event is SyntheticInteractionPair;
+export interface DrawFrame extends Instant {
+    name: Name.DRAW_FRAME;
+    args: Args & {
         layerTreeId: number;
         frameSeqId: number;
     };
 }
-export declare function isTraceEventDrawFrame(event: TraceEventData): event is TraceEventDrawFrame;
-export interface TraceEventLegacyDrawFrameBegin extends TraceEventAsync {
-    name: KnownEventName.DrawFrame;
+export declare function isDrawFrame(event: Event): event is DrawFrame;
+export interface LegacyDrawFrameBegin extends Async {
+    name: Name.DRAW_FRAME;
     ph: Phase.ASYNC_NESTABLE_START;
-    args: TraceEventArgs & {
+    args: Args & {
         layerTreeId: number;
         frameSeqId: number;
     };
 }
-export declare function isLegacyTraceEventDrawFrameBegin(event: TraceEventData): event is TraceEventLegacyDrawFrameBegin;
-export interface TraceEventBeginFrame extends TraceEventInstant {
-    name: KnownEventName.BeginFrame;
-    args: TraceEventArgs & {
+export declare function isLegacyTraceEventDrawFrameBegin(event: Event): event is LegacyDrawFrameBegin;
+export interface BeginFrame extends Instant {
+    name: Name.BEGIN_FRAME;
+    args: Args & {
         layerTreeId: number;
         frameSeqId: number;
     };
 }
-export declare function isTraceEventBeginFrame(event: TraceEventData): event is TraceEventBeginFrame;
-export interface TraceEventDroppedFrame extends TraceEventInstant {
-    name: KnownEventName.DroppedFrame;
-    args: TraceEventArgs & {
+export declare function isBeginFrame(event: Event): event is BeginFrame;
+export interface DroppedFrame extends Instant {
+    name: Name.DROPPED_FRAME;
+    args: Args & {
         layerTreeId: number;
         frameSeqId: number;
         hasPartialUpdate?: boolean;
     };
 }
-export declare function isTraceEventDroppedFrame(event: TraceEventData): event is TraceEventDroppedFrame;
-export interface TraceEventRequestMainThreadFrame extends TraceEventInstant {
-    name: KnownEventName.RequestMainThreadFrame;
-    args: TraceEventArgs & {
+export declare function isDroppedFrame(event: Event): event is DroppedFrame;
+export interface RequestMainThreadFrame extends Instant {
+    name: Name.REQUEST_MAIN_THREAD_FRAME;
+    args: Args & {
         layerTreeId: number;
     };
 }
-export declare function isTraceEventRequestMainThreadFrame(event: TraceEventData): event is TraceEventRequestMainThreadFrame;
-export interface TraceEventBeginMainThreadFrame extends TraceEventInstant {
-    name: KnownEventName.BeginMainThreadFrame;
-    args: TraceEventArgs & {
+export declare function isRequestMainThreadFrame(event: Event): event is RequestMainThreadFrame;
+export interface BeginMainThreadFrame extends Instant {
+    name: Name.BEGIN_MAIN_THREAD_FRAME;
+    args: Args & {
         layerTreeId: number;
-        data: TraceEventArgsData & {
+        data: ArgsData & {
             frameId?: number;
         };
     };
 }
-export declare function isTraceEventBeginMainThreadFrame(event: TraceEventData): event is TraceEventBeginMainThreadFrame;
-export interface TraceEventNeedsBeginFrameChanged extends TraceEventInstant {
-    name: KnownEventName.NeedsBeginFrameChanged;
-    args: TraceEventArgs & {
+export declare function isBeginMainThreadFrame(event: Event): event is BeginMainThreadFrame;
+export interface NeedsBeginFrameChanged extends Instant {
+    name: Name.NEEDS_BEGIN_FRAME_CHANGED;
+    args: Args & {
         layerTreeId: number;
-        data: TraceEventArgsData & {
+        data: ArgsData & {
             needsBeginFrame: number;
         };
     };
 }
-export declare function isTraceEventNeedsBeginFrameChanged(event: TraceEventData): event is TraceEventNeedsBeginFrameChanged;
-export interface TraceEventCommit extends TraceEventInstant {
-    name: KnownEventName.Commit;
-    args: TraceEventArgs & {
+export declare function isNeedsBeginFrameChanged(event: Event): event is NeedsBeginFrameChanged;
+export interface Commit extends Instant {
+    name: Name.COMMIT;
+    args: Args & {
         layerTreeId: number;
         frameSeqId: number;
     };
 }
-export declare function isTraceEventCommit(event: TraceEventData): event is TraceEventCommit;
-export interface TraceEventRasterTask extends TraceEventComplete {
-    name: KnownEventName.RasterTask;
-    args: TraceEventArgs & {
+export declare function isCommit(event: Event): event is Commit;
+export interface RasterTask extends Complete {
+    name: Name.RASTER_TASK;
+    args: Args & {
         tileData?: {
             layerId: number;
             sourceFrameNumber: number;
@@ -1236,45 +1281,45 @@ export interface TraceEventRasterTask extends TraceEventComplete {
         };
     };
 }
-export declare function isTraceEventRasterTask(event: TraceEventData): event is TraceEventRasterTask;
-export interface TraceEventCompositeLayers extends TraceEventInstant {
-    name: KnownEventName.CompositeLayers;
-    args: TraceEventArgs & {
+export declare function isRasterTask(event: Event): event is RasterTask;
+export interface CompositeLayers extends Instant {
+    name: Name.COMPOSITE_LAYERS;
+    args: Args & {
         layerTreeId: number;
     };
 }
-export declare function isTraceEventCompositeLayers(event: TraceEventData): event is TraceEventCompositeLayers;
-export interface TraceEventActivateLayerTree extends TraceEventInstant {
-    name: KnownEventName.ActivateLayerTree;
-    args: TraceEventArgs & {
+export declare function isCompositeLayers(event: Event): event is CompositeLayers;
+export interface ActivateLayerTree extends Instant {
+    name: Name.ACTIVATE_LAYER_TREE;
+    args: Args & {
         layerTreeId: number;
         frameId: number;
     };
 }
-export declare function isTraceEventActivateLayerTree(event: TraceEventData): event is TraceEventActivateLayerTree;
-export type InvalidationTrackingEvent = TraceEventScheduleStyleInvalidationTracking | TraceEventStyleRecalcInvalidationTracking | TraceEventStyleInvalidatorInvalidationTracking | TraceEventLayoutInvalidationTracking;
-export declare function isTraceEventInvalidationTracking(event: TraceEventData): event is InvalidationTrackingEvent;
-export interface TraceEventDrawLazyPixelRef extends TraceEventInstant {
-    name: KnownEventName.DrawLazyPixelRef;
-    args?: TraceEventArgs & {
+export declare function isActivateLayerTree(event: Event): event is ActivateLayerTree;
+export type InvalidationTrackingEvent = ScheduleStyleInvalidationTracking | StyleRecalcInvalidationTracking | StyleInvalidatorInvalidationTracking | LayoutInvalidationTracking;
+export declare function isInvalidationTracking(event: Event): event is InvalidationTrackingEvent;
+export interface DrawLazyPixelRef extends Instant {
+    name: Name.DRAW_LAZY_PIXEL_REF;
+    args?: Args & {
         LazyPixelRef: number;
     };
 }
-export declare function isTraceEventDrawLazyPixelRef(event: TraceEventData): event is TraceEventDrawLazyPixelRef;
-export interface TraceEventDecodeLazyPixelRef extends TraceEventInstant {
-    name: KnownEventName.DecodeLazyPixelRef;
-    args?: TraceEventArgs & {
+export declare function isDrawLazyPixelRef(event: Event): event is DrawLazyPixelRef;
+export interface DecodeLazyPixelRef extends Instant {
+    name: Name.DECODE_LAZY_PIXEL_REF;
+    args?: Args & {
         LazyPixelRef: number;
     };
 }
-export declare function isTraceEventDecodeLazyPixelRef(event: TraceEventData): event is TraceEventDecodeLazyPixelRef;
-export interface TraceEventDecodeImage extends TraceEventComplete {
-    name: KnownEventName.DecodeImage;
-    args: TraceEventArgs & {
+export declare function isDecodeLazyPixelRef(event: Event): event is DecodeLazyPixelRef;
+export interface DecodeImage extends Complete {
+    name: Name.DECODE_IMAGE;
+    args: Args & {
         imageType: string;
     };
 }
-export declare function isTraceEventDecodeImage(event: TraceEventData): event is TraceEventDecodeImage;
+export declare function isDecodeImage(event: Event): event is DecodeImage;
 export interface SelectorTiming {
     'elapsed (us)': number;
     'fast_reject_count': number;
@@ -1283,30 +1328,39 @@ export interface SelectorTiming {
     'style_sheet_id': string;
     'match_count': number;
 }
+export declare enum SelectorTimingsKey {
+    Elapsed = "elapsed (us)",
+    RejectPercentage = "reject_percentage",
+    FastRejectCount = "fast_reject_count",
+    MatchAttempts = "match_attempts",
+    MatchCount = "match_count",
+    Selector = "selector",
+    StyleSheetId = "style_sheet_id"
+}
 export interface SelectorStats {
     selector_timings: SelectorTiming[];
 }
-export interface TraceEventSelectorStats extends TraceEventComplete {
-    name: KnownEventName.SelectorStats;
-    args: TraceEventArgs & {
+export interface SelectorStats extends Complete {
+    name: Name.SELECTOR_STATS;
+    args: Args & {
         selector_stats?: SelectorStats;
     };
 }
-export declare function isTraceEventSelectorStats(event: TraceEventData): event is TraceEventSelectorStats;
-export interface TraceEventUpdateLayoutTree extends TraceEventComplete {
-    name: KnownEventName.UpdateLayoutTree;
-    args: TraceEventArgs & {
+export declare function isSelectorStats(event: Event): event is SelectorStats;
+export interface UpdateLayoutTree extends Complete {
+    name: Name.UPDATE_LAYOUT_TREE;
+    args: Args & {
         elementCount: number;
         beginData?: {
             frame: string;
-            stackTrace?: TraceEventCallFrame[];
+            stackTrace?: CallFrame[];
         };
     };
 }
-export declare function isTraceEventUpdateLayoutTree(event: TraceEventData): event is TraceEventUpdateLayoutTree;
-export interface TraceEventLayout extends TraceEventComplete {
-    name: KnownEventName.Layout;
-    args: TraceEventArgs & {
+export declare function isUpdateLayoutTree(event: Event): event is UpdateLayoutTree;
+export interface Layout extends Complete {
+    name: Name.LAYOUT;
+    args: Args & {
         beginData: {
             frame: string;
             dirtyObjects: number;
@@ -1322,17 +1376,17 @@ export interface TraceEventLayout extends TraceEventComplete {
         };
     };
 }
-export declare function isTraceEventLayout(event: TraceEventData): event is TraceEventLayout;
-export interface TraceEventInvalidateLayout extends TraceEventInstant {
-    name: KnownEventName.InvalidateLayout;
-    args: TraceEventArgs & {
+export declare function isLayout(event: Event): event is Layout;
+export interface InvalidateLayout extends Instant {
+    name: Name.INVALIDATE_LAYOUT;
+    args: Args & {
         data: {
             frame: string;
             nodeId: Protocol.DOM.BackendNodeId;
         };
     };
 }
-export declare function isTraceEventInvalidateLayout(event: TraceEventData): event is TraceEventInvalidateLayout;
+export declare function isInvalidateLayout(event: Event): event is InvalidateLayout;
 declare class ProfileIdTag {
     #private;
 }
@@ -1363,70 +1417,74 @@ declare class WorkerIdTag {
 }
 export type WorkerId = string & WorkerIdTag;
 export declare function WorkerId(value: string): WorkerId;
-export declare function isTraceEventComplete(event: TraceEventData): event is TraceEventComplete;
-export declare function isTraceEventBegin(event: TraceEventData): event is TraceEventBegin;
-export declare function isTraceEventEnd(event: TraceEventData): event is TraceEventEnd;
-export declare function isTraceEventDispatch(event: TraceEventData): event is TraceEventDispatch;
-export declare function isTraceEventInstant(event: TraceEventData): event is TraceEventInstant;
-export declare function isTraceEventRendererEvent(event: TraceEventData): event is TraceEventRendererEvent;
-export declare function isTraceEventFireIdleCallback(event: TraceEventData): event is TraceEventFireIdleCallback;
-export declare function isTraceEventSchedulePostMessage(event: TraceEventData): event is TraceEventSchedulePostMessage;
-export declare function isTraceEventHandlePostMessage(event: TraceEventData): event is TraceEventHandlePostMessage;
-export declare function isTraceEventUpdateCounters(event: TraceEventData): event is TraceEventUpdateCounters;
-export declare function isThreadName(traceEventData: TraceEventData): traceEventData is TraceEventThreadName;
-export declare function isProcessName(traceEventData: TraceEventData): traceEventData is TraceEventProcessName;
-export declare function isTraceEventTracingStartedInBrowser(traceEventData: TraceEventData): traceEventData is TraceEventTracingStartedInBrowser;
-export declare function isTraceEventFrameCommittedInBrowser(traceEventData: TraceEventData): traceEventData is TraceEventFrameCommittedInBrowser;
-export declare function isTraceEventCommitLoad(traceEventData: TraceEventData): traceEventData is TraceEventCommitLoad;
-export declare function isTraceEventNavigationStart(traceEventData: TraceEventData): traceEventData is TraceEventNavigationStart;
-export declare function isTraceEventAnimation(traceEventData: TraceEventData): traceEventData is TraceEventAnimation;
-export declare function isTraceEventLayoutShift(traceEventData: TraceEventData): traceEventData is TraceEventLayoutShift;
-export declare function isTraceEventLayoutInvalidationTracking(traceEventData: TraceEventData): traceEventData is TraceEventLayoutInvalidationTracking;
-export declare function isTraceEventFirstContentfulPaint(traceEventData: TraceEventData): traceEventData is TraceEventFirstContentfulPaint;
-export declare function isTraceEventLargestContentfulPaintCandidate(traceEventData: TraceEventData): traceEventData is TraceEventLargestContentfulPaintCandidate;
-export declare function isTraceEventLargestImagePaintCandidate(traceEventData: TraceEventData): traceEventData is TraceEventLargestImagePaintCandidate;
-export declare function isTraceEventLargestTextPaintCandidate(traceEventData: TraceEventData): traceEventData is TraceEventLargestTextPaintCandidate;
-export declare function isTraceEventMarkLoad(traceEventData: TraceEventData): traceEventData is TraceEventMarkLoad;
-export declare function isTraceEventFirstPaint(traceEventData: TraceEventData): traceEventData is TraceEventFirstPaint;
-export declare function isTraceEventMarkDOMContent(traceEventData: TraceEventData): traceEventData is TraceEventMarkDOMContent;
-export declare function isTraceEventInteractiveTime(traceEventData: TraceEventData): traceEventData is TraceEventInteractiveTime;
-export declare function isTraceEventEventTiming(traceEventData: TraceEventData): traceEventData is TraceEventEventTiming;
-export declare function isTraceEventEventTimingEnd(traceEventData: TraceEventData): traceEventData is TraceEventEventTimingEnd;
-export declare function isTraceEventEventTimingStart(traceEventData: TraceEventData): traceEventData is TraceEventEventTimingBegin;
-export declare function isTraceEventGPUTask(traceEventData: TraceEventData): traceEventData is TraceEventGPUTask;
-export declare function isTraceEventProfile(traceEventData: TraceEventData): traceEventData is TraceEventProfile;
-export declare function isSyntheticCpuProfile(traceEventData: TraceEventData): traceEventData is SyntheticCpuProfile;
-export declare function isTraceEventProfileChunk(traceEventData: TraceEventData): traceEventData is TraceEventProfileChunk;
-export declare function isTraceEventResourceChangePriority(traceEventData: TraceEventData): traceEventData is TraceEventResourceChangePriority;
-export declare function isTraceEventResourceSendRequest(traceEventData: TraceEventData): traceEventData is TraceEventResourceSendRequest;
-export declare function isTraceEventResourceReceiveResponse(traceEventData: TraceEventData): traceEventData is TraceEventResourceReceiveResponse;
-export declare function isTraceEventResourceMarkAsCached(traceEventData: TraceEventData): traceEventData is TraceEventResourceMarkAsCached;
-export declare function isTraceEventResourceFinish(traceEventData: TraceEventData): traceEventData is TraceEventResourceFinish;
-export declare function isTraceEventResourceWillSendRequest(traceEventData: TraceEventData): traceEventData is TraceEventResourceWillSendRequest;
-export declare function isTraceEventResourceReceivedData(traceEventData: TraceEventData): traceEventData is TraceEventResourceReceivedData;
-export declare function isSyntheticNetworkRequestEvent(traceEventData: TraceEventData): traceEventData is SyntheticNetworkRequest;
-export declare function isSyntheticWebSocketConnectionEvent(traceEventData: TraceEventData): traceEventData is SyntheticWebSocketConnectionEvent;
-export declare function isNetworkTrackEntry(traceEventData: TraceEventData): traceEventData is SyntheticWebSocketConnectionEvent | SyntheticNetworkRequest;
-export declare function isTraceEventPrePaint(traceEventData: TraceEventData): traceEventData is TraceEventPrePaint;
-export declare function isTraceEventNavigationStartWithURL(event: TraceEventData): event is TraceEventNavigationStart;
-export declare function isTraceEventMainFrameViewport(traceEventData: TraceEventData): traceEventData is TraceEventMainFrameViewport;
-export declare function isSyntheticUserTiming(traceEventData: TraceEventData): traceEventData is SyntheticUserTimingPair;
-export declare function isSyntheticConsoleTiming(traceEventData: TraceEventData): traceEventData is SyntheticConsoleTimingPair;
-export declare function isTraceEventPerformanceMeasure(traceEventData: TraceEventData): traceEventData is TraceEventPerformanceMeasure;
-export declare function isTraceEventPerformanceMark(traceEventData: TraceEventData): traceEventData is TraceEventPerformanceMark;
-export declare function isTraceEventConsoleTime(traceEventData: TraceEventData): traceEventData is TraceEventConsoleTime;
-export declare function isTraceEventTimeStamp(traceEventData: TraceEventData): traceEventData is TraceEventTimeStamp;
-export declare function isTraceEventParseHTML(traceEventData: TraceEventData): traceEventData is TraceEventParseHTML;
-export interface TraceEventAsync extends TraceEventData {
+export declare function isComplete(event: Event): event is Complete;
+export declare function isBegin(event: Event): event is Begin;
+export declare function isEnd(event: Event): event is End;
+export declare function isDispatch(event: Event): event is Dispatch;
+export declare function isInstant(event: Event): event is Instant;
+export declare function isRendererEvent(event: Event): event is RendererEvent;
+export declare function isFireIdleCallback(event: Event): event is FireIdleCallback;
+export declare function isSchedulePostMessage(event: Event): event is SchedulePostMessage;
+export declare function isHandlePostMessage(event: Event): event is HandlePostMessage;
+export declare function isUpdateCounters(event: Event): event is UpdateCounters;
+export declare function isThreadName(event: Event): event is ThreadName;
+export declare function isProcessName(event: Event): event is ProcessName;
+export declare function isTracingStartedInBrowser(event: Event): event is TracingStartedInBrowser;
+export declare function isFrameCommittedInBrowser(event: Event): event is FrameCommittedInBrowser;
+export declare function isCommitLoad(event: Event): event is CommitLoad;
+export declare function isNavigationStart(event: Event): event is NavigationStart;
+export declare function isAnimation(event: Event): event is Animation;
+export declare function isSyntheticAnimation(event: Event): event is SyntheticAnimationPair;
+export declare function isLayoutShift(event: Event): event is LayoutShift;
+export declare function isLayoutInvalidationTracking(event: Event): event is LayoutInvalidationTracking;
+export declare function isFirstContentfulPaint(event: Event): event is FirstContentfulPaint;
+export declare function isLargestContentfulPaintCandidate(event: Event): event is LargestContentfulPaintCandidate;
+export declare function isLargestImagePaintCandidate(event: Event): event is LargestImagePaintCandidate;
+export declare function isLargestTextPaintCandidate(event: Event): event is LargestTextPaintCandidate;
+export declare function isMarkLoad(event: Event): event is MarkLoad;
+export declare function isFirstPaint(event: Event): event is FirstPaint;
+export declare function isMarkDOMContent(event: Event): event is MarkDOMContent;
+export declare function isInteractiveTime(event: Event): event is InteractiveTime;
+export declare function isEventTiming(event: Event): event is EventTiming;
+export declare function isEventTimingEnd(event: Event): event is EventTimingEnd;
+export declare function isEventTimingStart(event: Event): event is EventTimingBegin;
+export declare function isGPUTask(event: Event): event is GPUTask;
+export declare function isProfile(event: Event): event is Profile;
+export declare function isSyntheticCpuProfile(event: Event): event is SyntheticCpuProfile;
+export declare function isProfileChunk(event: Event): event is ProfileChunk;
+export declare function isResourceChangePriority(event: Event): event is ResourceChangePriority;
+export declare function isResourceSendRequest(event: Event): event is ResourceSendRequest;
+export declare function isResourceReceiveResponse(event: Event): event is ResourceReceiveResponse;
+export declare function isResourceMarkAsCached(event: Event): event is ResourceMarkAsCached;
+export declare function isResourceFinish(event: Event): event is ResourceFinish;
+export declare function isResourceWillSendRequest(event: Event): event is ResourceWillSendRequest;
+export declare function isResourceReceivedData(event: Event): event is ResourceReceivedData;
+export declare function isSyntheticNetworkRequest(event: Event): event is SyntheticNetworkRequest;
+export declare function isSyntheticWebSocketConnection(event: Event): event is SyntheticWebSocketConnection;
+export declare function isNetworkTrackEntry(event: Event): event is SyntheticWebSocketConnection | SyntheticNetworkRequest;
+export declare function isPrePaint(event: Event): event is PrePaint;
+export declare function isNavigationStartWithURL(event: Event): event is NavigationStart;
+export declare function isMainFrameViewport(event: Event): event is MainFrameViewport;
+export declare function isSyntheticUserTiming(event: Event): event is SyntheticUserTimingPair;
+export declare function isSyntheticConsoleTiming(event: Event): event is SyntheticConsoleTimingPair;
+export declare function isUserTiming(event: Event): event is UserTiming;
+export declare function isDomLoading(event: Event): event is DomLoading;
+export declare function isBeginRemoteFontLoad(event: Event): event is BeginRemoteFontLoad;
+export declare function isPerformanceMeasure(event: Event): event is PerformanceMeasure;
+export declare function isPerformanceMark(event: Event): event is PerformanceMark;
+export declare function isConsoleTime(event: Event): event is ConsoleTime;
+export declare function isTimeStamp(event: Event): event is TimeStamp;
+export declare function isParseHTML(event: Event): event is ParseHTML;
+export interface Async extends Event {
     ph: Phase.ASYNC_NESTABLE_START | Phase.ASYNC_NESTABLE_INSTANT | Phase.ASYNC_NESTABLE_END | Phase.ASYNC_STEP_INTO | Phase.ASYNC_BEGIN | Phase.ASYNC_END | Phase.ASYNC_STEP_PAST;
 }
-export declare function isTraceEventAsyncPhase(traceEventData: TraceEventData): boolean;
-export declare function isSyntheticLayoutShift(traceEventData: TraceEventData): traceEventData is SyntheticLayoutShift;
-export declare function isProfileCall(event: TraceEventData): event is SyntheticProfileCall;
-export interface TraceEventPaint extends TraceEventComplete {
-    name: KnownEventName.Paint;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export declare function isSyntheticLayoutShift(event: Event): event is SyntheticLayoutShift;
+export declare function isSyntheticLayoutShiftCluster(event: Event): event is SyntheticLayoutShiftCluster;
+export declare function isProfileCall(event: Event): event is SyntheticProfileCall;
+export interface Paint extends Complete {
+    name: Name.PAINT;
+    args: Args & {
+        data: ArgsData & {
             clip: number[];
             frame: string;
             layerId: number;
@@ -1434,11 +1492,11 @@ export interface TraceEventPaint extends TraceEventComplete {
         };
     };
 }
-export declare function isTraceEventPaint(event: TraceEventData): event is TraceEventPaint;
-export interface TraceEventPaintImage extends TraceEventComplete {
-    name: KnownEventName.PaintImage;
-    args: TraceEventArgs & {
-        data: TraceEventData & {
+export declare function isPaint(event: Event): event is Paint;
+export interface PaintImage extends Complete {
+    name: Name.PAINT_IMAGE;
+    args: Args & {
+        data: Event & {
             height: number;
             width: number;
             x: number;
@@ -1450,42 +1508,42 @@ export interface TraceEventPaintImage extends TraceEventComplete {
         };
     };
 }
-export declare function isTraceEventPaintImage(event: TraceEventData): event is TraceEventPaintImage;
-export interface TraceEventScrollLayer extends TraceEventComplete {
-    name: KnownEventName.ScrollLayer;
-    args: TraceEventArgs & {
-        data: TraceEventData & {
+export declare function isPaintImage(event: Event): event is PaintImage;
+export interface ScrollLayer extends Complete {
+    name: Name.SCROLL_LAYER;
+    args: Args & {
+        data: Event & {
             frame: string;
             nodeId?: Protocol.DOM.BackendNodeId;
         };
     };
 }
-export declare function isTraceEventScrollLayer(event: TraceEventData): event is TraceEventScrollLayer;
-export interface TraceEventSetLayerTreeId extends TraceEventInstant {
-    name: KnownEventName.SetLayerTreeId;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export declare function isScrollLayer(event: Event): event is ScrollLayer;
+export interface SetLayerTreeId extends Instant {
+    name: Name.SET_LAYER_TREE_ID;
+    args: Args & {
+        data: ArgsData & {
             frame: string;
             layerTreeId: number;
         };
     };
 }
-export declare function isTraceEventSetLayerId(event: TraceEventData): event is TraceEventSetLayerTreeId;
-export interface TraceEventUpdateLayer extends TraceEventComplete {
-    name: KnownEventName.UpdateLayer;
-    args: TraceEventArgs & {
+export declare function isSetLayerId(event: Event): event is SetLayerTreeId;
+export interface UpdateLayer extends Complete {
+    name: Name.UPDATE_LAYER;
+    args: Args & {
         layerId: number;
         layerTreeId: number;
     };
 }
-export declare function isTraceEventUpdateLayer(event: TraceEventData): event is TraceEventUpdateLayer;
-export interface TraceEventDisplayItemListSnapshot extends TraceEventData {
-    name: KnownEventName.DisplayItemListSnapshot;
+export declare function isUpdateLayer(event: Event): event is UpdateLayer;
+export interface DisplayItemListSnapshot extends Event {
+    name: Name.DISPLAY_ITEM_LIST_SNAPSHOT;
     ph: Phase.OBJECT_SNAPSHOT;
     id2: {
         local?: string;
     };
-    args: TraceEventArgs & {
+    args: Args & {
         snapshot: {
             skp64: string;
             params?: {
@@ -1494,12 +1552,12 @@ export interface TraceEventDisplayItemListSnapshot extends TraceEventData {
         };
     };
 }
-export declare function isTraceEventDisplayListItemListSnapshot(event: TraceEventData): event is TraceEventDisplayItemListSnapshot;
-export interface TraceEventLayerTreeHostImplSnapshot extends TraceEventData {
-    name: KnownEventName.LayerTreeHostImplSnapshot;
+export declare function isDisplayListItemListSnapshot(event: Event): event is DisplayItemListSnapshot;
+export interface LayerTreeHostImplSnapshot extends Event {
+    name: Name.LAYER_TREE_HOST_IMPL_SNAPSHOT;
     ph: Phase.OBJECT_SNAPSHOT;
     id: string;
-    args: TraceEventArgs & {
+    args: Args & {
         snapshot: {
             active_tiles: Array<{
                 id: string;
@@ -1518,7 +1576,7 @@ export interface TraceEventLayerTreeHostImplSnapshot extends TraceEventData {
         };
     };
 }
-export declare function isTraceEventLayerTreeHostImplSnapshot(event: TraceEventData): event is TraceEventLayerTreeHostImplSnapshot;
+export declare function isLayerTreeHostImplSnapshot(event: Event): event is LayerTreeHostImplSnapshot;
 export interface TraceLayer {
     bounds: {
         height: number;
@@ -1546,80 +1604,80 @@ export interface TracingLayerTile {
     gpu_memory_usage: number;
     content_rect: number[];
 }
-export interface TraceEventFireAnimationFrame extends TraceEventComplete {
-    name: KnownEventName.FireAnimationFrame;
-    args: TraceEventArgs & {
+export interface FireAnimationFrame extends Complete {
+    name: Name.FIRE_ANIMATION_FRAME;
+    args: Args & {
         data: {
             frame: string;
             id: number;
         };
     };
 }
-export declare function isTraceEventFireAnimationFrame(event: TraceEventData): event is TraceEventFireAnimationFrame;
-export interface TraceEventRequestAnimationFrame extends TraceEventInstant {
-    name: KnownEventName.RequestAnimationFrame;
-    args: TraceEventArgs & {
+export declare function isFireAnimationFrame(event: Event): event is FireAnimationFrame;
+export interface RequestAnimationFrame extends Instant {
+    name: Name.REQUEST_ANIMATION_FRAME;
+    args: Args & {
         data: {
             frame: string;
             id: number;
-            stackTrace?: TraceEventCallFrame;
+            stackTrace?: CallFrame;
         };
     };
 }
-export declare function isTraceEventRequestAnimationFrame(event: TraceEventData): event is TraceEventRequestAnimationFrame;
-export interface TraceEventTimerInstall extends TraceEventInstant {
-    name: KnownEventName.TimerInstall;
-    args: TraceEventArgs & {
+export declare function isRequestAnimationFrame(event: Event): event is RequestAnimationFrame;
+export interface TimerInstall extends Instant {
+    name: Name.TIMER_INSTALL;
+    args: Args & {
         data: {
             frame: string;
             singleShot: boolean;
-            stackTrace?: TraceEventCallFrame;
+            stackTrace?: CallFrame;
             timeout: number;
             timerId: number;
         };
     };
 }
-export declare function isTraceEventTimerInstall(event: TraceEventData): event is TraceEventTimerInstall;
-export interface TraceEventTimerFire extends TraceEventComplete {
-    name: KnownEventName.TimerFire;
-    args: TraceEventArgs & {
+export declare function isTimerInstall(event: Event): event is TimerInstall;
+export interface TimerFire extends Complete {
+    name: Name.TIMER_FIRE;
+    args: Args & {
         data: {
             frame: string;
             timerId: number;
         };
     };
 }
-export declare function isTraceEventTimerFire(event: TraceEventData): event is TraceEventTimerFire;
-export interface TraceEventRequestIdleCallback extends TraceEventInstant {
-    name: KnownEventName.RequestIdleCallback;
-    args: TraceEventArgs & {
+export declare function isTimerFire(event: Event): event is TimerFire;
+export interface RequestIdleCallback extends Instant {
+    name: Name.REQUEST_IDLE_CALLBACK;
+    args: Args & {
         data: {
             frame: string;
             id: number;
             timeout: number;
-            stackTrace?: TraceEventCallFrame;
+            stackTrace?: CallFrame;
         };
     };
 }
-export declare function isTraceEventRequestIdleCallback(event: TraceEventData): event is TraceEventRequestIdleCallback;
-export interface TraceEventWebSocketCreate extends TraceEventInstant {
-    name: KnownEventName.WebSocketCreate;
-    args: TraceEventArgs & {
+export declare function isRequestIdleCallback(event: Event): event is RequestIdleCallback;
+export interface WebSocketCreate extends Instant {
+    name: Name.WEB_SOCKET_CREATE;
+    args: Args & {
         data: {
             identifier: number;
             url: string;
             frame?: string;
             workerId?: string;
             websocketProtocol?: string;
-            stackTrace?: TraceEventCallFrame;
+            stackTrace?: CallFrame;
         };
     };
 }
-export declare function isTraceEventWebSocketCreate(event: TraceEventData): event is TraceEventWebSocketCreate;
-export interface TraceEventWebSocketInfo extends TraceEventInstant {
-    name: KnownEventName.WebSocketDestroy | KnownEventName.WebSocketReceiveHandshake | KnownEventName.WebSocketReceiveHandshakeResponse;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export declare function isWebSocketCreate(event: Event): event is WebSocketCreate;
+export interface WebSocketInfo extends Instant {
+    name: Name.WEB_SOCKET_DESTROY | Name.WEB_SOCKET_RECEIVE_HANDSHAKE | Name.WEB_SOCKET_RECEIVE_HANDSHAKE_REQUEST;
+    args: Args & {
+        data: ArgsData & {
             identifier: number;
             url: string;
             frame?: string;
@@ -1627,10 +1685,10 @@ export interface TraceEventWebSocketInfo extends TraceEventInstant {
         };
     };
 }
-export interface TraceEventWebSocketTransfer extends TraceEventInstant {
-    name: KnownEventName.WebSocketSend | KnownEventName.WebSocketReceive;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export interface WebSocketTransfer extends Instant {
+    name: Name.WEB_SOCKET_SEND | Name.WEB_SOCKET_RECEIVE;
+    args: Args & {
+        data: ArgsData & {
             identifier: number;
             url: string;
             frame?: string;
@@ -1639,12 +1697,12 @@ export interface TraceEventWebSocketTransfer extends TraceEventInstant {
         };
     };
 }
-export declare function isTraceEventWebSocketInfo(traceEventData: TraceEventData): traceEventData is TraceEventWebSocketInfo;
-export declare function isTraceEventWebSocketTransfer(traceEventData: TraceEventData): traceEventData is TraceEventWebSocketTransfer;
-export interface TraceEventWebSocketSend extends TraceEventInstant {
-    name: KnownEventName.WebSocketSend;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export declare function isWebSocketInfo(event: Event): event is WebSocketInfo;
+export declare function isWebSocketTransfer(event: Event): event is WebSocketTransfer;
+export interface WebSocketSend extends Instant {
+    name: Name.WEB_SOCKET_SEND;
+    args: Args & {
+        data: ArgsData & {
             identifier: number;
             url: string;
             frame?: string;
@@ -1653,11 +1711,11 @@ export interface TraceEventWebSocketSend extends TraceEventInstant {
         };
     };
 }
-export declare function isTraceEventWebSocketSend(event: TraceEventData): event is TraceEventWebSocketSend;
-export interface TraceEventWebSocketReceive extends TraceEventInstant {
-    name: KnownEventName.WebSocketReceive;
-    args: TraceEventArgs & {
-        data: TraceEventArgsData & {
+export declare function isWebSocketSend(event: Event): event is WebSocketSend;
+export interface WebSocketReceive extends Instant {
+    name: Name.WEB_SOCKET_RECEIVE;
+    args: Args & {
+        data: ArgsData & {
             identifier: number;
             url: string;
             frame?: string;
@@ -1666,44 +1724,44 @@ export interface TraceEventWebSocketReceive extends TraceEventInstant {
         };
     };
 }
-export declare function isTraceEventWebSocketReceive(event: TraceEventData): event is TraceEventWebSocketReceive;
-export interface TraceEventWebSocketSendHandshakeRequest extends TraceEventInstant {
-    name: KnownEventName.WebSocketSendHandshakeRequest;
-    args: TraceEventArgs & {
+export declare function isWebSocketReceive(event: Event): event is WebSocketReceive;
+export interface WebSocketSendHandshakeRequest extends Instant {
+    name: Name.WEB_SOCKET_SEND_HANDSHAKE_REQUEST;
+    args: Args & {
         data: {
             frame: string;
             identifier: number;
         };
     };
 }
-export declare function isTraceEventWebSocketSendHandshakeRequest(event: TraceEventData): event is TraceEventWebSocketSendHandshakeRequest;
-export interface TraceEventWebSocketReceiveHandshakeResponse extends TraceEventInstant {
-    name: KnownEventName.WebSocketReceiveHandshakeResponse;
-    args: TraceEventArgs & {
+export declare function isWebSocketSendHandshakeRequest(event: Event): event is WebSocketSendHandshakeRequest;
+export interface WebSocketReceiveHandshakeResponse extends Instant {
+    name: Name.WEB_SOCKET_RECEIVE_HANDSHAKE_REQUEST;
+    args: Args & {
         data: {
             frame: string;
             identifier: number;
         };
     };
 }
-export declare function isTraceEventWebSocketReceiveHandshakeResponse(event: TraceEventData): event is TraceEventWebSocketReceiveHandshakeResponse;
-export interface TraceEventWebSocketDestroy extends TraceEventInstant {
-    name: KnownEventName.WebSocketDestroy;
-    args: TraceEventArgs & {
+export declare function isWebSocketReceiveHandshakeResponse(event: Event): event is WebSocketReceiveHandshakeResponse;
+export interface WebSocketDestroy extends Instant {
+    name: Name.WEB_SOCKET_DESTROY;
+    args: Args & {
         data: {
             frame: string;
             identifier: number;
         };
     };
 }
-export declare function isTraceEventWebSocketDestroy(event: TraceEventData): event is TraceEventWebSocketDestroy;
-export type WebSocketTraceEvent = TraceEventWebSocketCreate | TraceEventWebSocketInfo | TraceEventWebSocketTransfer;
-export declare function isWebSocketTraceEvent(event: TraceEventData): event is WebSocketTraceEvent;
-export type WebSocketEvent = WebSocketTraceEvent | SyntheticWebSocketConnectionEvent;
-export declare function isWebSocketEvent(event: TraceEventData): event is WebSocketTraceEvent | SyntheticWebSocketConnectionEvent;
-export interface TraceEventV8Compile extends TraceEventComplete {
-    name: KnownEventName.Compile;
-    args: TraceEventArgs & {
+export declare function isWebSocketDestroy(event: Event): event is WebSocketDestroy;
+export type WebSocketTraceEvent = WebSocketCreate | WebSocketInfo | WebSocketTransfer;
+export declare function isWebSocketTraceEvent(event: Event): event is WebSocketTraceEvent;
+export type WebSocketEvent = WebSocketTraceEvent | SyntheticWebSocketConnection;
+export declare function isWebSocketEvent(event: Event): event is WebSocketTraceEvent | SyntheticWebSocketConnection;
+export interface V8Compile extends Complete {
+    name: Name.COMPILE;
+    args: Args & {
         data?: {
             url?: string;
             columnNumber?: number;
@@ -1718,10 +1776,10 @@ export interface TraceEventV8Compile extends TraceEventComplete {
         fileName?: string;
     };
 }
-export declare function isTraceEventV8Compile(event: TraceEventData): event is TraceEventV8Compile;
-export interface TraceEventFunctionCall extends TraceEventComplete {
-    name: KnownEventName.FunctionCall;
-    args: TraceEventArgs & {
+export declare function isV8Compile(event: Event): event is V8Compile;
+export interface FunctionCall extends Complete {
+    name: Name.FUNCTION_CALL;
+    args: Args & {
         data?: {
             frame?: string;
             columnNumber?: number;
@@ -1732,175 +1790,222 @@ export interface TraceEventFunctionCall extends TraceEventComplete {
         };
     };
 }
-export declare function isTraceEventFunctionCall(event: TraceEventData): event is TraceEventFunctionCall;
+export declare function isFunctionCall(event: Event): event is FunctionCall;
+export declare function isSyntheticServerTiming(event: Event): event is SyntheticServerTiming;
 /**
  * Generally, before JS is executed, a trace event is dispatched that
  * parents the JS calls. These we call "invocation" events. This
  * function determines if an event is one of such.
  */
-export declare function isJSInvocationEvent(event: TraceEventData): boolean;
+export declare function isJSInvocationEvent(event: Event): boolean;
 /**
  * This is an exhaustive list of events we track in the Performance
  * panel. Note not all of them are necessarliry shown in the flame
  * chart, some of them we only use for parsing.
  * TODO(crbug.com/1428024): Complete this enum.
  */
-export declare const enum KnownEventName {
-    ThreadName = "thread_name",
-    Program = "Program",
-    RunTask = "RunTask",
-    AsyncTask = "AsyncTask",
-    RunMicrotasks = "RunMicrotasks",
-    XHRLoad = "XHRLoad",
-    XHRReadyStateChange = "XHRReadyStateChange",
-    ParseHTML = "ParseHTML",
-    ParseCSS = "ParseAuthorStyleSheet",
-    CompileCode = "V8.CompileCode",
-    CompileModule = "V8.CompileModule",
-    Compile = "v8.compile",
-    CompileScript = "V8.CompileScript",
-    Optimize = "V8.OptimizeCode",
-    WasmStreamFromResponseCallback = "v8.wasm.streamFromResponseCallback",
-    WasmCompiledModule = "v8.wasm.compiledModule",
-    WasmCachedModule = "v8.wasm.cachedModule",
-    WasmModuleCacheHit = "v8.wasm.moduleCacheHit",
-    WasmModuleCacheInvalid = "v8.wasm.moduleCacheInvalid",
-    ProfileCall = "ProfileCall",
-    EvaluateScript = "EvaluateScript",
-    FunctionCall = "FunctionCall",
-    EventDispatch = "EventDispatch",
-    EvaluateModule = "v8.evaluateModule",
-    RequestMainThreadFrame = "RequestMainThreadFrame",
-    RequestAnimationFrame = "RequestAnimationFrame",
-    CancelAnimationFrame = "CancelAnimationFrame",
-    FireAnimationFrame = "FireAnimationFrame",
-    RequestIdleCallback = "RequestIdleCallback",
-    CancelIdleCallback = "CancelIdleCallback",
-    FireIdleCallback = "FireIdleCallback",
-    TimerInstall = "TimerInstall",
-    TimerRemove = "TimerRemove",
-    TimerFire = "TimerFire",
-    WebSocketCreate = "WebSocketCreate",
-    WebSocketSendHandshake = "WebSocketSendHandshakeRequest",
-    WebSocketReceiveHandshake = "WebSocketReceiveHandshakeResponse",
-    WebSocketDestroy = "WebSocketDestroy",
-    WebSocketSend = "WebSocketSend",
-    WebSocketReceive = "WebSocketReceive",
-    CryptoDoEncrypt = "DoEncrypt",
-    CryptoDoEncryptReply = "DoEncryptReply",
-    CryptoDoDecrypt = "DoDecrypt",
-    CryptoDoDecryptReply = "DoDecryptReply",
-    CryptoDoDigest = "DoDigest",
-    CryptoDoDigestReply = "DoDigestReply",
-    CryptoDoSign = "DoSign",
-    CryptoDoSignReply = "DoSignReply",
-    CryptoDoVerify = "DoVerify",
-    CryptoDoVerifyReply = "DoVerifyReply",
-    V8Execute = "V8.Execute",
+export declare const enum Name {
+    THREAD_NAME = "thread_name",
+    PROGRAM = "Program",
+    RUN_TASK = "RunTask",
+    ASYNC_TASK = "AsyncTask",
+    RUN_MICROTASKS = "RunMicrotasks",
+    XHR_LOAD = "XHRLoad",
+    XHR_READY_STATE_CHANGED = "XHRReadyStateChange",
+    PARSE_HTML = "ParseHTML",
+    PARSE_CSS = "ParseAuthorStyleSheet",
+    COMPILE_CODE = "V8.CompileCode",
+    COMPILE_MODULE = "V8.CompileModule",
+    COMPILE = "v8.compile",
+    COMPILE_SCRIPT = "V8.CompileScript",
+    OPTIMIZE = "V8.OptimizeCode",
+    WASM_STREAM_FROM_RESPONSE_CALLBACK = "v8.wasm.streamFromResponseCallback",
+    WASM_COMPILED_MODULE = "v8.wasm.compiledModule",
+    WASM_CACHED_MODULE = "v8.wasm.cachedModule",
+    WASM_MODULE_CACHE_HIT = "v8.wasm.moduleCacheHit",
+    WASM_MODULE_CACHE_INVALID = "v8.wasm.moduleCacheInvalid",
+    PROFILE_CALL = "ProfileCall",
+    EVALUATE_SCRIPT = "EvaluateScript",
+    FUNCTION_CALL = "FunctionCall",
+    EVENT_DISPATCH = "EventDispatch",
+    EVALUATE_MODULE = "v8.evaluateModule",
+    REQUEST_MAIN_THREAD_FRAME = "RequestMainThreadFrame",
+    REQUEST_ANIMATION_FRAME = "RequestAnimationFrame",
+    CANCEL_ANIMATION_FRAME = "CancelAnimationFrame",
+    FIRE_ANIMATION_FRAME = "FireAnimationFrame",
+    REQUEST_IDLE_CALLBACK = "RequestIdleCallback",
+    CANCEL_IDLE_CALLBACK = "CancelIdleCallback",
+    FIRE_IDLE_CALLBACK = "FireIdleCallback",
+    TIMER_INSTALL = "TimerInstall",
+    TIMER_REMOVE = "TimerRemove",
+    TIMER_FIRE = "TimerFire",
+    WEB_SOCKET_CREATE = "WebSocketCreate",
+    WEB_SOCKET_SEND_HANDSHAKE = "WebSocketSendHandshakeRequest",
+    WEB_SOCKET_RECEIVE_HANDSHAKE = "WebSocketReceiveHandshakeResponse",
+    WEB_SOCKET_DESTROY = "WebSocketDestroy",
+    WEB_SOCKET_SEND = "WebSocketSend",
+    WEB_SOCKET_RECEIVE = "WebSocketReceive",
+    CRYPTO_DO_ENCRYPT = "DoEncrypt",
+    CRYPTO_DO_ENCRYPT_REPLY = "DoEncryptReply",
+    CRYPTO_DO_DECRYPT = "DoDecrypt",
+    CRYPTO_DO_DECRYPT_REPLY = "DoDecryptReply",
+    CRYPTO_DO_DIGEST = "DoDigest",
+    CRYPTO_DO_DIGEST_REPLY = "DoDigestReply",
+    CRYPTO_DO_SIGN = "DoSign",
+    CRYPTO_DO_SIGN_REPLY = "DoSignReply",
+    CRYPTO_DO_VERIFY = "DoVerify",
+    CRYPTO_DO_VERIFY_REPLY = "DoVerifyReply",
+    V8_EXECUTE = "V8.Execute",
     GC = "GCEvent",
     DOMGC = "BlinkGC.AtomicPhase",
-    MajorGC = "MajorGC",
-    MinorGC = "MinorGC",
-    GCCollectGarbage = "BlinkGC.AtomicPhase",
-    CPPGCSweep = "CppGC.IncrementalSweep",
-    ScheduleStyleRecalculation = "ScheduleStyleRecalculation",
-    Layout = "Layout",
-    UpdateLayoutTree = "UpdateLayoutTree",
-    InvalidateLayout = "InvalidateLayout",
-    LayoutInvalidationTracking = "LayoutInvalidationTracking",
-    ComputeIntersections = "ComputeIntersections",
-    HitTest = "HitTest",
-    PrePaint = "PrePaint",
-    Layerize = "Layerize",
-    LayoutShift = "LayoutShift",
-    UpdateLayerTree = "UpdateLayerTree",
-    ScheduleStyleInvalidationTracking = "ScheduleStyleInvalidationTracking",
-    StyleRecalcInvalidationTracking = "StyleRecalcInvalidationTracking",
-    StyleInvalidatorInvalidationTracking = "StyleInvalidatorInvalidationTracking",
-    SelectorStats = "SelectorStats",
-    BeginCommitCompositorFrame = "BeginCommitCompositorFrame",
-    ScrollLayer = "ScrollLayer",
-    UpdateLayer = "UpdateLayer",
-    PaintSetup = "PaintSetup",
-    Paint = "Paint",
-    PaintImage = "PaintImage",
-    Commit = "Commit",
-    CompositeLayers = "CompositeLayers",
-    RasterTask = "RasterTask",
-    ImageDecodeTask = "ImageDecodeTask",
-    ImageUploadTask = "ImageUploadTask",
-    DecodeImage = "Decode Image",
-    DrawLazyPixelRef = "Draw LazyPixelRef",
-    DecodeLazyPixelRef = "Decode LazyPixelRef",
-    GPUTask = "GPUTask",
-    Rasterize = "Rasterize",
-    EventTiming = "EventTiming",
-    OptimizeCode = "V8.OptimizeCode",
-    CacheScript = "v8.produceCache",
-    CacheModule = "v8.produceModuleCache",
-    V8Sample = "V8Sample",
-    JitCodeAdded = "JitCodeAdded",
-    JitCodeMoved = "JitCodeMoved",
-    StreamingCompileScript = "v8.parseOnBackground",
-    StreamingCompileScriptWaiting = "v8.parseOnBackgroundWaiting",
-    StreamingCompileScriptParsing = "v8.parseOnBackgroundParsing",
-    BackgroundDeserialize = "v8.deserializeOnBackground",
-    FinalizeDeserialization = "V8.FinalizeDeserialization",
-    CommitLoad = "CommitLoad",
-    MarkLoad = "MarkLoad",
-    MarkDOMContent = "MarkDOMContent",
-    MarkFirstPaint = "firstPaint",
-    MarkFCP = "firstContentfulPaint",
-    MarkLCPCandidate = "largestContentfulPaint::Candidate",
-    MarkLCPInvalidate = "largestContentfulPaint::Invalidate",
-    NavigationStart = "navigationStart",
-    TimeStamp = "TimeStamp",
-    ConsoleTime = "ConsoleTime",
-    UserTiming = "UserTiming",
-    InteractiveTime = "InteractiveTime",
-    BeginFrame = "BeginFrame",
-    NeedsBeginFrameChanged = "NeedsBeginFrameChanged",
-    BeginMainThreadFrame = "BeginMainThreadFrame",
-    ActivateLayerTree = "ActivateLayerTree",
-    DrawFrame = "DrawFrame",
-    DroppedFrame = "DroppedFrame",
-    FrameStartedLoading = "FrameStartedLoading",
-    PipelineReporter = "PipelineReporter",
-    Screenshot = "Screenshot",
-    ResourceWillSendRequest = "ResourceWillSendRequest",
-    ResourceSendRequest = "ResourceSendRequest",
-    ResourceReceiveResponse = "ResourceReceiveResponse",
-    ResourceReceivedData = "ResourceReceivedData",
-    ResourceFinish = "ResourceFinish",
-    ResourceMarkAsCached = "ResourceMarkAsCached",
-    WebSocketSendHandshakeRequest = "WebSocketSendHandshakeRequest",
-    WebSocketReceiveHandshakeResponse = "WebSocketReceiveHandshakeResponse",
-    Profile = "Profile",
-    StartProfiling = "CpuProfiler::StartProfiling",
-    ProfileChunk = "ProfileChunk",
-    UpdateCounters = "UpdateCounters",
-    JSSample = "JSSample",
-    Animation = "Animation",
-    ParseAuthorStyleSheet = "ParseAuthorStyleSheet",
-    EmbedderCallback = "EmbedderCallback",
-    SetLayerTreeId = "SetLayerTreeId",
-    TracingStartedInPage = "TracingStartedInPage",
-    TracingStartedInBrowser = "TracingStartedInBrowser",
-    TracingSessionIdForWorker = "TracingSessionIdForWorker",
-    LazyPixelRef = "LazyPixelRef",
-    LayerTreeHostImplSnapshot = "cc::LayerTreeHostImpl",
-    PictureSnapshot = "cc::Picture",
-    DisplayItemListSnapshot = "cc::DisplayItemList",
-    InputLatencyMouseMove = "InputLatency::MouseMove",
-    InputLatencyMouseWheel = "InputLatency::MouseWheel",
-    ImplSideFling = "InputHandlerProxy::HandleGestureFling::started",
-    SchedulePostMessage = "SchedulePostMessage",
-    HandlePostMessage = "HandlePostMessage",
-    RenderFrameImplCreateChildFrame = "RenderFrameImpl::createChildFrame"
+    MAJOR_GC = "MajorGC",
+    MINOR_GC = "MinorGC",
+    GC_COLLECT_GARBARGE = "BlinkGC.AtomicPhase",
+    CPPGC_SWEEP = "CppGC.IncrementalSweep",
+    SCHEDULE_STYLE_RECALCULATION = "ScheduleStyleRecalculation",
+    LAYOUT = "Layout",
+    UPDATE_LAYOUT_TREE = "UpdateLayoutTree",
+    INVALIDATE_LAYOUT = "InvalidateLayout",
+    LAYOUT_INVALIDATION_TRACKING = "LayoutInvalidationTracking",
+    COMPUTE_INTERSECTION = "ComputeIntersections",
+    HIT_TEST = "HitTest",
+    PRE_PAINT = "PrePaint",
+    LAYERIZE = "Layerize",
+    LAYOUT_SHIFT = "LayoutShift",
+    SYNTHETIC_LAYOUT_SHIFT_CLUSTER = "SyntheticLayoutShiftCluster",
+    UPDATE_LAYER_TREE = "UpdateLayerTree",
+    SCHEDULE_STYLE_INVALIDATION_TRACKING = "ScheduleStyleInvalidationTracking",
+    STYLE_RECALC_INVALIDATION_TRACKING = "StyleRecalcInvalidationTracking",
+    STYLE_INVALIDATOR_INVALIDATION_TRACKING = "StyleInvalidatorInvalidationTracking",
+    SELECTOR_STATS = "SelectorStats",
+    BEGIN_COMMIT_COMPOSITOR_FRAME = "BeginCommitCompositorFrame",
+    PARSE_META_VIEWPORT = "ParseMetaViewport",
+    SCROLL_LAYER = "ScrollLayer",
+    UPDATE_LAYER = "UpdateLayer",
+    PAINT_SETUP = "PaintSetup",
+    PAINT = "Paint",
+    PAINT_IMAGE = "PaintImage",
+    COMMIT = "Commit",
+    COMPOSITE_LAYERS = "CompositeLayers",
+    RASTER_TASK = "RasterTask",
+    IMAGE_DECODE_TASK = "ImageDecodeTask",
+    IMAGE_UPLOAD_TASK = "ImageUploadTask",
+    DECODE_IMAGE = "Decode Image",
+    DRAW_LAZY_PIXEL_REF = "Draw LazyPixelRef",
+    DECODE_LAZY_PIXEL_REF = "Decode LazyPixelRef",
+    GPU_TASK = "GPUTask",
+    RASTERIZE = "Rasterize",
+    EVENT_TIMING = "EventTiming",
+    OPTIMIZE_CODE = "V8.OptimizeCode",
+    CACHE_SCRIPT = "v8.produceCache",
+    CACHE_MODULE = "v8.produceModuleCache",
+    V8_SAMPLE = "V8Sample",
+    JIT_CODE_ADDED = "JitCodeAdded",
+    JIT_CODE_MOVED = "JitCodeMoved",
+    STREAMING_COMPILE_SCRIPT = "v8.parseOnBackground",
+    STREAMING_COMPILE_SCRIPT_WAITING = "v8.parseOnBackgroundWaiting",
+    STREAMING_COMPILE_SCRIPT_PARSING = "v8.parseOnBackgroundParsing",
+    BACKGROUND_DESERIALIZE = "v8.deserializeOnBackground",
+    FINALIZE_DESERIALIZATION = "V8.FinalizeDeserialization",
+    COMMIT_LOAD = "CommitLoad",
+    MARK_LOAD = "MarkLoad",
+    MARK_DOM_CONTENT = "MarkDOMContent",
+    MARK_FIRST_PAINT = "firstPaint",
+    MARK_FCP = "firstContentfulPaint",
+    MARK_LCP_CANDIDATE = "largestContentfulPaint::Candidate",
+    MARK_LCP_INVALIDATE = "largestContentfulPaint::Invalidate",
+    NAVIGATION_START = "navigationStart",
+    TIME_STAMP = "TimeStamp",
+    CONSOLE_TIME = "ConsoleTime",
+    USER_TIMING = "UserTiming",
+    INTERACTIVE_TIME = "InteractiveTime",
+    BEGIN_FRAME = "BeginFrame",
+    NEEDS_BEGIN_FRAME_CHANGED = "NeedsBeginFrameChanged",
+    BEGIN_MAIN_THREAD_FRAME = "BeginMainThreadFrame",
+    ACTIVATE_LAYER_TREE = "ActivateLayerTree",
+    DRAW_FRAME = "DrawFrame",
+    DROPPED_FRAME = "DroppedFrame",
+    FRAME_STARTED_LOADING = "FrameStartedLoading",
+    PIPELINE_REPORTER = "PipelineReporter",
+    SCREENSHOT = "Screenshot",
+    RESOURCE_WILL_SEND_REQUEST = "ResourceWillSendRequest",
+    RESOURCE_SEND_REQUEST = "ResourceSendRequest",
+    RESOURCE_RECEIVE_RESPONSE = "ResourceReceiveResponse",
+    RESOURCE_RECEIVE_DATA = "ResourceReceivedData",
+    RESOURCE_FINISH = "ResourceFinish",
+    RESOURCE_MARK_AS_CACHED = "ResourceMarkAsCached",
+    WEB_SOCKET_SEND_HANDSHAKE_REQUEST = "WebSocketSendHandshakeRequest",
+    WEB_SOCKET_RECEIVE_HANDSHAKE_REQUEST = "WebSocketReceiveHandshakeResponse",
+    PROFILE = "Profile",
+    START_PROFILING = "CpuProfiler::StartProfiling",
+    PROFILE_CHUNK = "ProfileChunk",
+    UPDATE_COUNTERS = "UpdateCounters",
+    JS_SAMPLE = "JSSample",
+    ANIMATION = "Animation",
+    PARSE_AUTHOR_STYLE_SHEET = "ParseAuthorStyleSheet",
+    EMBEDDER_CALLBACK = "EmbedderCallback",
+    SET_LAYER_TREE_ID = "SetLayerTreeId",
+    TRACING_STARTED_IN_PAGE = "TracingStartedInPage",
+    TRACING_STARTED_IN_BROWSER = "TracingStartedInBrowser",
+    TRACING_SESSION_ID_FOR_WORKER = "TracingSessionIdForWorker",
+    LAZY_PIXEL_REF = "LazyPixelRef",
+    LAYER_TREE_HOST_IMPL_SNAPSHOT = "cc::LayerTreeHostImpl",
+    PICTURE_SNAPSHOT = "cc::Picture",
+    DISPLAY_ITEM_LIST_SNAPSHOT = "cc::DisplayItemList",
+    INPUT_LATENCY_MOUSE_MOVE = "InputLatency::MouseMove",
+    INPUT_LATENCY_MOUSE_WHEEL = "InputLatency::MouseWheel",
+    IMPL_SIDE_FLING = "InputHandlerProxy::HandleGestureFling::started",
+    SCHEDULE_POST_MESSAGE = "SchedulePostMessage",
+    HANDLE_POST_MESSAGE = "HandlePostMessage",
+    RENDER_FRAME_IMPL_CREATE_CHILD_FRAME = "RenderFrameImpl::createChildFrame",
+    DOM_LOADING = "domLoading",
+    BEGIN_REMOTE_FONT_LOAD = "BeginRemoteFontLoad"
 }
 export declare const Categories: {
     readonly Console: "blink.console";
     readonly UserTiming: "blink.user_timing";
     readonly Loading: "loading";
 };
+/**
+ * The frames implementation in handlers/FramesHandler is considered "legacy"
+ * in that it is based on the old TimelineModel implementation rather than
+ * following the pattern of the other handlers. This will change in time as we
+ * migrate the frames track to use AnimationFrame events, but for now we
+ * maintain it because the effort required to migrate was large.
+ * Consequently, the types we use through the codebase to refer to these frames
+ * usually use ModelHandlers.FramesHandler.TimelineFrame, but in
+ * trace/types/*.ts we cannot refer to types defined in the Handlers. To avoid a
+ * circular dependency, we define these interfaces here which are implemented by
+ * the classes in FramesHandler.ts, but they can also be used to refer to
+ * instances of frames in trace/types/*.ts which is unable to import from
+ * handlers.
+ */
+export interface LegacyTimelineFrame extends Event {
+    startTime: MicroSeconds;
+    startTimeOffset: MicroSeconds;
+    endTime: MicroSeconds;
+    duration: MicroSeconds;
+    idle: boolean;
+    dropped: boolean;
+    isPartial: boolean;
+    layerTree: LegacyFrameLayerTreeData | null;
+    paints: LegacyLayerPaintEvent[];
+    mainFrameId?: number;
+    readonly seqId: number;
+    index: number;
+}
+export declare function isLegacyTimelineFrame(data: Event): data is LegacyTimelineFrame;
+export interface LegacyFrameLayerTreeData {
+    entry: LayerTreeHostImplSnapshot;
+    paints: LegacyLayerPaintEvent[];
+}
+export interface LegacyLayerPaintEvent {
+    layerId(): number;
+    event(): Paint;
+    picture(): LegacyLayerPaintEventPicture | null;
+}
+export interface LegacyLayerPaintEventPicture {
+    rect: Array<number>;
+    serializedPicture: string;
+}
 export {};