import type * as Handlers from './handlers/handlers.js';
import type * as Types from './types/types.js';
export declare class Model extends EventTarget {
    #private;
    constructor();
    /**
     * Parses an array of trace events into a structured object containing all the
     * information parsed by the trace handlers.
     * You can `await` this function to pause execution until parsing is complete,
     * or instead rely on the `ModuleUpdateEvent` that is dispatched when the
     * parsing is finished.
     *
     * Once parsed, you then have to call the `traceParsedData` method, providing an
     * index of the trace you want to have the data for. This is because any model
     * can store a number of traces. Each trace is given an index, which starts at 0
     * and increments by one as a new trace is parsed.
     *
     * @example
     * // Awaiting the parse method() to block until parsing complete
     * await this.traceModel.parse(events);
     * const data = this.traceModel.traceParsedData(0)
     *
     * @example
     * // Using an event listener to be notified when tracing is complete.
     * this.traceModel.addEventListener(Trace.ModelUpdateEvent.eventName, (event) => {
     *   if(event.data.data === 'done') {
     *     // trace complete
     *     const data = this.traceModel.traceParsedData(0);
     *   }
     * });
     * void this.traceModel.parse(events);
     **/
    parse(traceEvents: readonly Types.TraceEvents.TraceEventData[], metadata?: TraceFileMetaData, freshRecording?: boolean): Promise<void>;
    traceParsedData(index: number): Handlers.Types.TraceParseData | null;
    metadata(index: number): TraceFileMetaData | null;
    traceEvents(index: number): readonly Types.TraceEvents.TraceEventData[] | null;
    size(): number;
    deleteTraceByIndex(recordingIndex: number): void;
    getRecordingsAvailable(): string[];
    reset(): void;
}
/**
 * This parsed trace file is used by the Model. It keeps multiple instances
 * of these so that the user can swap between them. The key is that it is
 * essentially the TraceFile plus whatever the model has parsed from it.
 */
export type ParsedTraceFile = TraceFile & {
    traceParsedData: Handlers.Types.TraceParseData | null;
};
export declare const enum ModelUpdateType {
    GLOBAL = 0,
    TRACE = 1,
    LIGHTHOUSE = 2
}
export type ModelUpdateEventData = ModelUpdateEventGlobalData | ModelUpdateEventTraceData | ModelUpdateEventLighthouseData;
export type ModelUpdateEventGlobalData = {
    type: ModelUpdateType.GLOBAL;
    data: GlobalParseEventData;
};
export type ModelUpdateEventTraceData = {
    type: ModelUpdateType.TRACE;
    data: TraceParseEventData;
};
export type ModelUpdateEventLighthouseData = {
    type: ModelUpdateType.LIGHTHOUSE;
    data: LighthouseParseEventData;
};
export type GlobalParseEventData = 'done';
export type TraceParseEventData = TraceParseEventProgressData | 'done';
export type LighthouseParseEventData = 'done';
export type TraceParseEventProgressData = {
    index: number;
    total: number;
};
export declare class ModelUpdateEvent extends Event {
    data: ModelUpdateEventData;
    static readonly eventName = "modelupdate";
    constructor(data: ModelUpdateEventData);
}
export declare function isModelUpdateEventDataGlobal(object: ModelUpdateEventData): object is ModelUpdateEventGlobalData;
export declare function isModelUpdateEventDataTrace(object: ModelUpdateEventData): object is ModelUpdateEventTraceData;
export declare class TraceParseEvent extends Event {
    data: TraceParseEventData;
    static readonly eventName = "traceparse";
    constructor(data: TraceParseEventData, init?: EventInit);
}
export type TraceFile = {
    traceEvents: readonly Types.TraceEvents.TraceEventData[];
    metadata: TraceFileMetaData;
};
/**
 * Trace metadata that we persist to the file. This will allow us to
 * store specifics for the trace, e.g., which tracks should be visible
 * on load.
 */
export interface TraceFileMetaData {
    source?: 'DevTools';
    networkThrottling?: string;
    cpuThrottling?: number;
}
export type TraceFileContents = TraceFile | Types.TraceEvents.TraceEventData[];
declare global {
    interface HTMLElementEventMap {
        [TraceParseEvent.eventName]: TraceParseEvent;
    }
}