import { ThoughtNode, VerificationStatus, VerificationResult, CalculationVerificationResult } from '../types';
import { VerificationMemory } from '../verification-memory';
import { ToolIntegrator } from '../tool-integrator';
import { MetricsCalculator } from '../metrics-calculator';
import { IVerificationService, PreliminaryVerificationResult, PreviousVerificationResult } from './verification-service.interface';
/**
 * Service optimisé pour la vérification des informations
 * Utilise des expressions régulières précompilées, un cache LRU, et des promesses optimisées
 */
export declare class VerificationService implements IVerificationService {
    private toolIntegrator;
    private metricsCalculator;
    private verificationMemory;
    /**
     * Expressions régulières précompilées et mises en cache
     * pour une détection optimisée des caractéristiques
     */
    private static readonly REGEX_CACHE;
    /**
     * Cache LRU pour les résultats de vérification
     */
    private static readonly verificationCache;
    /**
     * Cache LRU pour les résultats de calcul
     */
    private static readonly calculationCache;
    /**
     * Constructeur du service de vérification
     *
     * @param toolIntegrator L'intégrateur d'outils pour les vérifications externes
     * @param metricsCalculator Le calculateur de métriques pour évaluer la fiabilité
     * @param verificationMemory La mémoire de vérification pour la persistance
     */
    constructor(toolIntegrator: ToolIntegrator, metricsCalculator: MetricsCalculator, verificationMemory: VerificationMemory);
    /**
     * Effectue une vérification préliminaire d'une pensée pour détecter des calculs
     * Version optimisée utilisant le cache et une détection plus efficace
     *
     * @param content Le contenu de la pensée à vérifier
     * @param explicitlyRequested Si la vérification est explicitement demandée
     * @returns Résultat de la vérification préliminaire
     */
    performPreliminaryVerification(content: string, explicitlyRequested?: boolean): Promise<PreliminaryVerificationResult>;
    /**
     * Vérifie si une pensée similaire a déjà été vérifiée
     * Version optimisée avec gestion de cache
     *
     * @param content Le contenu de la pensée à vérifier
     * @param sessionId ID de session
     * @param thoughtType Type de pensée (regular, conclusion, etc.)
     * @param connectedThoughtIds IDs des pensées connectées
     * @returns Résultat de la vérification précédente si trouvée
     */
    checkPreviousVerification(content: string, sessionId?: string, thoughtType?: string, connectedThoughtIds?: string[]): Promise<PreviousVerificationResult>;
    /**
     * Vérification approfondie d'une pensée
     * Version refactorisée et optimisée
     *
     * @param thought La pensée à vérifier
     * @param containsCalculations Indique si la pensée contient des calculs à vérifier
     * @param forceVerification Force une nouvelle vérification même si déjà vérifiée
     * @param sessionId Identifiant de la session de conversation actuelle
     * @returns Le résultat de la vérification
     */
    deepVerify(thought: ThoughtNode, containsCalculations?: boolean, forceVerification?: boolean, sessionId?: string): Promise<VerificationResult>;
    /**
     * Étape 1: Vérifier si l'information a déjà été vérifiée dans les vérifications précédentes
     *
     * @param thought La pensée à vérifier
     * @param forceVerification Si true, ignore les vérifications précédentes
     * @param sessionId Identifiant de la session
     * @returns Le résultat de vérification si trouvé, null sinon
     */
    private checkForPreviousVerification;
    /**
     * Étape 2: Analyser les besoins de vérification
     *
     * @param content Contenu à analyser
     * @returns Les besoins de vérification déterminés
     */
    private analyzeVerificationNeeds;
    /**
     * Étape 3: Sélectionner et exécuter les outils de vérification
     *
     * @param content Contenu à vérifier
     * @param verificationNeeds Besoins de vérification déterminés
     * @returns Résultats de vérification
     */
    private executeVerificationTools;
    /**
     * Étape 4: Vérifier les calculs si nécessaire
     *
     * @param content Contenu à vérifier
     * @param verificationResults Résultats de vérification existants
     * @returns Résultats de vérification des calculs
     */
    private verifyCalculations;
    /**
     * Étape 5: Analyser et agréger les résultats
     *
     * @param thought Pensée à vérifier
     * @param verificationResults Résultats de vérification
     * @param verifiedCalculations Résultats de vérification des calculs
     * @param sessionId ID de session
     * @returns Résultat final de vérification
     */
    private analyzeAndAggregateResults;
    /**
     * Détermine le statut et la confiance de la vérification à partir des résultats
     * Version optimisée et factorisée
     *
     * @param results Résultats de vérification
     * @param thought Pensée à vérifier
     * @returns Statut et niveau de confiance
     */
    private determineVerificationStatusAndConfidence;
    /**
     * Calcule la confiance moyenne à partir des résultats
     *
     * @param results Résultats pour lesquels calculer la moyenne
     * @returns Confiance moyenne
     */
    private calculateAverageConfidence;
    /**
     * Détecte et vérifie les calculs dans un texte de manière asynchrone
     * Version optimisée avec mise en cache
     *
     * @param content Le texte contenant potentiellement des calculs
     * @returns Une promesse résolvant vers un tableau de résultats de vérification de calculs
     */
    detectAndVerifyCalculations(content: string): Promise<CalculationVerificationResult[]>;
    /**
     * Annote une pensée avec les résultats de vérification des calculs
     *
     * @param content Le texte de la pensée à annoter
     * @param verifications Les résultats de vérification des calculs
     * @returns Le texte annoté avec les résultats de vérification
     */
    annotateThoughtWithVerifications(content: string, verifications: CalculationVerificationResult[]): string;
    /**
     * Version optimisée de la détection des contradictions
     *
     * @param results Résultats à analyser
     * @returns Tableau des contradictions détectées
     */
    private detectContradictions;
    /**
     * Version optimisée et plus informative de la génération des notes de vérification
     *
     * @param results Résultats de vérification
     * @param calculations Résultats de vérification des calculs
     * @returns Notes de vérification
     */
    private generateVerificationNotes;
    /**
     * Stocke une vérification dans la mémoire
     *
     * @param content Le contenu vérifié
     * @param status Le statut de vérification
     * @param confidence Le niveau de confiance
     * @param sources Les sources utilisées
     * @param sessionId L'identifiant de la session
     * @returns L'identifiant de la vérification stockée
     */
    storeVerification(content: string, status: VerificationStatus, confidence: number, sources?: string[], sessionId?: string): Promise<string>;
    /**
     * Récupère les statuts de vérification des pensées connectées
     *
     * @param thoughtIds IDs des pensées connectées à vérifier
     * @returns Tableau des statuts de vérification
     */
    private getConnectedThoughtsVerificationStatus;
    /**
     * Analyse les caractéristiques du contenu en une seule passe
     *
     * @param content Contenu à analyser
     * @returns Caractéristiques détectées
     */
    private analyzeContentCharacteristics;
    /**
     * Exécute une promesse avec un timeout pour éviter les opérations bloquantes
     *
     * @param promise Promesse à exécuter
     * @param timeoutMs Délai d'expiration en millisecondes
     * @returns Résultat de la promesse ou null en cas de timeout
     */
    private executeWithTimeout;
    /**
     * Génère un hash simple pour une chaîne (utilisé pour les clés de cache)
     *
     * @param str Chaîne à hacher
     * @returns Hash sous forme de chaîne
     */
    private hashString;
}