import type { Class_DataTag, Class_ProtoTag, Class_Tag } from '../types/Tag';
import type { Class_DataTagGroup, Class_TagGroup } from '../types/TagGroup';
import type { Type_Origin } from '../types/Origin';
import { Class_ElementValueTree, Class_LinkValue } from './LinkValues';
import { LinkControlPoints } from './LinkControlPoints';
import { Class_DrawingArea } from '../types/DrawingArea';
import { Class_NodeElement } from './Node';
import { Type_Side } from './ElementsAttributesConfig';
import { Class_LinkAttribute } from './Element';
import { LinkDrawNameLabel, LinkDrawValueLabel } from './DrawLabel';
import { Class_ApplicationData } from '../types/ApplicationData';
export declare function defaultLinkId(source: Class_NodeElement, target: Class_NodeElement): string;
/**
 * Allows to sort links alphabethically per id
 * @export
 * @param {(Class_LinkElement | Class_ElementStyle)} a
 * @param {(Class_LinkElement | Class_ElementStyle)} b
 * @return {*}
 */
export declare function sortLinksElementsByIds(a: Class_LinkElement, b: Class_LinkElement): 1 | 0 | -1;
/**
 * Allows to sort links of a given node by comparing their source / target relatives positions
 * @export
 * @param {Class_LinkElement} link_a
 * @param {Class_LinkElement} link_b
 * @param {Class_NodeElement} node
 * @return {*}
 */
export declare function sortLinksElementsByRelativeNodesPositions(link_a: Class_LinkElement, link_b: Class_LinkElement, node: Class_NodeElement): 1 | 0 | -1;
/**
 * Class that define how to display a link element and how to interact with it
 *
 * @class Class_LinkElement
 */
