export interface BenchmarkResult {
    operation: string;
    category: string;
    dataSize: number;
    synchronous: {
        time: number;
        result: any;
        error?: string;
        memoryUsed?: number;
        iterations?: number;
    };
    asynchronous: {
        time: number;
        result: any;
        error?: string;
        memoryUsed?: number;
        iterations?: number;
    };
    performanceRatio?: number;
    recommendation?: 'sync' | 'async' | 'neutral';
}
export interface BenchmarkSummary {
    testDataSize: number;
    cpuCount: number;
    results: BenchmarkResult[];
    summary: {
        synchronousTotal: number;
        asynchronousTotal: number;
        asyncSpeedup: string;
    };
}
export interface CustomBenchmarkOperation<T, R> {
    name: string;
    operation: (input: T) => R | Promise<R>;
    input: T;
    iterations?: number;
    warmupRuns?: number;
}
export interface CustomBenchmarkConfig {
    iterations?: number;
    warmupRuns?: number;
    trackMemory?: boolean;
    showProgress?: boolean;
    timeout?: number;
}
export interface BatchBenchmarkResult<T> {
    operations: Array<{
        name: string;
        time: number;
        result: T;
        error?: string;
        memoryUsed?: number;
        iterations: number;
    }>;
    summary: {
        fastest: string;
        slowest: string;
        averageTime: number;
        totalTime: number;
    };
}
export interface QueryBenchmarkOptions {
    dataSizes?: number[];
    iterations?: number;
    warmupRuns?: number;
    trackMemory?: boolean;
    scalabilityAnalysis?: boolean;
}
export interface BenchmarkComparison<T, R1, R2> {
    operation1: {
        name: string;
        time: number;
        result: R1;
        error?: string;
        memoryUsed?: number;
    };
    operation2: {
        name: string;
        time: number;
        result: R2;
        error?: string;
        memoryUsed?: number;
    };
    comparison: {
        fasterOperation: string;
        timeDifference: number;
        performanceRatio: number;
        recommendation: string;
    };
}
export declare class BenchmarkUtils {
    static measureTime<T>(operation: () => T | Promise<T>, operationName?: string): Promise<{
        time: number;
        result: T;
        error?: string;
        memoryUsage?: number;
    }>;
    static generateTestData(size: number): Array<{
        id: number;
        value: number;
        name: string;
        isActive: boolean;
    }>;
    static complexComputation(item: any): number;
    static asyncComputation(item: any): Promise<number>;
    static runComprehensiveBenchmark(dataSize?: number): Promise<BenchmarkSummary>;
    private static benchmarkOperation;
    static printBenchmarkSummary(summary: BenchmarkSummary): void;
    static quickBenchmark(dataSize?: number): Promise<void>;
    static runStressTest(sizes?: number[]): Promise<void>;
    static runScalabilityTest(startSize?: number, endSize?: number, steps?: number): Promise<void>;
    static runEdgeCaseTests(): Promise<void>;
    static runFullBenchmarkSuite(dataSize?: number): Promise<void>;
    static benchmarkCustomOperation<T, R>(operation: CustomBenchmarkOperation<T, R>, config?: CustomBenchmarkConfig): Promise<{
        operationName: string;
        averageTime: number;
        totalTime: number;
        iterations: number;
        memoryUsed?: number;
        result: R;
        error?: string;
    }>;
    static benchmarkOperationsBatch<T>(operations: CustomBenchmarkOperation<any, T>[], config?: CustomBenchmarkConfig): Promise<BatchBenchmarkResult<T>>;
    static benchmarkQuery<T, R>(queryOperation: (data: T[]) => R | Promise<R>, dataGenerator: (size: number) => T[], options?: QueryBenchmarkOptions): Promise<{
        operation: string;
        results: Array<{
            dataSize: number;
            time: number;
            memoryUsed?: number;
            result: R;
            error?: string;
        }>;
        scalabilityAnalysis?: {
            timeComplexity: string;
            recommendation: string;
            linearFit?: number;
        };
    }>;
    static compareOperations<T, R1, R2>(operation1: {
        name: string;
        operation: (input: T) => R1 | Promise<R1>;
    }, operation2: {
        name: string;
        operation: (input: T) => R2 | Promise<R2>;
    }, input: T, config?: CustomBenchmarkConfig): Promise<BenchmarkComparison<T, R1, R2>>;
    static runCustomBenchmarkSuite<T>(operations: CustomBenchmarkOperation<any, T>[], config?: CustomBenchmarkConfig): Promise<{
        suiteName: string;
        results: Array<{
            operationName: string;
            averageTime: number;
            totalTime: number;
            iterations: number;
            memoryUsed?: number;
            result: T;
            error?: string;
        }>;
        summary: {
            totalOperations: number;
            successfulOperations: number;
            failedOperations: number;
            avgSyncTime: number;
            avgAsyncTime: number;
            overallRecommendation: string;
        };
    }>;
}