import { Class_EventBus } from './EventBus';
import { Type_JSON } from './Utils';
export type Type_PanelMode = 'tooltip' | 'popup' | 'sidebar';
/** Géométrie d'une pop-up déplaçable : coin haut-gauche (coord. écran) + taille (px). */
export type Type_PopupGeometry = {
    x: number;
    y: number;
    w: number;
    h: number;
};
/** Point d'ancrage d'une info-bulle (au point d'ouverture ; le suivi curseur viendra au Lot 5). */
export type Type_TooltipAnchor = {
    x: number;
    y: number;
};
export declare const PANEL_SIDEBAR_DEFAULT_WIDTH_PX = 270;
export declare const PANEL_SIDEBAR_MIN_WIDTH_PX = 220;
export declare const PANEL_SIDEBAR_MAX_WIDTH_PX = 640;
export declare const PANEL_POPUP_DEFAULT_SIZE: {
    w: number;
    h: number;
};
export declare const PANEL_POPUP_MIN_SIZE: {
    w: number;
    h: number;
};
export declare const PANEL_POPUP_MAX_SIZE: {
    w: number;
    h: number;
};
/**
 * Modèle central des panneaux. Une instance vit dans Class_MenuConfig
 * (`menu_configuration.panels`) et partage SON bus d'événements, de sorte que
 * les abonnements passent par `menu_configuration.subscribe(PANELS_TOPIC, …)`.
 */
