@cadriciel/ui 0.5.0 → 0.7.0

package/types/cadriciel-ui.d.ts

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, Provider, ElementRef, TemplateRef, Signal, ViewContainerRef, Injector, ComponentRef, OnDestroy, AfterViewInit } from '@angular/core';
+import { InjectionToken, Provider, ElementRef, TemplateRef, Signal, ViewContainerRef, Injector, ComponentRef, OnDestroy, AfterViewInit, Type } from '@angular/core';
 import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
 import * as _angular_platform_browser from '@angular/platform-browser';
 import { SafeHtml } from '@angular/platform-browser';
@@ -6751,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()`. */
@@ -6808,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>[];
@@ -7121,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>;
@@ -7258,5 +7509,489 @@ 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, CadNavDrawerRow, 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>;
+}
+
+/**
+ * Le format d'une maquette de l'Atelier CadGrid.
+ *
+ * ⚠️ CE N'EST PAS UN FORMAT À NOUS. C'est celui des pages visuelles de frontless, et
+ * c'est tout l'intérêt : « ouvrir cette maquette comme page dans mon projet » devient un
+ * transfert de fichier, pas une fonctionnalité à écrire. Trois écrits l'imposent, et il
+ * faut qu'ils restent d'accord :
+ *
+ *   · le rendu de frontless — `serverless/shell/src/frontless/grid.ts` :
+ *       grid-template-columns: repeat(12, 1fr)
+ *       --gc = (x + 1) / span w      --gr = (y + 1) / span h
+ *   · l'assainisseur du backend — `backend/utils/layout-sanitize.js`, qui borne et
+ *     nettoie tout ce qui entre en base ;
+ *   · ce fichier.
+ *
+ * Les bornes ci-dessous sont donc RECOPIÉES de l'assainisseur, pas inventées. Les élargir
+ * ici ne servirait à rien : le backend rejetterait à l'écriture, ou pire, rognerait en
+ * silence et l'utilisateur perdrait son travail sans message.
+ *
+ * ATTENTION AU HOMONYME : `@cadriciel/ui` a aussi un `cad-grid` avec `[cadCol]`, qui est
+ * une grille de FLUX (on ne choisit qu'une largeur). Ce n'est pas celle-là. Ici le
+ * placement est ABSOLU — x, y, w, h — parce que c'est ce que frontless sait relire.
+ */
+/** Nombre de colonnes, figé par le contrat de frontless. */
+declare const ATELIER_COLONNES = 12;
+/** Bornes recopiées de `backend/utils/layout-sanitize.js`. */
+declare const ATELIER_BORNES: {
+    readonly yMax: 500;
+    readonly hMin: 1;
+    readonly hMax: 100;
+    readonly itemsMax: 200;
+    readonly propsMax: 30;
+};
+/** Un composant posé sur le plan. */
+interface AtelierItem {
+    /** Stable, pour que la sélection et l'annulation survivent à un réarrangement. */
+    id: string;
+    /** Le SÉLECTEUR du composant (`cad-badge`), pas son symbole : c'est ce que lit frontless. */
+    type: string;
+    /** Colonne de départ, 0-indexée. */
+    x: number;
+    /** Ligne de départ, 0-indexée. */
+    y: number;
+    /** Largeur en colonnes. */
+    w: number;
+    /** Hauteur en lignes. */
+    h: number;
+    props?: Record<string, string | number | boolean | string[]>;
+    /** événement → nom de méthode de l'hôte. */
+    ev?: Record<string, string>;
+    data?: {
+        service?: string;
+        field?: string;
+        label?: string;
+    };
+    hideMobile?: boolean;
+}
+interface AtelierLayout {
+    version: 1;
+    items: AtelierItem[];
+}
+/** Un plan vide, jamais `null` : un canevas absent et un canevas vide se traitent pareil. */
+declare const atelierLayoutVide: () => AtelierLayout;
+
+/** Identifiant conforme à l'assainisseur backend : `/^[A-Za-z0-9_-]{1,24}$/`. */
+declare function atelierNouvelId(): string;
+/** Remet le compteur à zéro. Réservé aux tests, pour qu'ils ne dépendent pas de leur ordre. */
+declare function atelierReinitialiserIds(): void;
+/**
+ * La première position libre pour un bloc de `w × h`, en balayant de haut en bas puis de
+ * gauche à droite.
+ *
+ * C'est ce qui rend le CLIC utilisable comme geste principal : on choisit dans la palette
+ * et ça se pose à un endroit sensé, sans viser. Le glisser sert ensuite à réarranger,
+ * là où il est réellement meilleur.
+ */
+declare function atelierPremierePlaceLibre(items: readonly AtelierItem[], w: number, h: number): {
+    x: number;
+    y: number;
+};
+/** Pose un composant, à la première place libre ou à l'endroit demandé. */
+declare function atelierAjouter(layout: AtelierLayout, type: string, gabarit?: {
+    w?: number;
+    h?: number;
+    props?: AtelierItem['props'];
+}): {
+    layout: AtelierLayout;
+    id: string;
+};
+/** Retire un composant. Sans effet si l'identifiant est inconnu. */
+declare function atelierRetirer(layout: AtelierLayout, id: string): AtelierLayout;
+/** Change une propriété. `undefined` la supprime plutôt que d'écrire un vide. */
+declare function atelierDefinirProp(layout: AtelierLayout, id: string, nom: string, valeur: string | number | boolean | string[] | undefined): AtelierLayout;
+/**
+ * Change la largeur, en gardant le bloc DANS la grille.
+ *
+ * On décale x quand la largeur déborde, plutôt que de rogner w : l'utilisateur a demandé
+ * une largeur, pas une place. Rogner silencieusement donnerait un bloc plus étroit que
+ * ce qu'il a réglé, sans rien dire.
+ */
+declare function atelierRedimensionner(layout: AtelierLayout, id: string, w: number): AtelierLayout;
+/**
+ * Déplace un bloc d'un cran dans l'ordre de lecture (haut/bas), puis recompacte.
+ *
+ * C'est le CHEMIN CLAVIER, et il passe par les mêmes fonctions que le glisser — la règle
+ * déjà tenue par `cad-taskboard` et `cad-calendar`. Deux chemins séparés divergent
+ * toujours, et c'est celui du clavier qui pourrit, parce que personne ne le regarde.
+ */
+declare function atelierDeplacer(layout: AtelierLayout, id: string, sens: -1 | 1): AtelierLayout;
+/**
+ * Repose tous les blocs dans l'ordre de lecture, en supprimant les trous verticaux.
+ *
+ * Le plan garde des positions ABSOLUES (c'est le contrat de frontless), mais une maquette
+ * criblée de lignes vides est illisible. On recompacte donc à chaque réarrangement, en
+ * respectant l'ordre voulu et les largeurs.
+ */
+declare function atelierRecompacter(layout: AtelierLayout): AtelierLayout;
+/**
+ * Repose les blocs DANS L'ORDRE DU TABLEAU REÇU, sans le retrier.
+ *
+ * La distinction avec `atelierRecompacter` n'est pas cosmétique : après un déplacement au
+ * clavier, l'ordre voulu est celui du tableau, et les `y` portent encore les anciennes
+ * positions. Retrier à ce moment-là annule l'échange — le déplacement devenait
+ * silencieusement inopérant, et c'est le test du clavier qui l'a montré.
+ */
+declare function atelierPoser(items: readonly AtelierItem[]): AtelierLayout;
+/**
+ * Ramène un plan venu de l'extérieur dans les clous — un lien partagé, un fichier collé.
+ *
+ * Écarte ce qui est irrécupérable plutôt que de le réparer au jugé : un bloc dont on a
+ * deviné le type serait pire qu'un bloc absent. Même doctrine que l'assainisseur backend,
+ * dont ce n'est PAS un doublon : celui-ci protège l'affichage, celui-là protège la base.
+ */
+declare function atelierNormaliser(brut: unknown): AtelierLayout;
+
+/** Une propriété telle que l'inspecteur doit la présenter. */
+interface AtelierProp {
+    nom: string;
+    type: string;
+    requise: boolean;
+    bidirectionnelle: boolean;
+    defaut?: string | number | boolean;
+    /** Le contrôle à afficher, DÉDUIT du type — c'est à ça que sert le lot 0. */
+    controle: 'interrupteur' | 'liste' | 'nombre' | 'texte' | 'liaison';
+    /** Valeurs proposées quand `controle === 'liste'`. */
+    choix?: string[];
+}
+interface AtelierComposant {
+    /**
+     * La clé stockée dans `layout.json`.
+     *
+     * ⚠️ CE N'EST PAS LE SÉLECTEUR, et ce ne peut pas l'être : l'assainisseur n'accepte que
+     * `/^(?:app:)?[a-z][a-z0-9-]{0,40}$/`, donc `button[cadButton]` — le sélecteur du
+     * composant le PLUS utilisé de la bibliothèque — y est inexprimable. On dérive donc la
+     * clé du SYMBOLE, qui est stable et unique. `CadBadgeComponent` → `cad-badge`.
+     */
+    cle: string;
+    symbole: string;
+    selecteur: string;
+    /** La balise à écrire ou à créer. Voir `hote` du registre : `<button cadButton>`. */
+    balise: string;
+    /** L'attribut à poser sur la balise, pour les composants à sélecteur d'attribut. */
+    attribut?: string;
+    groupe: string;
+    role: string | null;
+    props: AtelierProp[];
+    sorties: {
+        nom: string;
+        type?: string;
+    }[];
+    /** Largeur de départ, en colonnes sur 12. */
+    largeur: number;
+    /** Hauteur de départ, en lignes de grille. */
+    hauteur: number;
+}
+/** `CadBadgeComponent` → `cad-badge`. Dérivé, jamais saisi. */
+declare function atelierCleDeSymbole(symbole: string): string;
+/**
+ * La balise et l'attribut d'un sélecteur.
+ *
+ * `cad-badge` → `<cad-badge>` · `button[cadButton], a[cadButton]` → `<button cadButton>`.
+ * Écrire `<cad-button>` donnerait un élément inconnu, muet et sans style — sans erreur.
+ */
+declare function atelierBalise(selecteur: string): {
+    balise: string;
+    attribut?: string;
+};
+/**
+ * Le contrôle qu'appelle un type.
+ *
+ * C'est ici que le travail du lot 0 se transforme en interface : sans le type, tout
+ * retomberait sur un champ texte, y compris les 253 booléens de la bibliothèque.
+ */
+declare function atelierControle(type: string | undefined): Pick<AtelierProp, 'controle' | 'choix'>;
+/** Tous les composants posables, calculés une fois. */
+declare const ATELIER_PALETTE: readonly AtelierComposant[];
+/** Le composant derrière une clé de `layout.json`, ou `null` s'il n'existe plus. */
+declare function atelierComposant(cle: string): AtelierComposant | null;
+/** Recherche par nom, clé ou sélecteur. Sans terme, rend tout. */
+declare function atelierChercher(terme: string): AtelierComposant[];
+/** Les composants groupés, dans l'ordre d'affichage de la palette. */
+declare function atelierGroupes(terme?: string): {
+    groupe: string;
+    composants: AtelierComposant[];
+}[];
+
+/** `Relevé d'ouvrage` → `ReleveOuvrage`. */
+declare function atelierNomDeClasse(titre: string): string;
+/** `ReleveOuvrage` → `app-releve-ouvrage`. */
+declare function atelierSelecteurDeClasse(nom: string): string;
+/** Les entrées requises qu'aucune valeur ne remplit — nommées, jamais inventées. */
+declare function atelierManques(layout: AtelierLayout): string[];
+/** Les symboles à importer : uniquement ceux que la maquette pose réellement. */
+declare function atelierImports(layout: AtelierLayout): string[];
+/**
+ * Le gabarit seul.
+ *
+ * Les items sont écrits dans L'ORDRE DE LECTURE (y puis x), et ce n'est pas cosmétique :
+ * en dessous de 700 px la grille retombe à une colonne et l'ordre affiché devient l'ordre
+ * du DOM. Écrire dans l'ordre de création donnerait une page correcte sur bureau et
+ * mélangée sur téléphone — un défaut qu'on ne voit qu'en rétrécissant la fenêtre.
+ */
+declare function atelierGabarit(layout: AtelierLayout): string;
+/**
+ * Les styles du plan — RECOPIÉS du rendu de frontless (`serverless/shell/src/frontless/
+ * grid.ts`), pas réinventés. Une maquette doit s'afficher chez qui la colle exactement
+ * comme dans l'atelier, y compris son repli mobile à une colonne.
+ */
+declare const ATELIER_STYLES_PLAN = "    .plan {\n      display: grid;\n      grid-template-columns: repeat(12, 1fr);\n      grid-auto-rows: 58px;\n      gap: 10px;\n    }\n    .bloc { grid-column: var(--gc); grid-row: var(--gr); min-width: 0; overflow: hidden; }\n    @media (max-width: 700px) {\n      .plan { grid-template-columns: 1fr; grid-auto-rows: minmax(58px, auto); }\n      .bloc { grid-column: auto; grid-row: auto; }\n      .bloc.cache-mobile { display: none; }\n    }";
+/** Le composant Angular complet, prêt à coller dans un projet. */
+declare function atelierCode(layout: AtelierLayout, titre?: string): string;
+
+/**
+ * Registre d'exécution de la bibliothèque — GÉNÉRÉ, ne pas modifier à la main.
+ *
+ * Source : tools/gen-catalog.mjs, même passe AST que catalog.json.
+ * Régénérer : node tools/gen-catalog.mjs · Vérifier : node tools/gen-catalog.mjs --check
+ *
+ * `catalog.json` dit ce qui existe et comment le présenter ; ce fichier dit comment
+ * l'INSTANCIER. Un JSON ne peut pas porter de référence de classe, d'où les deux.
+ *
+ * `hote` est la balise à créer : elle ne vaut pas toujours le sélecteur. `CadButtonComponent`
+ * s'écrit `button[cadButton]` — il n'existe aucun élément `<cad-button>`, il faut fabriquer
+ * un `<button>` et y attacher le composant.
+ *
+ * Les 61 directives de la bibliothèque n'y figurent pas : une directive ne s'instancie
+ * pas seule, elle se pose sur un hôte existant. Elles restent visibles dans catalog.json.
+ */
+
+interface EntreeRegistre {
+    /** La classe du composant, prête pour `createComponent()`. */
+    readonly classe: Type<unknown>;
+    /** Le sélecteur tel qu'écrit dans le décorateur. */
+    readonly selecteur: string;
+    /** La balise à créer pour l'héberger. */
+    readonly hote: string;
+}
+/** Symbole -> de quoi le construire. 102 composants posables. */
+declare const REGISTRE: Readonly<Record<string, EntreeRegistre>>;
+/** La classe d'un symbole, ou `null` s'il n'est pas posable (directive, ou hôte indéterminable). */
+declare function classeDe(symbole: string): Type<unknown> | null;
+
+export { ATELIER_BORNES, ATELIER_COLONNES, ATELIER_PALETTE, ATELIER_STYLES_PLAN, 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, REGISTRE, addDays, addMonths, addYears, atelierAjouter, atelierBalise, atelierChercher, atelierCleDeSymbole, atelierCode, atelierComposant, atelierControle, atelierDefinirProp, atelierDeplacer, atelierGabarit, atelierGroupes, atelierImports, atelierLayoutVide, atelierManques, atelierNomDeClasse, atelierNormaliser, atelierNouvelId, atelierPoser, atelierPremierePlaceLibre, atelierRecompacter, atelierRedimensionner, atelierReinitialiserIds, atelierRetirer, atelierSelecteurDeClasse, 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, classeDe, compareDay, daysInMonth, endOfMonth, ensureMaplibreCss, formatDate, isBetweenDay, isSameDay, isSameMonth, isValidDate, isoOf, isoWeek, loadChartJs, loadMaplibre, monthNames, pad2, parseIso, parseWithFormat, provideCadIcons, startOfDay, startOfMonth, toDate, weekdayNames };
+export type { AtelierComposant, AtelierItem, AtelierLayout, AtelierProp, 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, EntreeRegistre, MLExpression, MaplibreModule };