/**
 * Load Testing Framework
 *
 * Provides comprehensive load testing capabilities with configurable scenarios,
 * real-time monitoring, and detailed performance analysis.
 */
import { EventEmitter } from 'events';
export interface LoadTestConfig {
    name: string;
    duration: number;
    concurrentUsers: number;
    rampUpTime?: number;
    requestInterval?: number;
    endpoint?: string;
    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
    headers?: Record<string, string>;
    body?: any;
    timeout?: number;
    thinkTime?: number;
}
export interface LoadTestScenario extends LoadTestConfig {
    scenarios: LoadTestStep[];
}
export interface LoadTestStep {
    name: string;
    weight?: number;
    config: LoadTestConfig;
}
export interface LoadTestResults {
    testName: string;
    startTime: number;
    endTime: number;
    duration: number;
    totalRequests: number;
    successfulRequests: number;
    failedRequests: number;
    errorRate: number;
    avgResponseTime: number;
    minResponseTime: number;
    maxResponseTime: number;
    p50: number;
    p95: number;
    p99: number;
    throughput: number;
    errors: Array<{
        error: string;
        count: number;
        firstOccurrence: number;
    }>;
    timeline: Array<{
        timestamp: number;
        activeUsers: number;
        requestsPerSecond: number;
        avgResponseTime: number;
        errorRate: number;
    }>;
}
/**
 * Advanced load testing framework
 */
export declare class LoadTestRunner extends EventEmitter {
    private results;
    private activeUsers;
    private requestResults;
    private isRunning;
    private startTime;
    private endTime;
    private timelineInterval?;
    private maxResultHistory;
    private maxActiveUsers;
    private memoryThreshold;
    private adaptiveMode;
    private lastMemoryCheck;
    constructor();
    /**
     * Run a simple load test
     */
    runLoadTest(config: LoadTestConfig): Promise<LoadTestResults>;
    /**
     * Run a complex scenario test
     */
    runScenario(scenario: LoadTestScenario): Promise<LoadTestResults>;
    /**
     * Run a stress test (gradually increasing load)
     */
    runStressTest(baseConfig: LoadTestConfig, maxUsers: number, stepSize?: number): Promise<LoadTestResults[]>;
    /**
     * Get all test results
     */
    getResults(): LoadTestResults[];
    /**
     * Clear all results
     */
    clearResults(): void;
    /**
     * Stop current test
     */
    stopTest(): void;
    private rampUpUsers;
    private runTestDuration;
    private rampDownUsers;
    private startUserActivity;
    private stopUserActivity;
    private makeRequest;
    private recordRequest;
    private calculateMaxResults;
    private analyzeResults;
    private getPercentile;
    /**
     * Check memory usage and adjust adaptive mode
     */
    private checkMemoryUsage;
    /**
     * Apply adaptive limits based on current memory and mode
     */
    private applyAdaptiveLimits;
    private startTimelineMonitoring;
    private stopTimelineMonitoring;
    private sleep;
}
/**
 * Predefined load test scenarios
 */
export declare const LoadTestScenarios: {
    /**
     * Basic smoke test - low load for short duration
     */
    smokeTest: (name: string, endpoint: string) => LoadTestConfig;
    /**
     * Load test - moderate load for extended duration
     */
    loadTest: (name: string, endpoint: string) => LoadTestConfig;
    /**
     * Stress test - gradually increasing load
     */
    stressTest: (name: string, endpoint: string) => LoadTestConfig;
    /**
     * Spike test - sudden high load burst
     */
    spikeTest: (name: string, endpoint: string) => LoadTestConfig;
};
export default LoadTestRunner;
//# sourceMappingURL=loadTest.d.ts.map