/**
 * Performance Benchmark Framework for LLMS SDK
 * Automated performance testing and regression detection
 */
import type { ChatClient } from "../types.js";
/**
 * Performance metric types
 */
export interface PerformanceMetric {
    name: string;
    value: number;
    unit: string;
    timestamp: string;
}
export interface BenchmarkResult {
    testName: string;
    provider: string;
    model: string;
    metrics: {
        responseTime: number;
        tokensPerSecond: number;
        firstTokenLatency: number;
        memoryUsage: number;
        cpuUsage: number;
    };
    metadata: {
        inputTokens: number;
        outputTokens: number;
        streamingEnabled: boolean;
        temperature: number;
        timestamp: string;
        gitCommit?: string;
    };
}
export interface PerformanceBaseline {
    version: string;
    timestamp: string;
    benchmarks: BenchmarkResult[];
}
export interface RegressionReport {
    hasRegression: boolean;
    summary: string;
    regressions: Array<{
        metric: string;
        baseline: number;
        current: number;
        percentChange: number;
        threshold: number;
    }>;
}
/**
 * Performance test configurations
 */
export interface PerformanceSuite {
    name: string;
    description: string;
    tests: PerformanceTest[];
}
export interface PerformanceTest {
    name: string;
    prompt: string;
    expectedTokens?: number;
    streaming?: boolean;
    temperature?: number;
    iterations?: number;
}
/**
 * Default performance test suites
 */
export declare const DEFAULT_PERFORMANCE_SUITES: PerformanceSuite[];
/**
 * Performance Benchmark Runner
 */
export declare class PerformanceBenchmark {
    private config;
    private client;
    private results;
    private baselinePath;
    constructor(client: ChatClient, config: {
        provider: string;
        model: string;
        baselinePath?: string;
        warmupRuns?: number;
        thresholds?: {
            responseTime?: number;
            tokensPerSecond?: number;
            memoryUsage?: number;
            cpuUsage?: number;
        };
    });
    /**
     * Run all performance benchmarks
     */
    runBenchmarks(suites?: PerformanceSuite[]): Promise<PerformanceBaseline>;
    /**
     * Run a single benchmark test
     */
    private runSingleBenchmark;
    /**
     * Measure a single test run
     */
    private measureSingleRun;
    /**
     * Perform warmup runs
     */
    private performWarmup;
    /**
     * Compare results against baseline
     */
    compareToBaseline(current: PerformanceBaseline): Promise<RegressionReport>;
    /**
     * Save baseline to file
     */
    saveBaseline(baseline: PerformanceBaseline): Promise<void>;
    /**
     * Generate performance report
     */
    generateReport(baseline: PerformanceBaseline, regression?: RegressionReport): string;
    /**
     * Print single result
     */
    private printResult;
    /**
     * Get current version
     */
    private getVersion;
    /**
     * Get current git commit
     */
    private getGitCommit;
}
/**
 * Resource usage monitor
 */
export declare class ResourceMonitor {
    private interval;
    private samples;
    /**
     * Start monitoring resources
     */
    start(intervalMs?: number): void;
    /**
     * Stop monitoring and get summary
     */
    stop(): {
        peakMemory: number;
        avgMemory: number;
        totalCpuTime: number;
        duration: number;
    };
}
/**
 * Performance test runner for CI/CD
 */
export declare function runPerformanceTests(config: {
    provider: string;
    apiKey: string;
    model?: string;
    baselinePath?: string;
    failOnRegression?: boolean;
    saveBaseline?: boolean;
}): Promise<{
    success: boolean;
    report: string;
}>;
//# sourceMappingURL=performance-benchmark.d.ts.map