import { ThoughtNode, ThoughtMetrics, ConnectionType, VerificationStatus, CalculationVerificationResult } from './types';
/**
 * metrics-calculator.ts - VERSION OPTIMISÉE
 *
 * Système centralisé pour tous les calculs de métriques dans Smart-Thinking
 * Implémente des algorithmes avancés optimisés pour calculer la confiance, la pertinence,
 * la qualité et autres métriques utilisées par le système.
 */
/**
 * Classe qui centralise tous les calculs de métriques dans Smart-Thinking.
 * Cette classe implémente des algorithmes avancés pour le calcul de confiance,
 * la pertinence, la qualité et d'autres métriques utilisées dans le système.
 */
export declare class MetricsCalculator {
    private positiveWords;
    private negativeWords;
    private qualityIndicators;
    private uncertaintyModifiers;
    private certaintyModifiers;
    private stopWords;
    private REGEX;
    private typeScoresMap;
    private connectionWeightsMap;
    private verificationScoreMap;
    private THRESHOLDS;
    private config;
    /**
     * Constructeur
     * @param customConfig Configuration personnalisée (optionnelle)
     */
    constructor(customConfig?: Partial<typeof MetricsCalculator.prototype.config>);
    /**
     * Valide et normalise tous les poids dans les configurations pour s'assurer qu'ils s'additionnent à 1.0
     * Affiche un avertissement si ce n'est pas le cas et corrige automatiquement
     */
    private validateWeights;
    /**
     * OPTIMISATION: Compter les modalisateurs avec RegExp (plus rapide)
     *
     * @param content Contenu à analyser
     * @param regex Expression régulière à utiliser
     * @returns Nombre d'occurrences
     */
    private countModifiers;
    /**
     * Calcule la métrique de confiance pour une pensée - VERSION OPTIMISÉE
     * Implémente un algorithme amélioré pour évaluer la confiance
     *
     * @param thought La pensée à évaluer
     * @returns Niveau de confiance entre 0 et 1
     */
    calculateConfidence(thought: ThoughtNode): number;
    /**
     * Calcule la métrique de pertinence pour une pensée par rapport à son contexte - VERSION OPTIMISÉE
     * Utilise un algorithme hybride combinant TF-IDF et analyse de connexions
     *
     * @param thought La pensée à évaluer
     * @param connectedThoughts Les pensées connectées (contexte)
     * @returns Niveau de pertinence entre 0 et 1
     */
    calculateRelevance(thought: ThoughtNode, connectedThoughts: ThoughtNode[]): number;
    /**
     * Calcule la métrique de qualité globale pour une pensée - VERSION OPTIMISÉE
     * Utilise une approche multi-factorielle
     *
     * @param thought La pensée à évaluer
     * @param connectedThoughts Les pensées connectées (contexte)
     * @returns Niveau de qualité entre 0 et 1
     */
    calculateQuality(thought: ThoughtNode, connectedThoughts: ThoughtNode[]): number;
    /**
     * Calcule un score global de fiabilité basé sur différentes métriques et vérifications
     * avec une normalisation automatique des poids - VERSION OPTIMISÉE
     *
     * @param metrics Les métriques de base
     * @param verificationStatus Statut de vérification actuel
     * @param calculationResults Résultats de vérification des calculs (optionnel)
     * @param previousScore Score précédent (optionnel)
     * @returns Score de fiabilité entre 0 et 1
     */
    calculateReliabilityScore(metrics: ThoughtMetrics, verificationStatus: VerificationStatus, calculationResults?: CalculationVerificationResult[], previousScore?: number): number;
    /**
     * Calcule un score de pertinence basé sur la correspondance avec le contexte - VERSION OPTIMISÉE
     *
     * @param thought La pensée à évaluer
     * @param context Le contexte actuel
     * @returns Score de pertinence (0-1)
     */
    calculateRelevanceScore(thought: ThoughtNode, context: string): number;
    /**
     * Extrait les mots-clés d'un texte donné - VERSION OPTIMISÉE
     *
     * @param text Le texte à analyser
     * @returns Un tableau de mots-clés
     */
    extractKeywords(text: string): string[];
    /**
     * Extrait et pondère les mots-clés du contexte - VERSION OPTIMISÉE
     *
     * @param text Le texte du contexte
     * @returns Un objet avec les mots-clés et leurs poids
     */
    extractAndWeightContextKeywords(text: string): Record<string, number>;
    /**
     * Obtient le poids associé à un type de connexion - VERSION OPTIMISÉE
     *
     * @param type Le type de connexion
     * @returns Le poids de ce type de connexion
     */
    getConnectionTypeWeight(type: ConnectionType): number;
    /**
     * Détermine le statut de vérification en fonction du score de confiance
     * et d'autres facteurs - VERSION OPTIMISÉE
     *
     * @param confidenceOrResults Niveau de confiance dans la vérification (0-1) ou résultats de vérification
     * @param hasContradictions Indique s'il y a des contradictions
     * @param hasInformation Indique s'il y a des informations disponibles
     * @returns Le statut de vérification
     */
    determineVerificationStatus(confidenceOrResults: number | any[], hasContradictions?: boolean, hasInformation?: boolean): VerificationStatus;
    /**
     * Détermine le statut de vérification à partir des résultats de multiples sources - VERSION OPTIMISÉE
     * Algorithme amélioré pour gérer les cas ambigus
     *
     * @param results Résultats de vérification provenant de différentes sources
     * @returns Statut de vérification (VerificationStatus)
     */
    private determineVerificationStatusFromResults;
    /**
     * Génère un résumé explicatif du niveau de certitude - VERSION OPTIMISÉE
     *
     * @param status Statut de vérification
     * @param confidence Niveau de confiance (0-1)
     * @returns Résumé textuel du niveau de certitude
     */
    generateCertaintySummary(status: VerificationStatus, confidence?: number): string;
    /**
     * Détecte les biais potentiels dans une pensée - VERSION OPTIMISÉE
     *
     * @param thought La pensée à analyser
     * @returns Un tableau des biais détectés avec leur score (0-1)
     */
    detectBiases(thought: ThoughtNode): Array<{
        type: string;
        score: number;
        description: string;
    }>;
    /**
     * Détermine les besoins de vérification pour un contenu donné - VERSION OPTIMISÉE
     *
     * @param content Le contenu textuel à analyser
     * @returns Configuration recommandée pour la vérification
     */
    determineVerificationRequirements(content: string): {
        needsFactCheck: boolean;
        needsMathCheck: boolean;
        needsSourceCheck: boolean;
        priority: 'low' | 'medium' | 'high';
        suggestedTools: string[];
        requiresMultipleVerifications: boolean;
        reasons: string[];
        recommendedVerificationsCount: number;
    };
    /**
     * Calcule un niveau de confiance pour un ensemble de résultats de vérification - VERSION OPTIMISÉE
     * en utilisant une approche bayésienne
     *
     * @param results Résultats de vérification
     * @returns Score de confiance entre 0 et 1
     */
    calculateVerificationConfidence(results: any[]): number;
}