export declare class Class_LinkElement extends Class_LinkAttribute {
    static readonly VALUE_OBJECTIVE_MIN = "min";
    static readonly VALUE_OBJECTIVE_MAX = "max";
    static readonly VALUE_OBJECTIVE_APPROACH = "target";
    private _position_ending;
    private _tooltip_text;
    private _is_unit_reference;
    protected _source_visibility_fingerprint: string;
    protected _target_visibility_fingerprint: string;
    protected _are_source_and_target_displayed: boolean | undefined;
    protected _flux_tags_fingerprint: string;
    protected _are_related_flux_tags_selected: boolean | undefined;
    protected _datatags_fingerprint: string;
    protected _is_not_zero: boolean | undefined;
    private _link_shape;
    protected _link_control_points: LinkControlPoints;
    protected _link_draw_label: LinkDrawNameLabel;
    protected _link_draw_value: LinkDrawValueLabel;
    protected _link_draw_icon: LinkDrawNameLabel;
    private _source;
    private _target;
    private _values;
    private _arrow_shape;
    private _arrow_shape_source;
    /**
     * os#1374 — Époque d'éventail à laquelle chaque pointe a été posée (cf.
     * `Class_DrawingArea.arrow_epoch`). `-1` = jamais posée.
     */
    private _arrow_stamp;
    private _arrow_stamp_source;
    /**
     * os#1384 — ANCRE dont chaque pointe a été déduite, à côté de l'époque. L'époque seule ne
     * suffit pas : elle ne change qu'à `Class_Sankey.draw`, alors qu'À L'INTÉRIEUR d'une passe les
     * ancres bougent encore (un nœud placé après la cible, une migration de coordonnées après le
     * premier dessin). Une pointe posée avant que l'ancre soit connue portait le numéro de l'époque
     * courante, survivait donc à l'invalidation, et le `draw()` qui avait la bonne ancre réutilisait
     * la forme périmée — mesuré à l'import e!Sankey « Building Energy Footprint » : pointe centrée
     * sur y = 0 au lieu de 679,647, corps du flux juste.
     */
    private _arrow_stamp_anchor;
    private _arrow_stamp_source_anchor;
    private _source_notch_shape;
    private _artifical_enlargement;
    private _is_expansion_link;
    private _origin;
    private _determination;
    private _source_side_locked;
    private _target_side_locked;
    private _source_side_frozen;
    private _target_side_frozen;
    private _source_anchor_delta;
    private _target_anchor_delta;
    /**
     * _scaleValueToPx transform a value to a proportional size in px according to data scale
     *
     * @private
     * @memberof Class_DrawingArea
     */
    private _scaleValueToPx;
    /**
     * Creates an instance of Class_LinkElement.
     * @param {string} id
     * @param {Class_DrawingArea} drawing_area
     * @memberof Class_LinkElement
     */
    constructor(id: string, source: Class_NodeElement, target: Class_NodeElement, drawing_area: Class_DrawingArea);
    createValue(parent: Class_ElementValueTree | Class_LinkElement): Class_LinkValue;
    /**
     * Define deletion behavior
     * @memberof Class_LinkElement
     */
    protected cleanForDeletion(): void;
    copyAttrFrom(_: Class_LinkElement): void;
    copyAnchorLockFrom(_: Class_LinkElement): void;
    copyFrom(_: Class_LinkElement): void;
    copyValues(_: Class_LinkElement): void;
    addValues(_: Class_LinkElement): void;
    unDraw(): void;
    /**
     * OS#1246 — caches de géométrie du flux recalculés paresseusement à chaque
     * draw (cf. _drawArrow / _drawSourceNotch : recalcul seulement si undefined).
     * Doit être vidé à chaque (re)dessin pour suivre les changements de position/
     * taille des nœuds ; appelé par draw() (réutilisation du <g>) ET par unDraw().
     */
    protected _invalidateDrawCaches(): void;
    /**
     * os#1384 — Ancre RÉELLEMENT consommée par l'éventail, côté cible puis côté source : ce sont
     * les mêmes valeurs que `Class_NodeElement.drawLinksArrow` lit pour placer l'apex
     * (`bandTransversePos`), donc deux pointes d'ancres identiques ont la même géométrie.
     */
    private _targetAnchorKey;
    private _sourceAnchorKey;
    /**
     * OS#1246 — un <g class="gg_links"> peut exister sans tracé : il est pré-créé
     * par l'enter du data-join, et c'est le nœud source/cible qui le remplit
     * (updateLinksPositions). Le contenu qui fait foi est la forme posée par
     * LinkDrawShape.drawShape : `.link_shape` (forme pleine) ou `.link_path`
     * (simple trait), selon le mode de tracé.
     */
    protected _hasDrawnContent(): boolean;
    drawShape(): void;
    drawArrow(): void;
    /**
     * OS#1302 — action des attributs d'apparence de pointe (shape_arrow_standalone,
     * shape_arrow_spike_*). La géométrie de pointe est calculée paresseusement et
     * mise en cache (_arrow_shape[_source]) : la redessiner sans invalider le cache
     * ne fait que re-render la forme périmée. On vide donc le cache avant de
     * redessiner ; _drawArrow rappelle alors le nœud pour recalculer tout l'éventail
     * du côté (les pointes voisines suivent le changement de somme). Cf. le bug où
     * changer un réglage de pointe ne mettait pas à jour le dessin.
     */
    refreshArrow(): void;
    drawSourceNotch(): void;
    drawValueLabel(): void;
    /** #285 — remet la font-size compensée du zoom sur les labels de bande déjà
     *  présents dans le DOM (cf. LinkDrawShape.drawTaggedValueBands), sans les
     *  reconstruire : suit la police du label de valeur + font_compensation. */
    refreshBandLabelsFontSize(): void;
    /**
     * #377 — objet de dessin du LIBELLÉ du flux. Exposé pour que le label de valeur puisse
     * connaître la hauteur déjà consommée par le libellé (règle « libellé prioritaire, puis
     * valeur »). Lecture seule : l'instance est créée au constructeur et ne change jamais.
     */
    get name_label_drawer(): LinkDrawNameLabel;
    drawNameLabel(): void;
    drawWithNodes(): void;
    drawAsSelected(): void;
    /**
     * Reverse source with target
     * @memberof Class_LinkElement
     */
    inverse(): void;
    /**
     * Check if given tag is referenced by link's data
     * @param {Class_Tag} tag
     * @return {*}
     * @memberof Class_LinkElement
     */
    hasGivenTag(tag: Class_Tag): boolean;
    tagsUpdated(): void;
    /**
     * Add and cross-reference a Tag with a link
     * @param {Class_Tag} tag
     * @memberof Class_LinkElement
     */
    addTag(tag: Class_Tag): void;
    /**
     * Remove given tag and cross-reference from link
     * @param {Class_Tag} tag
     * @memberof Class_LinkElement
     */
    removeTag(tag: Class_Tag): void;
    addDataTagGroup(tagg: Class_DataTagGroup): void;
    collapseDataTagGroup(tagg: Class_DataTagGroup, tag_for: (tag_id: string) => Class_Tag | undefined, selected_tag_id?: string | undefined): void;
    removeDataTagGroup(tagg: Class_DataTagGroup): void;
    addDataTag(tag: Class_DataTag): void;
    removeDataTag(tag: Class_DataTag): void;
    getShapeColorToUse(): string;
    getArrowColorToUse(): string;
    /**
     * Return maximum value possible for this link
     *
     * @return {*}
     * @memberof Class_LinkElement
     */
    getMaxValue(): number;
    getAllValues(): {
        [_: string]: [import("./LinkValues").Class_ElementValue, Class_DataTag[] | undefined];
    };
    setDomainLocalScale(_: number | undefined): void;
    setValuesForDataTags(tags: Class_DataTag[], val: Class_LinkValue): void;
    /**
     * #285 — bandes internes : subdivision de l'épaisseur du flux,
     * proportionnelle aux valeurs coordonnées VISIBLES de la feuille courante.
     * Choix d'affichage déclenché par la bannière `multi` d'un groupe libre
     * (sinon le flux montre sa seule valeur principale) ; une bande disparaît si
     * un tag de sa coordonnée est désélectionné. Les parts sont relatives à la
     * somme des valeurs visibles — les valeurs d'un flux ne sont PAS additives,
     * l'épaisseur du flux reste pilotée par la valeur principale.
     */
    get tagged_value_bands(): {
        id: string;
        px: number;
        share: number;
        color: string | null;
        value: number;
        unit?: string;
        label_visible?: boolean;
    }[];
    /** §3.0ter — épaisseur totale quand le flux s'affiche en bandes : somme des
     *  largeurs de bandes (chacune à l'échelle de son tag). */
    private get _bands_total_px();
    /** #285 — le flux affiche des bandes issues d'un groupe porteur ADDITIF : la
     *  valeur du flux (label principal) est le TOTAL, les bandes montrent le
     *  détail SANS label par bande. À l'inverse (unité), pas de total et un label
     *  par bande. Sert à DrawLabel (garder/masquer le label) et aux labels de bande. */
    get has_additive_bands(): boolean;
    /**
     * Set up element on d3 svg area
     * @private
     * @memberof Class_LinkElement
     */
    /**
     * OS#1246 — le flux ne doit avoir un <g> que s'il est visible ET au-dessus
     * du seuil de valeur. Sans ce gate, un flux passant sous le seuil garderait
     * son <g> racine réutilisé dans le DOM (l'ancien early-return de _draw ne le
     * supprimait pas). Le retour false fait déclencher un unDraw (exit) par draw().
     */
    _shouldBeDrawn(): boolean;
    protected _draw(): void;
    protected _initDraw(): void;
    drawIcon(): void;
    /**
     * Draw arrow shape on d3
     * @protected
     * @memberof Class_LinkElement
     */
    protected _drawArrow(): void;
    /**
     * Draw the "source notch" (negative arrow) on this link's d3 selection.
     * The chevron is computed once at the source node for ALL links leaving the
     * same side (so they share a single notch), then applied on each participating
     * link as an SVG <mask> that carves the chevron out of the link's own paint
     * (shape/path/bordure/pointe) : vraie découpe transparente, ce qui est derrière
     * l'encoche (nœuds, flux croisés, fond) reste visible — contrairement à
     * l'ancien recouvrement peint couleur de fond qui masquait tout.
     * @protected
     */
    protected _drawSourceNotch(): void;
    /** Id du mask d'encoche — id du flux échappé pour rester un fragment url(#...) valide. */
    private _sourceNotchMaskId;
    /**
     * (Ré)applique l'attribut mask de l'encoche sur les tracés peints du flux.
     * Les <path> (shape/path/bordure/pointe) sont détruits/recréés par
     * drawShape/_drawArrow et perdent l'attribut, alors que le <mask> lui-même
     * persiste dans le <g> du flux — d'où ce rattrapage dans chaque point
     * d'entrée public qui recrée les tracés.
     * @protected
     */
    protected _applySourceNotchMask(): void;
    /**
     * Draw all d3 elements on link d3 selection
     * @protected
     * @memberof Class_LinkElement
     */
    drawElements(): void;
    drawControlPoint(): void;
    /**
     * Put d3 elements in correct display order
     * @protected
     * @memberof Class_NodeElement
     */
    protected _orderD3Elements(): void;
    protected onDoubleLMBClick(_event: React.MouseEvent<HTMLButtonElement, React.MouseEvent>): void;
    protected onSingleLMBClick(event: React.MouseEvent<HTMLButtonElement, React.MouseEvent>): void;
    protected eventSimpleRMBClick(event: React.MouseEvent<HTMLButtonElement, React.MouseEvent>): void;
    protected addOrRemoveLinkFromSelection(): void;
    /**
     * Define event when mouse moves over element
     * @protected
     * @param {React.MouseEvent<HTMLButtonElement, React.MouseEvent>} event
     * @memberof ClassTemplate_Element
     */
    eventMouseOver(event: React.MouseEvent<HTMLButtonElement, React.MouseEvent>): void;
    /**
   * Define event when mouse moves in the element
   *
   * @protected
   * @param {React.MouseEvent<HTMLButtonElement, React.MouseEvent>} event
   * @memberof Class_LinkElement
   */
    eventMouseMove(event: React.MouseEvent<HTMLButtonElement, React.MouseEvent>): void;
    /**
     * Define event when mouse move out of element
     * @protected
     * @param {React.MouseEvent<HTMLButtonElement, React.MouseEvent>} event
     * @memberof ClassTemplate_Element
     */
    eventMouseOut(event: React.MouseEvent<HTMLButtonElement, React.MouseEvent>): void;
    protected scaleValueToPx(_: number): number;
    private redrawNodesSourceTarget;
    defaultLinkName(source: Class_NodeElement, target: Class_NodeElement): string;
    /**
     * Get name of link
     * @readonly
     * @memberof Class_LinkElement
     */
    get name(): string;
    get has_result(): boolean;
    get has_intervals(): boolean;
    get has_data(): boolean;
    set_only_data(): void;
    get is_zero(): boolean;
    /**
     * #fn — un flux à valeur nulle reste affiché si l'option GLOBALE « flux nuls
     * visibles » (drawing_area.show_zero_links, Paramètres d'affichage) est active,
     * OU si ce flux porte l'attribut PAR-FLUX `shape_visible_when_zero`. Lu dans
     * `_is_visible_ignoring_container_modes` pour outrepasser le filtre `is_not_zero`.
     */
    get is_forced_visible_when_zero(): boolean;
    /**
     * #188 — true when this flux is structurally absent for the currently selected
     * dataTags (pruned by the no-propagation option; #161 marker on the leaf). The
     * flux does not exist for that dataTag, so it must stay hidden even with
     * "show zero links" on or in structure mode — overriding the null-value path
     * in is_not_zero (valueCurrent is null for an absent leaf, which would
     * otherwise read as "!= 0" and reveal the link as a dashed phantom).
     * Legacy/default files carry no marker, so this is always false there.
     */
    get is_structurally_absent_for_current_datatags(): boolean;
    get is_expansion_link(): boolean;
    set is_expansion_link(v: boolean);
    get origin(): Type_Origin | undefined;
    set origin(v: Type_Origin | undefined);
    get determination(): number | null;
    set determination(v: number | null);
    get is_visible(): boolean;
    /**
     * Vrai si ce flux porte une valeur collectée SAISIE (donnée mesurée ou borne
     * min) sur au moins un datatag — à la différence de `has_data` qui inclut
     * aussi les flux définis par ratio/pourcentage (sans valeur mesurée).
     */
    get has_collected_data(): boolean;
    /**
     * Décide si ce lien doit être compté dans le sizing de `node`
     * (getShape{Height,Width}ToUse). Plus permissif qu'`is_visible` :
     * un lien masqué *uniquement* par `is_allowed_by_container_modes` est
     * inclus côté endpoint INTERNE au container (parent ou enfant de la dim
     * en container_mode qui le masque). L'endpoint externe, lui, voit déjà
     * le lien jumeau remonté sur le parent — il NE doit pas le compter en
     * plus, sinon sa taille double.
     */
    is_visible_for_sizing_of(node: Class_NodeElement): boolean;
    /**
     * Identique à `is_visible` mais sans le filtre `is_allowed_by_container_modes`.
     * Exposé public pour les agrégats côté nœud (data_value / data_label) :
     * dans un mode englobant qui masque TOUS les liens d'un endpoint
     * (typiquement `in_children_out_children` côté parent), le filtre
     * `is_visible` retourne 0 lien et la valeur du nœud disparaît — alors
     * que l'utilisateur, lui, considère ces liens comme visibles.
     */
    get is_visible_ignoring_container_modes(): boolean;
    /**
     * Variante de `is_visible_ignoring_container_modes` qui IGNORE la condition
     * `is_not_zero`. Un flux à valeur nulle (typiquement fraîchement créé, valeur
     * pas encore saisie) reste structurellement présent : il doit quand même
     * définir la topologie pour le placement automatique. Cf. `is_visible_ignoring_zero`.
     */
    get is_visible_ignoring_container_modes_and_zero(): boolean;
    private _is_visible_ignoring_container_modes;
    /**
     * Visibilité « structurelle » pour le placement automatique : identique à
     * `is_visible` mais en ignorant la valeur nulle. Le calcul d'index horizontal
     * (computeAutoSankey, qui pilote position_x) doit traverser un flux à 0 comme
     * le fait detectAllCyclesAndOptimize (qui pilote position_u) — sinon le nœud
     * cible d'un flux sans valeur n'est pas atteint et reste mal placé en X.
     */
    get is_visible_ignoring_zero(): boolean;
    /**
     * Container display mode link filter.
     *
     * When a dimension is in container mode, parent and children are visible
     * at the same time and the links are split by side:
     * - 'in_children_out_parent': inputs land on children, outputs leave from parent
     * - 'in_parent_out_children': inputs land on parent, outputs leave from children
     * - 'in_children_out_children': inputs and outputs both on children (parent is a pure envelope, no flux)
     * - 'in_parent_out_parent': inputs and outputs both on parent (children carry no flux of their own)
     *
     * Links inside a group (child → child of the same dimension) stay visible in
     * all modes. If any impacted dimension hides this link, the link is hidden.
     */
    get is_allowed_by_container_modes(): boolean;
    /**
     * Get source node
     * @memberof Class_LinkElement
     */
    get source(): Class_NodeElement;
    /**
     * set source node
     * @memberof Class_LinkElement
     */
    set source(_: Class_NodeElement);
    /**
     * Get starting node side for link
     * @readonly
     * @type {Type_Side}
     * @memberof Class_LinkElement
     */
    get source_side(): Type_Side;
    /** Side derived from node relative positions, ignoring any anchor lock. */
    /**
     * opensankey#1301 — auto-suivi du côté d'accroche : le côté du nœud `node` qui
     * FAIT FACE au point `pt` (1er/dernier waypoint). Les waypoints découplent la
     * direction de départ/arrivée de la position relative des nœuds, donc le côté
     * doit suivre la route, pas « où est l'autre nœud ». `undefined` si pas de point.
     */
    private _waypointFacingSide;
    private get _computed_source_side();
    /**
     * get destination node
     * @memberof Class_LinkElement
     */
    get target(): Class_NodeElement;
    /**
     * Set destination node
     * @memberof Class_LinkElement
     */
    set target(_: Class_NodeElement);
    /**
     * Reverse link direction by swapping its source and target nodes.
     * Done in one shot to avoid the transient source === target state
     * that the source/target setters would otherwise read as a recycling link.
     * @memberof Class_LinkElement
     */
    swapSourceAndTarget(): void;
    /**
     * Get starting node side for link
     * @readonly
     * @type {Type_Side}
     * @memberof Class_LinkElement
     */
    get target_side(): Type_Side;
    /** Side derived from node relative positions, ignoring any anchor lock. */
    private get _computed_target_side();
    get source_side_locked(): boolean;
    set source_side_locked(value: boolean);
    get target_side_locked(): boolean;
    set target_side_locked(value: boolean);
    get source_anchor_delta(): number;
    set source_anchor_delta(value: number);
    get target_anchor_delta(): number;
    set target_anchor_delta(value: number);
    /** Which end of this link is attached to `node` ('source' / 'target' / undefined). */
    private endForNode;
    /** Is the anchor on `node`'s side locked ? */
    getAnchorLockedForNode(node: Class_NodeElement): boolean;
    /** Lock / unlock the anchor on `node`'s side. */
    setAnchorLockedForNode(node: Class_NodeElement, value: boolean): void;
    /** Spacing inserted before the anchor on `node`'s side. */
    getAnchorDeltaForNode(node: Class_NodeElement): number;
    /** Set the spacing inserted before the anchor on `node`'s side. */
    setAnchorDeltaForNode(node: Class_NodeElement, value: number): void;
    /** Release both anchor locks — called by automatic layout passes. */
    resetAnchorLocks(): void;
    valueForTags(_: Class_ProtoTag[]): Class_LinkValue | null;
    /**
     * #1231 — Valeur numérique du flux pour un jeu de datatags EXPLICITE (même extraction que
     * `valueCurrent`, mais sans dépendre de la sélection courante). Utilisé par le mode % pour
     * lire la valeur du flux de référence à son datatag de référence (couple flux/datatag).
     */
    valueForDataTags(data_tags: Class_DataTag[]): number | null;
    valueForTag(tag: Class_DataTag | undefined): Class_LinkValue | null;
    get selected_data_tags_list(): Class_DataTag[];
    /**
     * Get value object.
     * Either search correct current value with data_taggs,
     * or return directly the value when there is no data_taggs
     * @readonly
     * @memberof Class_LinkElement
     */
    get value(): Class_LinkValue | null;
    /**
     * Épaisseur cible (px) de ce flux quand il est la référence d'échelle du view tag COURANT
     * (cf. DrawingArea.applyViewTagScaleReference). undefined si ce flux n'est pas la référence
     * du view tag courant, ou en « vue complète » (aucun view tag sélectionné). La donnée vit
     * sur la DrawingArea (par view tag), pas comme attribut de flux — la valeur dépend du view
     * tag affiché.
     */
    get scale_reference_thickness(): number | undefined;
    set scale_reference_thickness(value: number | undefined);
    private _is_computing;
    get valueCurrent(): number | null;
    /**
     * Calcule la valeur affichée d'un lien d'expansion (issue #1225).
     *
     * En expand_left, le lien va `enfant → parent`. La valeur représente la
     * part de l'enfant dans le flux entrant agrégé du parent — calculée comme
     * la somme des inputs visibles de l'enfant (flux venant de plus à gauche),
     * EXCLUANT les autres liens d'expansion. Si l'enfant n'a pas d'inputs
     * (extrémité), on retombe sur ses outputs (le parent joue le rôle
     * d'agrégateur). Symétrique pour expand_right.
     */
    private _computeExpansionValue;
    /**
     * Either set correct current value with data_taggs,
     *  or set directly the value when there is no data_taggs
     * @memberof Class_LinkElement
     */
    set valueCurrent(_: number | null);
    /**
     * SA#487 — intention d'optimisation sur la valeur de ce flux : « min », « max »
     * ou null. Écrite là où l'utilisateur formule son intention — la case Valeur —
     * exactement comme dans la colonne Valeur d'une feuille de données.
     *
     * Le rang est attribué ici, et il compte : c'est lui qui arbitre entre
     * plusieurs « min » concurrents, que le moteur fige l'un après l'autre. Dans
     * un classeur, c'est l'ordre des lignes ; dans l'application, il n'y a pas de
     * lignes — l'ordre est donc celui des déclarations, et le rang se prend à la
     * suite du plus grand déjà posé sur le diagramme.
     */
    get valueObjectiveCurrent(): string | null;
    set valueObjectiveCurrent(_: string | null);
    /**
     * SA#507 — cible visée par une intention « au plus près de … ».
     *
     * La poser EST la déclaration : elle installe l'intention `target` et sa
     * notation, comme écrire un nombre dans la cellule Valeur en regard d'une
     * incertitude infinie. Toujours un nombre FINI — l'infini se dit « max », et
     * le laisser entrer ici comme un nombre ramènerait la sentinelle que SA#487 a
     * chassée des solveurs.
     */
    get valueObjectiveTargetCurrent(): number | null;
    set valueObjectiveTargetCurrent(_: number | null);
    /**
     * SA#507 — « incertitude infinie » : la case Valeur cesse d'être une mesure
     * pour devenir une cible.
     *
     * C'est la notation du classeur, portée dans l'application : une incertitude
     * infinie est une valeur qui ne contraint rien, donc pas une donnée mais un
     * souhait. L'allumer transforme la valeur saisie en cible ; l'éteindre la
     * rend au champ Valeur, de sorte que l'aller-retour ne perde rien.
     */
    get dataUncertaintyIsInfinite(): boolean;
    set dataUncertaintyIsInfinite(_: boolean);
    private nextValueObjectiveRank;
    /**
     * Target (destination) value for the link.
     * When null, the link has uniform thickness (same as source).
     * When set, the link tapers from source value to target value.
     */
    get valueCurrentTarget(): number | null;
    set valueCurrentTarget(_: number | null);
    get dataMin(): number | null;
    set dataMin(_: number | null);
    get dataMax(): number | null;
    set dataMax(_: number | null);
    get dataUncertainty(): number | null;
    set dataUncertainty(_: number | null);
    /**
     * Either search correct current value with data_taggs,
     *  or return directly the value when there is no data_taggs
     * @return string
     * @memberof Class_LinkElement
     */
    get text_value(): string;
    /**
     * Either set correct current value with data_taggs,
     *  or set directly the value when there is no data_taggs
     * @memberof Class_LinkElement
     */
    set text_value(_: string);
    unit_name(prefix: 'name_label' | 'value_label'): string;
    data_label(prefix: 'name_label' | 'value_label'): string;
    /**
     * OS#1314 — texte du label de nom construit par gabarit à jetons
     * (`name_label_text_source === 'template'`). Exposé ici pour que le rendu
     * (DrawLabel) n'ait pas à importer types/Utils : ce chemin
     * DrawLabel -> Utils -> Node -> NodeBase -> DrawLabel refermerait le cycle
     * d'initialisation des modules (cf. arch_element_handler_init_cycle).
     */
    get template_label(): string;
    /**
     * Dict as [id: tag] of tags related to link
     * @readonly
     * @memberof Class_LinkElement
     */
    get flux_tags_dict(): {};
    /**
     * Array of tags related to link
     * @readonly
     * @memberof Class_LinkElement
     */
    get flux_tags_list(): Class_Tag[];
    /**
     * Dict as [id: tag group] of tag groups related to link
     * @readonly
     * @memberof Class_LinkElement
     */
    get flux_taggs_dict(): {
        [_: string]: Class_TagGroup;
    };
    /**
     * Array of tag groups related to link
     * @readonly
     * @memberof Class_LinkElement
     */
    get flux_taggs_list(): Class_TagGroup[];
    drawFO(): void;
    linkIsStructure: () => boolean;
    /**
     * Clamp a raw pixel thickness to the drawing area min/max limits.
     *
     * Le plancher est `minimum_flux` quand il est défini (0 compris → épaisseur
     * réelle du flux), sinon le plancher dur historique de 2px (#200). Politique
     * pure isolée dans flowThickness.ts (testable hors cycle d'imports).
     */
    private _clampThickness;
    /**
     * Get thickness of stroke shape (source side).
     * This is the main thickness used everywhere for backward compatibility.
     * @readonly
     * @memberof Class_LinkElement
     */
    /**
     * OS#189 — facteur d'échelle temporaire appliqué à l'épaisseur pendant la
     * génération des contours de bandes d'incertitude (formes pleines). Posé puis
     * remis à null immédiatement par LinkDrawShape autour d'un getBezierPath, de
     * sorte que toute la géométrie du contour (getLineShape/getBezierShape, qui
     * lisent thickness/thicknessSource/thicknessTarget) soit régénérée à la
     * largeur min/max sans dupliquer le code de tracé. null = épaisseur nominale.
     */
    private _uncertainty_thickness_scale;
    setUncertaintyThicknessScale(scale: number | null): void;
    private _scaleUncertainty;
    get thickness(): number;
    /**
     * Bornes d'incertitude à représenter (issue OS#189). L'intervalle [min, max]
     * entourant la valeur affichée suit le MODE d'affichage courant : en mode
     * `data` on prend les bornes saisies (data_min/data_max), sinon (réconcilié /
     * libre) les bornes réconciliées (result_min/result_max). Repli sur l'autre
     * jeu de bornes si celui du mode est absent. Null si aucun intervalle
     * exploitable (bornes absentes ou dégénérées max <= min).
     */
    get uncertaintyBounds(): {
        min: number;
        max: number;
    } | null;
    /**
     * Épaisseurs en px des trois tracés superposés min/moyenne/max servant à
     * matérialiser l'incertitude (OS#189). `meanPx` = épaisseur nominale du flux
     * (this.thickness). Renvoie null quand l'affichage est désactivé
     * (shape_uncertainty_display) ou qu'il n'y a pas d'intervalle exploitable.
     */
    get uncertaintyBandsPx(): {
        minPx: number;
        meanPx: number;
        maxPx: number;
    } | null;
    /**
     * Alias for thickness at the source end of the link.
     */
    get thicknessSource(): number;
    /**
     * Get thickness at the target (destination) end of the link.
     * When valueCurrentTarget is null, returns same as thicknessSource (uniform link).
     */
    get thicknessTarget(): number;
    private _safeRawThickness;
    get thicknessSourceRaw(): number;
    get thicknessTargetRaw(): number;
    /**
     * Whether this link has different source and target thicknesses (tapered/trapezoid shape).
     */
    get isTapered(): boolean;
    /**
     * OS#1250 phase 3 — points de contrôle du tracé, en coordonnées MONDE.
     *
     * Exposés pour borner le flux SANS mesurer le DOM : une Bézier est contenue dans
     * l'enveloppe convexe de ses points de contrôle, donc ces points (élargis de la
     * demi-épaisseur) majorent le tracé — y compris les flux de recyclage, qui bouclent
     * franchement hors du segment source→cible.
     */
    get control_points_position(): {
        starting_curve: number[];
        ending_curve: number[];
        starting_bezier: number[];
        ending_bezier: number[];
        middle_recycling: number[];
    };
    get position_x_start(): number;
    get position_y_start(): number;
    get position_x_end(): number;
    get position_y_end(): number;
    get is_horizontal(): boolean;
    get is_vertical(): boolean;
    get is_horizontal_vertical(): boolean;
    get is_vertical_horizontal(): boolean;
    /**
     * opensankey#1301 — RÉGIME ROUTÉ : le flux a des points de contrôle libres et n'est
     * plus paramétrique. shape_orientation (hh/vv/vh/hv) ne s'applique plus ; axe et côté
     * à chaque extrémité dérivent de la route (cf. NOTE-WAYPOINTS.md). Exclut le recyclage.
     */
    get is_routed(): boolean;
    /**
     * Axe d'accroche par EXTRÉMITÉ (h = côté gauche/droite, v = haut/bas), source de
     * vérité pour le layout du nœud et les extrémités du tracé. En régime routé, l'axe
     * suit le CÔTÉ dérivé de la route (source_side/target_side) ; sinon, l'ancienne
     * combinaison d'orientation (source = 1ère lettre, cible = 2ème).
     */
    get is_source_horizontal(): boolean;
    get is_target_horizontal(): boolean;
    /**
     * Set and redraw d3 path for link arrow
     */
    set shape_arrow_path(_: string);
    set shape_arrow_path_source(_: string);
    set shape_source_notch_path(_: string);
    get value_label_unit_is_reference(): boolean;
    set value_label_unit_is_reference(_: boolean);
    get datatags_fingerprint(): string;
    /**
     * If link has tags :
     * - check for each tag group if the flow has at least one selected tag that isn't filtered out
     * else if the link doesn't have tag it isn't filtered by them
     * @readonly
     * @memberof Class_LinkElement
     */
    get are_related_flux_tags_selected(): boolean;
    /**
     * If link value for current dataTagg parameter is different of 0 then pass the check,
     *
     * @readonly
     * @memberof Class_LinkElement
     */
    get is_not_zero(): boolean;
    /**
     * Check if node source and node target are displayed,
     * if one of them is not then we don't display the link
     *
     * @private
     * @return {*}
     * @memberof Class_LinkElement
     */
    private get are_source_and_target_displayed();
    /**
     * If drawing area has filter_link_value above 0:
     * - check if the link value is superior to the filter
     *   if not don't display the link
     * @readonly
     * @private
     * @memberof Class_LinkElement
     */
    protected get is_value_above_threshold(): boolean;
    /**
     * Seuil d'affichage exprimé en pixels (#seuil px). Renvoie true (= le flux passe
     * le seuil) quand : le seuil est nul/négatif (désactivé), le flux n'a pas de
     * valeur (ghost/structure — jamais masqué par un seuil), ou son épaisseur
     * PROPORTIONNELLE (scaleValueToPx, avant plancher de lisibilité minimum_flux)
     * atteint le seuil. On volontairement ne clampe pas : le seuil doit refléter la
     * taille réelle de la donnée, pas le plancher de lisibilité.
     */
    isThicknessAbovePxThreshold(px_threshold: number): boolean;
    get tooltip_text(): string;
    set tooltip_text(value: string);
    static updateLinks: <K extends "valueCurrent" | "valueCurrentTarget" | "text_value" | "dataMin" | "dataMax" | "dataUncertainty" | "valueObjectiveCurrent" | "dataUncertaintyIsInfinite">(data: Class_ApplicationData, elements: Class_LinkElement[], key: K, value: K extends "text_value" ? string : K extends "valueObjectiveCurrent" ? string | null : K extends "dataUncertaintyIsInfinite" ? boolean : number | null, refreshParentComponent: () => void) => void;
}