import { ThoughtMetrics, ThoughtNode, VerificationResult } from './types';
import { ThoughtGraph } from './thought-graph';
import { MetricsCalculator } from './metrics-calculator';
import { IVerificationService } from './services/verification-service.interface';
/**
 * Classe qui évalue la qualité des pensées
 * Utilise le service de vérification centralisé pour toutes les fonctionnalités de vérification
 * Version optimisée avec mise en cache et structures de données efficaces
 */
export declare class QualityEvaluator {
    private verificationService;
    metricsCalculator: MetricsCalculator;
    private evaluationCache;
    private biasCache;
    private suggestionCache;
    private readonly biasPatterns;
    private readonly suggestionMappings;
    private readonly typeSuggestionMap;
    constructor();
    /**
     * Définit le service de vérification à utiliser
     *
     * @param verificationService Le service de vérification
     */
    setVerificationService(verificationService: IVerificationService): void;
    /**
     * Obtient le service de vérification depuis le conteneur si nécessaire
     * @returns Le service de vérification
     */
    private getVerificationService;
    /**
     * Crée une clé unique pour le cache
     *
     * @param thoughtId L'identifiant de la pensée
     * @param contextId Un identifiant supplémentaire pour le contexte (comme l'ID de graphe)
     * @returns Une clé unique pour le cache
     */
    private createCacheKey;
    /**
     * Évalue la qualité d'une pensée avec mise en cache pour améliorer les performances
     *
     * @param thoughtId L'identifiant de la pensée à évaluer
     * @param thoughtGraph Le graphe de pensées contenant la pensée
     * @returns Les métriques de qualité évaluées
     */
    evaluate(thoughtId: string, thoughtGraph: ThoughtGraph): ThoughtMetrics;
    /**
     * Méthode de délégation pour performPreliminaryVerification
     */
    performPreliminaryVerification(thought: string, explicitlyRequested?: boolean): Promise<import("./services/verification-service.interface").PreliminaryVerificationResult>;
    /**
     * Méthode de délégation pour checkPreviousVerification
     */
    checkPreviousVerification(thoughtContent: string, sessionId?: string): Promise<import("./services/verification-service.interface").PreviousVerificationResult>;
    /**
     * Méthode de délégation pour deepVerify
     */
    deepVerify(thought: ThoughtNode, toolIntegrator: any, containsCalculations?: boolean, forceVerification?: boolean, sessionId?: string): Promise<VerificationResult>;
    /**
     * Méthode de délégation pour detectAndVerifyCalculations
     */
    detectAndVerifyCalculations(content: string): Promise<import("./types").CalculationVerificationResult[]>;
    /**
     * Méthode de délégation pour annotateThoughtWithVerifications
     */
    annotateThoughtWithVerifications(thought: string, verifications: any[]): string;
    /**
     * Détecte les biais potentiels dans une pensée avec mise en cache des résultats
     * et utilisation d'expressions régulières optimisées
     *
     * @param thought La pensée à analyser
     * @returns Un tableau de biais détectés, vide si aucun
     */
    detectBiases(thought: ThoughtNode): Array<{
        type: string;
        score: number;
        description: string;
    }>;
    /**
     * Suggère des améliorations pour une pensée avec mise en cache des résultats
     * et structure optimisée pour réduire les calculs redondants
     *
     * @param thought La pensée à améliorer
     * @param thoughtGraph Le graphe de pensées
     * @returns Un tableau de suggestions d'amélioration
     */
    suggestImprovements(thought: ThoughtNode, thoughtGraph: ThoughtGraph): string[];
    /**
     * Efface les caches pour forcer une réévaluation complète
     * Utile lorsque des pensées sont modifiées
     */
    clearCaches(): void;
    /**
     * Supprime une entrée spécifique des caches
     *
     * @param thoughtId L'identifiant de la pensée à supprimer des caches
     */
    invalidateCacheForThought(thoughtId: string): void;
}