import type { Class_DataTag } from '../types/Tag';
import type { NodePositioning } from './NodePositioning';
export declare class NodePositioningScaleAdapted {
    private readonly np;
    constructor(np: NodePositioning);
    private get drawingArea();
    private _scale_adapted_ref_magnitude;
    private _scale_adapted_ref_scale;
    /**
     * #384 — Grandeur du diagramme au datatag/viewtag courant : la SOMME DE LA COLONNE LA PLUS
     * HAUTE, exprimée EN VALEURS et non en pixels (aucune circularité avec l'échelle qu'elle sert
     * à fixer). C'est bien elle qui détermine la hauteur rendue du diagramme : la hauteur d'un
     * nœud vaut sa valeur ÷ échelle, et la hauteur totale est celle de la colonne la plus chargée.
     *
     * Mêmes conventions de colonne que `resolveScaleAdaptedOverlaps` : groupage par `position_u`,
     * exclusion des nœuds `echange` (import/export, placés au niveau de leur flux — ils gonfleraient
     * artificiellement une colonne), des nœuds relatifs et des cadres tied. Seuls les éléments
     * VISIBLES comptent : le cas du mode vue se règle ainsi sans code séparé.
     *
     * 0 si le diagramme n'a aucune valeur (garde-fou de `applyAdaptedScale`).
     */
    diagramMagnitude(): number;
    /**
     * os#1372 — La même grandeur, mais lue à un jeu de datatags EXPLICITE : c'est elle qui sert de
     * référence quand le document désigne un datatag de référence.
     *
     * La VISIBILITÉ reste celle de la sélection courante — seules les VALEURS changent. C'est
     * voulu : le mode compare une même vue d'un datatag à l'autre, donc la référence doit être la
     * grandeur de CETTE vue au datatag de référence. C'est aussi ce qui règle le défaut qui avait
     * motivé sa#384 : plus besoin qu'un élément désigné soit visible dans la vue.
     *
     * Limites héritées de `Link.valueForDataTags` (mêmes que le mode proportionnel) : un flux
     * d'expansion, dont la valeur est calculée depuis la sélection courante, et les valeurs
     * coordonnées d'un groupe porteur ne sont pas relues au datatag demandé.
     */
    diagramMagnitudeForDataTags(tags: Class_DataTag[]): number;
    /**
     * os#1383 — Valeur-équivalente du nœud VISIBLE le plus haut, tous nœuds confondus (le plafond
     * de hauteur s'applique à chacun, sans les exclusions de colonne de `diagramMagnitude`).
     *
     * Sert au plafond EXACT du mode « échelle adaptée » sans élément de référence : l'échelle qui
     * amène ce nœud à `maximum_node` px vaut `grandeur × 100 / maximum_node`. Calculée EN VALEURS
     * et non depuis la hauteur rendue, parce que celle-ci est plancher-ée (hauteur minimale de
     * nœud, `minimum_flux`) : à grande échelle, un nœud de 3 px rend 40, et un facteur pris sur
     * 40 ne l'amènerait jamais au plafond.
     *
     * 0 si aucun nœud visible ne porte de valeur.
     */
    tallestNodeMagnitude(): number;
    /** Corps commun : somme par colonne (`position_u`), maximum des colonnes. */
    private _columnsMagnitude;
    /**
     * os#1372 — Grandeur du diagramme AU DATATAG DE RÉFÉRENCE désigné par le document, ou
     * `undefined` s'il n'y en a pas (ou s'il ne désigne plus rien de connu).
     *
     * CALCULÉE, jamais stockée : c'est tout l'objet du réglage. La grandeur capturée au vol
     * (`scale_adapted_ref_magnitude`) figeait un nombre pris au dataTag qui se trouvait à l'écran
     * quand le mode a pris, que rien ne nommait et que la moindre correction de données rendait
     * faux. Ici la référence est ÉNONCÉE (des tags), et la grandeur s'en déduit à chaque dessin.
     */
    referenceDataTagMagnitude(): number | undefined;
    /**
     * Tags du datatag de référence, résolus depuis les ids persistés. `undefined` si aucun n'est
     * désigné — un id inconnu (dimension supprimée depuis) est simplement ignoré, la référence
     * restant valable sur les dimensions qui subsistent.
     */
    private referenceDataTags;
    /**
     * #384 — Valeur-équivalente de la hauteur d'un nœud : `max(Σ entrées, Σ sorties)`, augmentée
     * de la valeur de stock quand le nœud est dimensionné par son stock (miroir en valeurs de
     * `Node._getNaturalShapeHeight`, dont la hauteur-stock est divisée par
     * `stock_height_scale_factor`). Les planchers/plafonds en pixels (`minimum_flux`,
     * `maximum_node`) sont volontairement ignorés : ils ne suivent pas l'échelle, et les faire
     * entrer ici rendrait la grandeur dépendante de l'échelle courante.
     */
    private nodeMagnitude;
    /**
     * #384 — Valeur-équivalente de l'épaisseur d'un flux. `shape_local_link_scale` divise
     * l'échelle du flux (cf. `Link.scaleValueToPx`) : un flux à l'échelle locale f rend f fois
     * plus fin, sa contribution à la hauteur de la colonne est donc valeur/f. Les flux portés par
     * un tag d'unité ont leur propre échelle, indépendante de celle du diagramme : ils comptent
     * ici pour leur valeur brute (limite assumée, cf. #382).
     */
    private linkMagnitude;
    /**
     * #1231/#384 — Mode « échelle adaptée » : capture l'échelle courante et la grandeur du
     * diagramme. Sert de base au ratio appliqué ensuite (`applyAdaptedScale`). À l'entrée du
     * mode, grandeur_courante == grandeur_ref → échelle inchangée → pas de saut.
     *
     * #384 — Appelée aussi à chaque frame tant que le mode est ARMÉ mais pas appliqué (cf.
     * `DrawingArea.drawElements`) : la frame affichée est alors la référence. D'où le no-op sur
     * grandeur nulle — un datatag sans aucune valeur ne doit pas EFFACER une référence déjà
     * posée, sans quoi la capture repartirait de zéro au datatag suivant (pas de retard).
     * L'oubli explicite de la capture, lui, est le rôle de `clearScaleAdaptation`.
     */
    captureScaleReference(): void;
    /**
     * os#1352 — GRANDEUR DE RÉFÉRENCE du régime courant, au moment de la CAPTURE.
     *
     * Régime `diagram` (défaut, sa#384) : grandeur du diagramme au datatag/viewtag courant.
     * Régime `element` : valeur de l'élément de référence AU DATATAG DE RÉFÉRENCE — et non sa
     * valeur courante. C'est la convention d'avant sa#384 (`referenceFluxRefValue`), qui fait du
     * couple (élément, datatag de référence) le gabarit de taille ; s'en écarter changerait le
     * comportement des fichiers qu'on cherche justement à réhabiliter.
     *
     * `undefined` = pas de référence exploitable (aucun élément désigné, ou valeur nulle).
     */
    private referenceMagnitudeForCapture;
    /**
     * os#1352 — GRANDEUR COURANTE du régime courant, celle dont le ratio à la grandeur de référence
     * donne l'échelle.
     *
     * Régime `element` : en mode VUE, la valeur du CORRESPONDANT de la vue (l'enfant visible portant
     * l'étiquette sélectionnée, `referenceViewValue`) — c'est ce qui normalise une vue d'essence sur
     * une autre ; hors mode vue, la valeur courante de l'élément (`referenceCurrentValue`). Reprend
     * verbatim la dissymétrie d'avant sa#384, seule à traiter correctement un élément de référence
     * masqué par le filtre de vue (cas de CARTOFOB, dont le stock « Bois sur pied » est invisible
     * dans chaque vue d'essence).
     *
     * `undefined` = grandeur inexploitable → l'appelant SIGNALE au lieu de figer l'échelle en
     * silence, ce qui était le défaut ayant motivé le retrait du régime en sa#384.
     */
    private currentMagnitude;
    private _scale_adapted_warning;
    get scaleAdaptedWarning(): string | undefined;
    private _warned_selection;
    /**
     * os#1352 — Signale que le régime `element` n'a pas de grandeur exploitable au datatag/viewtag
     * courant. Le défaut reproché à l'ancien régime n'était pas de ne rien faire, c'était de ne rien
     * faire SANS LE DIRE : l'échelle restait celle de la sélection précédente et l'affichage
     * devenait inexploitable sans explication. On journalise une fois par sélection et on expose
     * l'état ; l'échelle précédente est conservée (rien de mieux à faire, mais ce n'est plus muet).
     */
    private warnElementReferenceUnusable;
    /**
     * os#1352 — Oublie la capture SANS toucher à l'échelle courante (à la différence de
     * `clearScaleAdaptation`, qui restaure l'échelle de base parce qu'on QUITTE le mode). Sert au
     * changement de RÉGIME : les grandeurs des deux régimes ne sont pas commensurables, la capture
     * de l'un ne peut pas servir de base à l'autre. La capture paresseuse repart au dessin suivant.
     */
    forgetScaleAdaptedCapture(): void;
    /**
     * #369 — Couple capturé du mode « échelle adaptée » (échelle de BASE + grandeur du diagramme),
     * exposé pour la PERSISTANCE. Le mode étant désormais restitué à l'ouverture (cf.
     * `positionModeOnLoad`), ce couple doit l'être aussi : la grandeur capturée d'un document à
     * élément de référence n'est pas recalculable à l'ouverture. os#1383 — `user_scale`, lui,
     * est désormais toujours l'échelle de BASE de l'utilisateur (l'adaptation n'écrit plus que
     * l'échelle effective de la frame). undefined tant que rien n'a été capturé (rien à écrire).
     */
    get scaleAdaptedReference(): {
        scale: number;
        magnitude: number;
    } | undefined;
    /**
     * #369 — Restaure le couple capturé lu dans le fichier (cf. `scaleAdaptedReference`). Valeurs
     * aberrantes ignorées : la capture paresseuse de `applyAdaptedScale` reprend alors la main
     * (comportement d'un fichier antérieur, qui ne porte pas ces clés).
     */
    restoreScaleReference(scale: number, magnitude: number): void;
    /**
     * #1231/#384 — Mode « échelle adaptée » : ajuste l'échelle (valeur→px) du diagramme pour qu'il
     * garde sa hauteur de référence à tous les datatags. Appelé en tête de `drawElements` avant
     * `_sankey.draw()`. Écrit l'échelle EFFECTIVE de la frame (`setEffectiveScale`, os#1383) —
     * jamais `_scale`, l'échelle absolue de l'utilisateur, ni via le setter `scale` (redraw →
     * récursion).
     *
     * Retourne vrai si une échelle a été adaptée, faux si le document ne fournit aucune grandeur
     * de référence exploitable (CARTOFOB : régime `element` sans élément désigné). Dans ce cas
     * `drawElements` rend le plafond de hauteur EXACT : c'est lui qui adapte.
     */
    applyAdaptedScale(): boolean;
    /**
     * #1231 — Sortie du mode « échelle adaptée » : oublie la capture. os#1383 — plus rien à
     * restaurer : l'adaptation n'écrivait que l'échelle effective de la frame, l'échelle de base
     * de l'utilisateur est intacte et la prochaine frame repart d'elle.
     */
    clearScaleAdaptation(): void;
    /**
     * #1231 — Mode « échelle adaptée » : dérive le coin de chaque nœud « libre » depuis son CENTRE
     * stocké, SANS jamais recommiter le coin dans le centre. Remplace `anchorAbsoluteNodesByCenter`
     * dans la branche scale_adapted de `drawElements` : on garde la même dérivation centre→coin,
     * mais on supprime la branche « taille inchangée → captureCenterFromCorner » qui figerait le
     * recalage d'affichage (anti-chevauchement / clamp, cf. `resolveScaleAdaptedOverlaps`) dans le
     * centre persisté → ce recalage se traînerait alors d'un viewtag/datatag à l'autre.
     *
     * Le centre reste la SEULE vérité : il n'est modifié que par les gestes utilisateur (drag,
     * resize → `settleCenterAnchor`) et les opérations structurelles, jamais par le dessin. À chaque
     * frame on repart donc du centre propre, et le recalage d'espacement est recalculé pour le
     * datatag/viewtag courant (transitoire, jamais persistant).
     *
     * Mêmes exclusions que `anchorAbsoluteNodesByCenter` : nœuds visibles, libres (non relatifs),
     * hors cadres tied. Lazy-init du centre au 1er dessin (fichier sans centre encore posé).
     */
    deriveScaleAdaptedCornersFromCenter(): void;
    /**
     * #1231 — Mode « échelle adaptée » : décale un nœud verticalement de `dy` POUR L'AFFICHAGE
     * seulement (coin `position_y`), SANS toucher au centre stocké. Le recalage d'espacement est
     * propre au datatag/viewtag courant : il est recalculé à chaque dessin à partir du centre
     * (cf. `deriveScaleAdaptedCornersFromCenter`) et ne doit donc jamais être persisté, sinon il se
     * traînerait d'un datatag/viewtag à l'autre. No-op si `dy` nul.
     */
    private shiftNodeY;
    /**
     * #1231 — Mode « échelle adaptée » : anti-chevauchement par colonne (DEPUIS LE HAUT) + clamp
     * du haut du diagramme. Appelé après `deriveScaleAdaptedCornersFromCenter` dans la branche
     * scale_adapted de `drawElements`.
     *
     * En mode échelle, les nœuds grossissent autour de leur centre FIXE quand l'échelle monte
     * (bascule datatag/viewtag). Deux effets indésirables :
     *  - deux nœuds d'une même colonne peuvent se recouvrir ;
     *  - le nœud du haut, dont le coin = centre − hauteur/2, peut passer AU-DESSUS du haut du
     *    diagramme (y < 0).
     *
     * On ne re-layoute PAS le diagramme :
     *  1. anti-chevauchement : le nœud le plus haut de chaque colonne garde sa place, chaque nœud
     *     suivant est descendu juste assez pour rétablir l'écart minimal (push vers le bas only) ;
     *  2. clamp du haut : si le sommet de la colonne dépasse y=0, on décale TOUTE la colonne vers
     *     le bas pour que son sommet tienne pile au haut du diagramme.
     * Ces décalages sont D'AFFICHAGE (coin seulement, cf. `shiftNodeY`) : recalculés à chaque
     * dessin depuis le centre, donc propres au datatag/viewtag courant et jamais persistés.
     *
     * Mêmes conventions de colonne que `backCalculateShapePositionDyFromY` : groupage par
     * `position_u`, exclusion des nœuds `echange` (import/export, placés au niveau de leur flux),
     * des nœuds relatifs et des cadres tied. `écart_min` = `shape_position_dy` GLOBAL.
     */
    resolveScaleAdaptedOverlaps(): void;
}