import { Class_NodeElement } from '../Elements/Node';
import { Class_NodeDimension, Type_ContainerMode } from '../Elements/NodeDimension';
import { Class_ApplicationData } from '../types/ApplicationData';
/**
 * Agrégation simple - remonte d'un niveau hiérarchique
 */
export declare const aggregate: (new_data: Class_ApplicationData, contextualised_node: Class_NodeElement, parent: string, register_history?: boolean) => void;
/**
 * #1231 — Reset des désagrégations LOCALES (hybrides). Quand l'utilisateur a désagrégé
 * des nœuds au clic droit, le diagramme est en état HYBRIDE (niveaux mixtes) et le menu
 * Hiérarchies global ne doit plus agir. Ce reset ramène à l'état uniforme montré par le
 * menu. Couvre TOUS les modes de désagrégation locale :
 *  - simple (force_show_children) : repositionne le parent sur le slot de ses enfants ;
 *  - englobement (container_mode) : détache le cadre géométrique (le flag + le style cadre
 *    seront nettoyés par showAccordingToLevelTags → unsetForcingToShow) puis repositionne ;
 *  - expansion (is_expanded) : `contract()` détruit les liens d'expansion et restaure les
 *    liens externes masqués.
 * Puis efface tous les force-flags (showAccordingToLevelTags) et réorganise / re-base le mode %.
 */
export declare const resetLocalHierarchy: (new_data: Class_ApplicationData) => void;
/**
 * #1231 — Applique l'ENGLOBEMENT (container) sur une dim, en réutilisant le cœur
 * de NodeActions._runContainerModeWithUndo via les API publiques. Utilisé par la
 * désagrégation GLOBALE pour réappliquer le type mémorisé d'un nœud (clic droit
 * englobant → menu Hiérarchies). Le parent devient cadre, ses enfants remplissent
 * son slot (mode d'écart configuré) et sont attachés à l'enveloppe.
 *
 * `setContainerMode(mode, true)` est appelé avec fromJSON=true pour POSER le flag
 * et le style sans déclencher de reorg/draw transitoire : l'appelant (Toolbar)
 * fait un unique draw final. Le positionnement (slot + enveloppe) est fait ici.
 */
export declare const applyContainerModeForDim: (new_data: Class_ApplicationData, dim: Class_NodeDimension, mode: Exclude<Type_ContainerMode, null>) => void;
/**
 * Désagrégation simple - descend d'un niveau hiérarchique
 */
export declare const disaggregate: (new_data: Class_ApplicationData, aggregateNode: Class_NodeElement, child: string, register_history?: boolean) => void;
/**
 * DisaggregationExpansion latérale - développe un nœud sur le côté.
 *
 * Refonte 2026-05 (issue #1225) : utilise les enfants RÉELS de la dimension
 * (plus de clones master/slave). Pose le flag `expanded_left|right` sur la
 * Class_NodeDimension et crée des liens d'expansion parent↔enfants entre
 * nœuds réels, avec valeurs redistribuées depuis les liens hiérarchiques
 * existants (c→B au niveau inférieur).
 */
export declare const disaggregationExpansion: (new_data: Class_ApplicationData, contextualised_node: Class_NodeElement, expand_left: boolean, child: Class_NodeElement, finalize?: boolean) => void;
/**
 * Collection latérale — supprimée comme fonctionnalité (issue #1225, décision C).
 * L'aggregation expansion créait un clone du parent à côté de plusieurs enfants
 * visibles, ce qui n'a plus de sens dans le modèle unifié sans clones.
 *
 * Conservée comme no-op pour ne pas casser les anciens appels potentiels.
 */
export declare const aggregationExpansion: (_new_data: Class_ApplicationData, _contextualised_node: Class_NodeElement, _expand_left: boolean, _child: Class_NodeElement) => void;
/**
 * Contraction — annule une expansion latérale précédente.
 *
 * Refonte 2026-05 (issue #1225) : détecte la dim expansée via le flag
 * `is_expanded` sur Class_NodeDimension (plus de detection par suffixe d'id
 * ou par master_node). Détruit tous les liens marqués `is_expansion_link`
 * entre le parent et chaque enfant de la dim, remet les liens externes
 * masqués visibles, et reset le flag.
 */
export declare const contract: (new_data: Class_ApplicationData, contextualised_node: Class_NodeElement) => void;
/**
 * Pré-positionne TOUS les nœuds in-place. Désagrège récursivement chaque nœud (enfants
 * placés dans le slot du parent — avec leurs VRAIES hauteurs, car réellement affichés
 * le temps de la passe), descend, puis ré-agrège : les positions des enfants PERSISTENT
 * (aggregate ne touche que le parent). Résultat : chaque nœud caché reçoit une position
 * cohérente dans l'empreinte de son ancêtre → le filtre vue (ou toute désagrégation
 * ultérieure) révèle des nœuds déjà placés, plus empilés à la position par défaut.
 * Opère sur la mise en page courante (ne relance PAS computeAutoSankey).
 */
export declare const prepositionAllInPlace: (new_data: Class_ApplicationData) => void;
/**
 * Place le CENTRE de chaque enfant sur le centre de son parent, récursivement : tous
 * les descendants se retrouvent donc au centre de leur ancêtre niveau 1. Version propre
 * et statique de l'ancien « mode ancêtres » : une fois lancé, le filtre vue qui révèle
 * des feuilles les montre empilées à la position de leur ancêtre (pas de mécanique
 * dynamique). Léger (ne fait que poser des centres, pas de désagrégation).
 */
export declare const centerChildrenOnParent: (new_data: Class_ApplicationData) => void;