import type { Class_NodeElement } from '../Elements/Node';
import type { Type_DisaggregationGap } from '../types/Utils';
/** Étendues verticales (haut/bas/centre) par colonne (position_u) d'un ensemble de nœuds. */
export declare function columnGeometricExtents(nodes: Class_NodeElement[]): Map<number, {
    top: number;
    bottom: number;
    center: number;
}>;
/** Empile verticalement les nœuds depuis `anchor_y` (écart = shape_position_dy sauf le premier). */
export declare function stackNodesVertically(nodes: Class_NodeElement[], anchor_y: number): void;
/**
 * Hauteur totale de la pile produite par `stackNodesVertically` :
 * somme des hauteurs + somme des `shape_position_dy` des nœuds (sauf le premier).
 */
export declare function totalStackHeight(nodes: Class_NodeElement[]): number;
/** Forme minimale d'un membre de pile verticale (typage structurel, cf. Type_ContainerCandidate). */
export type Type_StackMember = {
    position_v: number;
    position_y: number;
    shape_position_dy?: number;
    getShapeHeightToUse(): number;
};
/**
 * Ordre de parcours d'une pile : `position_v` croissant, `position_y` en départage. C'est le
 * tri qu'appliquent `anchorParametricNodesToAbsolute` et `restackContainerChildren`.
 */
export declare function sortStackMembers<T extends Type_StackMember>(members: T[]): T[];
/**
 * positions → ORDRE. Réinsère les membres DÉPLACÉS (`moved`) à leur rang vertical déposé, puis
 * repermute les `position_v` de la pile en conséquence. C'est ce qui fait qu'un nœud tiré
 * au-dessus de son prédécesseur y RESTE, au lieu d'être ramené juste en dessous par un écart
 * négatif clampé à 0.
 *
 * DEUX RÔLES, à ne pas confondre. Un membre déplacé porte une position DÉPOSÉE, qui fait
 * autorité ; les autres portent la position que le dernier empilement leur a donnée, laquelle
 * sera RECALCULÉE au prochain dessin. Trier toute la pile sur les y mélangerait les deux : tirer
 * une ancre sous sa propre pile ferait passer la pile devant elle, alors que la pile doit
 * simplement la suivre. Les non-déplacés gardent donc leur ordre relatif, et servent de repères.
 *
 * Seules les VALEURS de v sont permutées, l'ensemble est conservé : la pile ne peut pas dériver
 * vis-à-vis du reste du diagramme (nœuds masqués sous la sélection courante, notamment). Le rang
 * se compare sur les CENTRES : un membre est « au-dessus » d'un autre quand son centre l'est, ce
 * qui reste juste entre membres de hauteurs très différentes.
 *
 * Renvoie la pile dans son ordre RÉGLÉ — c'est elle qu'il faut passer à `settleStackGapsFromY`.
 */
export declare function settleStackOrderFromY<T extends Type_StackMember>(members: T[], moved: (member: T) => boolean): T[];
/**
 * positions → ÉCARTS. `shape_position_dy` de chaque membre retenu par `settles` devient l'écart
 * entre son bord supérieur et le bord INFÉRIEUR DU MEMBRE QUI LE PRÉCÈDE DANS LA CHAÎNE — la
 * relation exacte que l'empilement relit. Un chevauchement (écart négatif) est clampé à 0.
 *
 * `settles` ne doit retenir que les membres DÉPLACÉS : l'écart d'un membre que le dessin va
 * replacer est déjà juste, et le réécrire depuis sa position courante le figerait là où le
 * dessin PRÉCÉDENT l'avait mis — la pile ne suivrait plus son ancre.
 *
 * `chain` doit être la pile DÉJÀ ORDONNÉE (`sortStackMembers`, ou le retour de
 * `settleStackOrderFromY`). Renvoie le nombre d'écarts clampés.
 */
export declare function settleStackGapsFromY<T extends Type_StackMember>(chain: T[], settles?: (member: T) => boolean): number;
/**
 * Écart vertical AVANT un enfant de cadre englobant, selon le mode d'écart courant :
 *  - 'constant'  : `const_gap` (lu EN DIRECT sur `disaggregation_gap_value`) — éditer la valeur
 *                  modifie donc tous les englobements existants au prochain dessin, l'écart
 *                  n'étant volontairement PAS figé dans `shape_position_dy`.
 *  - autres modes: `shape_position_dy` de l'enfant (fill = valeur calculée figée au slot ;
 *                  children_dy = écart propre à l'enfant ; keep = les enfants ne sont pas
 *                  ré-empilés, cf. appelants).
 */
export declare function containerChildGap(child: Class_NodeElement, mode: Type_DisaggregationGap, const_gap: number): number;
/**
 * Empile verticalement les enfants d'un cadre englobant, comme `stackNodesVertically` mais avec
 * l'écart résolu par `containerChildGap` (constant lu en direct). Utilisé par le mode parametric
 * (Phase C de `recomputeParametricLayout`) et les autres modes (`restackContainerChildren`).
 */
export declare function stackContainerChildren(nodes: Class_NodeElement[], anchor_y: number, mode: Type_DisaggregationGap, const_gap: number): void;
/** Hauteur totale de la pile de `stackContainerChildren` (écart constant lu en direct). */
export declare function totalContainerStackHeight(nodes: Class_NodeElement[], mode: Type_DisaggregationGap, const_gap: number): number;
/**
 * Forme minimale d'un nœud pour décider s'il est un cadre englobant de premier niveau.
 * Typage structurel volontaire : la décision se teste sans construire de Class_NodeElement.
 */
export type Type_ContainerCandidate = {
    dimensions_as_parent: {
        container_mode?: unknown;
    }[];
    dimensions_as_child: {
        container_mode?: unknown;
    }[];
};
/**
 * Cadres englobants de PREMIER NIVEAU dont les enfants sont à ré-empiler : parents d'au moins
 * une dimension en `container_mode`, et qui ne sont pas eux-mêmes enfants d'un autre cadre
 * (ceux-là sont pris en charge par la descente de leur cadre racine).
 *
 * #365 — CAPITAL : la sélection ne regarde PAS `is_visible` du cadre. La visibilité d'un cadre
 * dépend de ses flux PROPRES, qu'un cadre en `in_children_out_children` n'a par construction
 * pas à montrer : un cadre pouvait donc être masqué alors que ses membres, eux, sont dessinés
 * (cf. #368). Filtrer sur la visibilité du cadre laissait alors ses enfants à la position que
 * le placement global venait de leur donner INDIVIDUELLEMENT — coin = centre persisté − hauteur
 * courante. Or un centre enregistré sous un datatag ne vaut que pour LES HAUTEURS DE CE
 * DATATAG : rouvrir sous un autre datatag rapprochait les enfants de la moitié de l'écart de
 * hauteur, et ils se chevauchaient (mesuré sur le modèle SOCLE « Détail des modes de
 * production » : 29,9 px en 2015, 20,1 px en 2019, fichier enregistré en 2023).
 *
 * Les enfants invisibles sont écartés plus bas, à la collecte des feuilles : un cadre dont
 * aucune feuille n'est visible n'empile rien.
 */
export declare function containerRootsToRestack<T extends Type_ContainerCandidate>(nodes: T[]): T[];
/** Tous les descendants (transitifs, via dimensions_as_parent) d'un nœud, lui inclus. */
export declare function collectNodeDescendants(node: Class_NodeElement): Set<Class_NodeElement>;