import type { Class_NodeElement } from '../Elements/Node';
import type { NodePositioning } from './NodePositioning';
export declare class NodePositioningProportional {
    private readonly np;
    constructor(np: NodePositioning);
    private get drawingArea();
    private get reference();
    private _prop_median_y;
    private _prop_top_y;
    private _prop_bottom_y;
    private _prop_ref_col_sums;
    suppressProportionalCompression: boolean;
    /** #243 (split modes) — Mediane (centre de gravite) du cadre proportionnel courant ; undefined si non capture. */
    get medianY(): number | undefined;
    /** #243 (split modes) — true si un cadre de reference proportionnel est capture (mediane + sommes par colonne). */
    get hasReferenceFrame(): boolean;
    /**
     * #1231 — Nœuds « libres » éligibles au mode proportionnel : visibles, non-échange,
     * non-relatifs, hors cadres tied. (Filtre commun capture/replacement.)
     */
    proportionalEligibleNodes(): Class_NodeElement[];
    /**
     * #1231 — Mode proportionnel : somme des hauteurs de nœuds par colonne (`position_u`)
     * au datatag courant. Proxy de la « somme des valeurs par colonne » (hauteur ∝ valeur
     * à échelle constante). Sert à calculer le facteur de compression f.
     */
    private proportionalColumnSums;
    /**
     * #1231 — Réinitialise complètement l'état du mode proportionnel : retire le flux de
     * référence (et son marqueur persisté) et oublie le cadre de référence capturé (médiane,
     * sommes par colonne, épaisseur du flux). Les positions courantes des nœuds sont
     * conservées (elles deviennent les positions absolues). Appelé au passage en mode absolu :
     * on repart « propre », un futur retour en proportionnel re-capture tout.
     */
    resetProportionalState(): void;
    /**
     * #1231 — Capture le cadre de référence du mode proportionnel sur l'état courant.
     * Deux régimes selon qu'un flux de référence est sélectionné ou non :
     *  - AVEC flux de référence : médiane (centre de gravité, FIXE) = centre vertical du flux
     *    à mi-parcours ; l'épaisseur du flux est mémorisée comme référence du facteur f.
     *  - SANS flux de référence (fallback) : médiane = moyenne, sur les colonnes, des **centres
     *    géométriques** de pile ; sommes de hauteurs par colonne mémorisées pour f (max ratio).
     * Dans les deux cas on capture le centre de référence de chaque nœud (pour le replacement).
     * Appelé à l'entrée du mode, après un drag et au changement de vue. `position_u` doit
     * être à jour (cf. `inferPositionUFromX`).
     */
    captureProportionalReference(): void;
    /** #1231b — Centre vertical de l'élément de référence (visibilité-gated). undefined si aucun. */
    private referenceCenterY;
    /**
     * #1231 — Facteur de compression/dilatation courant.
     *  - AVEC flux de référence : f = épaisseur courante du flux / épaisseur capturée. Tout le
     *    diagramme se comprime/dilate autour de la médiane (centre du flux) selon ce ratio.
     *  - SANS (fallback) : plus GRAND ratio (somme de hauteurs par colonne courante / référence)
     *    sur les colonnes communes.
     * 1 si pas de référence exploitable.
     */
    proportionalFactor(nodes: Class_NodeElement[]): number;
    /**
     * #1231 — Mode proportionnel : comprime/dilate le diagramme verticalement autour de
     * la médiane (centre de gravité fixe) par le facteur de flux. Appelé en tête de
     * `drawElements` avant `_sankey.draw()`. Capture la référence au 1er appel si absente.
     */
    anchorProportionalNodes(): void;
    /**
     * #1231 — Espacement des colonnes en mode proportionnel (option « écarts × f avec plancher »).
     * Raisonne en DISTANCES ENTRE CENTRES (et non en positions absolues) :
     *  - distance de référence entre deux nœuds voisins = écart de leurs centres capturés ;
     *  - distance voulue = max(distance_réf × f, ½h_haut + ½h_bas + écart_min) ;
     *  - la pile est centrée sur le centre comprimé de la colonne
     *    (médiane + (centre_réf_colonne − médiane) × f).
     * Propriétés :
     *  - à f = 1 et sans chevauchement de départ, reproduit EXACTEMENT le layout (centre de
     *    colonne = (cref_premier+cref_dernier)/2, indépendant de la médiane) → sélectionner/retirer
     *    le flux de référence ne bouge rien ;
     *  - garantit un écart ≥ écart_min entre voisins (jamais de chevauchement) ;
     *  - l'espacement suit le flux (× f) tant qu'il reste au-dessus du plancher.
     * `écart_min` = `shape_position_dy` GLOBAL (petit, ~50px) : un dy par-nœud aberrant (ex. 434)
     * forcerait un grand écart même quand le layout d'origine est plus serré → faux déplacements.
     */
    private proportionalMinFactor;
}