/**
 * Auto-Tuner Core Implementation
 * ADR-024: Self-Optimization Engine
 *
 * Main orchestrator for automatic parameter tuning.
 */
import type { TunableParameter, TuningConfig, EvaluationResult, TuningCycleResult, ParameterSuggestion, AutoTunerState, AutoTunerStats, ParameterApplicator, ParameterApplicatorRegistry } from './types.js';
import { MetricCollectorRegistry } from './metric-collectors.js';
import { TuningAlgorithm } from './tuning-algorithm.js';
/**
 * Events emitted by the auto-tuner
 */
export type AutoTunerEvent = {
    type: 'cycle-started';
    cycleId: string;
} | {
    type: 'cycle-completed';
    result: TuningCycleResult;
} | {
    type: 'parameter-changed';
    parameter: string;
    oldValue: number | string;
    newValue: number | string;
} | {
    type: 'suggestion-generated';
    suggestions: ParameterSuggestion[];
} | {
    type: 'error';
    error: Error;
};
export type AutoTunerEventHandler = (event: AutoTunerEvent) => void;
/**
 * Default implementation of ParameterApplicatorRegistry
 * Manages applicators that bridge tuning suggestions to real system changes
 */
export declare class DefaultParameterApplicatorRegistry implements ParameterApplicatorRegistry {
    private applicators;
    register(applicator: ParameterApplicator): void;
    get(parameterName: string): ParameterApplicator | undefined;
    getAll(): ParameterApplicator[];
    applyConfiguration(config: Record<string, number | string>): Promise<void>;
}
/**
 * Create a default (empty) parameter applicator registry
 * Users should register their own applicators for real system integration
 */
export declare function createParameterApplicatorRegistry(): ParameterApplicatorRegistry;
/**
 * AQE Auto-Tuner
 *
 * Automatically tunes system parameters based on performance metrics.
 * Uses gradient-free optimization to find optimal configurations.
 */
export declare class AQEAutoTuner {
    private parameters;
    private config;
    private collectorRegistry;
    private applicatorRegistry;
    private algorithm;
    private state;
    private evaluationHistory;
    private eventHandlers;
    private tuningTimer?;
    private collectionTimer?;
    constructor(parameters?: TunableParameter[], config?: Partial<TuningConfig> & {
        evaluationPeriodMs?: number;
    }, collectorRegistry?: MetricCollectorRegistry, algorithm?: TuningAlgorithm, applicatorRegistry?: ParameterApplicatorRegistry);
    /**
     * Register a parameter applicator for real system integration
     */
    registerApplicator(applicator: ParameterApplicator): void;
    /**
     * Get the applicator registry
     */
    getApplicatorRegistry(): ParameterApplicatorRegistry;
    /**
     * Start the auto-tuner
     */
    start(): void;
    /**
     * Stop the auto-tuner
     */
    stop(): void;
    /**
     * Check if the tuner is running
     */
    isRunning(): boolean;
    /**
     * Collect current metrics
     */
    collectMetrics(): Promise<void>;
    /**
     * Record a search latency metric
     */
    recordSearchLatency(latencyMs: number): void;
    /**
     * Record a routing outcome (properly handles the two-boolean interface)
     */
    recordRoutingOutcome(followedRecommendation: boolean, wasSuccessful: boolean): void;
    /**
     * Record a pattern quality score
     */
    recordPatternQuality(score: number): void;
    /**
     * Record a test maintainability score
     */
    recordTestMaintainability(score: number): void;
    /**
     * Generic metric recording (for numeric values only)
     * @deprecated Use specific record methods for type safety
     */
    recordMetric(metricName: string, value: number): void;
    /**
     * Run a single tuning cycle
     */
    runTuningCycle(): Promise<TuningCycleResult>;
    /**
     * Run a single evaluation by actually applying a configuration
     * and measuring the resulting metrics
     */
    private runEvaluation;
    /**
     * Sleep utility for evaluation period
     */
    private sleep;
    /**
     * Apply the best configuration found
     */
    private applyBestConfiguration;
    /**
     * Create a skipped cycle result
     */
    private createSkippedCycleResult;
    /**
     * Get current parameter values
     */
    getCurrentParameterValues(): Record<string, number | string>;
    /**
     * Get a specific parameter
     */
    getParameter(name: string): TunableParameter | undefined;
    /**
     * Update a parameter value manually
     */
    setParameter(name: string, value: number | string): boolean;
    /**
     * Add a new tunable parameter
     */
    addParameter(param: TunableParameter): void;
    /**
     * Remove a tunable parameter
     */
    removeParameter(name: string): boolean;
    /**
     * Enable or disable a parameter for tuning
     */
    setParameterEnabled(name: string, enabled: boolean): boolean;
    /**
     * Get current state
     */
    getState(): AutoTunerState;
    /**
     * Get statistics
     */
    getStats(): AutoTunerStats;
    /**
     * Get evaluation history
     */
    getEvaluationHistory(): EvaluationResult[];
    /**
     * Get parameter history
     */
    getParameterHistory(): AutoTunerState['parameterHistory'];
    /**
     * Subscribe to events
     */
    on(handler: AutoTunerEventHandler): () => void;
    /**
     * Emit an event
     */
    private emit;
    /**
     * Export state for persistence
     */
    exportState(): {
        parameters: TunableParameter[];
        evaluationHistory: EvaluationResult[];
        parameterHistory: AutoTunerState['parameterHistory'];
    };
    /**
     * Import state from persistence
     */
    importState(data: {
        parameters?: TunableParameter[];
        evaluationHistory?: EvaluationResult[];
        parameterHistory?: AutoTunerState['parameterHistory'];
    }): void;
    /**
     * Clear all history
     */
    clearHistory(): void;
}
/**
 * Create a new AQE auto-tuner
 */
export declare function createAutoTuner(parameters?: TunableParameter[], config?: Partial<TuningConfig>): AQEAutoTuner;
//# sourceMappingURL=auto-tuner.d.ts.map