import { type TraceProcessorRuntimeStats } from '../services/workingTraceProcessor';
import { type RequiredScene, type RequiredSizeBucket, type SizeBucket } from './enterpriseRssBenchmarkMatrix';
export { REQUIRED_RSS_BENCHMARK_SCENES, REQUIRED_RSS_BENCHMARK_SIZE_BUCKETS, } from './enterpriseRssBenchmarkMatrix';
export type { RequiredScene, RequiredSizeBucket, SizeBucket, } from './enterpriseRssBenchmarkMatrix';
type BenchmarkPhase = 'startup_load' | 'post_load' | 'query';
export interface QuerySpec {
    name: string;
    sql: string;
}
export interface TraceBenchmarkSpec {
    scene: string;
    path: string;
    label: string;
    sizeBucket?: SizeBucket;
}
export interface BenchmarkOptions {
    traces: TraceBenchmarkSpec[];
    outputPath?: string;
    markdownPath?: string;
    sampleIntervalMs: number;
    queries: QuerySpec[];
    requireCompleteMatrix: boolean;
}
interface TimelineSample {
    elapsedMs: number;
    phase: BenchmarkPhase;
    pid?: number;
    rssBytes: number | null;
    source: TraceProcessorRuntimeStats['rssSampleSource'];
    error?: string;
}
interface QueryBenchmarkResult {
    name: string;
    sql: string;
    durationMs: number;
    wallMs: number;
    rowCount: number;
    columns: string[];
    error?: string;
}
export interface RssSummary {
    startupRssBytes: number | null;
    loadPeakRssBytes: number | null;
    postLoadRssBytes: number | null;
    queryPeakRssBytes: number | null;
    queryIncrementalRssBytes: number | null;
    queryHeadroomBytes: number | null;
    maxRssBytes: number | null;
    traceSizeToLoadPeakRatio: number | null;
}
export interface TraceBenchmarkResult {
    traceId: string;
    scene: string;
    label: string;
    path: string;
    sizeBytes: number;
    sizeBucket: SizeBucket;
    status: 'passed' | 'failed';
    initializeMs: number;
    rssSummary: RssSummary;
    queries: QueryBenchmarkResult[];
    samples: TimelineSample[];
    error?: string;
}
export interface BenchmarkCoverage {
    complete: boolean;
    missingCells: string[];
    observedCells: string[];
}
export interface BenchmarkReport {
    generatedAt: string;
    traceProcessorPath: string;
    host: {
        platform: string;
        arch: string;
        node: string;
        totalMemoryBytes: number;
        freeMemoryBytesAtStart: number;
        cpuCount: number;
    };
    sampleIntervalMs: number;
    requiredMatrix: {
        scenes: readonly RequiredScene[];
        sizeBuckets: readonly RequiredSizeBucket[];
    };
    coverage: BenchmarkCoverage;
    traces: TraceBenchmarkResult[];
}
export declare function classifyRequiredSizeBucket(sizeBytes: number): SizeBucket;
export declare function inferBenchmarkSceneFromPath(filePath: string): string;
export declare function parseBenchmarkArgs(argv: string[], cwd?: string): BenchmarkOptions;
export declare function computeBenchmarkCoverage(results: TraceBenchmarkResult[]): BenchmarkCoverage;
export declare function runBenchmarkReport(options: BenchmarkOptions): Promise<BenchmarkReport>;
export declare function determineBenchmarkExitCode(report: BenchmarkReport, options: Pick<BenchmarkOptions, 'requireCompleteMatrix'>): number;
export declare function buildMarkdownReport(report: BenchmarkReport): string;
//# sourceMappingURL=benchmarkTraceProcessorRss.d.ts.map