import { Class_LinkElement } from './Link';
/** Une tranche de la série d'un flux (une combinaison de dataTags). */
export type Type_LinkSeriesEntry = {
    /** Clé stable de la combinaison (groupe:tag|groupe:tag). */
    key: string;
    /** Libellé de la combinaison, tel qu'affiché (« Auvergne-Rhône-Alpes »). */
    label: string;
    /** Valeur brute, pour dimensionner une barre. `null` = pas de valeur. */
    value: number | null;
    /** Valeur FORMATÉE (chiffres significatifs du flux), sans suffixe d'unité. */
    text: string;
    /** Cette tranche est-elle celle actuellement sélectionnée dans les bannières ? */
    is_current: boolean;
};
/** Série complète d'un flux : ses tranches et l'unité qui les qualifie toutes. */
export type Type_LinkSeries = {
    /** Symbole d'unité, '' si l'unité n'est pas affichée. */
    unit: string;
    entries: Type_LinkSeriesEntry[];
};
export declare class LinkTooltip {
    private _link;
    constructor(link: Class_LinkElement);
    getBlockHTML(block_id: string): string | null;
    /** Onglet principal : valeur du lien, donnée, tags de flux (contenu historique). */
    private getMainTabHTML;
    /**
     * Noms des DIMENSIONS sous lesquelles ce flux porte des données saisies — de
     * quoi annoncer le contenu du bloc « Données » sans le déplier.
     */
    getDataAxisNames(): string[];
    /**
     * Onglet Données : un tableau par dimension (axe d'agrégation). Chaque tableau
     * liste les flux enfants feuille→feuille de cet axe avec valeur et ratio.
     */
    private getDataTabHTML;
    /**
     * Formate la donnée saisie d'un lien (value.valueData), via le même chemin que
     * la ligne « donnée » de l'onglet principal : link_data_label('data', …) qui
     * renvoie '' s'il n'y a pas de data_value. Unité nommée comme formatLinkValue.
     */
    private formatLinkDataValue;
    /**
     * Formate un total brut (somme de valeurs enfants) avec la même unité/format
     * que les cellules Valeur du tableau (unité nommée).
     */
    private formatTotal;
    /**
     * Lignes <tr> "Source", "URL" et "Hypothèse" de la donnée courante du flux. Affichées
     * seulement si renseignées ; l'URL est rendue cliquable (le tooltip étant
     * épinglable, cf. #158). Aucun affichage si le flux n'a pas de valeur courante.
     */
    private getDataSourceUrlRows;
    /**
     * Rend une URL en lien cliquable (le tooltip étant épinglable, cf. #158).
     * Le libellé affiché est le domaine (hostname sans "www."), court et lisible ;
     * l'URL complète reste en href + en infobulle (title). Bleu souligné pour
     * qu'on voie que c'est un hyperlien.
     */
    private urlAnchor;
    /** Lignes <tr> du contexte dataTags courant : un groupe par ligne (tag(s) sélectionné(s)). */
    private getDataTagContextRows;
    /** Trie une combinaison de dataTags selon l'ordre des groupes du sankey. */
    private orderTags;
    /**
     * Combinaisons de dataTags d'un lien (séries) : pour chaque feuille de l'arbre
     * de valeurs, une entrée { clé stable, libellé "tag / tag", valeur }.
     * Vide si le lien n'a pas de dataTags (valeur unique).
     */
    private getValueComboEntries;
    /** Nombre affiché d'une valeur de lien selon le mode (data vs réconcilié). */
    private linkValueNumber;
    /**
     * Formate un nombre avec le même nombre de chiffres significatifs que la
     * valeur du flux (config value_label : significant_digits, scientific_notation,
     * custom_digit, unit_factor) — réplique l'étape de formatage de format_value,
     * SANS suffixe d'unité (l'unité est indiquée une fois au-dessus de la série).
     */
    private fmtNum;
    /** Symbole d'unité des séries ('' si l'unité n'est pas affichée sur ce flux). */
    private getSeriesUnit;
    /** Libellé « Unité : X » à afficher au-dessus des séries (vide si pas d'unité visible). */
    private getSeriesUnitLabelHTML;
    /**
     * SÉRIE du flux : sa valeur pour chaque combinaison de dataTags. Renvoie `null`
     * quand il n'y a pas de série (valeur unique, ou une seule combinaison).
     *
     * ORDRE PRÉSERVÉ — celui des groupes de dataTags du sankey, jamais un tri par
     * valeur : une série est souvent TEMPORELLE (des années), et la trier par
     * valeur décroissante détruirait la seule lecture qui compte, la chronologie.
     */
    getSeriesFlux(): Type_LinkSeries | null;
    /**
     * Onglet Séries données : un tableau par dimension ; flux enfants en lignes,
     * combinaisons de dataTags du flux parent en colonnes.
     */
    private getSeriesDataHTML;
    /**
     * Collecte les flux enfants groupés par dimension (axe d'agrégation).
     *
     * Les données sont stockées à des granularités MIXTES : parfois feuille→feuille
     * (ex. Bois sur pied - Chêne → Prélèvements - Bois d'œuvre - Chêne), parfois
     * depuis le nœud AGRÉGÉ vers des feuilles (ex. Bois sur pied → Pertes de récolte
     * - Pin maritime, donnée IFN). On considère donc, des deux côtés, le nœud
     * lui-même ET tous ses descendants (toutes dimensions, cross-product) comme
     * extrémités possibles — `descendAll` — en mémorisant le 1er axe emprunté
     * depuis la racine (null pour la racine). Indispensable aussi pour les flux « à
     * cheval » sur deux dimensions (source par essences, cible par type de bois ×
     * essences) : une descente mono-axe les ratait.
     *
     * Chaque flux trouvé est rangé dans le groupe du 1er axe de son extrémité
     * SOURCE (perspective source ; cible si la source est le nœud agrégé / ne se
     * désagrège pas). Comme un flux a une seule extrémité source, il tombe dans un
     * seul groupe.
     *
     * Filtre `valueData` : seuls les flux portant une donnée saisie apparaissent.
     * C'est aussi ce qui évite le double comptage antagoniste (essences vs
     * propriétés) : la donnée n'est saisie que sur UNE décomposition, alors que les
     * valeurs réconciliées existeraient sur les deux.
     */
    private getChildLinkGroups;
    /**
     * Renvoie le nœud `root` ET tous ses descendants (en suivant TOUTES ses
     * dimensions, cross-product), sous forme de map id → { nœud, firstAxis }, où
     * firstAxis est le 1er axe (id de groupe de level tags) emprunté depuis root
     * pour atteindre ce nœud (null pour root lui-même). Inclure root permet de
     * capter les flux-données stockés au niveau agrégé.
     */
    private descendAll;
}