@cadriciel/ui 0.4.1 → 0.6.0

package/types/cadriciel-ui.d.ts

@@ -2342,6 +2342,16 @@ interface CadNavDrawerItem {
     disabled?: boolean;
     /** Intertitre de regroupement : rendu comme un libellé, non cliquable. */
     section?: boolean;
+    /**
+     * Intertitre REPLIABLE : il devient un bouton qui masque les entrées qui le suivent,
+     * jusqu'au prochain intertitre. Sans effet hors `section: true`, et sans effet en `rail`
+     * où un intertitre n'est déjà plus qu'un filet.
+     *
+     * DONNEZ-LUI UN `value`. C'est lui qui sert de clé dans `collapsed` ; à défaut on retombe
+     * sur le libellé, et renommer le libellé perd alors l'état replié sans rien dire. Une clé
+     * se choisit immuable, jamais renommable.
+     */
+    collapsible?: boolean;
     command?: (ev: {
         item: CadNavDrawerItem;
         originalEvent: Event;
@@ -2349,6 +2359,23 @@ interface CadNavDrawerItem {
     ariaLabel?: string;
 }
 type CadNavDrawerMode = 'auto' | 'permanent' | 'temporary' | 'rail';
+/**
+ * Une ligne prête à rendre : l'entrée d'origine plus ce que seul le composant peut savoir —
+ * la clé de son intertitre, s'il est replié, et combien d'entrées il porte.
+ *
+ * Le calcul vit ici et pas dans l'hôte parce qu'il dépend du mode : en `rail` un intertitre
+ * n'est plus qu'un filet, donc rien ne doit y être masqué — sinon des entrées disparaîtraient
+ * sans qu'aucun bouton ne permette de les rouvrir.
+ */
+interface CadNavDrawerRow {
+    item: CadNavDrawerItem;
+    /** Intertitres uniquement : la clé utilisée dans `collapsed`. */
+    key: string;
+    collapsible: boolean;
+    collapsed: boolean;
+    /** Intertitres uniquement : nombre d'entrées portées, tous états confondus. */
+    count: number;
+}
 /**
  * <cad-nav-drawer [items]="items" [(open)]="open" [(value)]="page" mode="auto" (itemClick)/>
  *
@@ -2372,6 +2399,15 @@ declare class CadNavDrawerComponent {
     readonly open: _angular_core.ModelSignal<boolean>;
     /** Entrée courante, comparée à `item.value`. */
     readonly value: _angular_core.ModelSignal<string | null>;
+    /**
+     * Clés des intertitres repliés (`item.value`, à défaut `item.label`).
+     *
+     * Un TABLEAU et non un `Set` : c'est ce qui se lie en deux sens, se compare, et surtout se
+     * sérialise tel quel — l'hôte qui veut persister l'état le pose dans `localStorage` sans
+     * conversion. Le composant ne persiste rien lui-même : il ne saurait pas sous quelle clé,
+     * ni s'il a le droit.
+     */
+    readonly collapsed: _angular_core.ModelSignal<string[]>;
     readonly mode: _angular_core.InputSignal<CadNavDrawerMode>;
     /** Seuil de bascule permanent → tiroir, en mode `auto`. */
     readonly breakpoint: _angular_core.InputSignal<CadBreakpoint>;
@@ -2398,6 +2434,15 @@ declare class CadNavDrawerComponent {
     readonly effective: _angular_core.Signal<"permanent" | "temporary" | "rail">;
     readonly temporary: _angular_core.Signal<boolean>;
     readonly rail: _angular_core.Signal<boolean>;
+    /** Clé d'un intertitre. `value` d'abord : un libellé se renomme, une clé non. */
+    private cle;
+    /**
+     * Les lignes à rendre : les intertitres toujours, les entrées seulement si leur intertitre
+     * n'est pas replié. Une entrée qui précède tout intertitre n'appartient à aucun groupe et
+     * ne se replie donc jamais — sans quoi elle serait masquée sans bouton pour la rouvrir.
+     */
+    readonly rows: _angular_core.Signal<CadNavDrawerRow[]>;
+    toggleSection(r: CadNavDrawerRow): void;
     private readonly wasOpen;
     constructor();
     isActive(it: CadNavDrawerItem): boolean;
@@ -2408,7 +2453,7 @@ declare class CadNavDrawerComponent {
     onEscape(): void;
     pick(it: CadNavDrawerItem, ev: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CadNavDrawerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadNavDrawerComponent, "cad-nav-drawer", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "breakpoint": { "alias": "breakpoint"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "closeOnNavigate": { "alias": "closeOnNavigate"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "dismissableScrim": { "alias": "dismissableScrim"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "value": "valueChange"; "opened": "opened"; "closed": "closed"; "itemClick": "itemClick"; "changed": "changed"; }, ["headerSlot", "footerSlot"], ["[cadNavDrawerHeader]", "[cadNavDrawerFooter]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadNavDrawerComponent, "cad-nav-drawer", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "breakpoint": { "alias": "breakpoint"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "closeOnNavigate": { "alias": "closeOnNavigate"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "dismissableScrim": { "alias": "dismissableScrim"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "value": "valueChange"; "collapsed": "collapsedChange"; "opened": "opened"; "closed": "closed"; "itemClick": "itemClick"; "changed": "changed"; }, ["headerSlot", "footerSlot"], ["[cadNavDrawerHeader]", "[cadNavDrawerFooter]"], true, never>;
 }
 
 type CadSelectionMode = 'single' | 'multiple' | null;
@@ -3730,6 +3775,7 @@ declare class CadDialogContainerComponent {
     private static readonly DRAWER_SIZES;
     protected readonly width: _angular_core.Signal<string>;
     protected readonly height: _angular_core.Signal<string | null>;
+    /** Le plafond à 92% laisse respirer un dialogue centré ; en plein écran mobile il n'a plus lieu d'être. */
     protected readonly maxWidth: _angular_core.Signal<string>;
     private readonly drag;
     protected readonly dragTransform: _angular_core.Signal<string | null>;
@@ -4858,6 +4904,44 @@ declare const CAD_SHELL: InjectionToken<CadShellApi>;
  *   <cad-bottom-nav cadShellBottom [items]="dest" [(value)]="page"/>
  * </cad-app-shell>
  * ```
+ *
+ * ⚠️ N'ENVELOPPEZ JAMAIS UN EMPLACEMENT DANS UN `@if` (ni `@for`, ni `<ng-template>`).
+ *
+ * La projection de contenu est STATIQUE : Angular apparie les nœuds aux sélecteurs de
+ * `ng-content` sur la structure déclarée. Un `<header cadShellBar>` placé dans un bloc de
+ * flux de contrôle n'est jamais apparié — il tombe dans l'emplacement PAR DÉFAUT, donc dans
+ * la zone de CONTENU. Rien ne le signale : ça compile, ça s'affiche, et la barre se met à
+ * défiler avec le contenu — exactement le défaut que cette coquille existe pour empêcher.
+ * Constaté au navigateur le 22/08/2026 sur le showcase (`.cad-shell__bar` mesurait 0×0).
+ *
+ * ```html
+ * <!-- FAUX : la barre atterrit dans le contenu -->
+ * @if (connecte()) { <header cadShellBar>…</header> }
+ *
+ * <!-- JUSTE : l'emplacement est toujours rendu, c'est son CONTENU qui varie -->
+ * <header cadShellBar [class.est-masque]="!connecte()">…</header>
+ * ```
+ *
+ * Une rangée ou une colonne `auto` dont l'unique enfant est en `display: none` se replie à
+ * zéro : masquer ainsi ne laisse aucune trace dans la mise en page.
+ *
+ * ⚠️ ZONES SÛRES — DEUX CONDITIONS, ET LA PREMIÈRE EST DANS `index.html`.
+ *
+ * 1. **`<meta name="viewport" content="…, viewport-fit=cover">`**. Sans lui, iOS encadre la
+ *    page : elle ne s'étend jamais sous l'encoche, la bande du haut est peinte par le SYSTÈME,
+ *    et **tous les `env(safe-area-inset-*)` valent 0**. Toute la mécanique de zone sûre de la
+ *    bibliothèque — celle de `cad-bottom-nav`, celle du tiroir en mode temporaire — est alors
+ *    inerte sans que rien ne le signale.
+ * 2. **La barre peint sa propre zone sûre haute** : `padding-top: env(safe-area-inset-top)`
+ *    sur l'élément projeté, PAS sur la coquille. Le rembourrage est intérieur au fond, donc la
+ *    couleur de la barre monte jusqu'au bord de l'écran. Le poser côté coquille laisserait la
+ *    bande sous l'encoche au fond de la COQUILLE : la cassure resterait, d'une autre couleur.
+ *    Avec `box-sizing: border-box`, penser au `min-height: calc(52px + env(safe-area-inset-top))`
+ *    — sinon l'encoche mange la hauteur du contenu.
+ *
+ * En application autonome (ajoutée à l'écran d'accueil), la page ne passe pas sous la bande
+ * d'état : `viewport-fit=cover` n'y suffit pas et c'est `<meta name="theme-color">`, tenu à
+ * jour avec le thème, qui donne la continuité.
  */
 declare class CadAppShellComponent implements CadShellApi {
     private readonly bp;
@@ -6667,6 +6751,17 @@ interface CadPlanTask {
     duration?: string | null;
     /** Jalon : instant sans durée. */
     milestone?: boolean;
+    /**
+     * Événement « journée entière » : il n'a ni heure de début ni heure de fin.
+     *
+     * Un calendrier ne peut pas le deviner — une réunion de 9 h à 18 h et un jour de congé ont
+     * les mêmes bornes et se rendent pourtant à des endroits opposés : la première dans la
+     * grille horaire, le second dans le bandeau au-dessus. Sans ce champ il faudrait inventer
+     * une convention (« ça commence à minuit, donc c'est la journée »), et une réunion de nuit
+     * la ferait mentir. Ajouté le 22/08/2026 pour `cad-calendar` ; inoffensif pour les autres
+     * vues, où l'événement occupe simplement toute la journée.
+     */
+    allDay?: boolean;
     /** Colonne du taskboard. */
     bucket?: string | null;
     /** Rang FRACTIONNAIRE dans sa colonne / sa fratrie. Voir `cadRankBetween()`. */
@@ -6724,6 +6819,8 @@ interface CadPlannedTask {
     start: Date | null;
     end: Date | null;
     milestone: boolean;
+    /** Journée entière : rendu dans le bandeau, jamais dans la grille horaire. */
+    allDay: boolean;
     bucket: string | null;
     rank: string;
     assignments: Required<CadPlanAssignment>[];
@@ -7037,6 +7134,244 @@ declare function cadFindLinkCycle(links: readonly CadPlannedLink[]): string[];
 /** Tâches qu'aucune vue temporelle ne sait placer — la zone « non planifié », jamais le silence. */
 declare const cadUnscheduled: (plan: CadNormalizedPlan) => CadPlannedTask[];
 
+type CadRRuleFreq = 'DAILY' | 'WEEKLY' | 'MONTHLY' | 'YEARLY';
+interface CadRRule {
+    freq: CadRRuleFreq;
+    interval: number;
+    /** Jours de la semaine visés (0 = dimanche). `null` = celui de la date de départ. */
+    byday: number[] | null;
+    /** Quantièmes visés en mensuel. `null` = celui de la date de départ. */
+    bymonthday: number[] | null;
+    count: number | null;
+    until: Date | null;
+    /** Parties reconnues mais NON appliquées : on les nomme au lieu de les taire. */
+    ignore: string[];
+}
+/**
+ * Analyse une chaîne `RRULE`. Rend `null` si elle est inexploitable — jamais une règle
+ * approximative : mieux vaut un événement unique qu'une série fausse.
+ */
+declare function cadParseRRule(entree: string | null | undefined): CadRRule | null;
+/**
+ * Une occurrence projetée.
+ *
+ * `id` est COMPOSITE (`t-101@2026-09-15T09:00`) et c'est structurant : sans lui, la sélection
+ * et le glisser perdent la trace dès que la série bouge, parce que toutes les occurrences
+ * partageraient l'identifiant de la tâche mère.
+ */
+interface CadOccurrence {
+    id: string;
+    taskId: string;
+    start: Date;
+    end: Date;
+    allDay: boolean;
+    /** Vrai si elle vient d'une règle, faux si c'est un événement simple ou une exception. */
+    recurring: boolean;
+    /** Vrai si une occurrence modifiée a REMPLACÉ celle qu'aurait produite la règle. */
+    overridden: boolean;
+    task: CadPlannedTask;
+}
+/** Anomalie rencontrée pendant le dépliage. Jamais tue : une vue peut la montrer. */
+interface CadRecurrenceIssue {
+    taskId: string;
+    code: 'rrule-illisible' | 'rrule-partielle' | 'sans-date' | 'plafond-atteint';
+    detail?: string;
+}
+interface CadExpandResult {
+    occurrences: CadOccurrence[];
+    issues: CadRecurrenceIssue[];
+}
+declare function memeJour(a: Date, b: Date): boolean;
+/**
+ * Déplie les tâches sur la fenêtre `[du, au]`.
+ *
+ * TROIS RÈGLES, dans cet ordre :
+ * ① une tâche sans règle donne une occurrence unique, si elle croise la fenêtre ;
+ * ② une tâche avec règle est projetée, `exdates` retirées ;
+ * ③ une occurrence MODIFIÉE (`masterId` + `recurrenceId`) REMPLACE celle que la règle aurait
+ *    produite à cette date — convention iCalendar. Sans ce remplacement on afficherait les
+ *    deux, et l'utilisateur verrait sa modification en double au lieu de la voir appliquée.
+ */
+declare function cadExpandOccurrences(taches: readonly CadPlannedTask[], du: Date, au: Date): CadExpandResult;
+declare function joursDansMois(annee: number, mois: number): number;
+/** Lundi de la semaine de `d`. */
+declare function debutSemaine(d: Date): Date;
+declare const CAD_RECURRENCE_INTERNE: {
+    debutSemaine: typeof debutSemaine;
+    joursDansMois: typeof joursDansMois;
+    memeJour: typeof memeJour;
+    JOUR_MS: number;
+};
+
+/**
+ * Mise en page d'un calendrier — logique PURE, sans DOM, donc testable seule.
+ *
+ * Trois calculs, et ce sont les trois endroits où un calendrier se trompe :
+ * ① la grille du mois (combien de rangées, quels jours débordent) ;
+ * ② les BANDEAUX multi-jours, continus à travers une rangée de semaine ;
+ * ③ le placement côte à côte des événements horodatés d'une journée.
+ *
+ * BORNE DE FIN : dans cette bibliothèque, `end` est INCLUSIVE pour un événement journée
+ * entière — « congés du 21 au 25 » couvre le 25. La RFC 5545 la veut exclusive (DTEND au 26).
+ * On diverge SCIEMMENT : c'est ce qu'un humain saisit, c'est ce que font déjà le gantt et le
+ * scheduler pour une tâche qui « finit le 25 », et mélanger les deux conventions en silence
+ * est la première cause d'erreur d'un jour dans un calendrier. Un import iCalendar devra donc
+ * retrancher un jour à DTEND — c'est le travail de l'import, pas celui de la vue.
+ */
+/** Numéro de jour absolu, insensible au fuseau et à l'heure d'été. */
+declare function cadNumeroJour(d: Date): number;
+/** Minuit local du jour de `d`. */
+declare function cadMinuit(d: Date): Date;
+/** Début de la semaine contenant `d`. `premierJour` : 1 = lundi (défaut), 0 = dimanche. */
+declare function cadDebutSemaine(d: Date, premierJour?: number): Date;
+interface CadMonthGrid {
+    /** Premier jour affiché — souvent dans le mois précédent. */
+    debut: Date;
+    /** Rangées de 7 jours. 5 ou 6 selon le mois : on ne force JAMAIS 6. */
+    semaines: Date[][];
+    /** Mois de référence (0-11), pour distinguer les jours qui débordent. */
+    mois: number;
+    annee: number;
+}
+/**
+ * Grille du mois contenant `ancre`.
+ *
+ * On rend 5 OU 6 rangées, selon ce que le mois demande — jamais un nombre fixe. Forcer 6
+ * rangées laisse une semaine entière vide neuf mois sur douze ; en forcer 5 tronque les mois
+ * de 31 jours qui commencent un samedi. La hauteur de la vue s'adapte, pas la vérité.
+ */
+declare function cadMonthGrid(ancre: Date, premierJour?: number): CadMonthGrid;
+/**
+ * Un bandeau : une occurrence multi-jours projetée sur UNE rangée de semaine.
+ *
+ * `continueAvant` / `continueApres` sont indispensables : sans eux, un congé de trois semaines
+ * apparaîtrait comme trois congés d'une semaine. La vue doit pouvoir dire « ça déborde ».
+ */
+interface CadBand {
+    occurrence: CadOccurrence;
+    /** Colonnes INCLUSIVES dans la rangée, 0..6. */
+    colDebut: number;
+    colFin: number;
+    /** Voie d'empilement, 0 en haut. */
+    voie: number;
+    continueAvant: boolean;
+    continueApres: boolean;
+}
+interface CadBandRow {
+    bandes: CadBand[];
+    /** Nombre de voies occupées : la rangée doit réserver cette hauteur. */
+    voies: number;
+}
+/** Une occurrence va au bandeau si elle est journée entière OU si elle franchit un minuit. */
+declare function cadEstBandeau(o: CadOccurrence): boolean;
+/**
+ * Range les bandeaux d'une rangée de semaine en voies.
+ *
+ * Le tri place les plus LONGS en haut : sans lui, un événement d'un jour posé en voie 0 coupe
+ * en deux la place d'un événement de cinq jours, qui doit alors descendre — et la rangée
+ * devient un escalier illisible.
+ */
+declare function cadWeekBands(occurrences: readonly CadOccurrence[], jours: readonly Date[]): CadBandRow;
+/** Un événement horodaté placé dans la colonne d'une journée. */
+interface CadSlot {
+    occurrence: CadOccurrence;
+    /** Position verticale, en fraction de la plage affichée (0 = haut, 1 = bas). */
+    haut: number;
+    hauteur: number;
+    /** Voie et nombre de voies du GROUPE de chevauchement, pas de la journée entière. */
+    voie: number;
+    voies: number;
+}
+/**
+ * Place les événements horodatés d'une journée, côte à côte quand ils se chevauchent.
+ *
+ * Le nombre de voies est celui du GROUPE de chevauchement, pas de la journée : deux réunions
+ * qui se chevauchent le matin ne doivent pas rétrécir de moitié une réunion isolée de
+ * l'après-midi. C'est l'erreur la plus courante des calendriers faits à la main.
+ *
+ * `plageDebut` / `plageFin` en minutes depuis minuit. Un événement hors plage est CONSERVÉ et
+ * ramené au bord : le faire disparaître serait le mensonge le plus grave qu'une vue puisse
+ * commettre.
+ */
+declare function cadPackDay(occurrences: readonly CadOccurrence[], plageDebut?: number, plageFin?: number): CadSlot[];
+
+/**
+ * Projection d'un geste d'édition — logique PURE, sans DOM, donc testable seule.
+ *
+ * Un geste ne produit jamais une écriture : il produit une PROPOSITION de bornes, que le
+ * composant émet en intention. C'est ce fichier qui répond à « l'utilisateur a bougé de 43
+ * pixels vers le bas et de 1,2 colonne : qu'est-ce que ça veut dire en dates ? ».
+ *
+ * L'AIMANTAGE EST OBLIGATOIRE, pas cosmétique. Sans lui on crée des réunions de 9 h 07 à
+ * 10 h 23 : personne n'a voulu ça, et la donnée devient impossible à relire.
+ */
+type CadEditKind = 'create' | 'move' | 'resize-start' | 'resize-end';
+interface CadEditGeometry {
+    /** Hauteur d'une heure, en pixels. */
+    hauteurHeure: number;
+    /** Largeur d'une colonne de jour, en pixels. 0 = pas de déplacement horizontal possible. */
+    largeurJour: number;
+    /** Pas d'aimantage, en minutes. */
+    pas: number;
+    /** Plage horaire affichée, en minutes depuis minuit. */
+    plageDebut: number;
+    plageFin: number;
+}
+interface CadEditBase {
+    start: Date;
+    end: Date;
+    allDay: boolean;
+}
+/**
+ * Projette un geste en nouvelles bornes.
+ *
+ * `dx` / `dy` sont les déplacements du pointeur en pixels depuis le début du geste.
+ *
+ * TROIS INVARIANTS, et chacun corrige une bêtise classique :
+ * ① un déplacement CONSERVE la durée — sinon déplacer une réunion la rallonge en douce ;
+ * ② un redimensionnement ne franchit JAMAIS l'autre bord : il s'arrête à un pas ;
+ * ③ un événement journée entière ne bouge qu'en JOURS — lui donner une heure en le glissant
+ *    le ferait sortir du bandeau, ce que personne n'a demandé.
+ */
+declare function cadProjeterEdition(kind: CadEditKind, base: CadEditBase, dx: number, dy: number, g: CadEditGeometry): {
+    start: Date;
+    end: Date;
+};
+/**
+ * Bornes d'une création par glisser sur une plage vide.
+ *
+ * `y0` / `y1` sont les positions verticales dans la colonne, en pixels. On aimante les DEUX
+ * bords, et on garantit au moins un pas : un clic sec ne doit pas produire un événement de
+ * durée nulle, invisible et impossible à rattraper.
+ */
+declare function cadProjeterCreation(jour: Date, y0: number, y1: number, g: CadEditGeometry): {
+    start: Date;
+    end: Date;
+};
+/**
+ * Projection d'un geste dans une GRILLE DE MOIS — et ce n'est pas la même que dans une grille
+ * horaire, contrairement à ce que j'avais écrit.
+ *
+ * Dans un mois, l'axe vertical n'est PAS le temps de la journée : c'est la semaine. Descendre
+ * d'une rangée avance de SEPT JOURS, et l'heure ne bouge pas. Utiliser la projection horaire
+ * ici donnait « +3 h » au lieu de « +7 jours » (mesuré au navigateur le 22/08/2026 : glisser
+ * d'une rangée déplaçait un rendez-vous de 10 h 30 à 13 h 30 sans changer de date).
+ *
+ * Une seule règle à retenir : dans le mois, un geste ne déplace que des JOURS.
+ */
+declare function cadProjeterMois(kind: CadEditKind, base: CadEditBase, dx: number, dy: number, g: {
+    largeurJour: number;
+    hauteurRangee: number;
+}): {
+    start: Date;
+    end: Date;
+};
+/** Déplacement au CLAVIER, exprimé dans la même unité qu'un geste : jours et pas. */
+declare function cadProjeterClavier(kind: CadEditKind, base: CadEditBase, jours: number, pas: number, g: CadEditGeometry): {
+    start: Date;
+    end: Date;
+};
+
 /** Contenu d'une carte : `<ng-template cadTaskCard let-task let-bucket="bucket">`. */
 declare class CadTaskCardDirective {
     readonly tpl: TemplateRef<any>;
@@ -7174,5 +7509,227 @@ declare class CadTaskboardComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadTaskboardComponent, "cad-taskboard", never, { "plan": { "alias": "plan"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "groupBy": { "alias": "groupBy"; "required": false; "isSignal": true; }; "dragDisabled": { "alias": "dragDisabled"; "required": false; "isSignal": true; }; "collapsedKeys": { "alias": "collapsedKeys"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "dateFormat": { "alias": "dateFormat"; "required": false; "isSignal": true; }; "today": { "alias": "today"; "required": false; "isSignal": true; }; }, { "collapsedKeys": "collapsedKeysChange"; "taskMove": "taskMove"; "taskAssign": "taskAssign"; "taskOpen": "taskOpen"; "wipExceeded": "wipExceeded"; }, ["cardTpl", "rowTpl"], never, true, never>;
 }
 
-export { BanGeocoder, CAD_BREAKPOINTS, CAD_CHART_PALETTE, CAD_COLOR_PRESETS, CAD_DEFAULT_BASEMAPS, CAD_DEFAULT_PRIORITY_BREAKPOINTS, CAD_DIALOG_DATA, CAD_FILTER_OPERATORS, CAD_GEOCODER, CAD_ICONS, CAD_ICONS_CEREMA, CAD_ICONS_CORE, CAD_ICONS_DATA, CAD_ICONS_FILES, CAD_ICONS_GEO, CAD_ICONS_SUBSET, CAD_ICONS_TOKEN, CAD_ICONS_UI, CAD_ICON_ALIASES, CAD_ICON_CATEGORIES, CAD_MAPLIBRE_CSS_URL, CAD_MAP_CHILD, CAD_MAP_DEFAULTS, CAD_MAP_GLOBAL_STYLES, CAD_MAP_GLYPHS, CAD_MAP_PALETTE, CAD_MASK_PRESETS, CAD_MOBILE_BREAKPOINT, CAD_SELECT_POSITIONS, CAD_SELECT_TRIGGER_STYLES, CAD_SHEET_DATA, CAD_SHELL, CAD_TOUCH_DENSITY, CadAccordionComponent, CadAccordionPanelComponent, CadAppShellComponent, CadAvatarComponent, CadAvatarGroupComponent, CadBadgeComponent, CadBadgeDirective, CadBlockDirective, CadBlockOverlayComponent, CadBlockUiComponent, CadBottomNavComponent, CadBreadcrumbComponent, CadBreadcrumbItemDirective, CadBreakpointService, CadButtonComponent, CadButtonGroupComponent, CadCaptionDirective, CadCardComponent, CadCardDirective, CadCardHeaderDirective, CadCarouselComponent, CadCarouselItemDirective, CadCascadeSelectComponent, CadCellTemplateDirective, CadCenterComponent, CadChartComponent, CadCheckboxComponent, CadChipComponent, CadClusterComponent, CadColDirective, CadColorpickerComponent, CadColumnComponent, CadComboComponent, CadConfirmContentComponent, CadConfirmDialogComponent, CadConfirmService, CadContainerComponent, CadDataviewComponent, CadDataviewGridDirective, CadDataviewListDirective, CadDatepickerComponent, CadDialogComponent, CadDialogContainerComponent, CadDialogFooterDirective, CadDialogHeaderDirective, CadDialogRef, CadDialogService, CadDividerComponent, CadDrawerComponent, CadEditFocusDirective, CadEditorTemplateDirective, CadEmptyDirective, CadFieldComponent, CadFieldsetComponent, CadFieldsetLegendDirective, CadFilterChipComponent, CadFilterTemplateDirective, CadGeocodingService, CadGridComponent, CadGroupFooterDirective, CadGroupHeaderDirective, CadHeaderTemplateDirective, CadIconComponent, CadIconRegistry, CadIfDirective, CadImageComponent, CadInplaceComponent, CadInplaceContentDirective, CadInplaceDisplayDirective, CadInputDirective, CadJsonEditorComponent, CadKeyFilterDirective, CadListEmptyDirective, CadListFooterDirective, CadListHeaderDirective, CadListItemDirective, CadListboxComponent, CadMapBasemapRegistry, CadMapBasemapsComponent, CadMapCardComponent, CadMapChromeComponent, CadMapComponent, CadMapDrawEngine, CadMapLayerComponent, CadMapLayerGroupComponent, CadMapLayerToggleComponent, CadMapLegendComponent, CadMapMenuComponent, CadMapPanelComponent, CadMapPanels, CadMapRailComponent, CadMapRailItemComponent, CadMapSearchComponent, CadMapSectionComponent, CadMaskDirective, CadMenuComponent, CadMenubarComponent, CadMessageComponent, CadMeterComponent, CadMeterLabelDirective, CadMultiselectComponent, CadNavDrawerComponent, CadNavDrawerFooterDirective, CadNavDrawerHeaderDirective, CadNumberComponent, CadOptionListComponent, CadOrderlistComponent, CadOrgNodeDirective, CadOrgchartComponent, CadOverlayBase, CadPaginatorComponent, CadPanelComponent, CadPanelContentDirective, CadPanelHeaderDirective, CadPanelHeadingDirective, CadPasswordComponent, CadPicklistComponent, CadPopoverComponent, CadProgressComponent, CadRadioComponent, CadRadioGroupComponent, CadRatingComponent, CadRowActionsDirective, CadRowCountDirective, CadRowExpansionDirective, CadScrollTopComponent, CadSegmentedComponent, CadSelectBase, CadSelectComponent, CadSelectEmptyDirective, CadSelectFooterDirective, CadSelectHeaderDirective, CadSelectItemDirective, CadSelectSelectedDirective, CadSheetContainerComponent, CadSheetRef, CadSheetService, CadSidebarComponent, CadSidebarPanelDirective, CadSkeletonComponent, CadSliderComponent, CadSpacerComponent, CadSpeedDialComponent, CadSpinnerComponent, CadSplitButtonComponent, CadSplitComponent, CadSplitterComponent, CadSplitterPanelComponent, CadStackComponent, CadStepComponent, CadStepperComponent, CadSwitchComponent, CadTabComponent, CadTabContentDirective, CadTabLabelDirective, CadTableBase, CadTableComponent, CadTableEdit, CadTableEditUi, CadTableFooterDirective, CadTablePanelComponent, CadTableResponsive, CadTableSelection, CadTableSticky, CadTableVirtual, CadTabsComponent, CadTagComponent, CadTaskCardDirective, CadTaskRowDirective, CadTaskboardComponent, CadTimeAxis, CadTimelineComponent, CadTimelineContentDirective, CadTimelineMarkerDirective, CadTimelineOppositeDirective, CadToastComponent, CadToastItemDirective, CadToastService, CadToggleButtonComponent, CadTooltipComponent, CadTooltipDirective, CadTreeAdapter, CadTreeComponent, CadTreeNodeDirective, CadTreeselectComponent, CadUploadComponent, CadUploadContentDirective, CadUploadEmptyDirective, CadUploadItemDirective, CadValueAccessor, CadWorkCalendar, MAPLIBRE_MIN_CSS, addDays, addMonths, addYears, cadAggregate, cadApplyColumnOrder, cadApplyMask, cadArea, cadAutosizeWidth, cadBasemapThumbnail, cadBoundsOf, cadCategories, cadCentroid, cadColorExpr, cadCompare, cadCompareRank, cadCurrentOperator, cadDefaultMatchMode, cadDistance, cadDownloadCsv, cadDurationToMinutes, cadFilterData, cadFilterKindOf, cadFilterOperators, cadFilterRows, cadFindLinkCycle, cadFmtArea, cadFmtLength, cadFormatCell, cadFormatColor, cadFormatDuration, cadFormatSize, cadFrenchHolidays, cadGap, cadGeoJSONStats, cadGeometryKinds, cadHeaderMenuItems, cadHighlightJson, cadHslToRgb, cadHsvToRgb, cadId, cadIsGroupKey, cadIsRank, cadJsonErrorPos, cadLegendFromStyle, cadLength, cadMapEstVivante, cadMapLayerOf, cadMapLayersOf, cadMatch, cadMoveColumn, cadMoveItems, cadNormalize, cadNormalizeOptions, cadNormalizePlan, cadNumberExpr, cadPadBounds, cadParseColor, cadParseDuration, cadParseResponsive, cadPlanHeader, cadPlanTicks, cadPropsTable, cadRankBetween, cadRankFirst, cadRankLast, cadRankSequence, cadResolve, cadResolveResponsive, cadResponsive, cadRgbToHsl, cadRgbToHsv, cadRingArea, cadRowKey, cadRowPredicate, cadSameValue, cadScaleNext, cadScaleStart, cadSortData, cadStartResize, cadStyleToExpressions, cadUnmask, cadUnscheduled, cadValidateGeoJSON, cadValueForOperator, cadWriteField, compareDay, daysInMonth, endOfMonth, ensureMaplibreCss, formatDate, isBetweenDay, isSameDay, isSameMonth, isValidDate, isoOf, isoWeek, loadChartJs, loadMaplibre, monthNames, pad2, parseIso, parseWithFormat, provideCadIcons, startOfDay, startOfMonth, toDate, weekdayNames };
-export type { CadAggregate, CadAggregateFn, CadAggregates, CadBadgeSeverity, CadBasemap, CadBasemapKind, CadBottomNavItem, CadBounds, CadBreadcrumbItem, CadBreakpoint, CadCarouselResponsive, CadCellContext, CadCellEditState, CadChartClickEvent, CadChartType, CadColorFormat, CadColorSpec, CadColumnAlign, CadColumnDataType, CadColumnEditor, CadColumnFilterOption, CadColumnFilterType, CadColumnMenuActionEvent, CadColumnPinEvent, CadColumnReorderEvent, CadColumnResizeEvent, CadColumnToggleEvent, CadComboSource, CadConfirmOptions, CadDataviewLayout, CadDateMode, CadDateSelection, CadDateValue, CadDialogConfig, CadDialogPosition, CadDialogSize, CadDisplayRow, CadDrawMode, CadDrawOptions, CadDrawerPosition, CadDuration, CadDurationUnit, CadEditCompleteEvent, CadEditEvent, CadEditMode, CadEditorContext, CadFeatureEvent, CadFilterChangeEvent, CadFilterKind, CadFilterMatchMode, CadFilterMeta, CadFilterOperator, CadFilters, CadGap, CadGeoJSON, CadGeocodeOptions, CadGeocodeResult, CadGeocoder, CadGeometryKind, CadGroupBy, CadGroupContext, CadGroupInfo, CadGroupItem, CadHeaderMenuHost, CadHsva, CadLayerStyle, CadLazyLoadEvent, CadLegendItem, CadListGroup, CadListItem, CadListNormalizeOpts, CadListOption, CadListRow, CadLngLat, CadMapChild, CadMapChrome, CadMapClick, CadMapControl, CadMapLayerType, CadMapMenuConfig, CadMapMenuItem, CadMapMenuPanel, CadMapMenuRailItem, CadMapMenuSection, CadMapPosition, CadMapSide, CadMapView, CadMeasure, CadMenuItem, CadMenubarItem, CadMeterValue, CadNavDrawerItem, CadNavDrawerMode, CadNodeEvent, CadNormalizePlanOptions, CadNormalizedPlan, CadNumberSpec, CadOptionItem, CadOrgNode, CadOverlayHandle, CadPageEvent, CadPaintSet, CadPinnedColumns, CadPlacement, CadPlan, CadPlanAssignment, CadPlanBucket, CadPlanCalendar, CadPlanCalendarException, CadPlanDateInput, CadPlanHeader, CadPlanHours, CadPlanIssue, CadPlanLink, CadPlanLinkType, CadPlanMarker, CadPlanResource, CadPlanScale, CadPlanTask, CadPlanTick, CadPlanTicksOptions, CadPlannedLink, CadPlannedTask, CadPriorityBreakpoints, CadProgressSeverity, CadRgba, CadRowEditEvent, CadRowEditState, CadRowEvent, CadRowReorderEvent, CadSegmentOption, CadSelectItemContext, CadSelectionMode, CadSelectionPropagation, CadSeverity, CadSheetConfig, CadSheetHeight, CadShellApi, CadSize, CadSliderMark, CadSliderSeverity, CadSliderValue, CadSortEvent, CadSortMeta, CadSortOrder, CadStepState, CadTableEditContext, CadTableEditUiContext, CadTablePanelTab, CadTableResponsiveMode, CadTableSelectionContext, CadTagSeverity, CadTaskAssignEvent, CadTaskMoveEvent, CadTaskOpenEvent, CadTaskboardGroupBy, CadTaskboardMode, CadTimelineAlign, CadToastAction, CadToastMessage, CadToastPosition, CadToastSeverity, CadTreeAdapterOptions, CadTreeNode, CadTreeNodeEvent, CadUploadFile, CadUploadHandlerEvent, CadUploadStatus, CadVariant, CadVirtualRange, CadWipEvent, MLExpression, MaplibreModule };
+type CadCalendarView = 'month' | 'week' | 'day' | 'agenda' | 'year' | 'auto';
+/** Un agenda superposable. La couleur vient de la DONNÉE : le composant n'en connaît aucun. */
+interface CadCalendarSource {
+    id: string;
+    label: string;
+    /** Couleur CSS. Sans elle, l'accent de la bibliothèque. */
+    color?: string;
+}
+interface CadCalendarEventEvent {
+    occurrence: CadOccurrence;
+    originalEvent: Event;
+}
+/** Intention d'écriture. Le composant ne l'applique pas : il la propose. */
+interface CadCalendarChangeEvent {
+    occurrence: CadOccurrence;
+    start: Date;
+    end: Date;
+}
+interface CadCalendarCreateEvent {
+    start: Date;
+    end: Date;
+    allDay: boolean;
+}
+interface CadCalendarDateEvent {
+    date: Date;
+    originalEvent: Event;
+}
+/**
+ * `<cad-calendar [plan]="plan" [sources]="agendas" view="auto"/>`
+ *
+ * LA GRILLE EST LE TEMPS — c'est ce qui le distingue de `cad-scheduler`, dont les lignes sont
+ * des ressources. On répond ici à « qu'est-ce qui se passe le 17 ? », là-bas à « qui est libre
+ * jeudi ? ». Deux questions, deux composants, un seul document JSON.
+ *
+ * L'AGENDA D'UNE TÂCHE EST SON `bucket`. Pas un champ de plus : le taskboard rend les buckets
+ * en colonnes, le calendrier les rend en agendas superposés. C'est le pari « une donnée,
+ * plusieurs vues » qui paie, et ça évite d'inventer un `calendarId` que les autres vues
+ * ignoreraient.
+ *
+ * LA RÉCURRENCE EST EN LECTURE SEULE (voir `planning.recurrence.ts`). On déplie une règle pour
+ * l'afficher ; on n'édite pas de série. Une récurrence à moitié faite perd des modifications
+ * sans le dire — déplier n'écrit rien, donc ne peut rien perdre.
+ *
+ * LE COMPOSANT N'ÉCRIT JAMAIS : il émet `eventClick`, `dateClick`, `rangeChange`. Masquer un
+ * agenda est en revanche un état de PRÉSENTATION, donc un `model()` qu'il porte lui-même.
+ */
+declare class CadCalendarComponent {
+    protected readonly Math: Math;
+    private readonly bp;
+    private readonly hote;
+    /**
+     * Une colonne de jour, pour mesurer la largeur d'un pas horizontal.
+     *
+     * On MESURE au lieu de calculer : les colonnes sont en `minmax(0, 1fr)`, donc leur largeur
+     * dépend du conteneur, de la barre de défilement et du zoom. Un calcul serait faux dès que
+     * l'un des trois change, et le glisser dériverait d'un jour sans que rien ne le signale.
+     */
+    protected largeurColonne(): HTMLElement | null;
+    readonly plan: _angular_core.InputSignal<CadPlan | null>;
+    /** Agendas superposables. Un `bucket` sans source déclarée prend l'accent et son propre nom. */
+    readonly sources: _angular_core.InputSignal<readonly CadCalendarSource[]>;
+    /** Agendas décochés. État de PRÉSENTATION, donc porté ici et lié en deux sens. */
+    readonly hidden: _angular_core.ModelSignal<ReadonlySet<string>>;
+    readonly view: _angular_core.ModelSignal<CadCalendarView>;
+    /** Date d'ancrage : le mois, la semaine ou le jour affiché. */
+    readonly date: _angular_core.ModelSignal<Date>;
+    /** 1 = lundi (défaut), 0 = dimanche. Touche le mois, la semaine ET le mini-calendrier. */
+    readonly firstDay: _angular_core.InputSignal<0 | 1>;
+    /** Plage horaire affichée, en heures. Réglable : 7 → 20 par défaut. */
+    readonly dayStart: _angular_core.InputSignal<number>;
+    readonly dayEnd: _angular_core.InputSignal<number>;
+    readonly hourHeight: _angular_core.InputSignal<number>;
+    /** Événements montrés dans une case de mois avant le « +N ». */
+    readonly maxPerDay: _angular_core.InputSignal<number>;
+    readonly workCalendar: _angular_core.InputSignal<CadWorkCalendar | null>;
+    readonly today: _angular_core.InputSignal<Date | null>;
+    readonly locale: _angular_core.InputSignal<string>;
+    readonly emptyText: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly showNow: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly eventClick: _angular_core.OutputEmitterRef<CadCalendarEventEvent>;
+    readonly dateClick: _angular_core.OutputEmitterRef<CadCalendarDateEvent>;
+    /** La fenêtre affichée a changé : l'hôte peut aller chercher les données qui manquent. */
+    readonly rangeChange: _angular_core.OutputEmitterRef<{
+        start: Date;
+        end: Date;
+    }>;
+    /** Gestes d'édition. `false` = vue en lecture, sans poignée ni curseur trompeur. */
+    readonly editable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Aimantage, en minutes. Sans lui on crée des réunions de 9 h 07 que personne n'a voulues. */
+    readonly snap: _angular_core.InputSignal<number>;
+    readonly eventMove: _angular_core.OutputEmitterRef<CadCalendarChangeEvent>;
+    readonly eventResize: _angular_core.OutputEmitterRef<CadCalendarChangeEvent>;
+    readonly eventCreate: _angular_core.OutputEmitterRef<CadCalendarCreateEvent>;
+    /** `auto` : agenda sous le seuil. Une grille de mois à 55 px par jour ne montre plus rien. */
+    readonly vueEffective: _angular_core.Signal<"month" | "year" | "day" | "week" | "agenda">;
+    private readonly normalise;
+    private readonly ajd;
+    protected readonly hauteurHeure: _angular_core.Signal<number>;
+    protected readonly hauteurTotale: _angular_core.Signal<number>;
+    protected readonly heuresAffichees: _angular_core.Signal<number[]>;
+    /** Fenêtre couverte par la vue courante. Elle borne le dépliage : on ne projette pas l'infini. */
+    private readonly fenetre;
+    /**
+     * CORRECTIF OPTIMISTE. Le composant n'écrit jamais dans le document — mais sans état local
+     * le geste serait mort à l'écran : on relâche, et la barre revient à sa place en attendant
+     * que l'hôte réponde. On garde donc les bornes proposées, ATTACHÉES au `plan` d'origine, et
+     * on les abandonne dès qu'un nouveau `plan` arrive. Même patron que `cad-taskboard`.
+     */
+    private readonly patch;
+    private readonly occurrences;
+    /** Fantôme du geste en cours : il montre où l'on va tomber, APRÈS aimantage. */
+    protected readonly fantome: _angular_core.WritableSignal<{
+        jour: number;
+        haut: number;
+        hauteur: number;
+        texte: string;
+    } | null>;
+    /** Anomalies de dépliage — jamais tues : l'hôte peut les montrer. */
+    readonly issues: _angular_core.Signal<_cadriciel_ui.CadRecurrenceIssue[]>;
+    private readonly parJour;
+    protected readonly nomsJours: _angular_core.Signal<string[]>;
+    protected readonly semaines: _angular_core.Signal<{
+        voies: number;
+        bandes: CadBand[];
+        jours: {
+            date: Date;
+            cle: number;
+            n: number;
+            hors: boolean;
+            auj: boolean;
+            ferme: boolean;
+            puces: CadOccurrence[];
+            reste: number;
+        }[];
+    }[]>;
+    protected readonly joursGrille: _angular_core.Signal<{
+        date: Date;
+        cle: number;
+        n: number;
+        jsem: string;
+        auj: boolean;
+        ferme: boolean;
+        slots: CadSlot[];
+    }[]>;
+    protected readonly bandeGrille: _angular_core.Signal<_cadriciel_ui.CadBandRow>;
+    protected readonly colonnes: _angular_core.Signal<string>;
+    protected readonly maintenant: _angular_core.Signal<number | null>;
+    protected readonly groupes: _angular_core.Signal<{
+        cle: number;
+        n: number;
+        auj: boolean;
+        jsem: string;
+        evts: CadOccurrence[];
+    }[]>;
+    protected readonly miniMois: _angular_core.Signal<{
+        mois: number;
+        titre: string;
+        jours: {
+            date: Date;
+            cle: number;
+            n: number;
+            hors: boolean;
+            auj: boolean;
+            charge: number;
+        }[];
+    }[]>;
+    protected couleur(o: CadOccurrence): string;
+    protected nomSource(o: CadOccurrence): string;
+    protected heure(d: Date): string;
+    protected titre(o: CadOccurrence): string;
+    /**
+     * Une occurrence de SÉRIE n'est pas manipulable tant que l'édition de récurrence n'existe
+     * pas. Bouger l'une d'elles sans savoir si l'on modifie l'occurrence, la suite ou toute la
+     * série perdrait la modification EN SILENCE. On le montre (hachures, curseur interdit,
+     * motif au survol) plutôt que de laisser essayer et rater.
+     */
+    protected manipulable(o: CadOccurrence): boolean;
+    protected motifVerrou(o: CadOccurrence): string;
+    private geometrie;
+    /**
+     * Un glisser ne doit PAS produire aussi un clic.
+     *
+     * Le navigateur synthétise un `click` après tout `pointerup` sur un bouton : sans cette
+     * garde, déplacer un événement émettait `eventMove` PUIS `eventClick`, et un hôte qui ouvre
+     * une fiche au clic en ouvrirait une à chaque déplacement. Constaté au navigateur le
+     * 22/08/2026 — un test unitaire ne l'aurait pas vu, le clic synthétique n'existe pas en jsdom.
+     */
+    private finGeste;
+    private poser;
+    /**
+     * Un geste au pointeur. Le patron vient de `cadStartResize` de `cad-table` : on écoute sur
+     * le DOCUMENT, pas sur l'élément — sinon le geste s'interrompt dès que le pointeur sort de
+     * la barre, ce qui arrive tout le temps quand on déplace vite.
+     */
+    protected geste(kind: CadEditKind, o: CadOccurrence, ev: PointerEvent, colonne: HTMLElement | null): void;
+    /**
+     * Geste dans la GRILLE DE MOIS — projection différente, et c'est la correction du 22/08/2026.
+     *
+     * Ici l'axe vertical n'est pas l'heure : c'est la semaine. Une rangée vaut SEPT JOURS et
+     * l'heure ne bouge pas. En passant par la projection horaire, glisser d'une rangée déplaçait
+     * un rendez-vous de 10 h 30 à 13 h 30 sans changer de date — mesuré au navigateur, signalé
+     * par SZU. On MESURE la rangée plutôt que de la calculer : sa hauteur dépend du nombre de
+     * voies de bandeaux, donc elle change d'une semaine à l'autre.
+     */
+    protected gesteMois(kind: CadEditKind, o: CadOccurrence, ev: PointerEvent): void;
+    /** Création par glisser sur une plage libre. Un clic sec produit un pas, jamais rien. */
+    protected creer(jour: Date, ev: PointerEvent, colonne: HTMLElement): void;
+    /**
+     * Le CLAVIER passe par la MÊME projection que le pointeur — une seule logique de placement
+     * à éprouver, et l'accessibilité n'est pas une reprise ultérieure qui dérive.
+     * Ctrl/Cmd + flèches déplacent, Maj + flèches verticales redimensionnent par le bas.
+     */
+    protected clavier(o: CadOccurrence, e: KeyboardEvent): void;
+    protected clicEvenement(occurrence: CadOccurrence, originalEvent: Event): void;
+    /** Le « +N » et un jour de la vue année mènent au JOUR : c'est ce qu'on cherchait. */
+    protected voirJour(date: Date, originalEvent: Event): void;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CadCalendarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadCalendarComponent, "cad-calendar", never, { "plan": { "alias": "plan"; "required": false; "isSignal": true; }; "sources": { "alias": "sources"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "view": { "alias": "view"; "required": false; "isSignal": true; }; "date": { "alias": "date"; "required": false; "isSignal": true; }; "firstDay": { "alias": "firstDay"; "required": false; "isSignal": true; }; "dayStart": { "alias": "dayStart"; "required": false; "isSignal": true; }; "dayEnd": { "alias": "dayEnd"; "required": false; "isSignal": true; }; "hourHeight": { "alias": "hourHeight"; "required": false; "isSignal": true; }; "maxPerDay": { "alias": "maxPerDay"; "required": false; "isSignal": true; }; "workCalendar": { "alias": "workCalendar"; "required": false; "isSignal": true; }; "today": { "alias": "today"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "showNow": { "alias": "showNow"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "snap": { "alias": "snap"; "required": false; "isSignal": true; }; }, { "hidden": "hiddenChange"; "view": "viewChange"; "date": "dateChange"; "eventClick": "eventClick"; "dateClick": "dateClick"; "rangeChange": "rangeChange"; "eventMove": "eventMove"; "eventResize": "eventResize"; "eventCreate": "eventCreate"; }, never, never, true, never>;
+}
+
+export { BanGeocoder, CAD_BREAKPOINTS, CAD_CHART_PALETTE, CAD_COLOR_PRESETS, CAD_DEFAULT_BASEMAPS, CAD_DEFAULT_PRIORITY_BREAKPOINTS, CAD_DIALOG_DATA, CAD_FILTER_OPERATORS, CAD_GEOCODER, CAD_ICONS, CAD_ICONS_CEREMA, CAD_ICONS_CORE, CAD_ICONS_DATA, CAD_ICONS_FILES, CAD_ICONS_GEO, CAD_ICONS_SUBSET, CAD_ICONS_TOKEN, CAD_ICONS_UI, CAD_ICON_ALIASES, CAD_ICON_CATEGORIES, CAD_MAPLIBRE_CSS_URL, CAD_MAP_CHILD, CAD_MAP_DEFAULTS, CAD_MAP_GLOBAL_STYLES, CAD_MAP_GLYPHS, CAD_MAP_PALETTE, CAD_MASK_PRESETS, CAD_MOBILE_BREAKPOINT, CAD_RECURRENCE_INTERNE, CAD_SELECT_POSITIONS, CAD_SELECT_TRIGGER_STYLES, CAD_SHEET_DATA, CAD_SHELL, CAD_TOUCH_DENSITY, CadAccordionComponent, CadAccordionPanelComponent, CadAppShellComponent, CadAvatarComponent, CadAvatarGroupComponent, CadBadgeComponent, CadBadgeDirective, CadBlockDirective, CadBlockOverlayComponent, CadBlockUiComponent, CadBottomNavComponent, CadBreadcrumbComponent, CadBreadcrumbItemDirective, CadBreakpointService, CadButtonComponent, CadButtonGroupComponent, CadCalendarComponent, CadCaptionDirective, CadCardComponent, CadCardDirective, CadCardHeaderDirective, CadCarouselComponent, CadCarouselItemDirective, CadCascadeSelectComponent, CadCellTemplateDirective, CadCenterComponent, CadChartComponent, CadCheckboxComponent, CadChipComponent, CadClusterComponent, CadColDirective, CadColorpickerComponent, CadColumnComponent, CadComboComponent, CadConfirmContentComponent, CadConfirmDialogComponent, CadConfirmService, CadContainerComponent, CadDataviewComponent, CadDataviewGridDirective, CadDataviewListDirective, CadDatepickerComponent, CadDialogComponent, CadDialogContainerComponent, CadDialogFooterDirective, CadDialogHeaderDirective, CadDialogRef, CadDialogService, CadDividerComponent, CadDrawerComponent, CadEditFocusDirective, CadEditorTemplateDirective, CadEmptyDirective, CadFieldComponent, CadFieldsetComponent, CadFieldsetLegendDirective, CadFilterChipComponent, CadFilterTemplateDirective, CadGeocodingService, CadGridComponent, CadGroupFooterDirective, CadGroupHeaderDirective, CadHeaderTemplateDirective, CadIconComponent, CadIconRegistry, CadIfDirective, CadImageComponent, CadInplaceComponent, CadInplaceContentDirective, CadInplaceDisplayDirective, CadInputDirective, CadJsonEditorComponent, CadKeyFilterDirective, CadListEmptyDirective, CadListFooterDirective, CadListHeaderDirective, CadListItemDirective, CadListboxComponent, CadMapBasemapRegistry, CadMapBasemapsComponent, CadMapCardComponent, CadMapChromeComponent, CadMapComponent, CadMapDrawEngine, CadMapLayerComponent, CadMapLayerGroupComponent, CadMapLayerToggleComponent, CadMapLegendComponent, CadMapMenuComponent, CadMapPanelComponent, CadMapPanels, CadMapRailComponent, CadMapRailItemComponent, CadMapSearchComponent, CadMapSectionComponent, CadMaskDirective, CadMenuComponent, CadMenubarComponent, CadMessageComponent, CadMeterComponent, CadMeterLabelDirective, CadMultiselectComponent, CadNavDrawerComponent, CadNavDrawerFooterDirective, CadNavDrawerHeaderDirective, CadNumberComponent, CadOptionListComponent, CadOrderlistComponent, CadOrgNodeDirective, CadOrgchartComponent, CadOverlayBase, CadPaginatorComponent, CadPanelComponent, CadPanelContentDirective, CadPanelHeaderDirective, CadPanelHeadingDirective, CadPasswordComponent, CadPicklistComponent, CadPopoverComponent, CadProgressComponent, CadRadioComponent, CadRadioGroupComponent, CadRatingComponent, CadRowActionsDirective, CadRowCountDirective, CadRowExpansionDirective, CadScrollTopComponent, CadSegmentedComponent, CadSelectBase, CadSelectComponent, CadSelectEmptyDirective, CadSelectFooterDirective, CadSelectHeaderDirective, CadSelectItemDirective, CadSelectSelectedDirective, CadSheetContainerComponent, CadSheetRef, CadSheetService, CadSidebarComponent, CadSidebarPanelDirective, CadSkeletonComponent, CadSliderComponent, CadSpacerComponent, CadSpeedDialComponent, CadSpinnerComponent, CadSplitButtonComponent, CadSplitComponent, CadSplitterComponent, CadSplitterPanelComponent, CadStackComponent, CadStepComponent, CadStepperComponent, CadSwitchComponent, CadTabComponent, CadTabContentDirective, CadTabLabelDirective, CadTableBase, CadTableComponent, CadTableEdit, CadTableEditUi, CadTableFooterDirective, CadTablePanelComponent, CadTableResponsive, CadTableSelection, CadTableSticky, CadTableVirtual, CadTabsComponent, CadTagComponent, CadTaskCardDirective, CadTaskRowDirective, CadTaskboardComponent, CadTimeAxis, CadTimelineComponent, CadTimelineContentDirective, CadTimelineMarkerDirective, CadTimelineOppositeDirective, CadToastComponent, CadToastItemDirective, CadToastService, CadToggleButtonComponent, CadTooltipComponent, CadTooltipDirective, CadTreeAdapter, CadTreeComponent, CadTreeNodeDirective, CadTreeselectComponent, CadUploadComponent, CadUploadContentDirective, CadUploadEmptyDirective, CadUploadItemDirective, CadValueAccessor, CadWorkCalendar, MAPLIBRE_MIN_CSS, addDays, addMonths, addYears, cadAggregate, cadApplyColumnOrder, cadApplyMask, cadArea, cadAutosizeWidth, cadBasemapThumbnail, cadBoundsOf, cadCategories, cadCentroid, cadColorExpr, cadCompare, cadCompareRank, cadCurrentOperator, cadDebutSemaine, cadDefaultMatchMode, cadDistance, cadDownloadCsv, cadDurationToMinutes, cadEstBandeau, cadExpandOccurrences, cadFilterData, cadFilterKindOf, cadFilterOperators, cadFilterRows, cadFindLinkCycle, cadFmtArea, cadFmtLength, cadFormatCell, cadFormatColor, cadFormatDuration, cadFormatSize, cadFrenchHolidays, cadGap, cadGeoJSONStats, cadGeometryKinds, cadHeaderMenuItems, cadHighlightJson, cadHslToRgb, cadHsvToRgb, cadId, cadIsGroupKey, cadIsRank, cadJsonErrorPos, cadLegendFromStyle, cadLength, cadMapEstVivante, cadMapLayerOf, cadMapLayersOf, cadMatch, cadMinuit, cadMonthGrid, cadMoveColumn, cadMoveItems, cadNormalize, cadNormalizeOptions, cadNormalizePlan, cadNumberExpr, cadNumeroJour, cadPackDay, cadPadBounds, cadParseColor, cadParseDuration, cadParseRRule, cadParseResponsive, cadPlanHeader, cadPlanTicks, cadProjeterClavier, cadProjeterCreation, cadProjeterEdition, cadProjeterMois, cadPropsTable, cadRankBetween, cadRankFirst, cadRankLast, cadRankSequence, cadResolve, cadResolveResponsive, cadResponsive, cadRgbToHsl, cadRgbToHsv, cadRingArea, cadRowKey, cadRowPredicate, cadSameValue, cadScaleNext, cadScaleStart, cadSortData, cadStartResize, cadStyleToExpressions, cadUnmask, cadUnscheduled, cadValidateGeoJSON, cadValueForOperator, cadWeekBands, cadWriteField, compareDay, daysInMonth, endOfMonth, ensureMaplibreCss, formatDate, isBetweenDay, isSameDay, isSameMonth, isValidDate, isoOf, isoWeek, loadChartJs, loadMaplibre, monthNames, pad2, parseIso, parseWithFormat, provideCadIcons, startOfDay, startOfMonth, toDate, weekdayNames };
+export type { CadAggregate, CadAggregateFn, CadAggregates, CadBadgeSeverity, CadBand, CadBandRow, CadBasemap, CadBasemapKind, CadBottomNavItem, CadBounds, CadBreadcrumbItem, CadBreakpoint, CadCalendarChangeEvent, CadCalendarCreateEvent, CadCalendarDateEvent, CadCalendarEventEvent, CadCalendarSource, CadCalendarView, CadCarouselResponsive, CadCellContext, CadCellEditState, CadChartClickEvent, CadChartType, CadColorFormat, CadColorSpec, CadColumnAlign, CadColumnDataType, CadColumnEditor, CadColumnFilterOption, CadColumnFilterType, CadColumnMenuActionEvent, CadColumnPinEvent, CadColumnReorderEvent, CadColumnResizeEvent, CadColumnToggleEvent, CadComboSource, CadConfirmOptions, CadDataviewLayout, CadDateMode, CadDateSelection, CadDateValue, CadDialogConfig, CadDialogPosition, CadDialogSize, CadDisplayRow, CadDrawMode, CadDrawOptions, CadDrawerPosition, CadDuration, CadDurationUnit, CadEditBase, CadEditCompleteEvent, CadEditEvent, CadEditGeometry, CadEditKind, CadEditMode, CadEditorContext, CadExpandResult, CadFeatureEvent, CadFilterChangeEvent, CadFilterKind, CadFilterMatchMode, CadFilterMeta, CadFilterOperator, CadFilters, CadGap, CadGeoJSON, CadGeocodeOptions, CadGeocodeResult, CadGeocoder, CadGeometryKind, CadGroupBy, CadGroupContext, CadGroupInfo, CadGroupItem, CadHeaderMenuHost, CadHsva, CadLayerStyle, CadLazyLoadEvent, CadLegendItem, CadListGroup, CadListItem, CadListNormalizeOpts, CadListOption, CadListRow, CadLngLat, CadMapChild, CadMapChrome, CadMapClick, CadMapControl, CadMapLayerType, CadMapMenuConfig, CadMapMenuItem, CadMapMenuPanel, CadMapMenuRailItem, CadMapMenuSection, CadMapPosition, CadMapSide, CadMapView, CadMeasure, CadMenuItem, CadMenubarItem, CadMeterValue, CadMonthGrid, CadNavDrawerItem, CadNavDrawerMode, CadNavDrawerRow, CadNodeEvent, CadNormalizePlanOptions, CadNormalizedPlan, CadNumberSpec, CadOccurrence, CadOptionItem, CadOrgNode, CadOverlayHandle, CadPageEvent, CadPaintSet, CadPinnedColumns, CadPlacement, CadPlan, CadPlanAssignment, CadPlanBucket, CadPlanCalendar, CadPlanCalendarException, CadPlanDateInput, CadPlanHeader, CadPlanHours, CadPlanIssue, CadPlanLink, CadPlanLinkType, CadPlanMarker, CadPlanResource, CadPlanScale, CadPlanTask, CadPlanTick, CadPlanTicksOptions, CadPlannedLink, CadPlannedTask, CadPriorityBreakpoints, CadProgressSeverity, CadRRule, CadRRuleFreq, CadRecurrenceIssue, CadRgba, CadRowEditEvent, CadRowEditState, CadRowEvent, CadRowReorderEvent, CadSegmentOption, CadSelectItemContext, CadSelectionMode, CadSelectionPropagation, CadSeverity, CadSheetConfig, CadSheetHeight, CadShellApi, CadSize, CadSliderMark, CadSliderSeverity, CadSliderValue, CadSlot, CadSortEvent, CadSortMeta, CadSortOrder, CadStepState, CadTableEditContext, CadTableEditUiContext, CadTablePanelTab, CadTableResponsiveMode, CadTableSelectionContext, CadTagSeverity, CadTaskAssignEvent, CadTaskMoveEvent, CadTaskOpenEvent, CadTaskboardGroupBy, CadTaskboardMode, CadTimelineAlign, CadToastAction, CadToastMessage, CadToastPosition, CadToastSeverity, CadTreeAdapterOptions, CadTreeNode, CadTreeNodeEvent, CadUploadFile, CadUploadHandlerEvent, CadUploadStatus, CadVariant, CadVirtualRange, CadWipEvent, MLExpression, MaplibreModule };