import { type EmbeddingConfig } from './real-embeddings.js';
import { type SQLitePersistenceConfig } from './sqlite-persistence.js';
import { QEPattern, QEDomain, QEPatternContext, CreateQEPatternOptions } from './qe-patterns.js';
import { QEGuidance } from './qe-guidance.js';
import type { Result } from '../shared/types/index.js';
export interface RealQEReasoningBankConfig {
    /** SQLite database configuration */
    sqlite: Partial<SQLitePersistenceConfig>;
    /** Embedding model configuration */
    embeddings: Partial<EmbeddingConfig>;
    /** Enable learning from outcomes */
    enableLearning: boolean;
    /** Enable task routing */
    enableRouting: boolean;
    /** Enable guidance generation */
    enableGuidance: boolean;
    /** HNSW index parameters */
    hnsw: {
        M: number;
        efConstruction: number;
        efSearch: number;
    };
    /** Routing weights */
    routingWeights: {
        similarity: number;
        performance: number;
        capabilities: number;
    };
}
export declare const DEFAULT_REAL_CONFIG: RealQEReasoningBankConfig;
export interface RealQERoutingRequest {
    task: string;
    taskType?: 'test-generation' | 'analysis' | 'debugging' | 'optimization';
    domain?: QEDomain;
    capabilities?: string[];
    context?: Partial<QEPatternContext>;
}
export interface RealQERoutingResult {
    recommendedAgent: string;
    confidence: number;
    alternatives: Array<{
        agent: string;
        score: number;
    }>;
    domains: QEDomain[];
    patterns: QEPattern[];
    guidance: string[];
    reasoning: string;
    latencyMs: number;
}
export interface LearningOutcome {
    patternId: string;
    success: boolean;
    metrics?: {
        testsPassed?: number;
        testsFailed?: number;
        coverageImprovement?: number;
        executionTimeMs?: number;
    };
    feedback?: string;
}
export interface RealQEReasoningBankStats {
    totalPatterns: number;
    byDomain: Record<QEDomain, number>;
    byTier: Record<string, number>;
    routingRequests: number;
    avgRoutingLatencyMs: number;
    p95RoutingLatencyMs: number;
    learningOutcomes: number;
    patternSuccessRate: number;
    embeddingCacheSize: number;
    transformerAvailable: boolean;
    embeddingDimension: number;
    sqliteDbPath: string;
}
/**
 * Real QE ReasoningBank - Standalone Implementation
 *
 * Standalone implementation with REAL:
 * - Transformer embeddings (all-MiniLM-L6-v2, 384 dimensions)
 * - SQLite persistence (better-sqlite3 with WAL mode)
 * - HNSW vector indexing (hnswlib-node)
 *
 * Does NOT extend HybridReasoningBank due to upstream bugs and problematic singleton behavior.
 */
export declare class RealQEReasoningBank {
    private readonly qeConfig;
    private sqliteStore;
    private hnswIndex;
    private patternIdMap;
    private initialized;
    private stats;
    private readonly agentCapabilities;
    constructor(config?: Partial<RealQEReasoningBankConfig>);
    /**
     * Initialize the QE ReasoningBank
     */
    initialize(): Promise<void>;
    /**
     * Initialize HNSW index for fast similarity search
     */
    private initializeHNSW;
    /**
     * Load existing patterns into HNSW index
     */
    private loadPatternsIntoHNSW;
    /**
     * Load foundational QE patterns
     */
    private loadFoundationalPatterns;
    /**
     * Store a QE pattern with REAL embeddings
     */
    storeQEPattern(options: CreateQEPatternOptions): Promise<Result<QEPattern>>;
    /**
     * Search patterns using REAL vector similarity (HNSW)
     */
    searchQEPatterns(query: string, options?: {
        limit?: number;
        domain?: QEDomain;
        minSimilarity?: number;
    }): Promise<Result<Array<{
        pattern: QEPattern;
        similarity: number;
    }>>>;
    /**
     * Route a task to optimal agent
     */
    routeTask(request: RealQERoutingRequest): Promise<Result<RealQERoutingResult>>;
    /**
     * Record pattern usage outcome
     */
    recordOutcome(outcome: LearningOutcome): Promise<Result<void>>;
    /**
     * Check if pattern should be promoted to long-term
     */
    private shouldPromote;
    /**
     * Get QE guidance for a domain
     */
    getQEGuidance(domain: QEDomain): QEGuidance;
    /**
     * Generate guidance context
     */
    generateQEContext(domain: QEDomain, context?: {
        framework?: string;
        language?: string;
    }): string;
    /**
     * Check for anti-patterns
     */
    checkQEAntiPatterns(domain: QEDomain, content: string): import("./qe-guidance.js").AntiPattern[];
    /**
     * Get REAL statistics with REAL metrics
     */
    getQEStats(): Promise<RealQEReasoningBankStats>;
    /**
     * Record a pattern outcome for feedback learning
     */
    recordPatternOutcome(patternId: string, success: boolean, qualityScore: number): Promise<void>;
    /**
     * Check if a pattern should be promoted
     */
    checkPatternPromotion(patternId: string, successCount: number, successRate: number, avgQuality: number): Promise<boolean>;
    /**
     * Promote a pattern to the next tier
     */
    promotePattern(patternId: string): Promise<void>;
    /**
     * Demote a pattern to a lower tier
     */
    demotePattern(patternId: string): Promise<void>;
    /**
     * Dispose and cleanup
     */
    dispose(): Promise<void>;
}
/**
 * Create a Real QE ReasoningBank
 */
export declare function createRealQEReasoningBank(config?: Partial<RealQEReasoningBankConfig>): RealQEReasoningBank;
//# sourceMappingURL=real-qe-reasoning-bank.d.ts.map