import * as d3 from '../d3Modules';
import type { Class_DrawingArea } from './DrawingArea';
import { Class_NodeElement } from '../Elements/Node';
/**
 * Point d'application UNIQUE d'un transform de caméra.
 * `animate` : interpolation d3.interpolateZoom ; `from` : point de départ imposé.
 */
export declare function setCamera(da: Class_DrawingArea, target: d3.ZoomTransform, opts?: {
    animate?: boolean;
    from?: d3.ZoomTransform;
}): void;
/**
 * Applique un recadrage de fit (#1250) : échelle `k` puis placement du point MONDE (0,0) au pixel
 * `[px, py]`. Passe DÉLIBÉRÉMENT par scaleTo/translateTo (et non par setCamera/zoomListener.transform
 * direct) pour conserver le CONSTRAIN de d3-zoom (clamp selon translateExtent) : ce clamp est
 * load-bearing — le ré-ancrage des labels en police verrouillée (#165) en dépend. Les scrollbars
 * doivent avoir été rafraîchies AVANT (elles posent le translateExtent lu par le constrain).
 */
export declare function applyFitCamera(da: Class_DrawingArea, k: number, px: number, py: number): void;
/**
 * Ré-ancre la caméra : place le point MONDE `(wx, wy)` au pixel `[px, py]`, SANS toucher à
 * l'échelle.
 *
 * Comme applyFitCamera, passe délibérément par `translateTo` et non par setCamera : c'est le
 * CONSTRAIN de d3-zoom (clamp selon translateExtent) qui fait le travail — le ré-ancrage des
 * labels en police verrouillée (#165) en dépend, et `zoomListener.transform` le contournerait.
 * Les scrollbars doivent avoir été rafraîchies AVANT (elles posent le translateExtent lu par le
 * constrain).
 */
export declare function anchorCamera(da: Class_DrawingArea, wx: number, wy: number, px: number, py: number): void;
/**
 * Variante animée des recadrages EXPLICITES (boutons fit H/V). Calcule le cadrage cible via
 * areaAutoFit — inchangé, avec tous ses effets de bord (_k_fit, labels, fond) — puis anime la caméra
 * de l'ancien vers le nouveau transform. Les recadrages automatiques appellent areaAutoFit direct.
 */
export declare function areaAutoFitAnimated(da: Class_DrawingArea, horiz?: boolean, force_when_locked?: boolean, fill_axis_forced?: boolean): void;
/**
 * Variante animée du bouton « recentrer ».
 *
 * OS#1250 phase 2 — recenter() ne déplace plus les coordonnées MONDE : ce n'est
 * plus qu'un cadrage de caméra. La compensation qui existait ici (capture d'un
 * nœud témoin avant/après pour corriger le transform de départ du décalage monde,
 * via shiftTransformByWorldDelta) n'a donc plus d'objet — le delta serait
 * toujours nul. On anime simplement de la caméra courante vers celle du fit.
 */
export declare function recenterAnimated(da: Class_DrawingArea, force?: boolean): void;
/**
 * Centre la caméra sur un nœud avec une animation cinématique. Conserve l'échelle courante par
 * défaut ; `scale` force un niveau de zoom cible.
 */
export declare function flyToNode(da: Class_DrawingArea, node: Class_NodeElement, scale?: number): void;
/**
 * Centre la caméra sur un point MONDE `(wx, wy)` avec une animation cinématique. Conserve
 * l'échelle courante par défaut ; `scale` force un niveau de zoom cible.
 *
 * Généralisation de flyToNode aux éléments qui ne sont pas des nœuds (flux, zones de texte) :
 * la recherche (OS#1273) calcule le centre de l'élément trouvé et recadre dessus.
 */
