import { Class_LinkElement } from './Link';
import { LinkControlPoints } from './LinkControlPoints';
export declare class LinkDrawShape {
    private _link;
    private _link_control_points;
    private _link_control_points_internal;
    constructor(link: Class_LinkElement, link_control_points: LinkControlPoints);
    /**
   * Draw link shape on d3 svg
   * @protected
   * @memberof Class_LinkElement
   */
    drawShape(): void;
    /**
     * #285 — dessine une bande par valeur coordonnée visible du flux, dans le
     * contour du flux lui-même : mêmes points de contrôle que le tracé principal,
     * offsets transverses cumulés proportionnels aux parts (bandes jointives par
     * construction — le contour exact #1251 du flux entier, subdivisé). Les
     * bandes sont décoratives : pointer-events none, les interactions restent
     * portées par le tracé principal (invisible sous les bandes).
     * Pendant un drag, la géométrie EXACTE (échantillonnée) serait trop coûteuse
     * à chaque frame : on bascule sur le contour simple (translation transverse),
     * comme le tracé principal — l'exact est rétabli au redraw de fin de drag.
     * V1 : flux courbes hh/vv, hors recyclage. Retourne true si des bandes ont
     * été dessinées.
     */
    private drawTaggedValueBands;
    /**
     * OS#189 — régénère le contour PLEIN du flux à une épaisseur mise à l'échelle
     * (scale × épaisseur nominale). Pose un override d'échelle sur le lien le temps
     * du getBezierPath (qui lit thickness/thicknessSource/thicknessTarget), puis le
     * retire aussitôt. Réutilise donc toute la géométrie de contour existante.
     */
    private uncertaintyScaledOutline;
    /**
     * OS#189 — append une bande d'incertitude en forme pleine (fill, sans stroke,
     * non interactive). Classe dédiée `link_uncertainty_band` (nettoyée en tête de
     * drawShape).
     */
    private appendUncertaintyFilledBand;
    /**
     * Return a svg path for link path drawing
     * Varinat with only straight lines
     * @public
     * @return {string}
     */
    getLinesPath(): string;
    /**
     * Le flux a-t-il des points de contrôle libres à honorer ? Ignorés en mode
     * recyclage (géométrie de boucle dédiée).
     */
    hasWaypoints(): boolean;
    /**
     * Ligne médiane ÉCHANTILLONNÉE (polyligne dense) passant par les points de contrôle,
     * modèle e!Sankey : segment droit d'attache source → poignée de courbure début (p1),
     * segments droits entre les points avec un COIN ARRONDI à chaque sommet (rayon dérivé
     * de shape_curvature, borné à la demi-longueur du plus court segment adjacent →
     * jamais de débordement), segment droit de sortie p5 → cible. Coins vifs si
     * shape_is_curved est faux. Cette médiane unique alimente les 3 rendus (trait /
     * contour / contour exact) via getWaypointStroke et getWaypointOutline.
     * @return {Array<[number, number]>}
     */
    private getRoutedCenterline;
    /** Tracé simple trait (stroke) le long de la médiane routée. */
    getWaypointStroke(): string;
    /**
     * Contour fermé (forme pleine) : les deux bords sont décalés de ±½ épaisseur le long
     * de la médiane routée, épaisseur interpolée source→cible (tapered), normale par
     * sommet = moyenne des normales de segments adjacents avec compensation de miter
     * bornée. Alimente les modes contour Bézier / contour exact et la bordure.
     */
    getWaypointOutline(): string;
    /**
     * Return a svg shape for link path drawing using straight lines
     * Only used for short shapes.
     * @private
     * @return {*}
     * @memberof Class_LinkElement
     */
    private getLineShape;
    getBezierPath(is_outline: boolean): string;
    /**
     * Contour exact d'un lien courbe hh/vv : échantillonne la médiane (segment droit
     * d'attache, deux quadratiques, segment droit de sortie) et place les deux bords
     * le long de la normale locale de la courbe, aux offsets signés off_high (bord
     * côté -transverse) et off_low (bord côté +transverse). Résultat en polyligne
     * fermée : l'offset exact d'une Bézier n'est pas une Bézier, on ne peut pas
     * rester en Q. Chaque offset est interpolé linéairement de sa valeur source à sa
     * valeur cible le long de la courbe (liens tapered, faisceaux dont l'ordre
     * diffère aux deux extrémités), et constant sur les segments droits d'extrémité.
     * Lien seul : off_high = -épaisseur/2, off_low = +épaisseur/2. Bande d'un
     * faisceau : offsets de la bande par rapport à la médiane commune du faisceau.
     * p0/p6 : extrémités ; p1/p5 : points de courbure ; p2/p4 : points de contrôle ;
     * p3 : jonction des deux quadratiques (milieu de p2-p4).
     * transverse : axe transverse unitaire ([0,1] pour hh, [1,0] pour vv), fixe le
     * signe des offsets indépendamment du sens de parcours du lien.
     */
    private getExactBezierOutline;
    /**
     * Vrai pendant un drag de NŒUD (source ou cible) qui redessine ce lien en
     * continu : dans ce cas on retombe sur le contour simple, moins coûteux, car
     * plusieurs flux peuvent être redessinés à chaque frame.
     *
     * Le drag d'une poignée du flux (controlPoints.is_dragged) est volontairement
     * exclu : un seul flux est recalculé, et l'utilisateur reshape précisément ce
     * flux — on garde donc le contour exact en direct (opensankey#1251).
     */
    private isBeingDragged;
    /**
     * Faisceau de flux parallèles : si ce lien partage source ET cible avec d'autres
     * liens visibles du même type 'bezier_outline_exact', toutes les bandes sont
     * dérivées d'une médiane commune (celle du faisceau complet) avec les offsets
     * réels de leurs ancrages — les frontières coïncident alors exactement, sans
     * trou ni chevauchement, quelle que soit la pente (cf. opensankey#1251).
     * Retourne null si le lien est seul dans son faisceau (contour exact classique).
     * Les points de contrôle utilisés sont ceux de CE lien reportés sur la médiane :
     * les bandes restent jointives tant que les liens du faisceau partagent les
     * mêmes réglages de courbure (cas nominal).
     */
    private getParallelBandPath;
    /**
     * Return a svg shape for link path drawing using quadratic beziers
     * Only used for short shapes.
     * @public
     * @return {*}
     */
    getBezierShape(): string;
}