export type Type_PresentationTrigger = 'hover' | 'shift' | 'alt';
export declare const PRESENTATION_TRIGGERS: Type_PresentationTrigger[];
export declare const PRESENTATION_DELAY_MAX_MS = 3000;
export declare class Class_PanelManager {
    private _bus;
    private _sidebar_id;
    private _sidebar_collapsed;
    private _sidebar_width_px;
    private _last_sidebar_id;
    private _popups;
    private _pinned;
    private _just_dismissed;
    private _close_handlers;
    private _popup_geometry_memory;
    private _tooltip_id;
    private _tooltip_anchor;
    constructor(bus: Class_EventBus);
    /** Notifie les abonnés « panneaux » (re-render des coquilles). */
    private _notify;
    /** Notifie panneaux + grande zone : à utiliser quand la RÉSERVE de largeur de
     *  la barre latérale change, pour que la zone de dessin se recadre. */
    private _notifySidebar;
    /** Mode courant d'un panneau, ou `null` s'il est fermé. */
    getMode(id: string): Type_PanelMode | null;
    isOpen(id: string): boolean;
    /** Ids de TOUS les panneaux ouverts, tous contenants confondus. Permet à une
     *  feature de monter une coquille par panneau ouvert sans tenir son propre
     *  registre (cf. les panneaux de présentation, OS#305). */
    get open_ids(): string[];
    /**
     * Ouvre `id` dans `mode`, ou l'y PROMEUT s'il est déjà ouvert dans un autre
     * mode. Applique les invariants (une seule barre latérale ; une seule
     * info-bulle). `opts.geometry` fixe la position/taille d'une pop-up créée
     * (sinon défaut centré) ; `opts.anchor` le point d'ancrage d'une info-bulle.
     *
     * `opts.pinned` (OS#321) décide du type de pop-up : `false`/absent = pop-up
     * NON ÉPINGLÉE (le clic extérieur la referme) — c'est le défaut de toute
     * ouverture au clic ; `true` = pop-up ÉPINGLÉE, réservée aux gestes qui
     * expriment une intention de garder la fenêtre (l'épingle de l'en-tête, le
     * détachement de la barre latérale). Sans `opts.pinned`, un panneau DÉJÀ
     * épinglé le reste (une simple réouverture ne le désépingle pas).
     */
    setMode(id: string, mode: Type_PanelMode, opts?: {
        geometry?: Type_PopupGeometry;
        anchor?: Type_TooltipAnchor;
        pinned?: boolean;
    }): void;
    /** Ferme un panneau (le retire de tous les contenants). */
    close(id: string): void;
    /** Retire `id` de tous les registres, SANS notifier (usage interne). La barre
     *  latérale, elle, RESTE OUVERTE : on retire son contenu, pas le contenant. */
    private _detach;
    /** Cette pop-up est-elle ÉPINGLÉE (persistante malgré les clics extérieurs) ? */
    isPinned(id: string): boolean;
    /** Épingle / désépingle une pop-up OUVERTE (sans effet sur les autres modes). */
    setPinned(id: string, pinned: boolean): void;
    /** Ids des pop-ups ouvertes NON ÉPINGLÉES (celles qu'un clic extérieur ferme). */
    get transient_popup_ids(): string[];
    /**
     * Clic HORS des pop-ups : referme toutes les non épinglées, sauf `keep_id`
     * (le panneau qui contient le point cliqué, le cas échéant).
     *
     * Les ids fermés sont MÉMORISÉS jusqu'au prochain appel : le geste d'ouverture
     * qui suit dans le même clic les consulte (`consumeJustDismissed`) pour ne pas
     * rouvrir ce que ce même clic vient de fermer — c'est ce qui fait la BASCULE.
     */
    dismissTransientPopups(keep_id?: string): string[];
    /**
     * Referme TOUTES les pop-ups, épinglées ou non — geste « remets l'écran au
     * neutre » (Échap). L'épingle protège du clic posé ailleurs, pas d'une demande
     * explicite de tout refermer. La barre latérale, elle, n'est pas concernée :
     * c'est un contenant qu'on replie par son propre bouton.
     */
    closeAllPopups(): string[];
    /**
     * Ferme un panneau par sa porte PROPRE — quel que soit son contenant. À
     * préférer à `close` dès qu'un panneau fait davantage que se retirer du modèle
     * (la recherche remet sa requête à zéro, le filtre son miroir).
     */
    closeThrough(id: string): void;
    /** Renseigne (ou retire) la fermeture propre d'un panneau — appelé par sa
     *  coquille PanelShell au montage / démontage. */
    setCloseHandler(id: string, handler: (() => void) | null): void;
    /**
     * `id` vient-il d'être refermé par le clic en cours ? Consommé une seule fois :
     * l'ouverture qui suit renonce, et le clic d'après rouvre normalement.
     */
    consumeJustDismissed(id: string): boolean;
    get sidebar_id(): string | null;
    /** La barre latérale est-elle déployée ? Uniquement si elle porte un menu ET
     *  qu'il n'est pas replié : le contenant n'existe pas sans contenu. */
    get sidebar_open(): boolean;
    /** Alias historique (#300) : la barre réserve sa largeur dès qu'elle est ouverte. */
    get sidebar_visible(): boolean;
    /**
     * OÙ un clic ouvre un panneau. Règle UNIQUE, sans réglage ni exception : la
     * barre latérale si elle est déployée, une pop-up sinon.
     *
     * C'est le lecteur qui arbitre, par un geste qu'il fait déjà — ancrer un menu,
     * le détacher — au lieu d'un choix d'auteur à régler par menu et par élément.
     * Le menu ancré vaut donc préférence : « les prochains clics s'ouvrent ici ».
     * Le survol, lui, ne passe jamais par ici : il n'ouvre que des info-bulles.
     */
    defaultOpenMode(): 'sidebar' | 'popup';
    /**
     * Bascule de la barre latérale (bouton de la barre du haut, Ctrl+B).
     *
     * La barre n'existant jamais vide, le geste porte toujours sur un MENU :
     *  - un menu est ancré -> on le replie / le déplie (il reste ancré) ;
     *  - la barre est vide -> on la garnit, du dernier menu qu'elle a porté, sinon
     *    de la fenêtre ouverte la plus récente — « range ça sur le côté » ;
     *  - rien d'ouvert du tout -> rien à faire (il n'y a pas de bande à montrer).
     */
    toggleSidebar(): void;
    /** Le geste de bascule a-t-il prise ? Faux quand rien n'est ancré ni ouvert :
     *  la barre n'a alors rien à montrer, et son bouton rien à faire. */
    canToggleSidebar(): boolean;
    get sidebar_width_px(): number;
    set sidebar_width_px(px: number);
    /** Largeur (px) réservée à droite par la barre latérale : 0 tant qu'elle ne
     *  porte pas de menu déployé — elle ne prend la place que de ce qu'elle montre.
     *  Entre dans Class_MenuConfig.getRightChromeReservedPx (réserve du dessin). */
    getSidebarReservedPx(): number;
    getPopupGeometry(id: string): Type_PopupGeometry | null;
    /** Met à jour la géométrie d'une pop-up ouverte (déplacement / redimension).
     *  Taille bornée (Lot 3) ; position laissée telle quelle (react-draggable borne). */
    setPopupGeometry(id: string, geometry: Type_PopupGeometry): void;
    private _defaultPopupGeometry;
    get tooltip_id(): string | null;
    get tooltip_anchor(): Type_TooltipAnchor;
    toJSON(): Type_JSON;
    fromJSON(json: Type_JSON): void;
}