export declare function flyToPoint(da: Class_DrawingArea, wx: number, wy: number, scale?: number): void;
/**
 * Met à l'échelle EN PLACE la géométrie du modèle vivant par `r`. À appeler APRÈS setAbsoluteMode
 * (positions figées en absolu). Les extrémités et points de contrôle des flux ANCRÉS dérivent des
 * positions de nœuds (déjà ×r) et de tangentes en RATIO → recalculés à la bonne échelle au redraw.
 */
export declare function scaleModelGeometry(da: Class_DrawingArea, r: number, include_labels: boolean): void;
/**
 * « Figer le zoom à 100 % à diagramme constant » : bascule en MODE ABSOLU (positions figées, plus
 * de recompute paramétrique / auto-placement d'échange), scaling EN PLACE de toute la géométrie par
 * le zoom courant r, puis caméra à k=1 (translation conservée). Historique par snapshots
 * avant/après, sauf `record_history=false` (geste englobé, ex. import Excel).
 */
export declare function bakeZoomIntoGeometry(da: Class_DrawingArea, opts?: {
    record_history?: boolean;
}): void;
/**
 * Zoom EXPLICITE par facteur multiplicatif (boutons -/+), ancré au centre du viewport visible.
 * Passe par zoomListener.scaleBy pour conserver le scaleExtent (clamp [0.05, 20]) et le constrain
 * de d3-zoom (load-bearing, cf. applyFitCamera). Animé sauf reduced-motion / animations coupées.
 */
export declare function zoomByFactor(da: Class_DrawingArea, factor: number): void;
/**
 * Zoom EXPLICITE vers une échelle absolue `k` (ex. clic sur l'indicateur → 100% = k=1), ancré au
 * centre du viewport visible. Même canal (scaleTo) que zoomByFactor pour garder extent + constrain.
 */
export declare function zoomToScale(da: Class_DrawingArea, k: number): void;
/**
 * Viewport utile en pixels écran : zone réellement disponible pour le diagramme (fenêtre ou
 * conteneur hôte, réserves de panneaux déduites), et décalage vertical de la nav bar.
 */
export declare function getViewport(da: Class_DrawingArea): {
    width: number;
    height: number;
    top_offset: number;
};
/**
 * Bounds du contenu en coordonnées MONDE. Phase 1 : mesure DOM (getBBox du groupe des éléments) —
 * l'interface est posée, l'implémentation basculera vers un calcul depuis le modèle (positions +
 * tailles + labels estimés) en phase 3, ce qui supprimera les dépendances à l'ordre de rendu.
 *
 * `null` signifie « pas de zone à mesurer » (SVG absent), PAS « contenu vide ». Un contenu vide
 * renvoie un rect à zéro, fidèlement à getBBox : areaAutoFit distingue les deux cas — une bbox
 * vide y déclenche une remise à l'état « diagramme neuf » (indispensable au basculement
 * papier→libre sur une vue vide), qu'un `null` ferait sauter. Un appelant qui veut traiter le
 * contenu vide teste `width === 0 && height === 0`.
 */
export declare function contentBounds(da: Class_DrawingArea): {
    x: number;
    y: number;
    width: number;
    height: number;
} | null;
/**
 * OS#1250 phase 3a — bounds des FORMES (labels EXCLUS) calculés depuis le MODÈLE.
 *
 * Remplace la mesure masquée du fit (`display:none` sur les labels → getBBox → restauration),
 * qui forçait deux calculs de layout et mutait le DOM pour le mesurer.
 *
 * Contrat : MAJORER le tracé, jamais le sous-estimer — un cadrage trop large est bénin, trop
 * étroit fait déborder le contenu. D'où l'enveloppe convexe pour les Béziers (cf.
 * Link.control_points_position) plutôt qu'un échantillonnage.
 *
 * `null` = rien de visible à mesurer (même contrat que contentBounds : pas « vide » mais
 * « rien à mesurer » — l'appelant décide).
 */
export declare function contentBoundsFromModel(da: Class_DrawingArea): {
    x: number;
    y: number;
    width: number;
    height: number;
} | null;