@cadriciel/ui 0.2.0 → 0.4.0

package/types/cadriciel-ui.d.ts

@@ -4807,6 +4807,80 @@ declare class CadSplitterComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadSplitterComponent, "cad-splitter", never, { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "panelSizes": { "alias": "panelSizes"; "required": false; "isSignal": true; }; "minSizes": { "alias": "minSizes"; "required": false; "isSignal": true; }; "gutterSize": { "alias": "gutterSize"; "required": false; "isSignal": true; }; "stateKey": { "alias": "stateKey"; "required": false; "isSignal": true; }; }, { "resizeStart": "resizeStart"; "resizeEnd": "resizeEnd"; }, ["panels"], ["*"], true, never>;
 }
 
+/**
+ * Ce que la coquille dit à ses enfants, pour DÉCIDER.
+ *
+ * Les enfants qui ont seulement besoin de SE PLACER n'ont pas à injecter ceci : ils lisent
+ * les propriétés CSS (`--cad-shell-top` / `-bottom` / `-nav`). Un toast se pose au-dessus de
+ * la barre basse avec `calc(16px + var(--cad-shell-bottom, 0px))`, sans rien importer — et
+ * le repli à `0px` le laisse fonctionner hors coquille.
+ */
+interface CadShellApi {
+    /** Sous le seuil mobile. */
+    readonly compact: Signal<boolean>;
+    /** Hauteurs mesurées, en px (zones sûres comprises : elles sont dans le padding des barres). */
+    readonly topHeight: Signal<number>;
+    readonly bottomHeight: Signal<number>;
+    readonly navWidth: Signal<number>;
+    /** Un enfant demande l'ouverture du menu sans connaître le composant qui le porte. */
+    openNav(): void;
+}
+declare const CAD_SHELL: InjectionToken<CadShellApi>;
+/**
+ * Coquille d'application : barre haute, menu, contenu, barre basse.
+ *
+ * POURQUOI ELLE EXISTE — la bibliothèque avait `cad-bottom-nav`, `cad-menubar`,
+ * `cad-nav-drawer` et `cad-sidebar`, mais aucune coquille. Chaque application refaisait donc
+ * sa mise en page, et retombait sur le même défaut, signalé par SZU le 21/08/2026 : la barre
+ * du haut « défile au lieu de rester en place ». Ce n'était pas la barre qui bougeait, c'était
+ * le DOCUMENT qui défilait.
+ *
+ * LE PARTI PRIS — on ne fixe pas les barres une par une (`position: fixed`), on rend la
+ * coquille INCAPABLE de défiler : hauteur exacte du viewport, seul le contenu défile. Les
+ * barres restent en place parce qu'elles ne peuvent pas bouger. Rien à réserver dans le
+ * contenu, aucune zone sûre dupliquée, un seul seuil. `fixed` reste une porte de sortie pour
+ * un cas particulier, pas le mécanisme.
+ *
+ * AGENCEMENT — barre haute sur TOUTE la largeur, menu dessous : c'est celui du template
+ * CEREMA (`_topbar.scss` : `position: fixed; top: 0; width: 100%`), et une bibliothèque ne
+ * doit pas imposer l'inverse de ce que font les applications maison.
+ *
+ * ELLE MESURE LE MENU, ELLE NE LE POSSÈDE PAS (arbitrage SZU : « le tiroir c'est le composant
+ * menu lui-même »). Elle fonctionne donc sans menu (`--cad-shell-nav: 0`), n'exige aucun
+ * enfant, et `openNav()` se contente d'émettre `navRequested` — c'est l'hôte qui ouvre son
+ * `cad-nav-drawer`. Aucun couplage dans un sens ni dans l'autre.
+ *
+ * ```html
+ * <cad-app-shell (navRequested)="menu.set(true)">
+ *   <header cadShellBar>…</header>
+ *   <cad-nav-drawer cadShellNav [items]="menu" [(open)]="ouvert"/>
+ *   <router-outlet />
+ *   <cad-bottom-nav cadShellBottom [items]="dest" [(value)]="page"/>
+ * </cad-app-shell>
+ * ```
+ */
+declare class CadAppShellComponent implements CadShellApi {
+    private readonly bp;
+    /** Surcharge locale du seuil. Par defaut : celui de la bibliotheque (CAD_MOBILE_BREAKPOINT). */
+    readonly compactAt: _angular_core.InputSignal<number | null>;
+    /** Un enfant a demande le menu (bouton hamburger de la barre, par exemple). */
+    readonly navRequested: _angular_core.OutputEmitterRef<void>;
+    private readonly barRef;
+    private readonly navRef;
+    private readonly bottomRef;
+    private readonly _top;
+    private readonly _bottom;
+    private readonly _nav;
+    readonly topHeight: Signal<number>;
+    readonly bottomHeight: Signal<number>;
+    readonly navWidth: Signal<number>;
+    readonly compact: Signal<boolean>;
+    constructor();
+    openNav(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CadAppShellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadAppShellComponent, "cad-app-shell", never, { "compactAt": { "alias": "compactAt"; "required": false; "isSignal": true; }; }, { "navRequested": "navRequested"; }, never, ["[cadShellBar]", "[cadShellNav]", "*", "[cadShellBottom]"], true, never>;
+}
+
 /**
  * URL optionnelle de la feuille de style MapLibre à injecter dans <head> (ex. `/assets/maplibre-gl.css`).
  * Sans token, cadriciel-ui embarque un sous-ensemble minimal (positionnement canvas/contrôles/popup/marqueurs) et
@@ -6513,5 +6587,592 @@ declare class CadChartComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadChartComponent, "cad-chart", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "plugins": { "alias": "plugins"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "palette": { "alias": "palette"; "required": false; "isSignal": true; }; "themed": { "alias": "themed"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "accessibleTable": { "alias": "accessibleTable"; "required": false; "isSignal": true; }; }, { "chartClick": "chartClick"; "chartHover": "chartHover"; "ready": "ready"; "error": "error"; }, 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_SELECT_POSITIONS, CAD_SELECT_TRIGGER_STYLES, CAD_SHEET_DATA, CAD_TOUCH_DENSITY, CadAccordionComponent, CadAccordionPanelComponent, 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, CadTimelineComponent, CadTimelineContentDirective, CadTimelineMarkerDirective, CadTimelineOppositeDirective, CadToastComponent, CadToastItemDirective, CadToastService, CadToggleButtonComponent, CadTooltipComponent, CadTooltipDirective, CadTreeAdapter, CadTreeComponent, CadTreeNodeDirective, CadTreeselectComponent, CadUploadComponent, CadUploadContentDirective, CadUploadEmptyDirective, CadUploadItemDirective, CadValueAccessor, MAPLIBRE_MIN_CSS, addDays, addMonths, addYears, cadAggregate, cadApplyColumnOrder, cadApplyMask, cadArea, cadAutosizeWidth, cadBasemapThumbnail, cadBoundsOf, cadCategories, cadCentroid, cadColorExpr, cadCompare, cadCurrentOperator, cadDefaultMatchMode, cadDistance, cadDownloadCsv, cadFilterData, cadFilterKindOf, cadFilterOperators, cadFilterRows, cadFmtArea, cadFmtLength, cadFormatCell, cadFormatColor, cadFormatSize, cadGap, cadGeoJSONStats, cadGeometryKinds, cadHeaderMenuItems, cadHighlightJson, cadHslToRgb, cadHsvToRgb, cadId, cadIsGroupKey, cadJsonErrorPos, cadLegendFromStyle, cadLength, cadMapEstVivante, cadMapLayerOf, cadMapLayersOf, cadMatch, cadMoveColumn, cadMoveItems, cadNormalize, cadNormalizeOptions, cadNumberExpr, cadPadBounds, cadParseColor, cadParseResponsive, cadPropsTable, cadResolve, cadResolveResponsive, cadResponsive, cadRgbToHsl, cadRgbToHsv, cadRingArea, cadRowKey, cadRowPredicate, cadSameValue, cadSortData, cadStartResize, cadStyleToExpressions, cadUnmask, 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, 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, CadNumberSpec, CadOptionItem, CadOrgNode, CadOverlayHandle, CadPageEvent, CadPaintSet, CadPinnedColumns, CadPlacement, CadPriorityBreakpoints, CadProgressSeverity, CadRgba, CadRowEditEvent, CadRowEditState, CadRowEvent, CadRowReorderEvent, CadSegmentOption, CadSelectItemContext, CadSelectionMode, CadSelectionPropagation, CadSeverity, CadSheetConfig, CadSheetHeight, CadSize, CadSliderMark, CadSliderSeverity, CadSliderValue, CadSortEvent, CadSortMeta, CadSortOrder, CadStepState, CadTableEditContext, CadTableEditUiContext, CadTablePanelTab, CadTableResponsiveMode, CadTableSelectionContext, CadTagSeverity, CadTimelineAlign, CadToastAction, CadToastMessage, CadToastPosition, CadToastSeverity, CadTreeAdapterOptions, CadTreeNode, CadTreeNodeEvent, CadUploadFile, CadUploadHandlerEvent, CadUploadStatus, CadVariant, CadVirtualRange, MLExpression, MaplibreModule };
+/**
+ * Modèle de planification commun aux trois vues (taskboard, scheduler, gantt).
+ *
+ * DOCTRINE — aucun champ n'est obligatoire hors `id`. Chaque vue déclare ses prérequis et
+ * son repli : une tâche qu'une vue ne sait pas placer part dans sa zone « non planifié »,
+ * jamais dans le silence. C'est cette règle, et elle seule, qui rend le document commun.
+ *
+ * Les noms suivent les conventions EXISTANTES plutôt qu'une invention maison :
+ *   - RFC 5545 (iCalendar) pour l'événement daté et sa récurrence : rrule, exdates, recurrenceId ;
+ *   - MS Project / Primavera P6 pour les liens FS/SS/FF/SF et le décalage (lag).
+ * camelCase partout : c'est la convention du reste de la bibliothèque ET celle de slapi,
+ * ce qui donne une correspondance 1 pour 1 entre le JSON et les colonnes.
+ */
+/** Type de lien entre deux tâches (conventions MS Project). FS = fin -> début. */
+type CadPlanLinkType = 'FS' | 'SS' | 'FF' | 'SF';
+/** Date acceptée en entrée : ISO local, Date, horodatage, ou rien. */
+type CadPlanDateInput = string | Date | number | null | undefined;
+/** Plage horaire d'une journée ouvrée, en heures locales. `to: '24:00'` = fin de journée. */
+interface CadPlanHours {
+    from: string;
+    to: string;
+}
+/** Exception au calendrier : jour chômé, ou horaires particuliers, éventuellement pour une seule ressource. */
+interface CadPlanCalendarException {
+    /** Jour visé, 'yyyy-MM-dd'. */
+    date: string;
+    /** Jour entièrement chômé. */
+    off?: boolean;
+    /** Horaires de remplacement (ignorés si `off`). */
+    hours?: CadPlanHours[];
+    /** Restreint l'exception à cette ressource (absent = tout le monde). */
+    resource?: string | null;
+}
+/** Calendrier ouvré — lu par le scheduler et le gantt, ignoré par le taskboard. */
+interface CadPlanCalendar {
+    /** Jours ouvrés, 0 = dimanche … 6 = samedi. Défaut : lundi -> vendredi. */
+    workdays?: number[];
+    /** Horaires ouvrés d'une journée type. Défaut : journée pleine (00:00 -> 24:00). */
+    hours?: CadPlanHours[];
+    /** Jours fériés, 'yyyy-MM-dd'. Voir `cadFrenchHolidays()` pour les produire. */
+    holidays?: string[];
+    exceptions?: CadPlanCalendarException[];
+}
+/** Ligne du scheduler · pastille du taskboard · affectation du gantt. */
+interface CadPlanResource {
+    id: string;
+    label?: string;
+    /** Ressource parente (équipe, service) — hiérarchie facultative. */
+    parent?: string | null;
+    /** Capacité, en équivalents temps plein. Défaut 1. */
+    capacity?: number;
+    color?: string | null;
+    [extra: string]: unknown;
+}
+/** Colonne du taskboard — sert aussi de GROUPE en mode liste. */
+interface CadPlanBucket {
+    id: string;
+    label?: string;
+    order?: number;
+    /** Limite de travail en cours : au-delà, la colonne s'affiche en alerte. */
+    wipLimit?: number | null;
+    color?: string | null;
+}
+/** Affectation d'une ressource à une tâche. `units` = part de la capacité (1 = plein temps). */
+interface CadPlanAssignment {
+    resource: string;
+    units?: number;
+}
+/** Une tâche : carte du taskboard, événement du scheduler, barre du gantt. */
+interface CadPlanTask {
+    id: string;
+    label?: string;
+    /** Tâche parente : WBS du gantt, couloir du taskboard. */
+    parent?: string | null;
+    start?: CadPlanDateInput;
+    end?: CadPlanDateInput;
+    /** Alternative à `end`, en unités OUVRÉES : '3d', '4h', '90m', '2w'. */
+    duration?: string | null;
+    /** Jalon : instant sans durée. */
+    milestone?: boolean;
+    /** Colonne du taskboard. */
+    bucket?: string | null;
+    /** Rang FRACTIONNAIRE dans sa colonne / sa fratrie. Voir `cadRankBetween()`. */
+    rank?: string | null;
+    assignments?: CadPlanAssignment[];
+    /** Avancement, 0 -> 1. */
+    progress?: number | null;
+    tags?: string[];
+    color?: string | null;
+    /** Ni déplaçable ni redimensionnable. */
+    locked?: boolean;
+    /** Règle RFC 5545, ex. 'FREQ=WEEKLY;BYDAY=TU'. */
+    rrule?: string | null;
+    /** Occurrences supprimées, 'yyyy-MM-ddTHH:mm'. */
+    exdates?: string[];
+    /** Occurrence MODIFIÉE : la série d'origine. */
+    masterId?: string | null;
+    /** … et la date de l'occurrence qu'elle remplace. */
+    recurrenceId?: CadPlanDateInput;
+    /** Charge utile applicative, jamais interprétée par les composants. */
+    meta?: Record<string, unknown>;
+}
+/** Lien de dépendance entre deux tâches. */
+interface CadPlanLink {
+    id?: string;
+    from: string;
+    to: string;
+    /** Défaut 'FS'. */
+    type?: CadPlanLinkType;
+    /** Décalage en unités ouvrées, ex. '1d'. Négatif accepté ('-2d' = recouvrement). */
+    lag?: string | null;
+}
+/** Repère vertical sur l'axe (échéance, jalon transverse). */
+interface CadPlanMarker {
+    id?: string;
+    date: CadPlanDateInput;
+    label?: string;
+    color?: string | null;
+}
+/** Le document commun. */
+interface CadPlan {
+    version?: number;
+    calendar?: CadPlanCalendar;
+    resources?: CadPlanResource[];
+    buckets?: CadPlanBucket[];
+    tasks?: CadPlanTask[];
+    links?: CadPlanLink[];
+    markers?: CadPlanMarker[];
+}
+/** Tâche résolue : dates coercées, hiérarchie établie, valeurs par défaut posées. */
+interface CadPlannedTask {
+    id: string;
+    label: string;
+    parent: string | null;
+    start: Date | null;
+    end: Date | null;
+    milestone: boolean;
+    bucket: string | null;
+    rank: string;
+    assignments: Required<CadPlanAssignment>[];
+    progress: number;
+    tags: string[];
+    color: string | null;
+    locked: boolean;
+    rrule: string | null;
+    exdates: string[];
+    masterId: string | null;
+    recurrenceId: Date | null;
+    /** Profondeur dans la hiérarchie (0 = racine). */
+    level: number;
+    /** Identifiants des enfants directs, dans l'ordre des rangs. */
+    children: string[];
+    /** Vrai si la tâche est plaçable sur un axe de temps (début ET fin connus). */
+    scheduled: boolean;
+    /** Vrai si les dates viennent des descendants (barre récapitulative), pas de la tâche elle-même. */
+    rolled: boolean;
+    /** Vrai si la tâche porte une règle de récurrence (dépliage au lot 4). */
+    recurring: boolean;
+    meta: Record<string, unknown>;
+    /** La ligne d'origine, intacte. */
+    source: CadPlanTask;
+}
+/** Lien résolu : décalage converti en minutes ouvrées. */
+interface CadPlannedLink {
+    id: string;
+    from: string;
+    to: string;
+    type: CadPlanLinkType;
+    lagMinutes: number;
+}
+/** Anomalie relevée à la normalisation. Jamais silencieuse, jamais bloquante. */
+interface CadPlanIssue {
+    level: 'error' | 'warning';
+    /** Code stable, utilisable en test et en traduction. */
+    code: 'duplicate-task' | 'unknown-parent' | 'parent-cycle' | 'self-parent' | 'bad-date' | 'bad-duration' | 'end-before-start' | 'unknown-link-end' | 'self-link' | 'link-cycle' | 'unknown-bucket' | 'unknown-resource' | 'empty-calendar';
+    message: string;
+    /** Identifiant de l'objet concerné, quand il y en a un. */
+    ref?: string;
+}
+
+/**
+ * Durées en unités OUVRÉES : '3d', '4h', '90m', '2w', '1.5d', '-2d'.
+ *
+ * Une durée n'a de sens qu'appuyée sur un calendrier : 'd' vaut une JOURNÉE OUVRÉE, dont la
+ * longueur dépend des horaires déclarés (8 h ouvrées ou 24 h). La conversion en minutes se
+ * fait donc via `CadWorkCalendar.dailyMinutes`, jamais par une constante.
+ *
+ * 'w' vaut une semaine OUVRÉE = nombre de jours ouvrés déclarés (5 par défaut), pas 7 jours.
+ */
+/** Unité d'une durée ouvrée. */
+type CadDurationUnit = 'm' | 'h' | 'd' | 'w';
+interface CadDuration {
+    value: number;
+    unit: CadDurationUnit;
+}
+/**
+ * Analyse une durée. Accepte les alias français ('j' = jour, 's' = semaine) et la virgule
+ * décimale. Rend null si la forme est invalide — l'appelant en fait une anomalie, pas un plantage.
+ */
+declare function cadParseDuration(input: string | number | null | undefined): CadDuration | null;
+/**
+ * Convertit une durée en MINUTES OUVRÉES.
+ * `dailyMinutes` = minutes ouvrées d'une journée type, `weekDays` = jours ouvrés par semaine.
+ */
+declare function cadDurationToMinutes(d: CadDuration | null, dailyMinutes: number, weekDays: number): number;
+/** Rend une durée sous sa forme la plus lisible ('3d', '4h', '90m') depuis des minutes ouvrées. */
+declare function cadFormatDuration(minutes: number, dailyMinutes: number): string;
+
+/**
+ * Rang FRACTIONNAIRE : une chaîne ordonnable dans laquelle on peut toujours insérer.
+ *
+ * POURQUOI — déplacer une carte entre deux autres ne doit pas réécrire toute la colonne en
+ * base. À plusieurs utilisateurs, une renumérotation entière garantit les collisions et coûte
+ * un UPDATE par carte. Ici, insérer entre deux voisins produit une nouvelle chaîne comprise
+ * entre les leurs : UN SEUL enregistrement change.
+ *
+ * C'est un FORMAT STOCKÉ, pas une astuce d'affichage — d'où sa place au socle, avant toute vue.
+ *
+ * INVARIANT — un rang produit ici ne se termine JAMAIS par le caractère plancher ('0'), sans
+ * quoi il existerait des couples sans intervalle (rien ne tient entre '0' et '00'). Tous les
+ * rangs manipulés doivent donc venir de ces fonctions.
+ */
+/** Vrai si la chaîne est un rang exploitable (alphabet connu, pas de plancher final). */
+declare function cadIsRank(s: unknown): s is string;
+/**
+ * Rang strictement compris entre `prev` et `next`.
+ * `prev` absent = insertion en tête, `next` absent = insertion en queue, les deux = première carte.
+ */
+declare function cadRankBetween(prev?: string | null, next?: string | null): string;
+/** Rang d'une carte posée AVANT toutes les autres. */
+declare const cadRankFirst: (first?: string | null) => string;
+/** Rang d'une carte posée APRÈS toutes les autres. */
+declare const cadRankLast: (last?: string | null) => string;
+/**
+ * `n` rangs croissants bien répartis — pour initialiser une colonne ou rattraper des données
+ * qui n'en portaient pas. La répartition laisse de la place entre chaque voisin.
+ */
+declare function cadRankSequence(n: number): string[];
+/** Comparateur de rangs, utilisable tel quel dans un `sort`. */
+declare const cadCompareRank: (a: string, b: string) => number;
+
+/**
+ * Calendrier ouvré — le référentiel temps partagé par le scheduler et le gantt.
+ *
+ * Tout se calcule en HEURE MURALE locale (pas en millisecondes écoulées) : « 3 jours ouvrés »
+ * veut dire trois fois les horaires déclarés, que la période traverse ou non un changement
+ * d'heure. C'est la seule sémantique qui corresponde à ce qu'un planificateur attend.
+ *
+ * Les exceptions peuvent viser une ressource précise : un congé n'est pas un jour férié.
+ * La recherche est donc toujours « exception de CETTE ressource, sinon exception globale ».
+ */
+
+type Interval = readonly [number, number];
+/**
+ * Jours fériés français d'une année, au format 'yyyy-MM-dd' — les huit dates fixes plus les
+ * trois mobiles adossées à Pâques. Évite d'avoir à saisir la liste à la main chaque année.
+ */
+declare function cadFrenchHolidays(year: number): string[];
+/**
+ * Calendrier ouvré immuable. Toute la logique est pure : elle se teste sans DOM et sans horloge.
+ *
+ * ```ts
+ * const cal = new CadWorkCalendar({ workdays: [1,2,3,4,5], holidays: cadFrenchHolidays(2026) });
+ * cal.addMinutes(new Date(2026, 7, 21, 16, 0), 4 * 60);   // vendredi 16 h + 4 h ouvrées -> lundi
+ * ```
+ */
+declare class CadWorkCalendar {
+    /** Jours ouvrés, 0 = dimanche. */
+    readonly workdays: ReadonlySet<number>;
+    /** Minutes ouvrées d'une journée type — sert d'étalon à l'unité 'd'. */
+    readonly dailyMinutes: number;
+    /** Jours ouvrés par semaine — sert d'étalon à l'unité 'w'. */
+    readonly weekDays: number;
+    private readonly base;
+    private readonly holidays;
+    /** Clé 'yyyy-MM-dd' pour une exception globale, 'yyyy-MM-dd|ressource' pour une exception ciblée. */
+    private readonly exceptions;
+    constructor(spec?: CadPlanCalendar | null);
+    /** Vrai si aucun temps ouvré n'est déclarable — le normaliseur en fait une anomalie. */
+    get empty(): boolean;
+    /** Intervalles ouvrés d'une journée, en minutes depuis minuit. Vide = jour chômé. */
+    intervals(date: Date, resource?: string | null): Interval[];
+    /** Vrai si la journée comporte au moins un intervalle ouvré. */
+    isWorkday(date: Date, resource?: string | null): boolean;
+    /** Vrai si l'instant tombe DANS un intervalle ouvré (borne de fin exclue). */
+    isWorkingTime(date: Date, resource?: string | null): boolean;
+    /** Premier instant ouvré à partir de `date` (`date` lui-même s'il l'est). null si introuvable. */
+    nextWorkingStart(date: Date, resource?: string | null): Date | null;
+    /** Dernier instant ouvré jusqu'à `date` (exclu). null si introuvable. */
+    prevWorkingEnd(date: Date, resource?: string | null): Date | null;
+    /**
+     * Avance (ou recule, si négatif) de `minutes` OUVRÉES depuis `from`.
+     * Rend null si le calendrier ne permet pas d'y arriver (aucun jour ouvré déclaré).
+     */
+    addMinutes(from: Date, minutes: number, resource?: string | null): Date | null;
+    /** Minutes OUVRÉES entre deux instants. Négatif si `b` précède `a`. */
+    minutesBetween(a: Date, b: Date, resource?: string | null): number;
+    private cursorOf;
+    private scanForward;
+    private scanBackward;
+    private walkForward;
+    private walkBackward;
+}
+
+/**
+ * Axe de temps : graduations, et conversion pixel <-> date.
+ *
+ * LE POINT CRITIQUE — l'axe n'est PAS une division. Écrire `x = (t - t0) / msParPixel` est
+ * faux dès qu'on dézoome : un jour ne fait pas toujours 24 h (changement d'heure), un mois n'a
+ * pas de largeur fixe, une année pas davantage. Février et mars occuperaient alors des largeurs
+ * différentes alors que l'oeil attend des colonnes égales, et le défaut ne se voit qu'en mars
+ * et en octobre — donc jamais pendant le développement.
+ *
+ * Ici, l'axe est une LISTE DE GRADUATIONS de largeur égale, et la conversion est une recherche
+ * dans cette liste suivie d'une interpolation À L'INTÉRIEUR de la graduation trouvée. Chaque
+ * graduation porte sa vraie durée ; l'arithmétique linéaire ne s'applique que localement.
+ *
+ * Corollaire de rendu : la grille de fond n'a pas à exister en DOM. Des graduations de largeur
+ * égale se peignent en `repeating-linear-gradient`, ce qui évite de virtualiser 1 100 colonnes
+ * pour trois ans au jour. Seuls l'en-tête visible et les barres sont rendus.
+ */
+
+/** Échelle d'une graduation. */
+type CadPlanScale = 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
+/** Une graduation. `start` incluse, `end` exclue. */
+interface CadPlanTick {
+    start: Date;
+    end: Date;
+    label: string;
+    /** Début d'une unité supérieure (1er du mois, lundi, 1er janvier) — trait renforcé. */
+    major: boolean;
+    /** Hors temps ouvré selon le calendrier fourni (week-end, férié). */
+    off: boolean;
+    /** Contient l'instant « aujourd'hui ». */
+    today: boolean;
+}
+interface CadPlanTicksOptions {
+    locale?: string;
+    /** Premier jour de la semaine, 0 = dimanche. Défaut 1 (lundi). */
+    firstDay?: number;
+    /** Calendrier servant à marquer les graduations chômées. */
+    calendar?: CadWorkCalendar | null;
+    /** Instant à marquer. `null` désactive le repère (utile en test). Défaut : maintenant. */
+    today?: Date | null;
+    /** Libellé sur mesure. */
+    label?: (start: Date, scale: CadPlanScale, locale: string) => string;
+    /** Garde-fou : au-delà, la génération s'arrête. Défaut 20 000. */
+    max?: number;
+}
+/** Aligne un instant sur le début de sa graduation. */
+declare function cadScaleStart(date: Date, scale: CadPlanScale, firstDay?: number): Date;
+/**
+ * Début de la graduation SUIVANTE. Construit en heure locale, donc juste aux changements d'heure.
+ * L'entrée est alignée au préalable : `cadScaleNext(31 janvier, 'month')` rend le 1er février,
+ * jamais le 28 — sans quoi une date de milieu de mois produirait une graduation décalée.
+ */
+declare function cadScaleNext(date: Date, scale: CadPlanScale, firstDay?: number): Date;
+/**
+ * Graduations couvrant [from, to], alignées sur l'échelle.
+ * La dernière graduation dépasse `to` si nécessaire : un axe ne coupe jamais une unité en deux.
+ */
+declare function cadPlanTicks(from: Date, to: Date, scale: CadPlanScale, options?: CadPlanTicksOptions): CadPlanTick[];
+/** En-tête à deux étages : le bandeau supérieur porte l'unité au-dessus de l'échelle courante. */
+interface CadPlanHeader {
+    upper: CadPlanTick[];
+    lower: CadPlanTick[];
+}
+declare function cadPlanHeader(from: Date, to: Date, scale: CadPlanScale, options?: CadPlanTicksOptions): CadPlanHeader;
+/**
+ * Conversion pixel <-> date sur une liste de graduations de largeur égale.
+ *
+ * Hors de l'axe, la position est EXTRAPOLÉE sur la durée de la graduation de bord plutôt que
+ * rabattue sur la borne : une barre qui commence avant la fenêtre garde une position cohérente,
+ * et l'appelant décide seul de la découper ou de la masquer.
+ */
+declare class CadTimeAxis {
+    readonly ticks: readonly CadPlanTick[];
+    /** Largeur d'une graduation, en pixels. */
+    readonly unitWidth: number;
+    constructor(ticks: readonly CadPlanTick[], 
+    /** Largeur d'une graduation, en pixels. */
+    unitWidth: number);
+    get width(): number;
+    get start(): Date | null;
+    get end(): Date | null;
+    /** Indice de la graduation contenant `t` (millisecondes), par recherche binaire. */
+    private indexOf;
+    /** Abscisse d'une date, en pixels depuis le début de l'axe. */
+    xOf(date: Date): number;
+    /** Date à une abscisse donnée. */
+    dateAt(x: number): Date | null;
+    /** Position et largeur d'une barre. La largeur ne descend jamais sous zéro. */
+    spanOf(start: Date, end: Date): {
+        x: number;
+        width: number;
+    };
+}
+
+/**
+ * Normalisation du document de planification : ce que les trois vues consomment réellement.
+ *
+ * RÈGLE FONDATRICE — hors `id`, aucun champ n'est obligatoire. Une tâche sans dates reste une
+ * tâche : le taskboard la montre, le gantt et le scheduler la rangent dans leur zone « non
+ * planifié ». Rien n'est jamais écarté en silence ; tout écart devient une entrée de `issues`
+ * portant un code stable, que l'appelant affiche ou ignore, mais qu'il peut toujours lire.
+ *
+ * Le normaliseur ne DÉCIDE de rien qu'il ne puisse justifier : il ne replanifie pas, ne
+ * réordonne pas les dates, ne corrige pas les chevauchements. Il résout, indexe et signale.
+ */
+
+interface CadNormalizePlanOptions {
+    /**
+     * Une tâche parente sans dates propres prend l'étendue de ses descendants (barre récapitulative
+     * du gantt). Défaut true — c'est le comportement attendu d'un WBS.
+     */
+    rollup?: boolean;
+}
+/** Document résolu. */
+interface CadNormalizedPlan {
+    /** Toutes les tâches, dans l'ordre hiérarchique puis par rang. */
+    tasks: CadPlannedTask[];
+    byId: ReadonlyMap<string, CadPlannedTask>;
+    /** Identifiants des racines, dans l'ordre. */
+    roots: string[];
+    links: CadPlannedLink[];
+    resources: CadPlanResource[];
+    buckets: CadPlanBucket[];
+    calendar: CadWorkCalendar;
+    /** Étendue des tâches placées. null si aucune ne l'est. */
+    range: {
+        start: Date;
+        end: Date;
+    } | null;
+    issues: CadPlanIssue[];
+}
+/**
+ * Résout un document brut : dates coercées, durées converties par le calendrier, hiérarchie
+ * établie, rangs complétés, liens validés.
+ */
+declare function cadNormalizePlan(plan: CadPlan | null | undefined, options?: CadNormalizePlanOptions): CadNormalizedPlan;
+/**
+ * Identifiants participant à un cycle de dépendances, par tri topologique (Kahn) :
+ * ce qui ne sort jamais de la file est exactement ce qui est pris dans un cycle.
+ * Nécessaire bien avant le moteur de replanification — un cycle non détecté s'y traduirait
+ * par une boucle infinie plutôt que par un message.
+ */
+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[];
+
+/** Contenu d'une carte : `<ng-template cadTaskCard let-task let-bucket="bucket">`. */
+declare class CadTaskCardDirective {
+    readonly tpl: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CadTaskCardDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CadTaskCardDirective, "[cadTaskCard]", never, {}, {}, never, never, true, never>;
+}
+/** Contenu d'une ligne : `<ng-template cadTaskRow let-task let-group="group">`. */
+declare class CadTaskRowDirective {
+    readonly tpl: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CadTaskRowDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CadTaskRowDirective, "[cadTaskRow]", never, {}, {}, never, never, true, never>;
+}
+type CadTaskboardMode = 'board' | 'list' | 'auto';
+type CadTaskboardGroupBy = 'bucket' | 'resource';
+/** Déplacement demandé : changement de colonne et/ou de rang. */
+interface CadTaskMoveEvent {
+    id: string;
+    task: CadPlannedTask;
+    from: string | null;
+    to: string;
+    rank: string;
+    previousRank: string;
+    index: number;
+}
+/** Réaffectation demandée — même geste que le déplacement, en liste groupée par personne. */
+interface CadTaskAssignEvent {
+    id: string;
+    task: CadPlannedTask;
+    from: string | null;
+    to: string | null;
+    rank: string;
+}
+/** Limite de travail en cours dépassée : signalée, JAMAIS bloquante. */
+interface CadWipEvent {
+    bucket: string;
+    limit: number;
+    count: number;
+}
+interface CadTaskOpenEvent {
+    id: string;
+    task: CadPlannedTask;
+    event: Event;
+}
+interface Column {
+    id: string;
+    label: string;
+    color: string | null;
+    wipLimit: number | null;
+    tasks: CadPlannedTask[];
+}
+/**
+ * <cad-taskboard [plan]="plan" mode="auto" groupBy="bucket" (taskMove) (taskAssign) (taskOpen) (wipExceeded)>
+ *   <ng-template cadTaskCard let-t>…</ng-template>
+ *   <ng-template cadTaskRow let-t>…</ng-template>
+ * </cad-taskboard>
+ *
+ * UNE SEULE ENTRÉE sépare les deux présentations : `mode`. On transforme la présentation, jamais
+ * l'architecture de l'information — mêmes tâches, même rang, même geste, même intention. `auto`
+ * bascule en liste sous le seuil mobile, sur le patron de `cad-nav-drawer`.
+ *
+ * LE COMPOSANT N'ÉCRIT JAMAIS. Il émet `taskMove` / `taskAssign` et laisse l'application décider :
+ * c'est ce qui rend la source indifférente (slapi ou document statique). Pour que le geste reste
+ * vivant sans mentir, il conserve un CORRECTIF LOCAL optimiste, abandonné dès qu'un nouveau `plan`
+ * arrive — l'entrée n'est jamais mutée, et l'affichage suit l'application si elle refuse.
+ *
+ * La limite de travail en cours ALERTE mais ne bloque pas : un tableau qui refuse un geste sans
+ * l'expliquer se contourne au lieu d'être lu.
+ *
+ * Clavier : Entrée / Espace ouvrent la tâche ; Ctrl (ou Cmd) + flèches la déplacent — gauche et
+ * droite changent de colonne, haut et bas changent de rang. Chaque déplacement est annoncé.
+ */
+declare class CadTaskboardComponent {
+    /** Document de planification brut ; il est normalisé en interne et jamais muté. */
+    readonly plan: _angular_core.InputSignal<CadPlan | null>;
+    /** 'board' = cartes, 'list' = lignes groupées, 'auto' = liste sous le seuil mobile. */
+    readonly mode: _angular_core.InputSignal<CadTaskboardMode>;
+    /** Regroupement de la présentation liste. Par personne, le glisser réaffecte au lieu de ranger. */
+    readonly groupBy: _angular_core.InputSignal<CadTaskboardGroupBy>;
+    readonly dragDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Groupes repliés (présentation liste). */
+    readonly collapsedKeys: _angular_core.ModelSignal<ReadonlySet<string>>;
+    readonly emptyText: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Format d'échéance (jetons de `formatDate`). */
+    readonly dateFormat: _angular_core.InputSignal<string>;
+    /** Instant de référence pour « en retard ». Explicite en test, sinon maintenant. */
+    readonly today: _angular_core.InputSignal<Date | null>;
+    readonly taskMove: _angular_core.OutputEmitterRef<CadTaskMoveEvent>;
+    readonly taskAssign: _angular_core.OutputEmitterRef<CadTaskAssignEvent>;
+    readonly taskOpen: _angular_core.OutputEmitterRef<CadTaskOpenEvent>;
+    readonly wipExceeded: _angular_core.OutputEmitterRef<CadWipEvent>;
+    protected readonly cardTpl: _angular_core.Signal<CadTaskCardDirective | undefined>;
+    protected readonly rowTpl: _angular_core.Signal<CadTaskRowDirective | undefined>;
+    protected readonly orphanHint = "Sans colonne connue \u2014 rang\u00E9e par d\u00E9faut, jamais escamot\u00E9e";
+    protected readonly announcement: _angular_core.WritableSignal<string>;
+    private readonly bp;
+    private readonly patch;
+    /** Document résolu par le socle de planification. */
+    readonly normalized: _angular_core.Signal<_cadriciel_ui.CadNormalizedPlan>;
+    /** Présentation effective, une fois `auto` tranché par le seuil. */
+    readonly view: _angular_core.Signal<"list" | "board">;
+    protected readonly compact: _angular_core.Signal<boolean>;
+    /** Tâches après application du correctif optimiste (abandonné dès que `plan` change). */
+    private readonly tasks;
+    /** Colonnes déclarées, ou une colonne implicite : un tableau sans colonne reste un tableau. */
+    private readonly declared;
+    /** Colonnes (cartes, ou liste groupée par colonne) ou personnes (liste groupée par personne). */
+    readonly columns: _angular_core.Signal<Column[]>;
+    /** Colonne réelle d'une tâche : la sienne si elle existe, sinon la première. Jamais « nulle part ». */
+    protected bucketOf(t: CadPlannedTask): string;
+    protected isOrphan(t: CadPlannedTask): boolean;
+    protected countOf(c: Column): string;
+    protected wipState(c: Column): 'none' | 'full' | 'over';
+    protected due(t: CadPlannedTask): string;
+    protected isLate(t: CadPlannedTask): boolean;
+    protected pct(t: CadPlannedTask): number;
+    protected labelOfResource(id: string): string;
+    /** Initiales d'une personne : « S. Zuccatti » donne SZ, « Charles » donne CH. */
+    protected initialsOfResource(id: string): string;
+    protected colorOfResource(id: string): string | null;
+    protected isCollapsed(key: string): boolean;
+    protected toggle(key: string): void;
+    protected open(t: CadPlannedTask, event: Event): void;
+    protected onDrop(e: CdkDragDrop<string>, kind: CadTaskboardGroupBy): void;
+    protected onKey(e: KeyboardEvent, t: CadPlannedTask, colId: string): void;
+    /**
+     * Calcule le nouveau rang entre les deux voisins, pose le correctif optimiste et ÉMET.
+     * `fromIndex` >= 0 signale un déplacement dans le même groupe : le voisinage se lit alors sur
+     * la liste privée de la tâche déplacée, exactement comme le fait `moveItemInArray`.
+     */
+    private apply;
+    /** L'annonce ne dit pas « déplacé » : elle dit OÙ et À QUELLE PLACE — la seule information utile sans la vue. */
+    private announce;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CadTaskboardComponent, never>;
+    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 };