/**
 * Agentic QE v3 - Learning & Optimization Domain Plugin
 * Integrates the learning-optimization domain into the kernel
 */
import { DomainName, DomainEvent, Result } from '../../shared/types/index.js';
import { EventBus, MemoryBackend, AgentCoordinator } from '../../kernel/interfaces.js';
import { BaseDomainPlugin } from '../domain-interface.js';
import { ILearningOptimizationCoordinator, LearningCycleReport, OptimizationReport, CrossDomainSharingReport, LearningDashboard, ModelExport, ImportReport, LearnedPattern, Experience, Knowledge, PatternContext, PatternStats, KnowledgeQuery, OptimizedStrategy, OptimizationObjective, Strategy, ABTestConfig, ABTestResult, StrategyEvaluation } from './interfaces.js';
import { LearningCoordinatorConfig, LearningWorkflowStatus } from './coordinator.js';
import { LearningCoordinatorService, LearningCoordinatorConfig as ServiceConfig, TransferSpecialistService, TransferSpecialistConfig, MetricsOptimizerService, MetricsOptimizerConfig, ProductionIntelService, ProductionIntelConfig } from './services/index.js';
/**
 * Plugin configuration options
 */
export interface LearningOptimizationPluginConfig {
    coordinator?: Partial<LearningCoordinatorConfig>;
    learningService?: Partial<ServiceConfig>;
    transferService?: Partial<TransferSpecialistConfig>;
    optimizerService?: Partial<MetricsOptimizerConfig>;
    productionIntel?: Partial<ProductionIntelConfig>;
}
/**
 * Public API for the learning-optimization domain
 */
export interface LearningOptimizationAPI {
    runLearningCycle(domain: DomainName): Promise<Result<LearningCycleReport>>;
    optimizeAllStrategies(): Promise<Result<OptimizationReport>>;
    shareCrossDomainLearnings(): Promise<Result<CrossDomainSharingReport>>;
    getLearningDashboard(): Promise<Result<LearningDashboard>>;
    exportModels(domains?: DomainName[]): Promise<Result<ModelExport>>;
    importModels(modelExport: ModelExport): Promise<Result<ImportReport>>;
    learnPattern(experiences: Experience[]): Promise<Result<LearnedPattern>>;
    findMatchingPatterns(context: PatternContext, limit?: number): Promise<Result<LearnedPattern[]>>;
    applyPattern(pattern: LearnedPattern, variables: Record<string, unknown>): Promise<Result<string>>;
    updatePatternFeedback(patternId: string, success: boolean): Promise<Result<void>>;
    getPatternStats(domain?: DomainName): Promise<Result<PatternStats>>;
    queryKnowledge(query: KnowledgeQuery): Promise<Result<Knowledge[]>>;
    transferKnowledge(knowledge: Knowledge, targetDomain: DomainName): Promise<Result<Knowledge>>;
    optimizeStrategy(currentStrategy: Strategy, objective: OptimizationObjective, experiences: Experience[]): Promise<Result<OptimizedStrategy>>;
    runABTest(strategyA: Strategy, strategyB: Strategy, testConfig: ABTestConfig): Promise<Result<ABTestResult>>;
    recommendStrategy(context: PatternContext): Promise<Result<Strategy>>;
    evaluateStrategy(strategy: Strategy, experiences: Experience[]): Promise<Result<StrategyEvaluation>>;
}
/**
 * Extended API with internal access
 */
export interface LearningOptimizationExtendedAPI extends LearningOptimizationAPI {
    /** Get the internal coordinator */
    getCoordinator(): ILearningOptimizationCoordinator;
    /** Get active workflows */
    getActiveWorkflows(): LearningWorkflowStatus[];
    /** Get the learning service */
    getLearningService(): LearningCoordinatorService;
    /** Get the transfer service */
    getTransferService(): TransferSpecialistService;
    /** Get the optimizer service */
    getOptimizerService(): MetricsOptimizerService;
    /** Get the production intel service */
    getProductionIntelService(): ProductionIntelService;
}
/**
 * Learning & Optimization Domain Plugin
 * Provides cross-domain learning, pattern extraction, and strategy optimization
 */
export declare class LearningOptimizationPlugin extends BaseDomainPlugin {
    private readonly agentCoordinator;
    private coordinator;
    private learningService;
    private transferService;
    private optimizerService;
    private productionIntel;
    private readonly pluginConfig;
    constructor(eventBus: EventBus, memory: MemoryBackend, agentCoordinator: AgentCoordinator, config?: LearningOptimizationPluginConfig);
    get name(): DomainName;
    get version(): string;
    get dependencies(): DomainName[];
    /**
     * Get the domain's public API
     */
    getAPI<T>(): T;
    protected onInitialize(): Promise<void>;
    protected onDispose(): Promise<void>;
    protected subscribeToEvents(): void;
    protected onEvent(event: DomainEvent): Promise<void>;
    private runLearningCycle;
    private optimizeAllStrategies;
    private shareCrossDomainLearnings;
    private getLearningDashboard;
    private exportModels;
    private importModels;
    private learnPattern;
    private findMatchingPatterns;
    private applyPattern;
    private updatePatternFeedback;
    private getPatternStats;
    private queryKnowledge;
    private transferKnowledge;
    private optimizeStrategy;
    private runABTest;
    private recommendStrategy;
    private evaluateStrategy;
    private handleTestGenerated;
    private handleTestRunCompleted;
    private handleCoverageGap;
    private handleQualityGate;
    private handleDefectPredicted;
    private handleImpactAnalysis;
    private ensureInitialized;
    private handleError;
    private trackSuccessfulOperation;
    private trackFailedOperation;
}
/**
 * Factory function to create a LearningOptimizationPlugin
 */
export declare function createLearningOptimizationPlugin(eventBus: EventBus, memory: MemoryBackend, agentCoordinator: AgentCoordinator, config?: LearningOptimizationPluginConfig): LearningOptimizationPlugin;
//# sourceMappingURL=plugin.d.ts.map