fold-ng 0.7.0 → 0.9.0

package/types/fold-ng.d.ts

@@ -1,5 +1,6 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, Provider, TemplateRef, ElementRef, Signal, Type, Injector, InputSignal, WritableSignal } from '@angular/core';
+import { InjectionToken, Provider, TemplateRef, ElementRef, Signal, Type, Injector, WritableSignal } from '@angular/core';
+import * as fold_ng from 'fold-ng';
 import { FormValueControl, ValidationError, FormCheckboxControl } from '@angular/forms/signals';
 
 /**
@@ -61,8 +62,8 @@ import { FormValueControl, ValidationError, FormCheckboxControl } from '@angular
  * |----------------|-----------------------|-----------|--------------------------------------------|
  * | `headerLayout` | `"inset" \| "full"`   | `"inset"` | `inset` = header sits over the content column (rails climb its side); `full` = header spans the full width, above the rails. |
  * | `footerLayout` | `"inset" \| "full"`   | `"inset"` | `inset` = footer sits under the content column (rails climb its side); `full` = footer spans the full width, below the rails (the usual player-bar look). Ignored when `footerBehavior="scroll"`. |
- * | `footerBehavior`| `"pinned" \| "scroll"`| `"pinned"`| `pinned` = the footer is a fixed row, **always in sight** (a player / status bar) — supports `inset` and `full`. `scroll` = the footer flows at the **end of the content**, revealed when you scroll to the bottom (a legal / support footer) — it lives in the content column (inset), and the shell owns the content scroll, so project *flow* content, not a page that manages its own full-height scroll. |
- * | `contentScroll`| `"clip" \| "auto"`    | `"clip"`  | `clip` = the shell clips the content region; the page inside owns its scroll (`fold-page-layout`). `auto` = the content region scrolls itself, for plain content. Ignored under `footerBehavior="scroll"`. |
+ * | `footerBehavior`| `"pinned" \| "scroll"`| `"pinned"`| `pinned` = the footer is a fixed row, **always in sight** (a player / status bar) — supports `inset` and `full`. `scroll` = the footer flows at the **end of the content**, revealed when you scroll to the bottom (a legal / support footer) — it lives in the content column (inset). A short page still pushes it to the bottom (the content grows to fill), and a tall page reveals it below the fold; you never manage that. |
+ * | `scroll`       | `"scroll" \| "stage"` | `"scroll"`| **Who owns the content scroll.** `scroll` (default) = the shell's content region owns the scroll; pages flow inside it (`fold-page-layout scroll="flow"`), the chrome stays put, a `scroll` footer sits at the true end. `stage` = the content region is a fixed-height stage that does *not* scroll — the page fills it and scrolling happens inside `[foldScrollRegion]` areas (a mail-style split view). See `docs/scroll.md`. |
  *
  * ## Elevation (the floating look)
  * The shell owns **structure**, not skin — it drives no `floating` flag. To lift
@@ -144,15 +145,23 @@ declare class FoldAppShellComponent {
     /** `"pinned"` (default) keeps the footer always in sight as a fixed row (a player / status bar); `"scroll"` lets it flow at the end of the content, revealed when you scroll to the bottom (a legal / support footer). `scroll` is inset-only and makes the shell own the content scroll — project flow content, not a page that manages its own full-height scroll. */
     readonly footerBehavior: _angular_core.InputSignal<"pinned" | "scroll">;
     /**
-     * Who owns the content region's scroll:
-     * - `"clip"` (default) — the shell clips it; the page inside owns its scroll
-     *   (an `fold-page-layout` is its own scroll box). A full-bleed page paints to
-     *   the edges and never double-scrolls.
-     * - `"auto"` — the shell's content region scrolls itself. For plain content
-     *   that isn't wrapped in a self-scrolling page. Ignored under
-     *   `footerBehavior="scroll"` (which already makes the region scroll).
+     * Who owns the content region's scroll — the shell's single scroll switch.
+     * - `"scroll"` (default) — the shell's content region **owns** the scroll.
+     *   Pages flow inside it (`fold-page-layout` defaults to `scroll="flow"`), the
+     *   header/rails stay put, and a `footerBehavior="scroll"` footer sits at the
+     *   true end of the content. This is the document case — the vast majority.
+     * - `"stage"` — the content region is a **fixed-height stage** that does *not*
+     *   scroll; the page fills it and any scrolling happens inside
+     *   `[foldScrollRegion]` areas. This is the app case: a mail-style split view
+     *   where the list and the detail scroll independently and the viewport never
+     *   moves. A page that must scroll as a unit inside a stage sets
+     *   `fold-page-layout scroll="own"`.
+     *
+     * The scroll always lives on an **inner** scroll box, never on the content
+     * region itself, so a docked overlay (the panel host) anchored to the region
+     * stays fixed over the frame instead of scrolling away with the content.
      */
-    readonly contentScroll: _angular_core.InputSignal<"clip" | "auto">;
+    readonly scroll: _angular_core.InputSignal<"scroll" | "stage">;
     /** The skip-link's label — the first Tab stop, jumping keyboard users past the
      *  rails straight to `<main>`. Override for a non-English app. */
     readonly skipLinkLabel: _angular_core.InputSignal<string>;
@@ -195,6 +204,12 @@ declare class FoldAppShellComponent {
     readonly mobileNavOpen: _angular_core.ModelSignal<boolean>;
     /** The shell's own width, kept live by a shared `ResizeObserver` primitive. */
     private readonly width;
+    /** The registry of live scroll regions. The shell registers its own content
+     *  scroll box so an overlay (the panel host) can freeze it — the scroll owner
+     *  here is this inner box, not `document.body`. */
+    private readonly scrollRegions;
+    /** The inner content scroll box (`scroll` mode) / stage (`stage` mode). */
+    private readonly scrollBox;
     /** Whether the shell is narrow enough to collapse — tracked from its **own**
      *  width, not the viewport, so the drawer engages in step with the CSS
      *  collapse whether that fires on `@media` (the shell fills the viewport) or
@@ -221,7 +236,7 @@ declare class FoldAppShellComponent {
     protected readonly headerHeightVar: _angular_core.Signal<string | null>;
     protected readonly headerHeightMobileVar: _angular_core.Signal<string | null>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldAppShellComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldAppShellComponent, "fold-app-shell", ["foldAppShell"], { "railWidth": { "alias": "railWidth"; "required": false; "isSignal": true; }; "headerHeight": { "alias": "headerHeight"; "required": false; "isSignal": true; }; "headerHeightMobile": { "alias": "headerHeightMobile"; "required": false; "isSignal": true; }; "headerLayout": { "alias": "headerLayout"; "required": false; "isSignal": true; }; "footerLayout": { "alias": "footerLayout"; "required": false; "isSignal": true; }; "footerBehavior": { "alias": "footerBehavior"; "required": false; "isSignal": true; }; "contentScroll": { "alias": "contentScroll"; "required": false; "isSignal": true; }; "skipLinkLabel": { "alias": "skipLinkLabel"; "required": false; "isSignal": true; }; "drawerLabel": { "alias": "drawerLabel"; "required": false; "isSignal": true; }; "mobileNav": { "alias": "mobileNav"; "required": false; "isSignal": true; }; "mobileNavOpen": { "alias": "mobileNavOpen"; "required": false; "isSignal": true; }; }, { "mobileNavOpen": "mobileNavOpenChange"; }, never, ["[railPrimary]", "[railSecondary]", "[header]", "[footer]", "*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldAppShellComponent, "fold-app-shell", ["foldAppShell"], { "railWidth": { "alias": "railWidth"; "required": false; "isSignal": true; }; "headerHeight": { "alias": "headerHeight"; "required": false; "isSignal": true; }; "headerHeightMobile": { "alias": "headerHeightMobile"; "required": false; "isSignal": true; }; "headerLayout": { "alias": "headerLayout"; "required": false; "isSignal": true; }; "footerLayout": { "alias": "footerLayout"; "required": false; "isSignal": true; }; "footerBehavior": { "alias": "footerBehavior"; "required": false; "isSignal": true; }; "scroll": { "alias": "scroll"; "required": false; "isSignal": true; }; "skipLinkLabel": { "alias": "skipLinkLabel"; "required": false; "isSignal": true; }; "drawerLabel": { "alias": "drawerLabel"; "required": false; "isSignal": true; }; "mobileNav": { "alias": "mobileNav"; "required": false; "isSignal": true; }; "mobileNavOpen": { "alias": "mobileNavOpen"; "required": false; "isSignal": true; }; }, { "mobileNavOpen": "mobileNavOpenChange"; }, never, ["[railPrimary]", "[railSecondary]", "[header]", "[footer]", "*"], true, never>;
 }
 
 /** Fill style — `ghost` dashes the outline (guests). */
@@ -529,6 +544,27 @@ declare const FOLD_BUILTIN_ICONS: {
     readonly rewind: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"currentColor\"><path d=\"M11 18V6l-8.5 6 8.5 6zm.5-6l8.5 6V6l-8.5 6z\"/></svg>";
     readonly volume: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"currentColor\"><path d=\"M3 9v6h4l5 5V4L7 9H3zm13.5 3A4.5 4.5 0 0 0 14 7.97v8.05c1.48-.73 2.5-2.25 2.5-4.02zM14 3.23v2.06c2.89.86 5 3.54 5 6.71s-2.11 5.85-5 6.71v2.06c4.01-.91 7-4.49 7-8.77s-2.99-7.86-7-8.77z\"/></svg>";
     readonly waveform: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M2 20h.01M7 20v-4M12 20v-8M17 20V8M22 4v16\"/></svg>";
+    readonly "shopping-cart": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><circle cx=\"9\" cy=\"21\" r=\"1\"/><circle cx=\"20\" cy=\"21\" r=\"1\"/><path d=\"M1 1h4l2.68 13.39a2 2 0 0 0 2 1.61h9.72a2 2 0 0 0 2-1.61L23 6H6\"/></svg>";
+    readonly "shopping-bag": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M6 2 3 6v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V6l-3-4z\"/><path d=\"M3 6h18\"/><path d=\"M16 10a4 4 0 0 1-8 0\"/></svg>";
+    readonly basket: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M5.5 9h13l-1.13 9.06a2 2 0 0 1-1.98 1.94H8.61a2 2 0 0 1-1.98-1.94z\"/><path d=\"m8.5 9 3-6 3 6\"/><path d=\"M9.5 13v3\"/><path d=\"M14.5 13v3\"/></svg>";
+    readonly package: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M16.5 9.4 7.5 4.21\"/><path d=\"M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z\"/><path d=\"M3.27 6.96 12 12.01l8.73-5.05\"/><path d=\"M12 22.08V12\"/></svg>";
+    readonly "package-check": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M16 16.5V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-3 1.73\"/><path d=\"M3.3 7 12 12l3-1.7\"/><path d=\"M12 22V12\"/><path d=\"M21 8.5V16a2 2 0 0 1-1 1.73l-7 4a2 2 0 0 1-1.5.24\"/><path d=\"m16.5 19.5 2 2 4-4\"/></svg>";
+    readonly tag: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M20.59 13.41 13.42 20.58a2 2 0 0 1-2.83 0L2 12V2h10l8.59 8.59a2 2 0 0 1 0 2.82z\"/><path d=\"M7 7h.01\"/></svg>";
+    readonly tags: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M9 5H4a2 2 0 0 0-2 2v5l7.59 7.59a2 2 0 0 0 2.82 0l4.18-4.18a2 2 0 0 0 0-2.82z\"/><path d=\"M6 9.5h.01\"/><path d=\"m14 4 6.59 6.59a2 2 0 0 1 0 2.82L16 18\"/></svg>";
+    readonly barcode: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M3 5v14\"/><path d=\"M6.5 5v14\"/><path d=\"M10 5v14\"/><path d=\"M14 5v14\"/><path d=\"M17.5 5v14\"/><path d=\"M21 5v14\"/></svg>";
+    readonly "qr-code": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><rect x=\"3\" y=\"3\" width=\"7\" height=\"7\" rx=\"1\"/><rect x=\"14\" y=\"3\" width=\"7\" height=\"7\" rx=\"1\"/><rect x=\"3\" y=\"14\" width=\"7\" height=\"7\" rx=\"1\"/><path d=\"M14 14h3v3h-3z\"/><path d=\"M20 14h1\"/><path d=\"M14 20h1\"/><path d=\"M20 17v4\"/><path d=\"M17 20h4\"/></svg>";
+    readonly gift: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M20 12v9a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1v-9\"/><rect x=\"2\" y=\"7\" width=\"20\" height=\"5\" rx=\"1\"/><path d=\"M12 22V7\"/><path d=\"M12 7H7.5a2.5 2.5 0 0 1 0-5C11 2 12 7 12 7z\"/><path d=\"M12 7h4.5a2.5 2.5 0 0 0 0-5C13 2 12 7 12 7z\"/></svg>";
+    readonly "credit-card": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><rect x=\"2\" y=\"5\" width=\"20\" height=\"14\" rx=\"2\"/><path d=\"M2 10h20\"/></svg>";
+    readonly wallet: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M20 12V7H5a2 2 0 0 1 0-4h13a1 1 0 0 1 1 1v3\"/><path d=\"M3 5v14a2 2 0 0 0 2 2h15a1 1 0 0 0 1-1v-4\"/><path d=\"M18 12a2 2 0 0 0 0 4h4v-4z\"/></svg>";
+    readonly receipt: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M4 2v20l2.5-1.5L9 22l2.5-1.5L14 22l2.5-1.5L19 22l1-1V2l-2.5 1.5L15 2l-2.5 1.5L10 2 7.5 3.5 5 2z\"/><path d=\"M8 8h8\"/><path d=\"M8 12h8\"/><path d=\"M8 16h5\"/></svg>";
+    readonly coins: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><circle cx=\"8\" cy=\"8\" r=\"6\"/><path d=\"M18.09 10.37A6 6 0 1 1 10.34 18\"/><path d=\"M7 6h1v4\"/><path d=\"m16.71 13.88.7.71-2.82 2.82\"/></svg>";
+    readonly banknote: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><rect x=\"2\" y=\"6\" width=\"20\" height=\"12\" rx=\"2\"/><circle cx=\"12\" cy=\"12\" r=\"2\"/><path d=\"M6 12h.01\"/><path d=\"M18 12h.01\"/></svg>";
+    readonly percent: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M19 5 5 19\"/><circle cx=\"6.5\" cy=\"6.5\" r=\"2.5\"/><circle cx=\"17.5\" cy=\"17.5\" r=\"2.5\"/></svg>";
+    readonly truck: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M14 18V6a1 1 0 0 0-1-1H2a1 1 0 0 0-1 1v11a1 1 0 0 0 1 1h1\"/><path d=\"M14 9h4l3 3v5a1 1 0 0 1-1 1h-1\"/><circle cx=\"6\" cy=\"18\" r=\"2\"/><circle cx=\"17\" cy=\"18\" r=\"2\"/><path d=\"M8 18h6\"/></svg>";
+    readonly store: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M4 9.5V20a1 1 0 0 0 1 1h14a1 1 0 0 0 1-1V9.5\"/><path d=\"M2 9.5 3.6 4a1 1 0 0 1 1-.75h14.8a1 1 0 0 1 1 .75L22 9.5a3 3 0 0 1-6 0 3 3 0 0 1-6 0 3 3 0 0 1-6 0z\"/><path d=\"M9 21v-5a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v5\"/></svg>";
+    readonly warehouse: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M22 8.35V20a1 1 0 0 1-1 1H3a1 1 0 0 1-1-1V8.35a2 2 0 0 1 1.26-1.86l8-3.2a2 2 0 0 1 1.48 0l8 3.2A2 2 0 0 1 22 8.35z\"/><path d=\"M6 10h12\"/><path d=\"M6 14h12\"/><path d=\"M6 18h12\"/></svg>";
+    readonly "map-pin": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M21 10c0 7-9 13-9 13s-9-6-9-13a9 9 0 0 1 18 0z\"/><circle cx=\"12\" cy=\"10\" r=\"3\"/></svg>";
+    readonly "package-return": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M9 14 4 9l5-5\"/><path d=\"M4 9h11a5 5 0 0 1 5 5v0a5 5 0 0 1-5 5h-4\"/></svg>";
     readonly absence: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.7\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M9.5 1.5 14.5 6.5M14.5 1.5 9.5 6.5\"/><path d=\"M9 11v-1a4 4 0 0 1 6 0v1\"/><rect x=\"2.5\" y=\"11\" width=\"19\" height=\"2.6\" rx=\"0.7\"/><path d=\"M4.5 13.6V22M19.5 13.6V22\"/><path d=\"M7.5 16.6h9M8.5 16.6V22M15.5 16.6V22\"/></svg>";
     readonly bell: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M18 8A6 6 0 0 0 6 8c0 7-3 9-3 9h18s-3-2-3-9\"/><path d=\"M13.73 21a2 2 0 0 1-3.46 0\"/></svg>";
     readonly company: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.7\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><rect x=\"3\" y=\"7\" width=\"18\" height=\"14\" rx=\"2\"/><path d=\"M8 7V5a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2M3 13h18\"/></svg>";
@@ -597,6 +633,44 @@ declare const FOLD_BUILTIN_ICONS: {
     readonly view: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\"><path d=\"m23.705,18.549c-.896-1.325-2.959-3.549-6.705-3.549s-5.81,2.224-6.705,3.549c-.391.577-.392,1.323,0,1.902.896,1.325,2.96,3.549,6.706,3.549s5.809-2.224,6.705-3.549c.391-.578.391-1.324,0-1.902Zm-6.705,2.951c-1.105,0-2-.895-2-2s.895-2,2-2,2,.895,2,2-.895,2-2,2Zm-8.362.072c-.852-1.262-.851-2.888.001-4.146,1.116-1.651,3.689-4.427,8.361-4.427,3.311,0,5.568,1.395,7,2.796V5c0-2.761-2.239-5-5-5H5C2.239,0,0,2.239,0,5v13c0,2.761,2.239,5,5,5h4.797c-.489-.506-.872-1.004-1.159-1.428Zm2.362-16.572h7c.552,0,1,.448,1,1s-.448,1-1,1h-7c-.552,0-1-.448-1-1s.448-1,1-1Zm0,5h7c.552,0,1,.448,1,1s-.448,1-1,1h-7c-.552,0-1-.448-1-1s.448-1,1-1Zm-4.5-5.5c.828,0,1.5.672,1.5,1.5s-.672,1.5-1.5,1.5-1.5-.672-1.5-1.5.672-1.5,1.5-1.5Zm0,5c.828,0,1.5.672,1.5,1.5s-.672,1.5-1.5,1.5-1.5-.672-1.5-1.5.672-1.5,1.5-1.5Zm0,8c-.828,0-1.5-.672-1.5-1.5s.672-1.5,1.5-1.5,1.5.672,1.5,1.5-.672,1.5-1.5,1.5Z\"/></svg>";
     readonly wrench: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.77-3.77a6 6 0 0 1-7.94 7.94l-6.91 6.91a2.12 2.12 0 0 1-3-3l6.91-6.91a6 6 0 0 1 7.94-7.94l-3.76 3.76z\"/></svg>";
 };
+/**
+ * The built-in catalogue grouped by category, in display order — the single
+ * source of truth for tooling that browses icons by theme (e.g. the
+ * `fold-icon-devtool`). Each source file owns its slice; this list only names
+ * and orders them. Host-registered icons are *not* here — they carry no
+ * built-in category, so tooling buckets them separately.
+ */
+declare const FOLD_BUILTIN_ICON_CATEGORIES: readonly [{
+    readonly id: "ui";
+    readonly label: "UI";
+    readonly names: string[];
+}, {
+    readonly id: "nav";
+    readonly label: "Navigation";
+    readonly names: string[];
+}, {
+    readonly id: "commerce";
+    readonly label: "Commerce";
+    readonly names: string[];
+}, {
+    readonly id: "music";
+    readonly label: "Music";
+    readonly names: string[];
+}, {
+    readonly id: "status";
+    readonly label: "Status";
+    readonly names: string[];
+}, {
+    readonly id: "people";
+    readonly label: "People";
+    readonly names: string[];
+}, {
+    readonly id: "brands";
+    readonly label: "Brands";
+    readonly names: string[];
+}];
+/** A built-in icon category id (`"ui"`, `"commerce"`, …). */
+type FoldIconCategoryId = (typeof FOLD_BUILTIN_ICON_CATEGORIES)[number]["id"];
 /** Every built-in icon name — derived from the registry keys (autocompletes). */
 type FoldBuiltinIconName = keyof typeof FOLD_BUILTIN_ICONS;
 /**
@@ -756,6 +830,68 @@ declare class FoldButtonComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldButtonComponent, "button[foldButton], a[foldButton]", never, { "emphasis": { "alias": "emphasis"; "required": false; "isSignal": true; }; "intent": { "alias": "intent"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "block": { "alias": "block"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconTrailing": { "alias": "iconTrailing"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
+/**
+ * `<fold-danger-zone>` — the framed region for **destructive** actions on a
+ * settings page (delete an entity, close an account). A title, a projected
+ * explanation, and an optional guarded action.
+ *
+ * **Two appearances:**
+ * - `filled` (default) — the whole block is alert-tinted; a compact "delete X"
+ *   region (e.g. at the foot of a panel).
+ * - `section` — a **danger *section***: an alert-bordered card with a
+ *   **normal-background body**, so it can host ordinary content (rows,
+ *   descriptions, forms) with only the frame + heading signalling danger — the
+ *   GitHub "Danger Zone" look.
+ *
+ * **The confirm reveals on click.** The destructive control is a projected-free
+ * `actionLabel` button; activating it opens an in-place {@link
+ * FoldInlineConfirmComponent} — a simple "are you sure?", or (with
+ * `confirmPhrase`) a type-to-confirm field that must be retyped before the action
+ * arms. The input is never shown until the button is clicked. `(confirmed)` fires
+ * with the typed text (or `""`). Omit `actionLabel` for a framed danger section
+ * with no action of its own.
+ *
+ * ```html
+ * <fold-danger-zone
+ *   appearance="section"
+ *   title="Delete workspace"
+ *   actionLabel="Delete workspace"
+ *   [confirmPhrase]="workspace.name"
+ *   (confirmed)="delete()"
+ * >
+ *   <p>This permanently deletes the workspace and everything in it. It cannot be undone.</p>
+ * </fold-danger-zone>
+ * ```
+ *
+ * @selector `fold-danger-zone`
+ */
+declare class FoldDangerZoneComponent {
+    private readonly ids;
+    /** The region heading — also its accessible name. */
+    readonly title: _angular_core.InputSignal<string>;
+    /**
+     * `filled` (alert-tinted block) or `section` (alert-bordered card with a
+     * normal-background body — the danger *section*). @default 'filled'
+     */
+    readonly appearance: _angular_core.InputSignal<"section" | "filled">;
+    /** The destructive button's label. Omit for a framed danger section with no
+     *  action of its own. */
+    readonly actionLabel: _angular_core.InputSignal<string | undefined>;
+    /** The exact phrase the user must retype to arm the action (type-to-confirm).
+     *  Omit for a plain "are you sure?" reveal. */
+    readonly confirmPhrase: _angular_core.InputSignal<string | undefined>;
+    /** An optional warning shown above the confirm row when the action opens. */
+    readonly message: _angular_core.InputSignal<string | undefined>;
+    /** Colour of the destructive button. @default 'danger' */
+    readonly intent: _angular_core.InputSignal<FoldButtonIntent>;
+    /** Fires when the user confirms — carries the typed phrase (or `""`). */
+    readonly confirmed: _angular_core.OutputEmitterRef<string>;
+    /** Stable id the host's `aria-labelledby` points at. */
+    protected readonly titleId: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldDangerZoneComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldDangerZoneComponent, "fold-danger-zone", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "actionLabel": { "alias": "actionLabel"; "required": false; "isSignal": true; }; "confirmPhrase": { "alias": "confirmPhrase"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "intent": { "alias": "intent"; "required": false; "isSignal": true; }; }, { "confirmed": "confirmed"; }, never, ["*"], true, never>;
+}
+
 /** Surface shape of a `fold-button-icon`. */
 type FoldButtonIconShape = "square" | "round";
 /** Hit-area preset — `xs` 22px · `sm` 28px · `md` 32px · `lg` 38px. */
@@ -1739,7 +1875,7 @@ declare class FoldNavTileComponent {
     /** The label under the icon (also the accessible name of the control). */
     readonly label: _angular_core.InputSignal<string>;
     /** `"surface"` (default, subtle raised) or `"filled"` (solid brand fill). */
-    readonly variant: _angular_core.InputSignal<"surface" | "filled">;
+    readonly variant: _angular_core.InputSignal<"filled" | "surface">;
     /** Lights the active indicator — the current destination. */
     readonly active: _angular_core.InputSignalWithTransform<boolean, unknown>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldNavTileComponent, never>;
@@ -2103,232 +2239,1756 @@ declare class FoldStickyColumnDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FoldStickyColumnDirective, "[foldStickyColumn]", never, { "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "stickyOffset": { "alias": "stickyOffset"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-type FoldChoiceOption = {
-    key: string;
-    label: string;
-    /** Optional trailing count badge (e.g. how many rows match this filter). */
-    count?: number;
-};
 /**
- * `<fold-choice-row>` — a horizontal single-select control.
+ * Plain-date arithmetic for the calendar family — `YYYY-MM-DD` in, `YYYY-MM-DD`
+ * out. Framework-free and side-effect-free, so every rule here is unit-testable
+ * without a TestBed.
+ *
+ * ## Why a string and not a `Date`
+ * A calendar of all-day spans deals in **plain dates** — "the 18th of May",
+ * with no instant and no zone. A `Date` is a timestamp, so the moment one
+ * crosses a zone or a DST boundary the same span lands on a different cell:
+ * `new Date("2026-05-18")` is UTC midnight, which is the *17th* anywhere west
+ * of Greenwich. Modelling the domain as `YYYY-MM-DD` removes that entire bug
+ * class by construction, and buys three things for free: values compare
+ * **lexicographically** (`a <= b` *is* "on or before"), they are `===`-equal
+ * when they mean the same day (a `Date` never is), and they are already the
+ * wire format every backend sends.
+ *
+ * {@link FoldTimelineNode} keeps a native `Date` on purpose — it plots dated
+ * *instants* on a rail, which is the other domain.
+ *
+ * Arithmetic runs through `Date.UTC`, never local time: UTC has no DST, so a
+ * day is always exactly 86 400 000 ms and "add 1 day" can never silently
+ * return the same date twice (or skip one) around a clock change.
+ *
+ * ## Supported range
+ * `0001-01-01` to `9999-12-31`. The four-digit year is what makes the
+ * lexicographic guarantee hold, so it is enforced rather than assumed: years
+ * below 1000 are zero-padded (`0099-12-31`, which still sorts correctly), and
+ * arithmetic that walks past `9999-12-31` returns a five-digit string that
+ * {@link foldIsCalendarDate} rejects — a value that fails the type's own
+ * predicate rather than one that silently sorts before every other date.
+ */
+/**
+ * A plain calendar date — an ISO-8601 **date**, `YYYY-MM-DD`, with no time and
+ * no zone. Inclusive wherever it bounds a range.
  *
- * One row, one active option, emits the chosen `key`; the parent owns the
- * state and feeds it back via `activeKey`. Two layouts:
+ * A plain `string` alias, deliberately: it is the wire format, so a value read
+ * from an API or a `<input type="date">` has to flow in without a cast.
+ * {@link foldIsCalendarDate} is the runtime guard, and every component that
+ * takes one runs it in dev mode.
+ */
+type FoldCalendarDate = string;
+/** A day of the week, as the anchor a calendar's weeks start on. */
+type FoldWeekday = "mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun";
+/**
+ * The days a calendar shades as the weekend by default. A separate fact from
+ * the week's anchor day: a Sunday-first calendar still rests on Sat/Sun, and a
+ * Saturday-first one (much of the Middle East) rests on Fri/Sat while starting
+ * on Saturday — which is why the two are different inputs, not one derived
+ * from the other.
+ */
+declare const FOLD_DEFAULT_WEEKEND_DAYS: readonly ["sat", "sun"];
+/**
+ * Whether `value` is a well-formed **and real** plain date. Catches both a
+ * malformed shape (`"2026-5-1"`) and an impossible day (`"2026-02-30"`), the
+ * latter by round-tripping through UTC and checking the parts survived.
+ */
+declare function foldIsCalendarDate(value: string): boolean;
+/**
+ * Today, read from the **local** clock — the day the user believes it is,
+ * which is what a calendar highlights. Pass `now` to pin it (tests, a
+ * workspace clock).
+ */
+declare function foldToday(now?: Date): FoldCalendarDate;
+/**
+ * A native `Date` read as the plain date it shows on a **local** clock — the
+ * inbound bridge, and the one conversion every consumer would otherwise write
+ * by hand as `date.toISOString().slice(0, 10)`, which is UTC and therefore off
+ * by a day for anyone west of Greenwich after 6pm. That is the exact bug this
+ * whole module exists to remove, so the correct form ships with it.
  *
- * - `segmented` (default) — equal-width buttons that fill the row, no wrap.
- *   The right shape for a small mode/segment toggle (2–4 options).
- * - `chips` — auto-width rounded chips that wrap. The right shape for a
- *   status/category filter above a table or list.
+ * Pair with {@link foldToNativeDate} for the way out.
+ */
+declare function foldFromNativeDate(date: Date): FoldCalendarDate;
+/** `date` shifted by `days` (negative moves back). */
+declare function foldAddDays(date: FoldCalendarDate, days: number): FoldCalendarDate;
+/**
+ * Whole days from `from` to `to` — signed, and **exclusive** (same day → `0`),
+ * so a span's length is `foldDaysBetween(start, end) + 1`.
+ */
+declare function foldDaysBetween(from: FoldCalendarDate, to: FoldCalendarDate): number;
+/**
+ * `date` shifted by `months`, clamping the day to the target month's length so
+ * the result is always a real date (31 Jan + 1 month → 28/29 Feb, never 3 Mar).
+ */
+declare function foldAddMonths(date: FoldCalendarDate, months: number): FoldCalendarDate;
+/** The first day of `date`'s month. */
+declare function foldStartOfMonth(date: FoldCalendarDate): FoldCalendarDate;
+/** The last day of `date`'s month (28–31, leap years included). */
+declare function foldEndOfMonth(date: FoldCalendarDate): FoldCalendarDate;
+/**
+ * The start of the week `date` falls in, for a calendar anchored on
+ * `weekStartsOn`. Anchor-agnostic: a Monday-first and a Sunday-first calendar
+ * ask the same question and get their own answer.
+ */
+declare function foldStartOfWeek(date: FoldCalendarDate, weekStartsOn?: FoldWeekday): FoldCalendarDate;
+/**
+ * `date`'s position in its week, `0` on the anchor day — the column a day
+ * occupies in a 7-wide grid.
+ */
+declare function foldWeekdayIndex(date: FoldCalendarDate, weekStartsOn?: FoldWeekday): number;
+/**
+ * The ISO-8601 week number `date` falls in, `1`–`53`.
  *
- * @selector `fold-choice-row`
+ * ISO weeks always start on Monday and belong to the year holding their
+ * **Thursday**, which is why 1 January is sometimes week 52 of the year before
+ * — the rule European B2B reporting runs on, and the reason this cannot be
+ * derived from the calendar's own `weekStartsOn`.
+ */
+declare function foldIsoWeek(date: FoldCalendarDate): number;
+/** The ISO week-numbering year of `date` — not always its calendar year. */
+declare function foldIsoWeekYear(date: FoldCalendarDate): number;
+/** Which day of the week `date` falls on, anchor-independent. */
+declare function foldWeekdayOf(date: FoldCalendarDate): FoldWeekday;
+/**
+ * Whether `date` is one of the days a calendar shades as the weekend.
  *
- * @example
- * ```html
- * <fold-choice-row
- *   [options]="[{ key: 'manager', label: 'Manager' }, { key: 'member', label: 'Member' }]"
- *   [activeKey]="role()"
- *   (selected)="role.set($event)"
- * />
+ * Takes the weekend **as data**, because it is not derivable from the week's
+ * anchor: the two are independent locale facts. Deriving it — "the last two
+ * columns" — shades Friday and Saturday on a Sunday-first calendar and calls
+ * Sunday a working day, which is wrong everywhere it is used.
  *
- * <fold-choice-row
- *   layout="chips"
- *   [options]="statuses"
- *   [activeKey]="status()"
- *   ariaLabel="Filter by status"
- *   (selected)="setStatus($event)"
- * />
- * ```
+ * @default FOLD_DEFAULT_WEEKEND_DAYS (`['sat', 'sun']`)
  */
-declare class FoldChoiceRowComponent {
-    /** The selectable options, in display order. */
-    readonly options: _angular_core.InputSignal<readonly FoldChoiceOption[]>;
-    /** The `key` of the currently selected option. */
-    readonly activeKey: _angular_core.InputSignal<string>;
-    /** `segmented` (equal-width, default) or `chips` (auto-width, wraps). */
-    readonly layout: _angular_core.InputSignal<"segmented" | "chips">;
-    /** Accessible label for the group. */
-    readonly ariaLabel: _angular_core.InputSignal<string>;
-    /** Emits the `key` of the clicked option. */
-    readonly selected: _angular_core.OutputEmitterRef<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldChoiceRowComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldChoiceRowComponent, "fold-choice-row", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "activeKey": { "alias": "activeKey"; "required": true; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, never, never, true, never>;
+declare function foldIsWeekend(date: FoldCalendarDate, weekendDays?: readonly FoldWeekday[]): boolean;
+/**
+ * Anything whose `toString()` opens with an ISO date — `Temporal.PlainDate`,
+ * `PlainDateTime` and `ZonedDateTime` all do, and so does a plain string.
+ *
+ * Typed structurally on purpose: the package takes no dependency on `Temporal`
+ * and works whether or not the runtime has it.
+ */
+interface FoldIsoDateLike {
+    toString(): string;
 }
-
 /**
- * The design tokens, as a typed source-of-truth.
+ * A `Temporal` value read as the plain date it starts with.
  *
- * These lists are the CONTRACT. The token contract test asserts that the CSS
- * declares exactly these tokens — for colours, that the `:root` (dark) and
- * `[data-theme="lumen"]` blocks each declare exactly the colour set (parity);
- * for scales, that `scales.css` declares exactly the radius/type steps. Add a
- * token here and to the CSS in the same change, or the test fails. That is how
- * the theme stays complete and drift-free.
+ * `Temporal.PlainDate.toString()` **is** `YYYY-MM-DD` — the primitive this
+ * module chose for correctness turns out to be exactly Temporal-shaped, which
+ * no `Date`-based calendar can say. Going the other way needs no helper at all:
+ * `Temporal.PlainDate.from(foldDate)` already accepts one of ours.
  *
- * They also power typed `fold*Var` helpers so call sites get autocomplete and a
- * compile error on a misspelt token.
+ * A `PlainDateTime` or a `ZonedDateTime` drops its time here, which is the
+ * point — this family plots whole days, and the day you mean is the one in the
+ * value's own calendar and zone, not the one UTC would have given you.
+ *
+ * Returns `""` for anything that is not an ISO date, so a bad value fails
+ * {@link foldIsCalendarDate} rather than silently rendering the wrong month.
  */
-declare const FOLD_SEMANTIC_COLOR_TOKENS: readonly ["bg-page", "bg-header", "bg-rail-primary", "bg-rail-secondary", "bg-rail-tertiary", "primary", "primary-strong", "on-primary", "primary-text", "primary-surface", "primary-border", "info", "info-text", "info-surface", "info-border", "warning", "warning-text", "warning-surface", "warning-border", "alert", "alert-text", "alert-surface", "alert-border", "success", "success-text", "success-surface", "success-border", "text", "text-secondary", "text-muted", "text-faded", "surface-card", "surface-sunken", "surface-subtle", "surface-raised", "surface-hover", "border", "border-subtle", "glass", "glass-border", "scrim"];
-type FoldSemanticColorToken = (typeof FOLD_SEMANTIC_COLOR_TOKENS)[number];
-/** Border-radius scale. `lg` is a real large radius; `pill` is the capsule. */
-declare const FOLD_RADIUS_TOKENS: readonly ["xs", "sm", "md", "lg", "pill", "round"];
-type FoldRadiusToken = (typeof FOLD_RADIUS_TOKENS)[number];
-/** Type (font-size) scale. */
-declare const FOLD_TEXT_TOKENS: readonly ["xs", "sm", "md", "lg", "xl"];
-type FoldTextToken = (typeof FOLD_TEXT_TOKENS)[number];
-/** Icon-size scale — the length a `fold-icon` renders at, per size preset. */
-declare const FOLD_ICON_SIZE_TOKENS: readonly ["xs", "sm", "md", "lg", "xl"];
-type FoldIconSizeToken = (typeof FOLD_ICON_SIZE_TOKENS)[number];
-/** Space (gap / padding / margin) scale. */
-declare const FOLD_SPACE_TOKENS: readonly ["xs", "sm", "md", "lg", "xl", "2xl", "3xl", "4xl", "5xl"];
-type FoldSpaceToken = (typeof FOLD_SPACE_TOKENS)[number];
-/** Motion scale — `transition` shorthands (duration + easing). */
-declare const FOLD_MOTION_TOKENS: readonly ["fast", "base", "slow"];
-type FoldMotionToken = (typeof FOLD_MOTION_TOKENS)[number];
-/** Backdrop-blur radii (`--fold-blur-*`). */
-declare const FOLD_BLUR_TOKENS: readonly ["glass"];
-type FoldBlurToken = (typeof FOLD_BLUR_TOKENS)[number];
+declare function foldFromTemporal(value: FoldIsoDateLike): FoldCalendarDate;
 /**
- * Elevation scale — full `box-shadow` values. The shared depth language: a
- * component never spells its own shadow, it names a level. Theme-invariant
- * (black ink via `color-mix`, which reads acceptably on both themes), so they
- * live with the scales. `panel-*` are the directional side-panel shadows.
+ * A `Date` at **UTC midnight** of `date` — the bridge to `Intl.DateTimeFormat`
+ * for month and weekday names. Format it with `timeZone: "UTC"`, or the local
+ * zone will shift the label back a day west of Greenwich.
  */
-declare const FOLD_SHADOW_TOKENS: readonly ["sm", "md", "lg", "panel-right", "panel-left"];
-type FoldShadowToken = (typeof FOLD_SHADOW_TOKENS)[number];
-/** The full custom-property name for a semantic colour token. */
-declare function foldColorProperty(token: FoldSemanticColorToken): string;
-/** A ready-to-use `var(--fold-color-…)` reference for a semantic colour token. */
-declare function foldColorVar(token: FoldSemanticColorToken): string;
-/** A ready-to-use `var(--fold-radius-…)` reference. */
-declare function foldRadiusVar(token: FoldRadiusToken): string;
-/** A ready-to-use `var(--fold-text-…)` reference. */
-declare function foldTextVar(token: FoldTextToken): string;
-/** A ready-to-use `var(--fold-space-…)` reference. */
-declare function foldSpaceVar(token: FoldSpaceToken): string;
-/** A ready-to-use `var(--fold-motion-…)` reference. */
-declare function foldMotionVar(token: FoldMotionToken): string;
-/** A ready-to-use `var(--fold-blur-…)` reference. */
-declare function foldBlurVar(token: FoldBlurToken): string;
-/** A ready-to-use `var(--fold-shadow-…)` reference. */
-declare function foldShadowVar(token: FoldShadowToken): string;
+declare function foldToNativeDate(date: FoldCalendarDate): Date;
 
-/** Spinner size — an icon-size token (`xs…xl`) or an explicit pixel number. */
-type FoldSpinnerSize = FoldIconSizeToken | number;
 /**
- * `fold-spinner` — an indeterminate loading indicator: a rotating arc drawn in
- * `currentColor`, sized off the same scale as `fold-icon` so it drops into a
- * button in place of its glyph without shifting layout.
- *
- * Give it a `label` when it stands alone (it becomes `role="status"` +
- * `aria-label`, so assistive tech announces the wait). Leave `label` unset when
- * it lives inside something that already announces busy-ness (a button with
- * `aria-busy`) — it then renders `aria-hidden`, purely decorative.
- *
- * Honours `prefers-reduced-motion`: the rotation stops and a fuller static ring
- * is shown instead, so the indicator still reads as "busy" without animating.
- *
- * @selector `fold-spinner`
+ * Wall-clock time for the time grid — `HH:mm`, 24-hour, **no zone**.
+ *
+ * ## Why not an instant
+ * The same decision as the date, for the same reason. A meeting at 09:00 is at
+ * 09:00 on the wall the person is looking at; storing it as an instant means
+ * every render re-derives that wall time from a zone, and the moment the zone
+ * is wrong — a server default, a user travelling, a DST edge — the grid draws
+ * the wrong hour. `"09:00"` cannot be wrong about which hour it means.
+ *
+ * The zone is the **app's** boundary, exactly like the date: convert once on
+ * the way in ({@link foldFromTemporal} takes a `ZonedDateTime` and drops it to
+ * the day and, here, the caller reads its `.hour`/`.minute`), and the calendar
+ * never has to know.
+ *
+ * Times compare **lexicographically** like the dates do — `"09:00" < "14:30"` —
+ * which is what makes overlap detection a string comparison rather than a
+ * parse. `24:00` is legal and means the end of the day, so a span that runs to
+ * midnight has an end greater than its start.
+ */
+/** A wall-clock time, `HH:mm`, `00:00`–`24:00`. */
+type FoldCalendarTime = string;
+/** Minutes in a day — the grid's own unit. */
+declare const FOLD_MINUTES_PER_DAY = 1440;
+/**
+ * Whether `value` is a well-formed **and real** wall-clock time.
  *
- * @example
- * ```html
- * <fold-spinner label="Loading contracts" />
- * <fold-spinner size="sm" />           <!-- decorative, inside a busy control -->
- * <fold-spinner [size]="18" />
- * ```
+ * The shape check is not enough on its own: `"10:75"` and `"23:60"` both match
+ * `HH:mm` and both sit under 1440 minutes, so a range check on the total would
+ * wave them through. The fields are validated separately — minutes `00`–`59`,
+ * hours `00`–`23`, plus the single `24:00` that means the end of the day — the
+ * same rigour {@link foldIsCalendarDate} applies to `2026-02-30`.
  */
-declare class FoldSpinnerComponent {
-    /** Size — an icon-size token (`xs…xl`, default `md`) or a pixel number. */
-    readonly size: _angular_core.InputSignal<FoldSpinnerSize>;
-    /** Accessible label. Set → `role="status"` + `aria-label`; unset → decorative. */
-    readonly label: _angular_core.InputSignal<string | undefined>;
-    /** Resolves the size to a CSS length for `--fold-spinner-size`. */
-    readonly sizeVar: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldSpinnerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldSpinnerComponent, "fold-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
+declare function foldIsCalendarTime(value: string): boolean;
+/** Minutes since midnight — the number the grid positions on. */
+declare function foldToMinutes(time: FoldCalendarTime): number;
+/** Minutes since midnight back to `HH:mm`, clamped to the day. */
+declare function foldFromMinutes(minutes: number): FoldCalendarTime;
+/** `time` shifted by `minutes`, clamped to the day rather than wrapping. */
+declare function foldAddMinutes(time: FoldCalendarTime, minutes: number): FoldCalendarTime;
 
 /**
- * Generates unique, SSR-safe element ids.
- *
- * A per-injector counter (`providedIn: 'root'` → one instance per application,
- * and a fresh one per request on the server) so the sequence is deterministic
- * in render order and therefore matches between server and client. That's the
- * point: `crypto.randomUUID()` returns a different value on the server than on
- * the client for the same element, which trips Angular hydration; a counter
- * reset per request does not, and can't collide across requests or grow
- * unbounded.
- *
- * Used by the labelled controls that own their id ({@link FoldInputComponent},
- * `fold-select`) and by {@link FoldFieldIdDirective} for loose native controls.
+ * Every date format the calendar family renders, in one table.
+ *
+ * They used to be five components' worth of inline `Intl.DateTimeFormat`
+ * option bags — which is how the day view ended up asking for
+ * `{ weekday: 'long', month: 'long' }` and printing "Saturday May", a phrase in
+ * no locale. Side by side they can be read against each other, and a consumer
+ * can see what a locale is actually asked for.
+ *
+ * `timeZone: 'UTC'` is not optional: a plain date is bridged to `Date` at UTC
+ * midnight, so formatting it in the local zone would print the day before for
+ * anyone west of Greenwich.
+ *
+ * `calendar: 'gregory'` is pinned for the same reason `timeZone` is: the grid
+ * counts days and groups months in the Gregorian calendar (that is what a
+ * `YYYY-MM-DD` string *is*), so the names beside those numbers must be Gregorian
+ * too. Left to the locale's own default, `ar-SA` would print Hijri month names
+ * over Gregorian day numbers on rows that break on Gregorian months — a
+ * calendar contradicting itself. The family is Gregorian, localised into the
+ * language of the locale, not into its calendar system; a non-Gregorian layout
+ * is a separate widget this one does not pretend to be.
  */
-declare class FoldIdService {
-    private counter;
-    /**
-     * The next unique id, e.g. `fold-input-3`.
-     * @param prefix a short, human-readable namespace for the id.
-     */
-    next(prefix?: string): string;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldIdService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FoldIdService>;
-}
+declare const FOLD_CALENDAR_FORMATS: {
+    /** Whole date, spelled out — accessible names. */
+    readonly dateFull: {
+        readonly dateStyle: "long";
+    };
+    /** Whole date **with its weekday** — a period title, where it is the heading. */
+    readonly dateFullWeekday: {
+        readonly dateStyle: "full";
+    };
+    /** `18 May 2026` — the ends of a week, which `formatRange` then joins. */
+    readonly dayMonthYear: {
+        readonly day: "numeric";
+        readonly month: "long";
+        readonly year: "numeric";
+    };
+    /** `Mon` — grid column headers. */
+    readonly weekdayShort: {
+        readonly weekday: "short";
+    };
+    /** `Monday` — a day heading, where there is room. */
+    readonly weekdayLong: {
+        readonly weekday: "long";
+    };
+    /** `May` — beside a day number, never on its own with a weekday. */
+    readonly monthLong: {
+        readonly month: "long";
+    };
+    /** `May` (abbreviated) — the agenda rail, where width is scarce. */
+    readonly monthShort: {
+        readonly month: "short";
+    };
+    /** `May 2026` — a period title. */
+    readonly monthYear: {
+        readonly month: "long";
+        readonly year: "numeric";
+    };
+    /** `18 May` — a span's ends, which `formatRange` then joins. */
+    readonly dayMonthShort: {
+        readonly day: "numeric";
+        readonly month: "short";
+    };
+    /** `09:00` in France, `9:00 AM` in the US — an hour down the grid's gutter. */
+    readonly hourMark: {
+        readonly hour: "numeric";
+        readonly minute: "2-digit";
+    };
+};
+/** A key of {@link FOLD_CALENDAR_FORMATS}. */
+type FoldCalendarFormat = keyof typeof FOLD_CALENDAR_FORMATS;
 
 /**
- * Auto-assigns a unique, SSR-safe `id` to any native form control (`<input>`,
- * `<select>`, `<textarea>`) that has neither an `id` nor a `name`.
- *
- * You don't write `foldFieldId` on elements — the directive **auto-applies** by
- * selector. Add it to a component's `imports` once and every unidentified native
- * control in that component's template is fixed in one go, with no per-element
- * edit. It silences the browser's *"A form field element should have an id or
- * name attribute"* warning (autofill + accessibility), and the id it sets can be
- * targeted by a `<label for>`.
+ * Every string the calendar renders that does not come from the caller's data.
  *
- * The selector matches only controls missing **both** `id` and `name` — static
- * or bound (`[id]`/`[attr.id]`/`[name]` all count as present) — so it never
- * fights a control you've already identified. Components that render their own
- * labelled control ({@link FoldInputComponent}, `fold-select`) own their id
- * explicitly and are unaffected.
+ * Month and weekday names are deliberately **absent**: they come from
+ * `Intl.DateTimeFormat` driven by the `locale` input, so a consumer gets all
+ * ~200 locales for free instead of hand-translating twelve month names. What
+ * remains here is the chrome — the words `Intl` cannot supply.
  */
-declare class FoldFieldIdDirective {
-    /** Assigned once at construction, in deterministic render order (SSR-safe). */
-    protected readonly autoId: string;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldFieldIdDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FoldFieldIdDirective, "input:not([id]):not([name]),select:not([id]):not([name]),textarea:not([id]):not([name])", never, {}, {}, never, never, true, never>;
+interface FoldCalendarLabels {
+    /** Accessible name of the grid itself. */
+    readonly grid: string;
+    /** Word marking the cell that is today, appended to its accessible name. */
+    readonly today: string;
+    /** The chip standing for events a week had no lane for. */
+    readonly moreEvents: (count: number) => string;
+    /**
+     * A count of events — announced on a day cell, and on a chip that collapses
+     * a group into one.
+     */
+    readonly eventCount: (count: number) => string;
+    /**
+     * Announced on a day cell that is showing fewer events than it holds — the
+     * lane budget is a visual limit, and a screen reader is told about it rather
+     * than silently given a smaller number.
+     */
+    readonly hiddenCount: (count: number) => string;
+    /** Label of the time grid's all-day strip. */
+    readonly allDay: string;
+    /** Accessible name of the time grid's scrollable hour area. */
+    readonly hours: string;
+    /** Header of the ISO week-number column — a symbol, not a sentence. */
+    readonly weekNumberShort: string;
+    /** Accessible reading of a week number, since the column header is a glyph. */
+    readonly weekNumber: (week: number) => string;
+    /** Shown by the day view when nothing sits on the day. */
+    readonly emptyDay: string;
+    /** Shown by the list view when the range holds nothing. */
+    readonly emptyRange: string;
+    /** The toolbar's jump-to-today button. */
+    readonly todayAction: string;
+    /** Accessible name of the toolbar's back control. */
+    readonly previousPeriod: string;
+    /** Accessible name of the toolbar's forward control. */
+    readonly nextPeriod: string;
+    /** Accessible name of the view switch. */
+    readonly viewSwitch: string;
+    /** The four view names, in the switch. */
+    readonly viewMonth: string;
+    readonly viewWeek: string;
+    readonly viewDay: string;
+    readonly viewList: string;
+    /** Accessible name of the agenda rail. */
+    readonly agenda: string;
+    /** Accessible name of the rail's slice switch — distinct from the rail itself. */
+    readonly agendaModes: string;
+    /** The agenda's two slices, in its own switch. */
+    readonly agendaTodo: string;
+    readonly agendaUpcoming: string;
+    /** Shown when the agenda's current slice is clear. */
+    readonly agendaEmptyTodo: string;
+    readonly agendaEmptyUpcoming: string;
+    /** Shown when `limit` stopped the rail short of what is actually ahead. */
+    readonly agendaMore: (days: number) => string;
+    /** Relative day names the agenda prefers over a date. */
+    readonly relativeToday: string;
+    readonly relativeTomorrow: string;
+    /** Accessible names of the rail's collapse control, in each state. */
+    readonly collapse: string;
+    readonly expand: string;
+    /** Accessible name of the source filter. */
+    readonly sourceFilter: string;
+    /** Reading of a source's state, e.g. `("Absences", true) => "Absences, shown"`. */
+    readonly sourceState: (label: string, shown: boolean) => string;
 }
+/** The English defaults — the base every override merges onto. */
+declare const FOLD_CALENDAR_DEFAULT_LABELS: FoldCalendarLabels;
+/** App-wide calendar labels; defaults to English. */
+declare const FOLD_CALENDAR_LABELS: InjectionToken<FoldCalendarLabels>;
+/** Provide calendar labels for the whole app, merged over the English defaults. */
+declare function provideFoldCalendarLabels(labels: Partial<FoldCalendarLabels>): Provider;
 
 /**
- * `[foldRepeatPress]` — press-and-hold auto-repeat.
- *
- * Fires `(foldRepeatPress)` once immediately on pointer press, then keeps firing
- * on a fixed cadence while the pointer is held, stopping on release, leave,
- * cancel or destroy. Bind `[foldRepeatPressDisabled]` to a reactive bound (e.g.
- * "at max") so the repeat also stops the instant the action becomes unavailable
- * mid-hold — a plain `pointerup` is unreliable once the host button disables
- * itself under the finger.
+ * The three things every calendar view needs and none of them is about: its
+ * labels, its locale, and the chip template a consumer may have projected.
  *
- * Keyboard activation is intentionally out of scope: it produces `click`, not
- * `pointerdown`, so wire a separate `(click)` handler for Enter/Space.
+ * Applied through `hostDirectives`, so `locale` and `labels` are still ordinary
+ * inputs on `<fold-calendar-month>`, `<fold-calendar-week>` and the rest — the
+ * consumer sees no difference, and the five views stop carrying five identical
+ * copies of the same eight lines.
  *
- * @selector `[foldRepeatPress]`
+ * Internal — a view exposes it, it is never applied by hand.
  *
  * @example
- * ```html
- * <button
- *   foldRepeatPress
- *   [foldRepeatPressDisabled]="atMax()"
- *   (foldRepeatPress)="step(1)"
- * >+</button>
+ * ```ts
+ * @Component({
+ *   hostDirectives: [
+ *     { directive: FoldCalendarChromeDirective, inputs: ['locale', 'labels'] },
+ *   ],
+ * })
+ * export class FoldCalendarWeekComponent<T = unknown> {
+ *   protected readonly chrome = inject(FoldCalendarChromeDirective);
+ * }
  * ```
  */
-declare class FoldRepeatPressDirective {
-    /** Fires immediately on press, then repeatedly while the pointer is held. */
-    readonly repeat: _angular_core.OutputEmitterRef<void>;
-    /** When true, a press does nothing and any running repeat stops at once. */
-    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Delay before the auto-repeat begins, in ms. @default 350 */
-    readonly delay: _angular_core.InputSignal<number>;
-    /** Cadence of the auto-repeat once started, in ms. @default 60 */
-    readonly period: _angular_core.InputSignal<number>;
+declare class FoldCalendarChromeDirective {
+    /** BCP-47 tag driving every `Intl` name; omitted, the runtime default. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /** Per-instance label overrides, merged over the app-wide (or English) set. */
+    readonly labels: _angular_core.InputSignal<Partial<FoldCalendarLabels> | undefined>;
+    /**
+     * Per-instance `Intl` option overrides, merged over
+     * {@link FOLD_CALENDAR_FORMATS}. Labels let a locale translate; this lets it
+     * **reformat** — a numeric weekday header, a four-digit year, a narrow month.
+     */
+    readonly formats: _angular_core.InputSignal<Partial<Record<"dateFull" | "dateFullWeekday" | "dayMonthYear" | "weekdayShort" | "weekdayLong" | "monthLong" | "monthShort" | "monthYear" | "dayMonthShort" | "hourMark", Intl.DateTimeFormatOptions>> | undefined>;
+    private readonly injectedLabels;
+    private readonly projectedEvent;
+    /** Effective labels — the app-wide (or English) set, with `labels` on top. */
+    readonly l: _angular_core.Signal<FoldCalendarLabels>;
+    /** The custom chip template, when one is projected. */
+    readonly eventContent: _angular_core.Signal<_angular_core.TemplateRef<fold_ng.FoldCalendarEventContext<any>> | null>;
+    /**
+     * What this locale says its week looks like — the default behind
+     * `weekStartsOn` and `weekendDays`, so a calendar is right in Cairo and
+     * Chicago without the caller having to know either.
+     */
+    readonly weekInfo: _angular_core.Signal<fold_ng.FoldWeekInfo>;
+    /** The anchor a view should use: the caller's, else the locale's. */
+    anchor(explicit: FoldWeekday | undefined): FoldWeekday;
+    /** The weekend a view should shade: the caller's, else the locale's. */
+    weekend(explicit: readonly FoldWeekday[] | undefined): readonly FoldWeekday[];
+    /** One date, in this view's locale and its format overrides. */
+    format(date: FoldCalendarDate, format: FoldCalendarFormat): string;
+    /** A wall-clock time, in this view's locale (24-hour, or AM/PM). */
+    formatTime(time: string): string;
+    /** A span, in this view's locale and its format overrides. */
+    formatRange(from: FoldCalendarDate, to: FoldCalendarDate, format: FoldCalendarFormat): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldCalendarChromeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FoldCalendarChromeDirective, never, never, { "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "formats": { "alias": "formats"; "required": false; "isSignal": true; }; }, {}, ["projectedEvent"], never, true, never>;
+}
+
+/**
+ * Public data model for the calendar family. The calendar knows nothing of the
+ * domain it plots — an app maps its own records onto {@link FoldCalendarEvent}
+ * and gets them back, still typed, on every output.
+ *
+ * That ignorance is the design, not a stage it will grow out of. The family
+ * **displays**; it never originates a record, because the validation and the
+ * write path both belong to the consumer. Which is also why `tone` is an input
+ * rather than something derived here: a band that turns amber and then red as
+ * an account sits unactivated, and a band that is amber because a leave request
+ * is pending, are the same component being told two different things.
+ */
+/**
+ * Semantic weight of an event, mapped to the shared tone roles. `muted` reads
+ * as struck-through and dimmed — the "it no longer counts" state (cancelled,
+ * withdrawn, superseded) rather than a quieter `neutral`.
+ */
+type FoldCalendarTone = "neutral" | "success" | "warning" | "alert" | "muted";
+/** Which half of a day an event's edge falls on. */
+type FoldCalendarHalfDay = "morning" | "afternoon";
+/**
+ * An entry on the calendar, spanning one or more whole days.
+ *
+ * Generic over `T` so `data` carries the app's own record through layout and
+ * back out of `eventClick` without a cast. Both bounds are **inclusive**: a
+ * single-day event has `start === end`.
+ */
+interface FoldCalendarEvent<T = unknown> {
+    /** Stable identity — also the layout key, so it must be unique per render. */
+    readonly id: string;
+    /** First day, inclusive. */
+    readonly start: FoldCalendarDate;
+    /** Last day, inclusive. Equal to {@link start} for a single-day event. */
+    readonly end: FoldCalendarDate;
+    /** Primary text on the chip. */
+    readonly label: string;
+    /** Secondary line — status, duration, venue. Rendered verbatim. */
+    readonly subline?: string;
+    /** Semantic weight. @default 'neutral' */
+    readonly tone?: FoldCalendarTone;
+    /** Leading glyph, drawn with `fold-icon`. */
+    readonly icon?: FoldIconName;
+    /**
+     * Wall-clock start, `HH:mm`. An event carrying **both** times is placed on
+     * the time grid's clock; anything else — neither, or only one — is an all-day
+     * span, which is what the month, week, day and list views plot. Half a time
+     * is a data bug, and reading it as all-day loses the least.
+     *
+     * No zone, by the same decision as the date: 09:00 is the hour on the wall,
+     * and the app converts once at its own boundary.
+     */
+    readonly startTime?: FoldCalendarTime;
+    /** Wall-clock end, `HH:mm`. `24:00` is midnight at the end of {@link end}. */
+    readonly endTime?: FoldCalendarTime;
+    /** Which half of {@link start} the event opens on. */
+    readonly startHalfDay?: FoldCalendarHalfDay;
+    /** Which half of {@link end} the event closes on. */
+    readonly endHalfDay?: FoldCalendarHalfDay;
+    /**
+     * Collapses events sharing this key into a single chip carrying a count —
+     * for a bulk action that would otherwise flood the grid (a whole team off on
+     * the same days).
+     *
+     * The chip covers the **union** of the members' ranges, and is open-ended if
+     * **any** member is. Everything else it renders (tone, icon, label, subline,
+     * `sourceKey`) comes from one real member: the most severe by tone
+     * (`alert` → `warning` → `success` → `neutral` → `muted`), ties going to
+     * document order. Picking one event rather than merging fields keeps the chip
+     * something that actually exists in the feed, and stops a first cancelled
+     * member from quietly greying out a group that contains an alert.
+     */
+    readonly groupId?: string;
+    /** Label for the collapsed chip; falls back to the representative's `label`. */
+    readonly groupLabel?: string;
+    /**
+     * The real range extends past {@link start} beyond what was loaded — the
+     * caller clamped it to the queried window. Renders the same open edge as a
+     * span continuing from an earlier week.
+     */
+    readonly openStart?: boolean;
+    /** As {@link openStart}, for an end with no known bound (an open contract). */
+    readonly openEnd?: boolean;
+    /**
+     * Which feed this came from — the key a {@link FoldCalendarSource} declares.
+     * A calendar usually merges several (a programme, staff leave, contracts),
+     * and this is what lets one be counted and switched off without the calendar
+     * knowing what any of them mean.
+     */
+    readonly sourceKey?: string;
+    /** The app's own record, handed back untouched on every output. */
+    readonly data?: T;
+}
+/** One feed of events, as the source filter lists it. */
+interface FoldCalendarSource {
+    /** Matches {@link FoldCalendarEvent.sourceKey}. */
+    readonly key: string;
+    /** Shown on the chip. */
+    readonly label: string;
+    /** Dot colour — the tone the feed reads as. @default 'neutral' */
+    readonly tone?: FoldCalendarTone;
+}
+/**
+ * One day cell of a grid — the calendar's answer to "what is this square",
+ * with every flag a view needs to style it already resolved.
+ */
+interface FoldCalendarDay {
+    /** The day this cell stands for. */
+    readonly date: FoldCalendarDate;
+    /** Day of the month, `1`–`31`, for the cell's number. */
+    readonly dayOfMonth: number;
+    /** Inside the month being displayed — `false` for the leading/trailing pad. */
+    readonly inMonth: boolean;
+    /** Matches the calendar's "today". */
+    readonly isToday: boolean;
+    /** Falls on one of the configured weekend days. */
+    readonly isWeekend: boolean;
+    /** How many events cover this day — already counted, so a view never refilters. */
+    readonly eventCount: number;
+    /**
+     * How many of them no lane could take, so this cell is showing fewer events
+     * than it has. Always `0` in the column views, which never drop anything.
+     */
+    readonly hiddenCount: number;
+}
+/**
+ * Extra class names for one day cell — the hook for anything the calendar
+ * cannot know: a public holiday, a closure, a blackout, "fully staffed". Each
+ * name is emitted as `data-fold-day-<name>` on the cell, so an app styles it
+ * from its own sheet without reaching for an internal class.
+ *
+ * @example
+ * ```ts
+ * readonly holidays = (day: FoldCalendarDay) =>
+ *   HOLIDAYS.has(day.date) ? ['holiday'] : [];
+ * ```
+ */
+type FoldCalendarDayModifiers = (day: FoldCalendarDay) => readonly string[];
+/**
+ * A laid-out slice of one event inside one week row: which columns it covers,
+ * which lane it sits in, and whether its edges are real or a continuation.
+ *
+ * An event spanning a week boundary produces one band per week — same event,
+ * different segment — which is why {@link key} exists alongside the event id.
+ */
+interface FoldCalendarBand<T = unknown> {
+    /** Unique per segment (`<eventId>@<weekStart>`) — the `@for` track key. */
+    readonly key: string;
+    /** The event this segment belongs to (the representative, when grouped). */
+    readonly event: FoldCalendarEvent<T>;
+    /** First column covered, `0`–`6`. */
+    readonly startColumn: number;
+    /** Last column covered, `0`–`6`, inclusive. */
+    readonly endColumn: number;
+    /** Row within the week's stack, `0`-based. */
+    readonly lane: number;
+    /** The span started before this week (or is open-ended) — draw an open edge. */
+    readonly continuesBefore: boolean;
+    /** The span continues after this week (or is open-ended). */
+    readonly continuesAfter: boolean;
+    /** Events collapsed into this band; `1` when it stands for itself. */
+    readonly groupSize: number;
+    /** Half-day edge, only when this segment carries the event's real start. */
+    readonly startHalfDay?: FoldCalendarHalfDay;
+    /** Half-day edge, only when this segment carries the event's real end. */
+    readonly endHalfDay?: FoldCalendarHalfDay;
+}
+/**
+ * A day with the events sitting on it — the render model of the column views
+ * (week, day), where chips stack in a list and need no lane packing.
+ */
+interface FoldCalendarDayEvents<T = unknown> {
+    readonly day: FoldCalendarDay;
+    /** Events covering {@link day}, in the caller's order. */
+    readonly events: readonly FoldCalendarEvent<T>[];
+}
+/** One row of a month grid: its seven days, the bands over them, and what did not fit. */
+interface FoldCalendarWeek<T = unknown> {
+    /** The week's anchor day — also the segment keys' discriminator. */
+    readonly start: FoldCalendarDate;
+    /** Seven cells, in column order. */
+    readonly days: readonly FoldCalendarDay[];
+    /** Placed bands, ordered by lane then column. */
+    readonly bands: readonly FoldCalendarBand<T>[];
+    /**
+     * Spans overlapping this week that no lane could take. What each *day* lost
+     * is on the day itself ({@link FoldCalendarDay.hiddenCount}) — a row-wide
+     * total says a week is crowded without saying which day to open.
+     */
+    readonly hiddenCount: number;
+}
+
+/**
+ * `<fold-calendar-month>` — a month grid where events span the days they cover.
+ *
+ * The grid is a **date axis**: seven columns of whole days, and over them a
+ * layer of bands, each stretching from the column its event starts on to the
+ * column it ends on. An event crossing a week boundary is drawn once per week
+ * with an open edge on the side that continues, so a three-week holiday reads
+ * as one thing rather than twenty-one chips.
+ *
+ * Dates are plain `YYYY-MM-DD` strings — see `calendar-date.ts` for why that,
+ * and not `Date`.
+ *
+ * ## Inputs
+ * | Input          | Type                          | Default       | Meaning |
+ * |----------------|-------------------------------|---------------|---------|
+ * | `month`        | `FoldCalendarDate`            | —             | **Two-way.** Any date in the month on display; keyboard paging writes back. |
+ * | `events`       | `FoldCalendarEvent<T>[]`      | `[]`          | What to plot. Anything outside the grid is ignored. |
+ * | `today`        | `FoldCalendarDate`            | —             | The day to mark. Omitted, nothing is marked — pass `foldToday()`. |
+ * | `weekStartsOn` | `FoldWeekday`                 | the locale's   | Which day opens the row — `Intl.Locale` knows, so it is only an override. |
+ * | `weekendDays`  | `FoldWeekday[]`               | the locale's   | Which days are shaded — a separate fact from the anchor, and also in the locale. |
+ * | `showWeekNumbers` | `boolean`                  | `false`       | An ISO week number in a leading column. |
+ * | `maxLanes`     | `number`                      | `3`           | Bands a week stacks before the rest collapse into overflow chips. |
+ * | `fixedWeeks`   | `boolean`                     | `false`       | Always six rows, so the grid keeps one height across months. |
+ * | `dayModifiers` | `(day) => string[]`           | —             | Extra names per cell, emitted as `data-fold-day-modifiers`. |
+ * | `locale`       | `string`                      | runtime       | Drives month/weekday names through `Intl`. |
+ * | `labels`       | `Partial<FoldCalendarLabels>` | —             | Per-instance overrides of the chrome strings. |
+ *
+ * ## Outputs
+ * | Output          | Payload                | Fires on |
+ * |-----------------|------------------------|----------|
+ * | `dayClick`      | `FoldCalendarDate`     | A day cell activated by click, `Enter` or `Space`. |
+ * | `eventClick`    | `FoldCalendarEvent<T>` | A band clicked. Grouped bands emit their representative. |
+ * | `overflowClick` | `FoldCalendarDate`     | A `+N` chip — the **day** whose events overflowed, so the caller knows which one to open. |
+ *
+ * ## Templates
+ * | Directive              | Replaces |
+ * |------------------------|----------|
+ * | `foldCalendarEvent`    | The inside of a band — icon + label + count. |
+ * | `foldCalendarDay`      | The inside of a day cell — the day number. |
+ * | `foldCalendarOverflow` | The `+N` chip. |
+ *
+ * ## Theming
+ * | CSS variable                          | Default | Sets |
+ * |---------------------------------------|---------|------|
+ * | `--fold-calendar-month-header-row`    | `30px`  | Height of the day-number row. |
+ * | `--fold-calendar-month-lane`          | `22px`  | Height of one band lane. |
+ * | `--fold-calendar-month-row-min-height`| `112px` | Minimum height of a week row. |
+ * | `--fold-calendar-month-daynum-size`   | `22px`  | The day number's round box. |
+ * | `--fold-calendar-month-cell-padding`  | `--fold-space-sm` | Padding inside a day cell. |
+ * | `--fold-calendar-month-week-number-width` | `34px` | The ISO week column, when shown. |
+ * | `--fold-calendar-bar-width`           | `3px`   | The tone bar down a band's leading edge. |
+ * | `--fold-calendar-band-radius`         | `--fold-radius-sm` | Band and chip corners. |
+ * | `--fold-calendar-band-gutter`         | `--fold-space-xs` | Gap between a band and its cell edge. |
+ *
+ * ## Accessibility
+ * The **date grid** is the ARIA structure: `role="grid"` over rows of
+ * `gridcell` days, with one roving tab stop (the focused day, else today, else
+ * the 1st) and the grid pattern on the arrow keys — horizontal steps a day,
+ * vertical steps a week, `Home`/`End` snap to the week, and `PageUp`/`PageDown`
+ * page the month, writing back through `month`.
+ *
+ * Bands cannot be `gridcell`s — they span columns, which is the whole point —
+ * so they are **`aria-hidden` mouse affordances**, and each day cell instead
+ * announces its date, the today marker, its **event count** and, when the lane
+ * budget hid some, **how many it is not showing**.
+ *
+ * That makes `dayClick` **load-bearing, not optional**: it is the accessible
+ * path into an individual event. A month that handles only `eventClick` is a
+ * view whose events no keyboard can reach — wire `dayClick` to a day or list
+ * view, as the gallery does.
+ *
+ * @selector `fold-calendar-month`
+ *
+ * @example
+ * ```html
+ * <fold-calendar-month
+ *   [(month)]="month"
+ *   [events]="events()"
+ *   [today]="today"
+ *   (dayClick)="openDay($event)"
+ *   (eventClick)="openEvent($event)"
+ * />
+ * ```
+ */
+declare class FoldCalendarMonthComponent<T = unknown> {
+    /** Any date inside the month on display. Two-way: keyboard paging writes back. */
+    readonly month: _angular_core.ModelSignal<string>;
+    /** Events to plot; those missing the grid entirely are ignored. */
+    readonly events: _angular_core.InputSignal<readonly FoldCalendarEvent<T>[]>;
+    /** The day to mark as today. Omit and none is marked (an SSR-stable default). */
+    readonly today: _angular_core.InputSignal<string | undefined>;
+    /** Day the weeks start on. @default the locale's own first day */
+    readonly weekStartsOn: _angular_core.InputSignal<FoldWeekday | undefined>;
+    /** Days shaded as the weekend. @default the locale's own weekend */
+    readonly weekendDays: _angular_core.InputSignal<readonly FoldWeekday[] | undefined>;
+    /** Show the ISO week number in a leading column. */
+    readonly showWeekNumbers: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Bands a week stacks before the rest collapse into overflow chips. @default 3 */
+    readonly maxLanes: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Always emit six rows, so the grid keeps one height across months. */
+    readonly fixedWeeks: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Extra names for a cell, emitted as `data-fold-day-modifiers`. */
+    readonly dayModifiers: _angular_core.InputSignal<FoldCalendarDayModifiers | undefined>;
+    /** A day cell was activated. */
+    readonly dayClick: _angular_core.OutputEmitterRef<string>;
+    /** A band was clicked; a grouped band emits its representative event. */
+    readonly eventClick: _angular_core.OutputEmitterRef<FoldCalendarEvent<T>>;
+    /** A `+N` chip was clicked, with the day whose events overflowed. */
+    readonly overflowClick: _angular_core.OutputEmitterRef<string>;
+    /** Labels, locale and the projected chip template — see the directive. */
+    protected readonly chrome: FoldCalendarChromeDirective;
+    private readonly host;
+    private readonly projectedDay;
+    private readonly projectedOverflow;
+    /** The custom day-cell template, when one is projected. */
+    protected readonly dayContent: _angular_core.Signal<_angular_core.TemplateRef<fold_ng.FoldCalendarDayContext> | null>;
+    /** The custom overflow-chip template, when one is projected. */
+    protected readonly overflowContent: _angular_core.Signal<_angular_core.TemplateRef<fold_ng.FoldCalendarOverflowContext> | null>;
+    /**
+     * Lanes this grid stacks — clamped once, by the layout, and read back here so
+     * the geometry and the CSS row template can never disagree.
+     */
+    private readonly lanes;
+    /** The laid-out grid: week rows, their days, and their packed bands. */
+    /** The anchor in force: the caller's, else the one the locale declares. */
+    protected readonly anchor: _angular_core.Signal<FoldWeekday>;
+    protected readonly weeks: _angular_core.Signal<readonly FoldCalendarWeek<T>[]>;
+    /** Column headers, walked out of `Intl` so every locale comes for free. */
+    protected readonly weekdayNames: _angular_core.Signal<readonly string[]>;
+    /**
+     * Columns before the first day. The week-number column is a real grid column,
+     * so everything placed by index — cells, bands, overflow chips — shifts with
+     * it, and nothing has to know why.
+     */
+    protected readonly columnOffset: _angular_core.Signal<0 | 1>;
+    /** The ISO week each row belongs to — always Monday-based, whatever the anchor. */
+    protected weekNumber(week: FoldCalendarWeek<T>): number;
+    /**
+     * Row track sizes: the day-number row, one row per lane, then the overflow
+     * row. Both heights are themeable knobs, which is why they are `var()`s.
+     */
+    protected readonly rowTemplate: _angular_core.Signal<string>;
+    /** The overflow chips' row — always the one after the last lane. */
+    protected readonly overflowRow: _angular_core.Signal<number>;
+    /** Every date the grid currently shows — the bound focus may not leave. */
+    private readonly gridDates;
+    /** Where the tab stop sits before the user moves it: today, else the 1st. */
+    private readonly defaultStop;
+    /** The grid's single tab stop and the arrow keys that move it. */
+    private readonly focus;
+    protected dayTabIndex(date: FoldCalendarDate): 0 | -1;
+    /** A cell's caller-supplied names, as one `~=`-matchable attribute. */
+    protected dayModifierAttr(day: FoldCalendarDay): string | null;
+    /**
+     * A day's accessible name: its date, the today marker, what sits on it, and
+     * what the lane budget is keeping from it.
+     */
+    protected dayLabel(day: FoldCalendarDay): string;
+    /** A band's text: the group's label when it stands for several events. */
+    protected bandLabel(band: FoldCalendarBand<T>): string;
+    /** The leading glyph — suppressed on a continuation, which has no real start. */
+    protected bandIcon(band: FoldCalendarBand<T>): FoldIconName | null;
+    protected onDayFocus(date: FoldCalendarDate): void;
+    /** A cell is not a `<button>`, so activation is wired by hand. */
+    protected onDayKeydown(event: KeyboardEvent, date: FoldCalendarDate): void;
+    private rootElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldCalendarMonthComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldCalendarMonthComponent<any>, "fold-calendar-month", never, { "month": { "alias": "month"; "required": true; "isSignal": true; }; "events": { "alias": "events"; "required": false; "isSignal": true; }; "today": { "alias": "today"; "required": false; "isSignal": true; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; "isSignal": true; }; "weekendDays": { "alias": "weekendDays"; "required": false; "isSignal": true; }; "showWeekNumbers": { "alias": "showWeekNumbers"; "required": false; "isSignal": true; }; "maxLanes": { "alias": "maxLanes"; "required": false; "isSignal": true; }; "fixedWeeks": { "alias": "fixedWeeks"; "required": false; "isSignal": true; }; "dayModifiers": { "alias": "dayModifiers"; "required": false; "isSignal": true; }; }, { "month": "monthChange"; "dayClick": "dayClick"; "eventClick": "eventClick"; "overflowClick": "overflowClick"; }, ["projectedDay", "projectedOverflow"], never, true, [{ directive: typeof FoldCalendarChromeDirective; inputs: { "locale": "locale"; "labels": "labels"; "formats": "formats"; }; outputs: {}; }]>;
+}
+
+/**
+ * `<fold-calendar-week>` — one week as seven day columns of stacked chips.
+ *
+ * Where the month view packs spans into lanes, a week simply lists what covers
+ * each day: a three-day event appears under all three, which is the reading a
+ * week is for. Nothing spans, so nothing is clipped and there is no overflow.
+ *
+ * ## Inputs
+ * | Input          | Type                     | Default | Meaning |
+ * |----------------|--------------------------|---------|---------|
+ * | `date`         | `FoldCalendarDate`       | —       | Any date in the week on display. |
+ * | `events`       | `FoldCalendarEvent<T>[]` | `[]`    | What to list. |
+ * | `today`        | `FoldCalendarDate`       | —       | The day to mark. |
+ * | `weekStartsOn` | `FoldWeekday`            | the locale's | Which day opens the week — `Intl.Locale` knows. |
+ * | `weekendDays`  | `FoldWeekday[]`          | the locale's | Which days are shaded. |
+ * | `locale`       | `string`                 | runtime | Drives the column headers through `Intl`. |
+ * | `labels`       | `Partial<FoldCalendarLabels>` | — | Per-instance label overrides. |
+ *
+ * `date` is a plain input, not a `model`: this view never pages itself, so
+ * writing back would be a promise it does not keep. Pair it with
+ * `<fold-calendar-toolbar>`, which does own the paging.
+ *
+ * ## Theming
+ * | CSS variable                          | Default | Sets |
+ * |---------------------------------------|---------|------|
+ * | `--fold-calendar-week-column-height`  | `320px` | Height of the day columns. |
+ * | `--fold-calendar-bar-width`           | `3px`   | The tone bar down a chip's leading edge. |
+ * | `--fold-calendar-band-radius`         | `--fold-radius-sm` | Chip corners. |
+ *
+ * ## Outputs
+ * | Output       | Payload                | Fires on |
+ * |--------------|------------------------|----------|
+ * | `dayClick`   | `FoldCalendarDate`     | A column header activated. |
+ * | `eventClick` | `FoldCalendarEvent<T>` | A chip activated. |
+ *
+ * ## Accessibility
+ * Each column is a `<section>` named by its full date, holding a header button
+ * and a list of chips. Because a chip sits **inside** the day it belongs to —
+ * no spanning, no overlay — every control is a real child in the natural tab
+ * order, so this view needs none of the month grid's roving-tabindex machinery
+ * and every event is reachable by keyboard.
+ *
+ * @selector `fold-calendar-week`
+ *
+ * @example
+ * ```html
+ * <fold-calendar-week
+ *   [(date)]="date"
+ *   [events]="events()"
+ *   [today]="today"
+ *   (eventClick)="open($event)"
+ * />
+ * ```
+ */
+declare class FoldCalendarWeekComponent<T = unknown> {
+    /** Any date inside the week on display. */
+    readonly date: _angular_core.InputSignal<string>;
+    /** Events to list under the days they cover. */
+    readonly events: _angular_core.InputSignal<readonly FoldCalendarEvent<T>[]>;
+    /** The day to mark as today. */
+    readonly today: _angular_core.InputSignal<string | undefined>;
+    /** Day the week starts on. @default the locale's own first day */
+    readonly weekStartsOn: _angular_core.InputSignal<FoldWeekday | undefined>;
+    /** Days shaded as the weekend. @default ['sat', 'sun'] */
+    readonly weekendDays: _angular_core.InputSignal<readonly FoldWeekday[] | undefined>;
+    /** A column header was activated. */
+    readonly dayClick: _angular_core.OutputEmitterRef<string>;
+    /** A chip was activated. */
+    readonly eventClick: _angular_core.OutputEmitterRef<FoldCalendarEvent<T>>;
+    /** Labels, locale and the projected chip template — see the directive. */
+    protected readonly chrome: FoldCalendarChromeDirective;
+    protected readonly columns: _angular_core.Signal<readonly FoldCalendarDayEvents<T>[]>;
+    protected weekdayName(column: FoldCalendarDayEvents<T>): string;
+    /** A column's accessible name: its date, the today marker, and what sits on it. */
+    protected columnLabel(column: FoldCalendarDayEvents<T>): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldCalendarWeekComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldCalendarWeekComponent<any>, "fold-calendar-week", never, { "date": { "alias": "date"; "required": true; "isSignal": true; }; "events": { "alias": "events"; "required": false; "isSignal": true; }; "today": { "alias": "today"; "required": false; "isSignal": true; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; "isSignal": true; }; "weekendDays": { "alias": "weekendDays"; "required": false; "isSignal": true; }; }, { "dayClick": "dayClick"; "eventClick": "eventClick"; }, never, never, true, [{ directive: typeof FoldCalendarChromeDirective; inputs: { "locale": "locale"; "labels": "labels"; "formats": "formats"; }; outputs: {}; }]>;
+}
+
+/**
+ * `<fold-calendar-day>` — one day, its events listed in full.
+ *
+ * The end of the drill-down: where the month view has room only for a label,
+ * this one has room for the subline too, so it is the view a `dayClick`
+ * naturally lands on.
+ *
+ * ## Inputs
+ * | Input    | Type                     | Default | Meaning |
+ * |----------|--------------------------|---------|---------|
+ * | `date`   | `FoldCalendarDate`       | —       | The day on display. |
+ * | `events` | `FoldCalendarEvent<T>[]` | `[]`    | Filtered to those covering `date`. |
+ * | `today`  | `FoldCalendarDate`       | —       | Marks the header when it matches. |
+ * | `locale` | `string`                 | runtime | Drives the header through `Intl`. |
+ * | `labels` | `Partial<FoldCalendarLabels>` | — | Per-instance label overrides. |
+ *
+ * ## Outputs
+ * | Output       | Payload                | Fires on |
+ * |--------------|------------------------|----------|
+ * | `eventClick` | `FoldCalendarEvent<T>` | A chip activated. |
+ *
+ * ## Slots
+ * | Selector                       | Region |
+ * |--------------------------------|--------|
+ * | `button[empty]`, `a[empty]`, `div[empty]` | Under the empty message — the place for a "new request" action. |
+ * | *(default)*                    | After the list. |
+ *
+ * The `empty` slot is **tag-qualified** (rule 4.8): `empty` is also an input on
+ * `fold-field` and `fold-data-table`, and a bare `[empty]` selector would
+ * capture either of them whole.
+ *
+ * ## Theming
+ * | CSS variable                       | Default | Sets |
+ * |------------------------------------|---------|------|
+ * | `--fold-calendar-day-number-size`  | `--fold-text-3xl` | The big day number. |
+ * | `--fold-calendar-bar-width`        | `3px`   | The tone bar down a chip's leading edge. |
+ * | `--fold-calendar-band-radius`      | `--fold-radius-sm` | Chip corners. |
+ *
+ * @selector `fold-calendar-day`
+ *
+ * @example
+ * ```html
+ * <fold-calendar-day [date]="date()" [events]="events()" [today]="today">
+ *   <button empty foldButton (click)="request()">New request</button>
+ * </fold-calendar-day>
+ * ```
+ */
+declare class FoldCalendarDayComponent<T = unknown> {
+    /** The day on display. */
+    readonly date: _angular_core.InputSignal<string>;
+    /** Events to filter down to this day. */
+    readonly events: _angular_core.InputSignal<readonly FoldCalendarEvent<T>[]>;
+    /** The day to mark as today. */
+    readonly today: _angular_core.InputSignal<string | undefined>;
+    /** A chip was activated. */
+    readonly eventClick: _angular_core.OutputEmitterRef<FoldCalendarEvent<T>>;
+    /** Labels, locale and the projected chip template — see the directive. */
+    protected readonly chrome: FoldCalendarChromeDirective;
+    protected readonly dayEvents: _angular_core.Signal<readonly FoldCalendarEvent<T>[]>;
+    protected readonly isToday: _angular_core.Signal<boolean>;
+    /** `Saturday` — the weekday alone; the month sits beside the number. */
+    protected readonly weekdayName: _angular_core.Signal<string>;
+    /** `May` — read with the day number, which is why it is not in the line above. */
+    protected readonly monthName: _angular_core.Signal<string>;
+    protected readonly dayOfMonth: _angular_core.Signal<number>;
+    /** The header's accessible name: the full date, plus the today marker. */
+    protected readonly headerLabel: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldCalendarDayComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldCalendarDayComponent<any>, "fold-calendar-day", never, { "date": { "alias": "date"; "required": true; "isSignal": true; }; "events": { "alias": "events"; "required": false; "isSignal": true; }; "today": { "alias": "today"; "required": false; "isSignal": true; }; }, { "eventClick": "eventClick"; }, never, ["button[empty], a[empty], div[empty]", "*"], true, [{ directive: typeof FoldCalendarChromeDirective; inputs: { "locale": "locale"; "labels": "labels"; "formats": "formats"; }; outputs: {}; }]>;
+}
+
+/**
+ * `<fold-calendar-list>` — everything in a range, in date order.
+ *
+ * The flat reading of the same data: no grid, no packing, so nothing is ever
+ * hidden behind a lane budget. Each row leads with the span it covers, which
+ * is what the grid views can only imply.
+ *
+ * For a sortable, column-configurable table instead, feed
+ * `foldEventsInRange()` straight into {@link FoldDataTableComponent} — this
+ * view stays deliberately small.
+ *
+ * ## Inputs
+ * | Input    | Type                     | Default | Meaning |
+ * |----------|--------------------------|---------|---------|
+ * | `events` | `FoldCalendarEvent<T>[]` | `[]`    | Source events. |
+ * | `from`   | `FoldCalendarDate`       | —       | Range start; omit to list everything. |
+ * | `to`     | `FoldCalendarDate`       | —       | Range end; omit to list everything. |
+ * | `locale` | `string`                 | runtime | Drives the span labels through `Intl`. |
+ * | `labels` | `Partial<FoldCalendarLabels>` | — | Per-instance label overrides. |
+ *
+ * ## Outputs
+ * | Output       | Payload                | Fires on |
+ * |--------------|------------------------|----------|
+ * | `eventClick` | `FoldCalendarEvent<T>` | A row activated. |
+ *
+ * ## Theming
+ * | CSS variable                       | Default | Sets |
+ * |------------------------------------|---------|------|
+ * | `--fold-calendar-list-date-width`  | `7rem`  | The leading date column — widen it for verbose locales. |
+ * | `--fold-calendar-bar-width`        | `3px`   | The tone bar down a row's leading edge. |
+ *
+ * A projected `foldCalendarEvent` template replaces a row's **whole** inside,
+ * as in every other view: the built-in bar and date belong to the default
+ * rendering, not to the frame around it.
+ *
+ * @selector `fold-calendar-list`
+ *
+ * @example
+ * ```html
+ * <fold-calendar-list
+ *   [events]="events()"
+ *   [from]="range().from"
+ *   [to]="range().to"
+ *   (eventClick)="open($event)"
+ * />
+ * ```
+ */
+declare class FoldCalendarListComponent<T = unknown> {
+    /** Source events. */
+    readonly events: _angular_core.InputSignal<readonly FoldCalendarEvent<T>[]>;
+    /** Range start, inclusive. Omit (with `to`) to list every event given. */
+    readonly from: _angular_core.InputSignal<string | undefined>;
+    /** Range end, inclusive. */
+    readonly to: _angular_core.InputSignal<string | undefined>;
+    /** A row was activated. */
+    readonly eventClick: _angular_core.OutputEmitterRef<FoldCalendarEvent<T>>;
+    /** Labels, locale and the projected chip template — see the directive. */
+    protected readonly chrome: FoldCalendarChromeDirective;
+    /** In range (when one is given), earliest first. */
+    protected readonly rows: _angular_core.Signal<readonly FoldCalendarEvent<T>[]>;
+    /**
+     * The span, collapsed to one date when it covers a single day — `Intl`'s
+     * own range formatter does that, and picks the locale's separator and its
+     * order, which is why this is not a translatable label.
+     */
+    protected rangeLabel(event: FoldCalendarEvent<T>): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldCalendarListComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldCalendarListComponent<any>, "fold-calendar-list", never, { "events": { "alias": "events"; "required": false; "isSignal": true; }; "from": { "alias": "from"; "required": false; "isSignal": true; }; "to": { "alias": "to"; "required": false; "isSignal": true; }; }, { "eventClick": "eventClick"; }, never, never, true, [{ directive: typeof FoldCalendarChromeDirective; inputs: { "locale": "locale"; "labels": "labels"; "formats": "formats"; }; outputs: {}; }]>;
+}
+
+/**
+ * The time grid's geometry: hour columns with events placed **inside** a day,
+ * and an all-day strip above them.
+ *
+ * The two halves are two different problems and stay two: a timed event is an
+ * interval in minutes laid out across a column's width
+ * ({@link foldLayOutOverlaps}), an all-day event is a span across days laid out
+ * in lanes ({@link foldPackRow}) — the same packer the month grid uses, so a
+ * three-day absence reads identically in both.
+ *
+ * Everything here is a **fraction of the visible window**, not a pixel: the
+ * window is a caller's choice (`dayStart`/`dayEnd`), the height is CSS's, and a
+ * layout that computed pixels would have to be told about both.
+ */
+/** How to build a time grid. */
+interface FoldTimeGridOptions {
+    /** Any date inside the range to display. */
+    readonly date: FoldCalendarDate;
+    /** Days to show: `1` is a day view, `7` a week. @default 7 */
+    readonly dayCount?: number;
+    /** Snap the range to the week — ignored unless `dayCount` is 7. @default true */
+    readonly snapToWeek?: boolean;
+    /** Day the week starts on. @default 'mon' */
+    readonly weekStartsOn?: FoldWeekday;
+    /** Days shaded as the weekend. @default ['sat', 'sun'] */
+    readonly weekendDays?: readonly FoldWeekday[] | undefined;
+    /** The day to flag as today; omit to flag none. */
+    readonly today?: FoldCalendarDate | undefined;
+    /** First hour on screen. @default '00:00' */
+    readonly dayStart?: FoldCalendarTime;
+    /** Last hour on screen; `24:00` is midnight. @default '24:00' */
+    readonly dayEnd?: FoldCalendarTime;
+    /** Lanes the all-day strip stacks before events overflow. @default 2 */
+    readonly maxAllDayLanes?: number;
+}
+/** One timed event's slice of one day. */
+interface FoldCalendarBlock<T = unknown> {
+    /** Unique per slice (`<eventId>@<date>`) — the `@for` track key. */
+    readonly key: string;
+    readonly event: FoldCalendarEvent<T>;
+    /** Where it starts, as a fraction `0`–`1` of the visible window. */
+    readonly top: number;
+    /** How tall it is, as a fraction of the visible window. */
+    readonly height: number;
+    /** Its column inside its overlap cluster, `0`-based. */
+    readonly column: number;
+    /** How many columns the cluster needed — the denominator of the width. */
+    readonly columns: number;
+    /** It began before this day, or before the visible window. */
+    readonly continuesBefore: boolean;
+    /** It runs past this day, or past the visible window. */
+    readonly continuesAfter: boolean;
+}
+/** One day column: the cell it stands for, and the events inside it. */
+interface FoldTimeGridColumn<T = unknown> {
+    readonly day: FoldCalendarDay;
+    /** Timed events, in the caller's order. */
+    readonly blocks: readonly FoldCalendarBlock<T>[];
+}
+/** A laid-out time grid. */
+interface FoldTimeGrid<T = unknown> {
+    /** The day columns, earliest first. */
+    readonly columns: readonly FoldTimeGridColumn<T>[];
+    /** All-day spans across the strip on top, packed into lanes. */
+    readonly allDay: readonly FoldCalendarBand<T>[];
+    /** All-day spans no lane could take. */
+    readonly allDayHiddenCount: number;
+    /** The hour labels down the gutter, as `HH:mm`. */
+    readonly hours: readonly FoldCalendarTime[];
+    /** First minute on screen. */
+    readonly startMinute: number;
+    /** Last minute on screen. */
+    readonly endMinute: number;
+}
+/**
+ * Whether an event is placed on the clock or on the strip.
+ *
+ * **Both** ends are needed: an event with only a start has no height, and one
+ * with only an end has no origin. Half a time is a data bug, and treating it as
+ * all-day is the reading that loses the least.
+ */
+declare function foldIsTimed<T>(event: FoldCalendarEvent<T>): boolean;
+/**
+ * Lays out `dayCount` days as hour columns plus an all-day strip.
+ *
+ * Timed events are placed on the clock; everything else — no times, or only one
+ * of them — goes on the strip, where it spans days exactly as it does in the
+ * month grid.
+ */
+declare function foldBuildTimeGrid<T>(events: readonly FoldCalendarEvent<T>[], options: FoldTimeGridOptions): FoldTimeGrid<T>;
+
+/**
+ * `<fold-calendar-timegrid>` — days as hour columns, with an all-day strip.
+ *
+ * The reading the other four cannot give: **when inside a day**. A meeting is a
+ * block whose height is its duration and whose width is shared with whatever it
+ * collides with; an absence is a band across the strip on top, spanning days
+ * exactly as it does in the month view — the same packer draws both, so a
+ * three-day leave request reads identically wherever it appears.
+ *
+ * Times are wall-clock `HH:mm`, never instants — the same decision as the date,
+ * for the same reason. 09:00 is the hour on the wall; the app converts once at
+ * its own boundary, and no zone can move a meeting after that.
+ *
+ * ## Inputs
+ * | Input             | Type                     | Default   | Meaning |
+ * |-------------------|--------------------------|-----------|---------|
+ * | `date`            | `FoldCalendarDate`       | —         | Any date in the range. |
+ * | `events`          | `FoldCalendarEvent<T>[]` | `[]`      | Timed events go on the clock, the rest on the strip. |
+ * | `dayCount`        | `number`                 | `7`       | `1` is a day view, `7` a week. |
+ * | `today`           | `FoldCalendarDate`       | —         | The column to mark. |
+ * | `now`             | `FoldCalendarTime`       | —         | Draws the current-time line on `today`'s column. Passed in, never read from a clock — the package has none, and an SSR render must not invent one. |
+ * | `dayStart`/`dayEnd` | `FoldCalendarTime`     | `00:00`/`24:00` | The visible window; `08:00`–`20:00` is a working day. |
+ * | `weekStartsOn`    | `FoldWeekday`            | the locale's | Which day opens the week. |
+ * | `weekendDays`     | `FoldWeekday[]`          | the locale's | Which columns are shaded. |
+ * | `maxAllDayLanes`  | `number`                 | `2`       | Lanes the strip stacks before overflowing. |
+ * | `locale`/`labels`/`formats` | —              | —         | See the other views. |
+ *
+ * ## Outputs
+ * | Output       | Payload                | Fires on |
+ * |--------------|------------------------|----------|
+ * | `dayClick`   | `FoldCalendarDate`     | A column header activated. |
+ * | `eventClick` | `FoldCalendarEvent<T>` | A block or an all-day band activated. |
+ *
+ * ## Theming
+ * | CSS variable                          | Default | Sets |
+ * |---------------------------------------|---------|------|
+ * | `--fold-calendar-timegrid-height`     | `640px` | Height of the hour area. |
+ * | `--fold-calendar-timegrid-gutter`     | `56px`  | Width of the hour labels. |
+ * | `--fold-calendar-timegrid-lane`       | `20px`  | Height of one all-day lane. |
+ * | `--fold-calendar-bar-width`           | `3px`   | The tone bar down a block's leading edge. |
+ *
+ * ## Accessibility
+ * Every block and every band is a real `<button>` inside the column it belongs
+ * to, so the tab order follows the day and this view needs none of the month
+ * grid's roving-tabindex machinery. A block's accessible name carries its
+ * **times**, which its position on the clock conveys only visually.
+ *
+ * @selector `fold-calendar-timegrid`
+ *
+ * @example
+ * ```html
+ * <fold-calendar-timegrid
+ *   [date]="date()"
+ *   [events]="events()"
+ *   [today]="today"
+ *   [now]="now()"
+ *   dayStart="08:00"
+ *   dayEnd="20:00"
+ *   (eventClick)="open($event)"
+ * />
+ * ```
+ */
+declare class FoldCalendarTimegridComponent<T = unknown> {
+    /** Any date inside the range on display. */
+    readonly date: _angular_core.InputSignal<string>;
+    /** Events to plot; timed ones on the clock, the rest on the strip. */
+    readonly events: _angular_core.InputSignal<readonly FoldCalendarEvent<T>[]>;
+    /** Days to show: `1` is a day view, `7` a week. @default 7 */
+    readonly dayCount: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** The day to mark as today. */
+    readonly today: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The current wall-clock time, for the "now" line. Passed in rather than
+     * read: this package owns no clock (`today` works the same way), and a
+     * server render that invented one would hydrate to a different position.
+     */
+    readonly now: _angular_core.InputSignal<string | undefined>;
+    /** First hour on screen. @default '00:00' */
+    readonly dayStart: _angular_core.InputSignal<string>;
+    /** Last hour on screen. @default '24:00' */
+    readonly dayEnd: _angular_core.InputSignal<string>;
+    /** Day the week starts on. @default the locale's own first day */
+    readonly weekStartsOn: _angular_core.InputSignal<FoldWeekday | undefined>;
+    /** Days shaded as the weekend. @default the locale's own weekend */
+    readonly weekendDays: _angular_core.InputSignal<readonly FoldWeekday[] | undefined>;
+    /** Lanes the all-day strip stacks before events overflow. @default 2 */
+    readonly maxAllDayLanes: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** A column header was activated. */
+    readonly dayClick: _angular_core.OutputEmitterRef<string>;
+    /** A block or an all-day band was activated. */
+    readonly eventClick: _angular_core.OutputEmitterRef<FoldCalendarEvent<T>>;
+    /** Labels, locale and the projected chip template — see the directive. */
+    protected readonly chrome: FoldCalendarChromeDirective;
+    protected readonly grid: _angular_core.Signal<fold_ng.FoldTimeGrid<T>>;
+    /** Lane rows for the all-day strip, or none when nothing spans. */
+    protected readonly stripRows: _angular_core.Signal<string>;
+    /** Where the "now" line sits, as a fraction of the window, or `null`. */
+    protected readonly nowOffset: _angular_core.Signal<number | null>;
+    protected weekdayName(column: FoldTimeGridColumn<T>): string;
+    protected hourLabel(hour: FoldCalendarTime): string;
+    /** A column's accessible name: its date, the today marker, and its load. */
+    protected columnLabel(column: FoldTimeGridColumn<T>): string;
+    /**
+     * A block's accessible name — its times first, because where it sits on the
+     * clock is information a screen reader has no other way to get.
+     */
+    protected blockLabel(block: FoldCalendarBlock<T>): string;
+    /** A band's text: the group's label when it stands for several events. */
+    protected bandLabel(band: FoldCalendarBand<T>): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldCalendarTimegridComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldCalendarTimegridComponent<any>, "fold-calendar-timegrid", never, { "date": { "alias": "date"; "required": true; "isSignal": true; }; "events": { "alias": "events"; "required": false; "isSignal": true; }; "dayCount": { "alias": "dayCount"; "required": false; "isSignal": true; }; "today": { "alias": "today"; "required": false; "isSignal": true; }; "now": { "alias": "now"; "required": false; "isSignal": true; }; "dayStart": { "alias": "dayStart"; "required": false; "isSignal": true; }; "dayEnd": { "alias": "dayEnd"; "required": false; "isSignal": true; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; "isSignal": true; }; "weekendDays": { "alias": "weekendDays"; "required": false; "isSignal": true; }; "maxAllDayLanes": { "alias": "maxAllDayLanes"; "required": false; "isSignal": true; }; }, { "dayClick": "dayClick"; "eventClick": "eventClick"; }, never, never, true, [{ directive: typeof FoldCalendarChromeDirective; inputs: { "locale": "locale"; "labels": "labels"; "formats": "formats"; }; outputs: {}; }]>;
+}
+
+/** What an event template is handed. */
+interface FoldCalendarEventContext<T> {
+    /** The event to render — `let-event`. */
+    readonly $implicit: FoldCalendarEvent<T>;
+    /**
+     * The laid-out segment in the month view, `null` in the column views — so a
+     * template can react to a continuation edge where there is one, and does not
+     * have to pretend there is one where there is not.
+     */
+    readonly band: FoldCalendarBand<T> | null;
+}
+/**
+ * Marks an `<ng-template>` as the renderer for every event chip inside a
+ * calendar view, replacing the built-in icon + label + count row:
+ *
+ * ```html
+ * <fold-calendar-month [(month)]="month" [events]="events()">
+ *   <ng-template foldCalendarEvent let-event let-band="band">
+ *     <fold-avatar [name]="event.data.owner" size="xs" />
+ *     <span>{{ event.label }}</span>
+ *   </ng-template>
+ * </fold-calendar-month>
+ * ```
+ *
+ * `let-event` and `let-band` are **fully typed** under `strictTemplates`: the
+ * directive is generic over the same `T` as the events it renders, and its
+ * context guard carries that through, so `event.data` is the app's own record
+ * with no cast.
+ *
+ * @selector `ng-template[foldCalendarEvent]`
+ */
+declare class FoldCalendarEventDirective<T = unknown> {
+    readonly template: TemplateRef<FoldCalendarEventContext<T>>;
+    /** Teaches the template checker what `let-event` and `let-band` are. */
+    static ngTemplateContextGuard<T>(_directive: FoldCalendarEventDirective<T>, context: unknown): context is FoldCalendarEventContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldCalendarEventDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FoldCalendarEventDirective<any>, "ng-template[foldCalendarEvent]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The containers a calendar draws around its events, opened up as templates.
+ *
+ * The chip has always been replaceable ({@link FoldCalendarEventDirective});
+ * these are the four places an app reaches for next — the cell behind the
+ * chips, the heading above them, the period title, and the chip standing for
+ * what did not fit. Each is a plain `<ng-template>` with a typed context, so
+ * replacing one costs nothing and leaves the rest of the view alone.
+ */
+/** What a day-cell template is handed. */
+interface FoldCalendarDayContext {
+    /** The cell to render — `let-day`. Carries its own counts and flags. */
+    readonly $implicit: FoldCalendarDay;
+}
+/**
+ * Replaces the **inside of a month day cell** — by default just the day number.
+ *
+ * This is the hook for everything the calendar cannot know: a holiday marker, a
+ * closure, "3/8 staffed", a price. The cell itself (the button, its focus
+ * behaviour, its accessible name) stays the calendar's job.
+ *
+ * ```html
+ * <ng-template foldCalendarDay let-day>
+ *   <span>{{ day.dayOfMonth }}</span>
+ *   @if (closed(day.date)) { <fold-icon name="lock" size="xs" /> }
+ * </ng-template>
+ * ```
+ *
+ * @selector `ng-template[foldCalendarDay]`
+ */
+declare class FoldCalendarDayDirective {
+    readonly template: TemplateRef<FoldCalendarDayContext>;
+    static ngTemplateContextGuard(_directive: FoldCalendarDayDirective, context: unknown): context is FoldCalendarDayContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldCalendarDayDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FoldCalendarDayDirective, "ng-template[foldCalendarDay]", never, {}, {}, never, never, true, never>;
+}
+/** What a day-heading template is handed. */
+interface FoldCalendarHeadingContext<T> {
+    /** The day being headed — `let-date`. */
+    readonly $implicit: FoldCalendarDate;
+    /** The events filed under it, so a heading can count or summarise them. */
+    readonly events: readonly FoldCalendarEvent<T>[];
+}
+/**
+ * Replaces the **day heading** of the agenda rail — by default a big day number
+ * with a relative name beside it. Where an app puts a per-day count, a total,
+ * or a quick action.
+ *
+ * @selector `ng-template[foldCalendarHeading]`
+ */
+declare class FoldCalendarHeadingDirective<T = unknown> {
+    readonly template: TemplateRef<FoldCalendarHeadingContext<T>>;
+    static ngTemplateContextGuard<T>(_directive: FoldCalendarHeadingDirective<T>, context: unknown): context is FoldCalendarHeadingContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldCalendarHeadingDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FoldCalendarHeadingDirective<any>, "ng-template[foldCalendarHeading]", never, {}, {}, never, never, true, never>;
+}
+/** What a toolbar-title template is handed. */
+interface FoldCalendarTitleContext {
+    /** The period name the toolbar would have rendered — `let-title`. */
+    readonly $implicit: string;
+    /** First day of the period on display. */
+    readonly from: FoldCalendarDate;
+    /** Last day of the period on display. */
+    readonly to: FoldCalendarDate;
+    /** The view the period belongs to. */
+    readonly view: string;
+}
+/**
+ * Replaces the toolbar's **period title** — by default an `<h2>` holding
+ * `foldViewTitle()`. Project one to change the wording, or to give the title a
+ * heading level that fits the page's outline.
+ *
+ * @selector `ng-template[foldCalendarTitle]`
+ */
+declare class FoldCalendarTitleDirective {
+    readonly template: TemplateRef<FoldCalendarTitleContext>;
+    static ngTemplateContextGuard(_directive: FoldCalendarTitleDirective, context: unknown): context is FoldCalendarTitleContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldCalendarTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FoldCalendarTitleDirective, "ng-template[foldCalendarTitle]", never, {}, {}, never, never, true, never>;
+}
+/** What an overflow-chip template is handed. */
+interface FoldCalendarOverflowContext {
+    /** How many events this day could not show — `let-count`. */
+    readonly $implicit: number;
+    /** The day they belong to. */
+    readonly date: FoldCalendarDate;
+}
+/**
+ * Replaces the month view's **`+N` chip** — by default a small text button.
+ * Where an app puts an avatar stack, or the trigger of a "see all" popover.
+ *
+ * @selector `ng-template[foldCalendarOverflow]`
+ */
+declare class FoldCalendarOverflowDirective {
+    readonly template: TemplateRef<FoldCalendarOverflowContext>;
+    static ngTemplateContextGuard(_directive: FoldCalendarOverflowDirective, context: unknown): context is FoldCalendarOverflowContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldCalendarOverflowDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FoldCalendarOverflowDirective, "ng-template[foldCalendarOverflow]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * What a locale says about its own week.
+ *
+ * `Intl` hands us every month and weekday name, and then most calendars stop
+ * there and hard-code Monday — which is right in France and wrong in the United
+ * States, Egypt and the Maldives. `Intl.Locale` also knows **which day the week
+ * starts on and which days are the weekend**; asking is one call, and it turns
+ * two inputs from "the caller guesses" into "the caller overrides".
+ *
+ * Support is uneven (`getWeekInfo()` in Chrome and Safari, the `weekInfo`
+ * getter in older Firefox), so both shapes are probed and neither is assumed.
+ * A runtime with neither falls back to Monday + Sat/Sun, which is the most
+ * common answer and the previous behaviour.
+ */
+/** A locale's week conventions. */
+interface FoldWeekInfo {
+    /** The day its calendars open on. */
+    readonly weekStartsOn: FoldWeekday;
+    /** The days it shades as the weekend. */
+    readonly weekendDays: readonly FoldWeekday[];
+}
+/** What a runtime that cannot answer gets: the most common week in the world. */
+declare const FOLD_FALLBACK_WEEK_INFO: FoldWeekInfo;
+/**
+ * The week conventions of `locale` — its first day and its weekend.
+ *
+ * `undefined` asks the runtime for its own locale, which is what a calendar
+ * with no `locale` input is already formatting in.
+ */
+declare function foldLocaleWeekInfo(locale?: string): FoldWeekInfo;
+
+/**
+ * Where a key press moves the focused day. Split out of the component because
+ * "what does ArrowDown mean on a calendar" is a pure question about dates, and
+ * answering it here means it can be tested without a grid, a DOM or a TestBed.
+ *
+ * {@link foldCalendarNextFocus} is public: it is the other half of the geometry
+ * tier, and a hand-rolled date grid owes its users the same arrow keys as the
+ * built-in one. {@link foldFocusDayCell} stays internal — it reads a
+ * `data-fold-day` attribute this package writes, and exporting it would freeze
+ * that attribute into the public contract.
+ */
+/**
+ * The day `key` moves focus to from `from`, or `null` when the key is not a
+ * grid-navigation key and the component should leave the event alone.
+ *
+ * The mapping is the ARIA grid pattern applied to a date axis: horizontal keys
+ * step a day, vertical keys step a **week** (the column stays put, which is the
+ * whole point of a 7-wide grid), `Home`/`End` snap to the week's bounds, and
+ * `PageUp`/`PageDown` page by month.
+ */
+declare function foldCalendarNextFocus(key: string, from: FoldCalendarDate, weekStartsOn?: FoldWeekday): FoldCalendarDate | null;
+
+/**
+ * Month geometry — where every chip lands, and what did not fit.
+ *
+ * Packing spans into lanes is the one genuinely algorithmic part of a calendar,
+ * so it lives on its own, framework-free apart from a dev-mode warning, and is
+ * tested exhaustively without rendering anything.
+ *
+ * **Public on purpose.** `fold-calendar-month` is one consumer of this, not its
+ * owner: an app that needs a month laid out but drawn its own way calls
+ * `foldBuildMonthGrid` and renders the rows itself, and gets the packing, the
+ * week-boundary clipping and the open edges for free. Pair it with
+ * `foldCalendarNextFocus` for the keyboard, and with `FoldCalendarLabels` for
+ * the strings.
+ */
+/** How to build a month grid. */
+interface FoldMonthGridOptions {
+    /** Any date inside the month to display. */
+    readonly month: FoldCalendarDate;
+    /** Day the weeks start on. @default 'mon' */
+    readonly weekStartsOn?: FoldWeekday;
+    /** Days shaded as the weekend. @default ['sat', 'sun'] */
+    readonly weekendDays?: readonly FoldWeekday[] | undefined;
+    /** The day to flag as today; omit to flag none (an SSR-stable default). */
+    readonly today?: FoldCalendarDate | undefined;
+    /** Lanes a week row can stack before events spill into the overflow count. @default 3 */
+    readonly maxLanes?: number;
+    /**
+     * Always emit six week rows, so the grid keeps one height across months
+     * instead of reflowing between 4, 5 and 6 rows. @default false
+     */
+    readonly fixedWeeks?: boolean;
+}
+/**
+ * Lays a month out as week rows with their events already packed into lanes.
+ *
+ * The grid runs from the week containing the 1st to the week containing the
+ * last day, so it always starts and ends on whole weeks; `fixedWeeks` pads it
+ * to six rows. Events outside that window are dropped, and an event crossing a
+ * week boundary yields one band per week it touches.
+ *
+ * An unparseable `month` yields **no rows** rather than a grid of `Invalid
+ * Date` cells, with a dev-mode warning naming the value.
+ */
+declare function foldBuildMonthGrid<T>(events: readonly FoldCalendarEvent<T>[], options: FoldMonthGridOptions): readonly FoldCalendarWeek<T>[];
+
+/**
+ * Render models for the column views (week, day).
+ *
+ * Nothing is packed here: chips stack in a column, so a multi-day event simply
+ * appears under every day it covers, and no event is ever dropped — which is
+ * why these cells always report `hiddenCount: 0`.
+ */
+/** How to build a column view. */
+interface FoldDayColumnsOptions {
+    /** Any date inside the range to display. */
+    readonly date: FoldCalendarDate;
+    /** Day the week starts on — ignored when building a single day. @default 'mon' */
+    readonly weekStartsOn?: FoldWeekday;
+    /** Days shaded as the weekend. @default ['sat', 'sun'] */
+    readonly weekendDays?: readonly FoldWeekday[] | undefined;
+    /** The day to flag as today; omit to flag none. */
+    readonly today?: FoldCalendarDate | undefined;
+}
+/**
+ * The seven days of `date`'s week, each with the events covering it — the
+ * render model of the week view.
+ */
+declare function foldBuildWeek<T>(events: readonly FoldCalendarEvent<T>[], options: FoldDayColumnsOptions): readonly FoldCalendarDayEvents<T>[];
+/** A single day with its events — the render model of the day view. */
+declare function foldBuildDay<T>(events: readonly FoldCalendarEvent<T>[], options: FoldDayColumnsOptions): FoldCalendarDayEvents<T>;
+
+/**
+ * The three selections every view and every consumer makes over a feed.
+ *
+ * Deliberately the smallest, least coupled part of the family: an app that
+ * wants the calendar's semantics — "covers this day", "overlaps this window",
+ * "belongs to a live feed" — without any of its rendering imports only this.
+ */
+/**
+ * Events covering `date`, in the caller's order — the selection the week, day
+ * and list views render, where chips stack in a column and need no packing.
+ */
+declare function foldEventsOnDay<T>(events: readonly FoldCalendarEvent<T>[], date: FoldCalendarDate): readonly FoldCalendarEvent<T>[];
+/** Events overlapping `[from, to]` at all, in the caller's order. */
+declare function foldEventsInRange<T>(events: readonly FoldCalendarEvent<T>[], from: FoldCalendarDate, to: FoldCalendarDate): readonly FoldCalendarEvent<T>[];
+/**
+ * Events from the feeds in `active`, in the caller's order — the other half of
+ * `fold-calendar-source-filter`, which owns only the selection.
+ *
+ * `null` means nothing has been switched off yet and everything passes; it is
+ * the filter chips' own initial value, so the one function built to consume
+ * that model accepts it rather than making every caller write the ternary.
+ * An empty `Set` is the opposite — every feed switched off — which is why the
+ * two are not collapsed.
+ *
+ * An event with no `sourceKey` belongs to no feed, so no chip can hide it and
+ * it always passes.
+ */
+declare function foldFilterBySource<T>(events: readonly FoldCalendarEvent<T>[], active: ReadonlySet<string> | null): readonly FoldCalendarEvent<T>[];
+
+/**
+ * Where overlapping timed events sit side by side — the time grid's only
+ * genuinely algorithmic part, and the same shape as the month's lane packing
+ * turned ninety degrees: intervals over **minutes** instead of days, laid out
+ * across the column's width instead of down its height.
+ *
+ * Pure, so the rule can be exercised exhaustively without a grid.
+ */
+/** An interval to place, in minutes since midnight. */
+interface FoldOverlapInput {
+    readonly startMinute: number;
+    /** Exclusive: an event ending at 10:00 does not overlap one starting there. */
+    readonly endMinute: number;
+}
+/** Where one interval landed across the width. */
+interface FoldOverlapSlot {
+    /** Its column index inside the cluster, `0`-based. */
+    readonly column: number;
+    /** How many columns its cluster needed — the denominator of its width. */
+    readonly columns: number;
+}
+/**
+ * Lays intervals out across the width, one slot per input, in input order.
+ *
+ * Two events that merely touch — one ends at 10:00, the next starts at 10:00 —
+ * do **not** overlap and each keep the full width. That is the difference
+ * between the month grid (inclusive days: touching means colliding) and a time
+ * grid (exclusive minutes: touching means back-to-back), and getting it wrong
+ * halves the width of every event in a packed morning.
+ *
+ * Events are grouped into **clusters** — runs connected by overlap — and each
+ * cluster is widened only as far as it needs, so one triple-booked hour does
+ * not narrow the rest of the day.
+ */
+declare function foldLayOutOverlaps(intervals: readonly FoldOverlapInput[]): readonly FoldOverlapSlot[];
+
+type FoldChoiceOption = {
+    key: string;
+    label: string;
+    /** Optional trailing count badge (e.g. how many rows match this filter). */
+    count?: number;
+};
+/**
+ * `<fold-choice-row>` — a horizontal single-select control.
+ *
+ * One row, one active option, emits the chosen `key`; the parent owns the
+ * state and feeds it back via `activeKey`. Two layouts:
+ *
+ * - `segmented` (default) — equal-width buttons that fill the row, no wrap.
+ *   The right shape for a small mode/segment toggle (2–4 options).
+ * - `chips` — auto-width rounded chips that wrap. The right shape for a
+ *   status/category filter above a table or list.
+ *
+ * @selector `fold-choice-row`
+ *
+ * @example
+ * ```html
+ * <fold-choice-row
+ *   [options]="[{ key: 'manager', label: 'Manager' }, { key: 'member', label: 'Member' }]"
+ *   [activeKey]="role()"
+ *   (selected)="role.set($event)"
+ * />
+ *
+ * <fold-choice-row
+ *   layout="chips"
+ *   [options]="statuses"
+ *   [activeKey]="status()"
+ *   ariaLabel="Filter by status"
+ *   (selected)="setStatus($event)"
+ * />
+ * ```
+ */
+declare class FoldChoiceRowComponent {
+    /** The selectable options, in display order. */
+    readonly options: _angular_core.InputSignal<readonly FoldChoiceOption[]>;
+    /** The `key` of the currently selected option. */
+    readonly activeKey: _angular_core.InputSignal<string>;
+    /** `segmented` (equal-width, default) or `chips` (auto-width, wraps). */
+    readonly layout: _angular_core.InputSignal<"segmented" | "chips">;
+    /** Accessible label for the group. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Emits the `key` of the clicked option. */
+    readonly selected: _angular_core.OutputEmitterRef<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldChoiceRowComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldChoiceRowComponent, "fold-choice-row", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "activeKey": { "alias": "activeKey"; "required": true; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, never, never, true, never>;
+}
+
+/**
+ * The design tokens, as a typed source-of-truth.
+ *
+ * These lists are the CONTRACT. The token contract test asserts that the CSS
+ * declares exactly these tokens — for colours, that the `:root` (dark) and
+ * `[data-theme="lumen"]` blocks each declare exactly the colour set (parity);
+ * for scales, that `scales.css` declares exactly the radius/type steps. Add a
+ * token here and to the CSS in the same change, or the test fails. That is how
+ * the theme stays complete and drift-free.
+ *
+ * They also power typed `fold*Var` helpers so call sites get autocomplete and a
+ * compile error on a misspelt token.
+ */
+declare const FOLD_SEMANTIC_COLOR_TOKENS: readonly ["bg-page", "bg-header", "bg-rail-primary", "bg-rail-secondary", "bg-rail-tertiary", "primary", "primary-strong", "on-primary", "primary-text", "primary-surface", "primary-border", "info", "info-text", "info-surface", "info-border", "warning", "warning-text", "warning-surface", "warning-border", "alert", "alert-text", "alert-surface", "alert-border", "success", "success-text", "success-surface", "success-border", "text", "text-secondary", "text-muted", "text-faded", "surface-card", "surface-sunken", "surface-subtle", "surface-raised", "surface-hover", "border", "border-subtle", "glass", "glass-border", "scrim"];
+type FoldSemanticColorToken = (typeof FOLD_SEMANTIC_COLOR_TOKENS)[number];
+/** Border-radius scale. `lg` is a real large radius; `pill` is the capsule. */
+declare const FOLD_RADIUS_TOKENS: readonly ["xs", "sm", "md", "lg", "pill", "round"];
+type FoldRadiusToken = (typeof FOLD_RADIUS_TOKENS)[number];
+/** Type (font-size) scale. */
+declare const FOLD_TEXT_TOKENS: readonly ["xs", "sm", "md", "lg", "xl"];
+type FoldTextToken = (typeof FOLD_TEXT_TOKENS)[number];
+/** Icon-size scale — the length a `fold-icon` renders at, per size preset. */
+declare const FOLD_ICON_SIZE_TOKENS: readonly ["xs", "sm", "md", "lg", "xl"];
+type FoldIconSizeToken = (typeof FOLD_ICON_SIZE_TOKENS)[number];
+/** Space (gap / padding / margin) scale. */
+declare const FOLD_SPACE_TOKENS: readonly ["xs", "sm", "md", "lg", "xl", "2xl", "3xl", "4xl", "5xl"];
+type FoldSpaceToken = (typeof FOLD_SPACE_TOKENS)[number];
+/** Motion scale — `transition` shorthands (duration + easing). */
+declare const FOLD_MOTION_TOKENS: readonly ["fast", "base", "slow"];
+type FoldMotionToken = (typeof FOLD_MOTION_TOKENS)[number];
+/** Backdrop-blur radii (`--fold-blur-*`). */
+declare const FOLD_BLUR_TOKENS: readonly ["glass"];
+type FoldBlurToken = (typeof FOLD_BLUR_TOKENS)[number];
+/**
+ * Elevation scale — full `box-shadow` values. The shared depth language: a
+ * component never spells its own shadow, it names a level. Theme-invariant
+ * (black ink via `color-mix`, which reads acceptably on both themes), so they
+ * live with the scales. `panel-*` are the directional side-panel shadows.
+ */
+declare const FOLD_SHADOW_TOKENS: readonly ["sm", "md", "lg", "panel-right", "panel-left"];
+type FoldShadowToken = (typeof FOLD_SHADOW_TOKENS)[number];
+/** The full custom-property name for a semantic colour token. */
+declare function foldColorProperty(token: FoldSemanticColorToken): string;
+/** A ready-to-use `var(--fold-color-…)` reference for a semantic colour token. */
+declare function foldColorVar(token: FoldSemanticColorToken): string;
+/** A ready-to-use `var(--fold-radius-…)` reference. */
+declare function foldRadiusVar(token: FoldRadiusToken): string;
+/** A ready-to-use `var(--fold-text-…)` reference. */
+declare function foldTextVar(token: FoldTextToken): string;
+/** A ready-to-use `var(--fold-space-…)` reference. */
+declare function foldSpaceVar(token: FoldSpaceToken): string;
+/** A ready-to-use `var(--fold-motion-…)` reference. */
+declare function foldMotionVar(token: FoldMotionToken): string;
+/** A ready-to-use `var(--fold-blur-…)` reference. */
+declare function foldBlurVar(token: FoldBlurToken): string;
+/** A ready-to-use `var(--fold-shadow-…)` reference. */
+declare function foldShadowVar(token: FoldShadowToken): string;
+
+/** Spinner size — an icon-size token (`xs…xl`) or an explicit pixel number. */
+type FoldSpinnerSize = FoldIconSizeToken | number;
+/**
+ * `fold-spinner` — an indeterminate loading indicator: a rotating arc drawn in
+ * `currentColor`, sized off the same scale as `fold-icon` so it drops into a
+ * button in place of its glyph without shifting layout.
+ *
+ * Give it a `label` when it stands alone (it becomes `role="status"` +
+ * `aria-label`, so assistive tech announces the wait). Leave `label` unset when
+ * it lives inside something that already announces busy-ness (a button with
+ * `aria-busy`) — it then renders `aria-hidden`, purely decorative.
+ *
+ * Honours `prefers-reduced-motion`: the rotation stops and a fuller static ring
+ * is shown instead, so the indicator still reads as "busy" without animating.
+ *
+ * @selector `fold-spinner`
+ *
+ * @example
+ * ```html
+ * <fold-spinner label="Loading contracts" />
+ * <fold-spinner size="sm" />           <!-- decorative, inside a busy control -->
+ * <fold-spinner [size]="18" />
+ * ```
+ */
+declare class FoldSpinnerComponent {
+    /** Size — an icon-size token (`xs…xl`, default `md`) or a pixel number. */
+    readonly size: _angular_core.InputSignal<FoldSpinnerSize>;
+    /** Accessible label. Set → `role="status"` + `aria-label`; unset → decorative. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Resolves the size to a CSS length for `--fold-spinner-size`. */
+    readonly sizeVar: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldSpinnerComponent, "fold-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Generates unique, SSR-safe element ids.
+ *
+ * A per-injector counter (`providedIn: 'root'` → one instance per application,
+ * and a fresh one per request on the server) so the sequence is deterministic
+ * in render order and therefore matches between server and client. That's the
+ * point: `crypto.randomUUID()` returns a different value on the server than on
+ * the client for the same element, which trips Angular hydration; a counter
+ * reset per request does not, and can't collide across requests or grow
+ * unbounded.
+ *
+ * Used by the labelled controls that own their id ({@link FoldInputComponent},
+ * `fold-select`) and by {@link FoldFieldIdDirective} for loose native controls.
+ */
+declare class FoldIdService {
+    private counter;
+    /**
+     * The next unique id, e.g. `fold-input-3`.
+     * @param prefix a short, human-readable namespace for the id.
+     */
+    next(prefix?: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldIdService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FoldIdService>;
+}
+
+/**
+ * Auto-assigns a unique, SSR-safe `id` to any native form control (`<input>`,
+ * `<select>`, `<textarea>`) that has neither an `id` nor a `name`.
+ *
+ * You don't write `foldFieldId` on elements — the directive **auto-applies** by
+ * selector. Add it to a component's `imports` once and every unidentified native
+ * control in that component's template is fixed in one go, with no per-element
+ * edit. It silences the browser's *"A form field element should have an id or
+ * name attribute"* warning (autofill + accessibility), and the id it sets can be
+ * targeted by a `<label for>`.
+ *
+ * The selector matches only controls missing **both** `id` and `name` — static
+ * or bound (`[id]`/`[attr.id]`/`[name]` all count as present) — so it never
+ * fights a control you've already identified. Components that render their own
+ * labelled control ({@link FoldInputComponent}, `fold-select`) own their id
+ * explicitly and are unaffected.
+ */
+declare class FoldFieldIdDirective {
+    /** Assigned once at construction, in deterministic render order (SSR-safe). */
+    protected readonly autoId: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldFieldIdDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FoldFieldIdDirective, "input:not([id]):not([name]),select:not([id]):not([name]),textarea:not([id]):not([name])", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * `[foldRepeatPress]` — press-and-hold auto-repeat.
+ *
+ * Fires `(foldRepeatPress)` once immediately on pointer press, then keeps firing
+ * on a fixed cadence while the pointer is held, stopping on release, leave,
+ * cancel or destroy. Bind `[foldRepeatPressDisabled]` to a reactive bound (e.g.
+ * "at max") so the repeat also stops the instant the action becomes unavailable
+ * mid-hold — a plain `pointerup` is unreliable once the host button disables
+ * itself under the finger.
+ *
+ * Keyboard activation is intentionally out of scope: it produces `click`, not
+ * `pointerdown`, so wire a separate `(click)` handler for Enter/Space.
+ *
+ * @selector `[foldRepeatPress]`
+ *
+ * @example
+ * ```html
+ * <button
+ *   foldRepeatPress
+ *   [foldRepeatPressDisabled]="atMax()"
+ *   (foldRepeatPress)="step(1)"
+ * >+</button>
+ * ```
+ */
+declare class FoldRepeatPressDirective {
+    /** Fires immediately on press, then repeatedly while the pointer is held. */
+    readonly repeat: _angular_core.OutputEmitterRef<void>;
+    /** When true, a press does nothing and any running repeat stops at once. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Delay before the auto-repeat begins, in ms. @default 350 */
+    readonly delay: _angular_core.InputSignal<number>;
+    /** Cadence of the auto-repeat once started, in ms. @default 60 */
+    readonly period: _angular_core.InputSignal<number>;
     private startTimer;
     private tick;
     constructor();
@@ -2443,6 +4103,101 @@ declare class FoldElevatedDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FoldElevatedDirective, "[foldElevated]", never, { "foldElevated": { "alias": "foldElevated"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/** Which axis a scroll region scrolls on. */
+type FoldScrollAxis = "block" | "inline" | "both";
+/**
+ * `[foldScrollRegion]` — turns any element into a **bounded, coordinated scroll
+ * box** without the consumer ever writing `overflow`.
+ *
+ * It is the one opt-in of the shell scroll system (`docs/scroll.md`): with
+ * `fold-app-shell` owning the page scroll, a layout that genuinely needs an
+ * independently-scrolling area (a split list/detail, a data-table body, a sticky
+ * sidebar, a panel body) marks that area with this directive instead of
+ * hand-rolling the three foot-guns. It:
+ *
+ * - sets `overflow: auto`, `min-height: 0` (and `min-width: 0` for the inline
+ *   axis) and `overscroll-behavior: contain` — the three foot-guns, in one place;
+ * - paints the thin house scrollbar (`scrollbar-width: thin`; the tokenised
+ *   colour/radius lands with the scroll-system Slice C);
+ * - **registers with the {@link ScrollRegionRegistry}**, so an overlay (the panel
+ *   host) can freeze this region — alongside the shell's own scroll box — while a
+ *   modal is open, robust to the scroll owner being the shell rather than `body`.
+ *   The registry is injected optionally, so the directive is a useful bounded
+ *   scroll box even outside a shell; the coordination is a bonus when one is present.
+ *
+ * The axis is the directive's own value (default `block` = vertical):
+ * `foldScrollRegion` / `foldScrollRegion="block"` (vertical), `="inline"`
+ * (horizontal), `="both"`.
+ *
+ * @selector `[foldScrollRegion]`
+ *
+ * @example
+ * ```html
+ * <!-- a split view: the list scrolls on its own, the detail flows -->
+ * <fold-aside-layout>
+ *   <nav asideleft foldScrollRegion>…long list…</nav>
+ *   <article>…detail…</article>
+ * </fold-aside-layout>
+ *
+ * <div foldScrollRegion="both" class="table-body">…</div>
+ * ```
+ */
+declare class FoldScrollRegionDirective {
+    /** The scroll axis; defaults to `block` (vertical), including a bare attribute. */
+    readonly foldScrollRegion: _angular_core.InputSignalWithTransform<FoldScrollAxis, "" | FoldScrollAxis>;
+    /** `scrollbar-color: <thumb> <track>`, tokenised with a self-sufficient
+     *  fallback so the region paints a subtle thumb even without `tokens.css`. */
+    protected readonly scrollbarColor = "var(--fold-scrollbar-thumb, color-mix(in srgb, currentColor 24%, transparent)) var(--fold-scrollbar-track, transparent)";
+    protected readonly overflowY: _angular_core.Signal<"auto" | null>;
+    protected readonly overflowX: _angular_core.Signal<"auto" | null>;
+    /** A scrollable box must be shrinkable on its scroll axis, or flex/grid parents
+     *  pin it to content height and it never scrolls. */
+    protected readonly minHeight: _angular_core.Signal<"0" | null>;
+    protected readonly minWidth: _angular_core.Signal<"0" | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldScrollRegionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FoldScrollRegionDirective, "[foldScrollRegion]", never, { "foldScrollRegion": { "alias": "foldScrollRegion"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Registry of the live scroll regions in a shell — the shell's own content
+ * scroll box and every `[foldScrollRegion]`.
+ *
+ * It exists so an overlay can freeze **the real scroll containers** at once, not
+ * just `document.body`. In a `fold-app-shell` the scroll owner is an inner box
+ * (`.content-scroll`), not `body`, so the body scroll-lock alone leaves the page
+ * scrollable behind a modal panel. The panel host freezes this registry too, and
+ * every registered region — the shell box and each nested `foldScrollRegion` —
+ * stops scrolling until the overlay closes.
+ *
+ * `freeze()`/`unfreeze()` are **reference-counted** (like {@link ScrollLockService}):
+ * stacked overlays each freeze once; the regions thaw only when the last unfreezes.
+ * Freezing toggles {@link FOLD_SCROLL_FROZEN_CLASS} rather than writing inline
+ * `overflow`, so a region's own overflow (inline binding or stylesheet) is never
+ * clobbered — it simply returns when the class is removed.
+ *
+ * SSR-safe: registration only stores an element reference; the class toggles
+ * happen in `freeze()`, which an overlay only calls in the browser.
+ */
+declare class ScrollRegionRegistry {
+    /** The live regions. A `Set` so a double-register is idempotent. */
+    private readonly regions;
+    /** How many overlays currently hold the freeze. */
+    private freezes;
+    /** Add a region. If a freeze is already active, the new region joins it. */
+    register(element: HTMLElement): void;
+    /** Remove a region (on directive/shell teardown) and thaw it. */
+    unregister(element: HTMLElement): void;
+    /** Freeze every region's scroll (idempotent per matching `unfreeze()`). */
+    freeze(): void;
+    /** Release one freeze; thaws the regions only when the last is released. */
+    unfreeze(): void;
+    /** True while at least one overlay holds the freeze. */
+    get isFrozen(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollRegionRegistry, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScrollRegionRegistry>;
+}
+
 /**
  * `<fold-input>` — the text-input control (`value: string`): the *edit* half of a
  * record, where {@link FoldFieldComponent} is the *read* half. It renders an
@@ -2586,39 +4341,340 @@ type FoldNumberControls = "inside" | "outside";
  * field. It also keeps the number-only knobs ({@link min} / {@link max} /
  * {@link step}) off the text input.
  *
- * Empty is a first-class value: clearing the field sets `null` (not `0`, not
- * `NaN`), so an optional number reads correctly. Shares the exact visual shell as
- * `fold-input` (same tokens, sizes, variants) via `input-shell.scss`.
+ * Empty is a first-class value: clearing the field sets `null` (not `0`, not
+ * `NaN`), so an optional number reads correctly. Shares the exact visual shell as
+ * `fold-input` (same tokens, sizes, variants) via `input-shell.scss`.
+ *
+ * @selector `fold-number-input`
+ *
+ * @example
+ * ```html
+ * <!-- Signal-forms field (form.bpm: number) -->
+ * <fold-number-input placeholder="BPM" [min]="0" [formField]="form.bpm" />
+ *
+ * <!-- Standalone two-way -->
+ * <fold-number-input align="center" [step]="0.5" [(value)]="gain" />
+ * ```
+ */
+declare class FoldNumberInputComponent implements FormValueControl<number | null> {
+    /** The bound value — `null` when the field is empty. A `model()` so signal
+     *  forms' `FormField` and `[(value)]` both keep it in sync. */
+    readonly value: _angular_core.ModelSignal<number | null>;
+    /** Disabled state — bound automatically by `FormField` from the field. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Two-way touched state — set on blur (so `FormField` marks the field
+     *  touched), and kept in sync with the field's touched state. */
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    /** Validation errors — bound by `FormField` from the field. */
+    readonly errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+    /** Size preset — see {@link FoldInputComponent.size}. @default 'md' */
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    /** Text alignment inside the box. @default 'start' */
+    readonly align: _angular_core.InputSignal<"center" | "start">;
+    /** Visual variant — see {@link FoldInputComponent.variant}. @default 'default' */
+    readonly variant: _angular_core.InputSignal<"default" | "panel">;
+    /** Optional label displayed above the input. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Show a required marker on the label (and set the native `required`). */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show a lighter `(optional)` marker on the label (ignored when required). */
+    readonly optional: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The word inside the optional marker. @default 'optional' */
+    readonly optionalLabel: _angular_core.InputSignal<string>;
+    /** Optional helper text shown under the input. */
+    readonly hint: _angular_core.InputSignal<string | undefined>;
+    /** Placeholder text. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Render as read-only. Named `readOnly` to avoid the `FormField` reserved binding. */
+    readonly readOnly: _angular_core.InputSignal<boolean>;
+    /** Minimum value — passthrough + bound by a field's `min` validator. */
+    readonly min: _angular_core.InputSignal<number | undefined>;
+    /** Maximum value — passthrough + bound by a field's `max` validator. */
+    readonly max: _angular_core.InputSignal<number | undefined>;
+    /** Increment applied by the spinner buttons / arrow keys. @default 1 */
+    readonly step: _angular_core.InputSignal<number | undefined>;
+    /** The step glyph — `plusminus` (`−`/`+`, default), `arrows` (chevrons), `none`. */
+    readonly spinner: _angular_core.InputSignal<FoldNumberSpinner>;
+    /** Where the buttons sit — `inside` the box (default) or `outside`, flanking it. */
+    readonly controls: _angular_core.InputSignal<FoldNumberControls>;
+    /** Show the {@link step} as a small suffix, so the increment is visible. */
+    readonly showStep: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Keep the value on the step grid. When on, a manually typed value snaps to
+     * the nearest valid `base + n·step` **on blur** (base is {@link min}, else 0),
+     * then clamps to min/max — so free typing is allowed while editing, and the
+     * settled value always respects the step. Off by default.
+     */
+    readonly snapToStep: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Cap the number of decimal places on the settled value: it is rounded to this
+     * many decimals when stepping and on blur. `undefined` = unconstrained (any
+     * decimals allowed). See {@link integer} for the `0` shorthand.
+     */
+    readonly decimals: _angular_core.InputSignal<number | undefined>;
+    /** Shorthand for `decimals = 0` — integers only. Takes precedence over {@link decimals}. */
+    readonly integer: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Unique, SSR-safe id for label association (see {@link FoldIdService}). */
+    readonly inputId: string;
+    /** The effective step (defaults to 1 when unset). */
+    protected readonly effectiveStep: _angular_core.Signal<number>;
+    /** The resolved decimal cap: `0` when {@link integer}, else {@link decimals}. */
+    private readonly maxDecimals;
+    /** The active numeric constraints — shared by settling and the alignment check. */
+    private readonly constraints;
+    /** The native `step` attribute — `1` for integers with no explicit step. */
+    protected readonly nativeStep: _angular_core.Signal<number | undefined>;
+    /** At/below the min bound — the decrement button is disabled. */
+    protected readonly atMin: _angular_core.Signal<boolean>;
+    /** At/above the max bound — the increment button is disabled. */
+    protected readonly atMax: _angular_core.Signal<boolean>;
+    /** Whether any spinner button renders. */
+    protected readonly hasControls: _angular_core.Signal<boolean>;
+    /** Non-interactive (disabled or read-only) → both buttons off. */
+    private readonly frozen;
+    /** The increment button is disabled. */
+    protected readonly incDisabled: _angular_core.Signal<boolean>;
+    /** The decrement button is disabled. */
+    protected readonly decDisabled: _angular_core.Signal<boolean>;
+    /** The message to show under the field: the first error, once touched. */
+    protected readonly errorMessage: _angular_core.Signal<string | undefined>;
+    /** `aria-describedby` target: the error when shown, else the hint, else none. */
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    constructor();
+    /** Parses the native value: empty or unparseable → `null`, otherwise a `number`. */
+    onInputChange(event: Event): void;
+    /** On blur: mark touched; settle the value onto its constraints when any apply. */
+    protected onBlur(): void;
+    /** Keyboard-only click (Enter/Space have `detail === 0`); pointer presses are
+     *  driven by {@link FoldRepeatPressDirective} so they don't double-step. */
+    protected onButtonClick(direction: 1 | -1, event: MouseEvent): void;
+    /** Own the ↑/↓ arrows so keyboard stepping obeys snap/clamp/precision, not the
+     *  native `step` (which would only reconcile on blur). */
+    protected onArrow(direction: 1 | -1, event: Event): void;
+    /** A focused number field changes value on scroll — blur so the page scrolls
+     *  instead (blur on an unfocused input is a no-op). */
+    protected onWheel(event: WheelEvent): void;
+    /** The glyph for a step button in the given direction (arrows vs `− / +`). */
+    protected iconFor(direction: 1 | -1): FoldIconName;
+    /** Nudge the value by ±step, then settle it onto its constraints. */
+    protected stepBy(direction: 1 | -1): void;
+    /**
+     * Resolve a raw number to a valid settled value — the single source of truth
+     * for "what counts as valid", so blur and stepping never diverge. Delegates to
+     * the pure {@link settleNumber} with the current constraints.
+     */
+    private settle;
+    private warnStepMisaligned;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldNumberInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldNumberInputComponent, "fold-number-input", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "optionalLabel": { "alias": "optionalLabel"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "spinner": { "alias": "spinner"; "required": false; "isSignal": true; }; "controls": { "alias": "controls"; "required": false; "isSignal": true; }; "showStep": { "alias": "showStep"; "required": false; "isSignal": true; }; "snapToStep": { "alias": "snapToStep"; "required": false; "isSignal": true; }; "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "integer": { "alias": "integer"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
+/**
+ * `<fold-textarea>` — the multiline sibling of {@link FoldInputComponent}
+ * (`value: string`): a note / description field. It shares the exact box chrome
+ * (tokens, sizes, `panel` variant, focus/disabled) as `fold-input` via
+ * `input-shell.scss`, and the label / required / hint / error chrome via {@link
+ * FoldInputBaseComponent} — so a multiline field is no longer a hand-rolled native
+ * `<textarea>` + duplicated box CSS.
+ *
+ * **No resize handle by design** — the box has a fixed row count and **wraps +
+ * scrolls** its overflow (`resize: none; overflow-y: auto`), so it never breaks a
+ * panel/form layout the way a user-draggable corner does. Height is driven by
+ * `rows` (the box shares the control font / padding / radius but not a fixed
+ * height).
+ *
+ * Integrates with signal forms via the `FormValueControl` contract (bind with
+ * `[formField]`), or drive it standalone with `[(value)]` / `(valueChange)`.
+ *
+ * @selector `fold-textarea`
+ *
+ * @example
+ * ```html
+ * <!-- Signal-forms field -->
+ * <fold-textarea label="Note" [rows]="3" [formField]="form.note" />
+ *
+ * <!-- Standalone two-way -->
+ * <fold-textarea placeholder="Consigne…" [(value)]="note" />
+ * ```
+ */
+declare class FoldTextareaComponent implements FormValueControl<string> {
+    /** The bound value — a `model()` so signal forms' `FormField` and `[(value)]`
+     *  both keep it in sync. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Disabled state — bound automatically by `FormField` from the field. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Two-way touched state — set on blur, kept in sync with the field. */
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    /** Validation errors — bound by `FormField` from the field. */
+    readonly errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+    /** Visible row count — the initial (and, with no resize, effective) height.
+     *  Overflow beyond it wraps and scrolls. @default 3 */
+    readonly rows: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Size preset — see {@link FoldInputComponent.size}. @default 'md' */
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    /** Visual variant — see {@link FoldInputComponent.variant}. @default 'default' */
+    readonly variant: _angular_core.InputSignal<"default" | "panel">;
+    /** Optional label displayed above the control. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Show a required marker on the label (and set the native `required`). */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show a lighter `(optional)` marker on the label (ignored when required). */
+    readonly optional: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The word inside the optional marker. @default 'optional' */
+    readonly optionalLabel: _angular_core.InputSignal<string>;
+    /** Optional helper text shown under the control. */
+    readonly hint: _angular_core.InputSignal<string | undefined>;
+    /** Placeholder text. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Render as read-only. Named `readOnly` (not `readonly`) to avoid the
+     *  signal-forms `FormField` reserved `readonly` field-state binding. */
+    readonly readOnly: _angular_core.InputSignal<boolean>;
+    /** Unique, SSR-safe id for label association (see {@link FoldIdService}). */
+    readonly inputId: string;
+    /** The message to show under the field: the first error, once touched. */
+    protected readonly errorMessage: _angular_core.Signal<string | undefined>;
+    /** `aria-describedby` target: the error when shown, else the hint, else none. */
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** Handles native input event. `value.set()` also fires the model's auto
+     *  `valueChange` output for standalone `(valueChange)` consumers. */
+    onInputChange(event: Event): void;
+    /** Mark the field touched on blur, so errors can surface. */
+    protected onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldTextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldTextareaComponent, "fold-textarea", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "optionalLabel": { "alias": "optionalLabel"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
+/** The native calendar-date input types `fold-date` wraps — they share the exact
+ *  chrome and a `string` value; only the picker granularity differs. For a
+ *  clock/time field use {@link FoldTimeComponent} (`fold-time`). */
+type FoldDateType = "date" | "datetime-local" | "month" | "week";
+/**
+ * `<fold-date>` — the calendar-field sibling of {@link FoldInputComponent}: a thin
+ * wrapper around a **native `<input type="date">`** (and its family — `datetime-local`,
+ * `month`, `week` via {@link type}), like `fold-select` wraps the native `<select>`.
+ * It honours the project's Signal-Forms convention (native `[value]` / `(input)`)
+ * and gives back a **typed `[(value)]`** (the native value string, `YYYY-MM-DD` for
+ * a date) — so consumers stop hand-writing an `inputValue($event)` reader on a bare
+ * `<input type="date">`. For a time-of-day field, use the sibling {@link
+ * FoldTimeComponent} (`fold-time`).
+ *
+ * The native pickers keep the OS calendar + mobile keyboard for free (same
+ * reasoning as {@link FoldNumberInputComponent} staying `type="number"`). This is
+ * **not** a calendar popover — that's the `fold-calendar` family; this is the plain
+ * field. Shares the exact box chrome (tokens, sizes, `panel` variant) via
+ * `input-shell.scss` and the label / required / hint / error chrome via {@link
+ * FoldInputBaseComponent}.
+ *
+ * @selector `fold-date`
+ *
+ * @example
+ * ```html
+ * <!-- A date field, signal-forms bound -->
+ * <fold-date label="Date de livraison" [formField]="form.date" />
+ *
+ * <!-- A month field, standalone two-way -->
+ * <fold-date type="month" [(value)]="billingMonth" />
+ * ```
+ */
+declare class FoldDateComponent implements FormValueControl<string> {
+    /** The bound value — the native input string (`YYYY-MM-DD`, `HH:mm`, …). A
+     *  `model()` so `FormField` and `[(value)]` both stay in sync. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Disabled state — bound automatically by `FormField` from the field. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Two-way touched state — set on blur, kept in sync with the field. */
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    /** Validation errors — bound by `FormField` from the field. */
+    readonly errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+    /** Which native temporal picker to render. @default 'date' */
+    readonly type: _angular_core.InputSignal<FoldDateType>;
+    /** Native `min` bound (e.g. `2026-01-01`) — passes through to the input. Typed
+     *  `string | undefined` (not `| null`) to stay assignable to the signal-forms
+     *  `FormValueControl` reserved `min` field-state binding. */
+    readonly min: _angular_core.InputSignal<string | undefined>;
+    /** Native `max` bound — passes through to the input (see {@link min}). */
+    readonly max: _angular_core.InputSignal<string | undefined>;
+    /** Native `step` (e.g. `60` for whole-minute time) — passes through. */
+    readonly step: _angular_core.InputSignal<string | number | undefined>;
+    /** Size preset — see {@link FoldInputComponent.size}. @default 'md' */
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    /** Visual variant — see {@link FoldInputComponent.variant}. @default 'default' */
+    readonly variant: _angular_core.InputSignal<"default" | "panel">;
+    /** Optional label displayed above the control. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Show a required marker on the label (and set the native `required`). */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show a lighter `(optional)` marker on the label (ignored when required). */
+    readonly optional: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The word inside the optional marker. @default 'optional' */
+    readonly optionalLabel: _angular_core.InputSignal<string>;
+    /** Optional helper text shown under the control. */
+    readonly hint: _angular_core.InputSignal<string | undefined>;
+    /** Render as read-only. Named `readOnly` (not `readonly`) to avoid the
+     *  signal-forms `FormField` reserved `readonly` field-state binding. */
+    readonly readOnly: _angular_core.InputSignal<boolean>;
+    /** Unique, SSR-safe id for label association (see {@link FoldIdService}). */
+    readonly inputId: string;
+    /** The message to show under the field: the first error, once touched. */
+    protected readonly errorMessage: _angular_core.Signal<string | undefined>;
+    /** `aria-describedby` target: the error when shown, else the hint, else none. */
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** Write the chosen native value back through the model. */
+    onInputChange(event: Event): void;
+    /** Mark the field touched on blur, so errors can surface. */
+    protected onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldDateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldDateComponent, "fold-date", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "optionalLabel": { "alias": "optionalLabel"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
+/**
+ * `<fold-time>` — the time-of-day sibling of {@link FoldDateComponent}: a thin
+ * wrapper around a **native `<input type="time">`**, like `fold-select` wraps the
+ * native `<select>`. It honours the project's Signal-Forms convention (native
+ * `[value]` / `(input)`) and gives back a **typed `[(value)]`** (the native value
+ * string, `HH:mm`, or `HH:mm:ss` when a sub-minute `step` is set) — so consumers
+ * stop hand-writing an `inputValue($event)` reader on a bare `<input type="time">`.
+ *
+ * A separate control from `fold-date` (rather than a `type="time"` on it) so each
+ * reads for what it is at the call site — the same "one control, one job" split as
+ * {@link FoldInputComponent} vs {@link FoldNumberInputComponent}. Shares the exact
+ * box chrome (tokens, sizes, `panel` variant) via `input-shell.scss` and the label
+ * / required / hint / error chrome via {@link FoldInputBaseComponent}.
  *
- * @selector `fold-number-input`
+ * @selector `fold-time`
  *
  * @example
  * ```html
- * <!-- Signal-forms field (form.bpm: number) -->
- * <fold-number-input placeholder="BPM" [min]="0" [formField]="form.bpm" />
+ * <!-- Signal-forms bound -->
+ * <fold-time label="Heure de retrait" [formField]="form.time" />
  *
- * <!-- Standalone two-way -->
- * <fold-number-input align="center" [step]="0.5" [(value)]="gain" />
+ * <!-- Standalone two-way, whole-minute steps -->
+ * <fold-time [step]="60" [(value)]="pickupTime" />
  * ```
  */
-declare class FoldNumberInputComponent implements FormValueControl<number | null> {
-    /** The bound value — `null` when the field is empty. A `model()` so signal
-     *  forms' `FormField` and `[(value)]` both keep it in sync. */
-    readonly value: _angular_core.ModelSignal<number | null>;
+declare class FoldTimeComponent implements FormValueControl<string> {
+    /** The bound value — the native input string (`HH:mm` / `HH:mm:ss`). A
+     *  `model()` so `FormField` and `[(value)]` both stay in sync. */
+    readonly value: _angular_core.ModelSignal<string>;
     /** Disabled state — bound automatically by `FormField` from the field. */
     readonly disabled: _angular_core.InputSignal<boolean>;
-    /** Two-way touched state — set on blur (so `FormField` marks the field
-     *  touched), and kept in sync with the field's touched state. */
+    /** Two-way touched state — set on blur, kept in sync with the field. */
     readonly touched: _angular_core.ModelSignal<boolean>;
     /** Validation errors — bound by `FormField` from the field. */
     readonly errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+    /** Native `min` bound (e.g. `09:00`) — passes through to the input. Typed
+     *  `string | undefined` (not `| null`) to stay assignable to the signal-forms
+     *  `FormValueControl` reserved `min` field-state binding. */
+    readonly min: _angular_core.InputSignal<string | undefined>;
+    /** Native `max` bound (e.g. `18:00`) — passes through (see {@link min}). */
+    readonly max: _angular_core.InputSignal<string | undefined>;
+    /** Native `step` in seconds (e.g. `60` whole-minute, `1` seconds field). */
+    readonly step: _angular_core.InputSignal<string | number | undefined>;
     /** Size preset — see {@link FoldInputComponent.size}. @default 'md' */
     readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
-    /** Text alignment inside the box. @default 'start' */
-    readonly align: _angular_core.InputSignal<"center" | "start">;
     /** Visual variant — see {@link FoldInputComponent.variant}. @default 'default' */
     readonly variant: _angular_core.InputSignal<"default" | "panel">;
-    /** Optional label displayed above the input. */
+    /** Optional label displayed above the control. */
     readonly label: _angular_core.InputSignal<string | undefined>;
     /** Show a required marker on the label (and set the native `required`). */
     readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
@@ -2626,92 +4682,23 @@ declare class FoldNumberInputComponent implements FormValueControl<number | null
     readonly optional: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** The word inside the optional marker. @default 'optional' */
     readonly optionalLabel: _angular_core.InputSignal<string>;
-    /** Optional helper text shown under the input. */
+    /** Optional helper text shown under the control. */
     readonly hint: _angular_core.InputSignal<string | undefined>;
-    /** Placeholder text. */
-    readonly placeholder: _angular_core.InputSignal<string>;
-    /** Render as read-only. Named `readOnly` to avoid the `FormField` reserved binding. */
+    /** Render as read-only. Named `readOnly` (not `readonly`) to avoid the
+     *  signal-forms `FormField` reserved `readonly` field-state binding. */
     readonly readOnly: _angular_core.InputSignal<boolean>;
-    /** Minimum value — passthrough + bound by a field's `min` validator. */
-    readonly min: _angular_core.InputSignal<number | undefined>;
-    /** Maximum value — passthrough + bound by a field's `max` validator. */
-    readonly max: _angular_core.InputSignal<number | undefined>;
-    /** Increment applied by the spinner buttons / arrow keys. @default 1 */
-    readonly step: _angular_core.InputSignal<number | undefined>;
-    /** The step glyph — `plusminus` (`−`/`+`, default), `arrows` (chevrons), `none`. */
-    readonly spinner: _angular_core.InputSignal<FoldNumberSpinner>;
-    /** Where the buttons sit — `inside` the box (default) or `outside`, flanking it. */
-    readonly controls: _angular_core.InputSignal<FoldNumberControls>;
-    /** Show the {@link step} as a small suffix, so the increment is visible. */
-    readonly showStep: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /**
-     * Keep the value on the step grid. When on, a manually typed value snaps to
-     * the nearest valid `base + n·step` **on blur** (base is {@link min}, else 0),
-     * then clamps to min/max — so free typing is allowed while editing, and the
-     * settled value always respects the step. Off by default.
-     */
-    readonly snapToStep: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /**
-     * Cap the number of decimal places on the settled value: it is rounded to this
-     * many decimals when stepping and on blur. `undefined` = unconstrained (any
-     * decimals allowed). See {@link integer} for the `0` shorthand.
-     */
-    readonly decimals: _angular_core.InputSignal<number | undefined>;
-    /** Shorthand for `decimals = 0` — integers only. Takes precedence over {@link decimals}. */
-    readonly integer: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Unique, SSR-safe id for label association (see {@link FoldIdService}). */
     readonly inputId: string;
-    /** The effective step (defaults to 1 when unset). */
-    protected readonly effectiveStep: _angular_core.Signal<number>;
-    /** The resolved decimal cap: `0` when {@link integer}, else {@link decimals}. */
-    private readonly maxDecimals;
-    /** The active numeric constraints — shared by settling and the alignment check. */
-    private readonly constraints;
-    /** The native `step` attribute — `1` for integers with no explicit step. */
-    protected readonly nativeStep: _angular_core.Signal<number | undefined>;
-    /** At/below the min bound — the decrement button is disabled. */
-    protected readonly atMin: _angular_core.Signal<boolean>;
-    /** At/above the max bound — the increment button is disabled. */
-    protected readonly atMax: _angular_core.Signal<boolean>;
-    /** Whether any spinner button renders. */
-    protected readonly hasControls: _angular_core.Signal<boolean>;
-    /** Non-interactive (disabled or read-only) → both buttons off. */
-    private readonly frozen;
-    /** The increment button is disabled. */
-    protected readonly incDisabled: _angular_core.Signal<boolean>;
-    /** The decrement button is disabled. */
-    protected readonly decDisabled: _angular_core.Signal<boolean>;
     /** The message to show under the field: the first error, once touched. */
     protected readonly errorMessage: _angular_core.Signal<string | undefined>;
     /** `aria-describedby` target: the error when shown, else the hint, else none. */
     protected readonly describedBy: _angular_core.Signal<string | null>;
-    constructor();
-    /** Parses the native value: empty or unparseable → `null`, otherwise a `number`. */
+    /** Write the chosen native value back through the model. */
     onInputChange(event: Event): void;
-    /** On blur: mark touched; settle the value onto its constraints when any apply. */
+    /** Mark the field touched on blur, so errors can surface. */
     protected onBlur(): void;
-    /** Keyboard-only click (Enter/Space have `detail === 0`); pointer presses are
-     *  driven by {@link FoldRepeatPressDirective} so they don't double-step. */
-    protected onButtonClick(direction: 1 | -1, event: MouseEvent): void;
-    /** Own the ↑/↓ arrows so keyboard stepping obeys snap/clamp/precision, not the
-     *  native `step` (which would only reconcile on blur). */
-    protected onArrow(direction: 1 | -1, event: Event): void;
-    /** A focused number field changes value on scroll — blur so the page scrolls
-     *  instead (blur on an unfocused input is a no-op). */
-    protected onWheel(event: WheelEvent): void;
-    /** The glyph for a step button in the given direction (arrows vs `− / +`). */
-    protected iconFor(direction: 1 | -1): FoldIconName;
-    /** Nudge the value by ±step, then settle it onto its constraints. */
-    protected stepBy(direction: 1 | -1): void;
-    /**
-     * Resolve a raw number to a valid settled value — the single source of truth
-     * for "what counts as valid", so blur and stepping never diverge. Delegates to
-     * the pure {@link settleNumber} with the current constraints.
-     */
-    private settle;
-    private warnStepMisaligned;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldNumberInputComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldNumberInputComponent, "fold-number-input", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "optionalLabel": { "alias": "optionalLabel"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "spinner": { "alias": "spinner"; "required": false; "isSignal": true; }; "controls": { "alias": "controls"; "required": false; "isSignal": true; }; "showStep": { "alias": "showStep"; "required": false; "isSignal": true; }; "snapToStep": { "alias": "snapToStep"; "required": false; "isSignal": true; }; "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "integer": { "alias": "integer"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldTimeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldTimeComponent, "fold-time", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "optionalLabel": { "alias": "optionalLabel"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
 }
 
 /**
@@ -2906,6 +4893,22 @@ interface FoldSelectOption<T> {
     /** Skip in keyboard nav and block selection. @default false */
     readonly disabled?: boolean;
 }
+/**
+ * A labelled group of options for the array API — the data-driven counterpart to
+ * a projected `<fold-optgroup>`. Put groups (and/or plain options) in the
+ * `[options]` array; the control renders each group's `options` under its
+ * `label`, and keyboard nav still roves the flattened list in order.
+ */
+interface FoldSelectOptionGroup<T> {
+    /** The group heading — its accessible name; not selectable. */
+    readonly label: string;
+    /** The options under this heading. */
+    readonly options: readonly FoldSelectOption<T>[];
+}
+/** One entry of the `[options]` array: a plain option or a labelled group. */
+type FoldSelectItem<T> = FoldSelectOption<T> | FoldSelectOptionGroup<T>;
+/** True when an `[options]` entry is a group (has nested `options`), not a leaf. */
+declare function isFoldSelectOptionGroup<T>(item: FoldSelectItem<T>): item is FoldSelectOptionGroup<T>;
 
 /**
  * The contract a `fold-option` needs from whatever owns it — the single-select
@@ -2957,8 +4960,10 @@ declare class FoldListboxComponent<T> implements FormValueControl<T | null>, Fol
     readonly compareWith: _angular_core.InputSignal<((a: T, b: T) => boolean) | undefined>;
     /** Data-driven options — the alternative to projecting `<fold-option>`. When
      *  set, the value type is linked to the options at compile time (no projection
-     *  seam). For rich rows, project `<ng-template #option let-o>`. */
-    readonly options: _angular_core.InputSignal<readonly FoldSelectOption<T>[] | undefined>;
+     *  seam). Entries can be plain options or labelled {@link FoldSelectOptionGroup}s
+     *  (the array counterpart to `<fold-optgroup>`). For rich rows, project
+     *  `<ng-template #option let-o>`. */
+    readonly options: _angular_core.InputSignal<readonly FoldSelectItem<T>[] | undefined>;
     /** Disabled state — bound automatically by `FormField`. */
     readonly disabled: _angular_core.InputSignal<boolean>;
     /** Two-way touched state — set on selection / blur, kept in sync with the field. */
@@ -3032,6 +5037,11 @@ declare class FoldListboxComponent<T> implements FormValueControl<T | null>, Fol
     constructor();
     /** A value is selected when it equals the current one (via `compareWith`). */
     isSelected(value: T): boolean;
+    /** Narrow an `[options]` entry to a group, or `null` — lets the template
+     *  branch on the two shapes with each side fully typed (no `any`). */
+    protected asGroup(item: FoldSelectItem<T>): FoldSelectOptionGroup<T> | null;
+    /** Narrow an `[options]` entry to a plain option, or `null`. */
+    protected asOption(item: FoldSelectItem<T>): FoldSelectOption<T> | null;
     /** Clear the selection (the `allowClear` ×). */
     protected clear(event: Event): void;
     /** Open with the keys a native select opens on; otherwise type-ahead picks
@@ -3083,9 +5093,11 @@ declare class FoldMultiselectComponent<T> implements FormValueControl<readonly T
      *  values; primitives don't need it. @default `Object.is` */
     readonly compareWith: _angular_core.InputSignal<((a: T, b: T) => boolean) | undefined>;
     /** Data-driven options — the alternative to projecting `<fold-option>`. When
-     *  set, the value type is linked to the options at compile time. For rich rows,
-     *  project `<ng-template #option let-o>`. */
-    readonly options: _angular_core.InputSignal<readonly FoldSelectOption<T>[] | undefined>;
+     *  set, the value type is linked to the options at compile time. Entries can be
+     *  plain options or labelled {@link FoldSelectOptionGroup}s (the array
+     *  counterpart to `<fold-optgroup>`). For rich rows, project
+     *  `<ng-template #option let-o>`. */
+    readonly options: _angular_core.InputSignal<readonly FoldSelectItem<T>[] | undefined>;
     /** Disabled state — bound automatically by `FormField`. */
     readonly disabled: _angular_core.InputSignal<boolean>;
     /** Two-way touched state — set on the first toggle, kept in sync with the field. */
@@ -3112,6 +5124,16 @@ declare class FoldMultiselectComponent<T> implements FormValueControl<readonly T
     readonly placeholder: _angular_core.InputSignal<string | undefined>;
     /** Preferred popup placement. @default 'bottom-start' */
     readonly placement: _angular_core.InputSignal<FoldPopoverPlacement>;
+    /** Offer a **Select all** bulk action at the top of the panel (adds every
+     *  enabled option to the set). @default false */
+    readonly allowSelectAll: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Offer a **Clear** bulk action at the top of the panel (empties the set). The
+     *  multiselect counterpart to `fold-listbox`'s trigger `allowClear`. @default false */
+    readonly allowClear: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Label of the select-all action. @default 'Select all' */
+    readonly selectAllLabel: _angular_core.InputSignal<string>;
+    /** Label of the clear action. @default 'Clear' */
+    readonly clearLabel: _angular_core.InputSignal<string>;
     /** Unique, SSR-safe id for label association (see {@link FoldIdService}). */
     readonly inputId: string;
     /** Id of the `role="listbox"` element (own, distinct from the popover panel). */
@@ -3142,12 +5164,22 @@ declare class FoldMultiselectComponent<T> implements FormValueControl<readonly T
     protected readonly errorMessage: _angular_core.Signal<string | undefined>;
     /** `aria-describedby` target: the error when shown, else the hint, else none. */
     protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** Whether the bulk-action bar shows at all (either affordance enabled, and
+     *  there is at least one option to act on). */
+    protected readonly showBulk: _angular_core.Signal<boolean>;
+    /** Every enabled option is already selected — nothing left for "Select all". */
+    protected readonly allEnabledSelected: _angular_core.Signal<boolean>;
     /** Has the popup been opened this lifetime — so any close marks touched (blur
      *  parity), even one that picked nothing. */
     private hasOpened;
     constructor();
     /** A value is selected when it's in the current set (via `compareWith`). */
     isSelected(value: T): boolean;
+    /** Narrow an `[options]` entry to a group, or `null` — lets the template
+     *  branch on the two shapes with each side fully typed (no `any`). */
+    protected asGroup(item: FoldSelectItem<T>): FoldSelectOptionGroup<T> | null;
+    /** Narrow an `[options]` entry to a plain option, or `null`. */
+    protected asOption(item: FoldSelectItem<T>): FoldSelectOption<T> | null;
     /** Open with the keys a native select opens on. */
     protected onTriggerKeydown(event: KeyboardEvent): void;
     /** Keyboard while the list is open and focused — delegated to the core. */
@@ -3160,10 +5192,15 @@ declare class FoldMultiselectComponent<T> implements FormValueControl<readonly T
     private firstSelectedIndex;
     /** Index of the enabled option under an event target, or -1. */
     private enabledIndexFrom;
+    /** Add every enabled option to the set (keeps already-picked disabled ones);
+     *  the panel stays open. */
+    protected selectAll(): void;
+    /** Empty the set (the bulk "Clear"). */
+    protected clearAll(): void;
     /** Add or remove the option's value from the set; the panel stays open. */
     private toggle;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldMultiselectComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldMultiselectComponent<any>, "fold-multiselect", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "optionalLabel": { "alias": "optionalLabel"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; "open": "openChange"; }, ["optionTemplate", "projectedOptions"], ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldMultiselectComponent<any>, "fold-multiselect", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "optionalLabel": { "alias": "optionalLabel"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "allowSelectAll": { "alias": "allowSelectAll"; "required": false; "isSignal": true; }; "allowClear": { "alias": "allowClear"; "required": false; "isSignal": true; }; "selectAllLabel": { "alias": "selectAllLabel"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; "open": "openChange"; }, ["optionTemplate", "projectedOptions"], ["*"], true, never>;
 }
 
 /**
@@ -3205,6 +5242,40 @@ declare class FoldOptionComponent<T> {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldOptionComponent<any>, "fold-option", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
+/**
+ * `<fold-optgroup>` — a labelled group of `<fold-option>`s inside a
+ * {@link FoldListboxComponent} / {@link FoldMultiselectComponent}, the styleable
+ * counterpart to the native `<optgroup>`. Purely presentational: it renders a
+ * non-selectable header and projects its options, which the owning listbox still
+ * discovers (it queries options with `descendants: true`) and roves across in
+ * document order — so grouping changes the layout, never the keyboard model.
+ *
+ * `role="group"` + `aria-labelledby` names the group for assistive tech; the
+ * header carries no `role="option"`, so keyboard nav skips straight over it.
+ *
+ * ```html
+ * <fold-listbox [(value)]="city">
+ *   <fold-optgroup label="France">
+ *     <fold-option value="paris">Paris</fold-option>
+ *     <fold-option value="lyon">Lyon</fold-option>
+ *   </fold-optgroup>
+ *   <fold-optgroup label="Italia">
+ *     <fold-option value="roma">Roma</fold-option>
+ *   </fold-optgroup>
+ * </fold-listbox>
+ * ```
+ *
+ * @selector `fold-optgroup`
+ */
+declare class FoldOptgroupComponent {
+    /** The group's visible heading — also its accessible name (`aria-labelledby`). */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Stable, SSR-safe id the group's `aria-labelledby` points at. */
+    readonly labelId: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldOptgroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldOptgroupComponent, "fold-optgroup", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
 /**
  * One password requirement shown as a live-validating dot in
  * {@link FoldPasswordFieldComponent}. The predicate is deliberately just a
@@ -3639,7 +5710,7 @@ declare class FoldCalloutComponent {
     protected readonly iconName: _angular_core.Signal<FoldIconName>;
     /** The resolved ARIA role — public so a consumer (or the gallery) can show
      *  what `announce` actually did, since it changes nothing visually. */
-    readonly role: _angular_core.Signal<"alert" | "note" | "status">;
+    readonly role: _angular_core.Signal<"alert" | "status" | "note">;
     /** The resolved live-region politeness, or `null` when passive. */
     readonly ariaLive: _angular_core.Signal<"assertive" | "polite" | null>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldCalloutComponent, never>;
@@ -3971,6 +6042,10 @@ declare class FoldIconRegistry {
     resolve(name: string): string | undefined;
     /** Whether a name is registered. Reactive. */
     has(name: string): boolean;
+    /** Every registered icon name (built-ins + runtime additions), sorted.
+     *  Reactive — recomputes when an icon is registered. Powers tooling that
+     *  browses the live catalogue (e.g. the `fold-icon-devtool`). */
+    names(): string[];
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldIconRegistry, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<FoldIconRegistry>;
 }
@@ -4248,6 +6323,20 @@ declare class FoldPageTitleDirective {
  * </fold-page-layout>
  * ```
  *
+ * ## Who owns the scroll
+ * The `scroll` input decides whether the page is its own scroll box:
+ * - **`flow` (default)** — the page owns **no** scroll; it flows inside its
+ *   host's scroll region (typically the `fold-app-shell` content, which owns the
+ *   scroll). This is the "never manage scroll again" default — the page just
+ *   grows and the shell scrolls, so a shell footer at the end of the content is
+ *   always reachable and there is never a page-inside-shell double scrollbar.
+ * - **`own`** — the page is its own scroll box (the legacy behaviour):
+ *   `overflow-y: auto` + `overscroll-behavior: contain`, filling the height its
+ *   frame gives it. Reach for it only when the page must scroll as a self-
+ *   contained unit — dropped into a `stage` shell (whose content region does not
+ *   scroll) or a bare fixed-height container. See the shell's `scroll` knob and
+ *   `docs/scroll.md`.
+ *
  * @selector `fold-page-layout`
  */
 declare class FoldPageLayoutComponent {
@@ -4257,11 +6346,19 @@ declare class FoldPageLayoutComponent {
     readonly title: _angular_core.InputSignal<string | undefined>;
     /** An optional leading icon shown beside the title. */
     readonly icon: _angular_core.InputSignal<FoldIconName | undefined>;
+    /**
+     * Who owns the page's scroll:
+     * - `"flow"` (default) — the page flows inside its host's scroll (the shell
+     *   owns the scroll); the page has no scroll box of its own.
+     * - `"own"` — the page is its own scroll box (`overflow-y: auto`), for a page
+     *   dropped into a non-scrolling `stage` shell or a bare fixed-height frame.
+     */
+    readonly scroll: _angular_core.InputSignal<"flow" | "own">;
     /** A projected `[pageTitle]`, if any — switches the header on for a custom
      *  title even without the `title` input. */
     protected readonly customTitle: _angular_core.Signal<FoldPageTitleDirective | undefined>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldPageLayoutComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldPageLayoutComponent, "fold-page-layout", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, ["customTitle"], ["[pageTitle]", "[titleBadge]", "p[description]", "[pageActions]", "*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldPageLayoutComponent, "fold-page-layout", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "scroll": { "alias": "scroll"; "required": false; "isSignal": true; }; }, {}, ["customTitle"], ["[pageTitle]", "[titleBadge]", "p[description]", "[pageActions]", "*"], true, never>;
 }
 
 /**
@@ -4640,12 +6737,98 @@ declare class FoldViewNavComponent {
     readonly background: _angular_core.InputSignal<"transparent" | "surface">;
     /** The nearest layout, if any — lets `direction="auto"` follow it. */
     private readonly layout;
+    /**
+     * No wrapping `fold-nav-layout`. Standalone, the bar owns its gap to the
+     * following content; inside a layout, the layout owns it (avoiding a double
+     * gap).
+     */
+    protected readonly isStandalone: _angular_core.Signal<boolean>;
     /** `direction` with `auto` resolved against the wrapping layout. */
     protected readonly resolvedDirection: _angular_core.Signal<"vertical" | "horizontal">;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldViewNavComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldViewNavComponent, "fold-view-nav", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "activeKey": { "alias": "activeKey"; "required": false; "isSignal": true; }; "activeStyle": { "alias": "activeStyle"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "background": { "alias": "background"; "required": false; "isSignal": true; }; }, { "activeKey": "activeKeyChange"; }, never, never, true, never>;
 }
 
+/**
+ * One crumb in a {@link FoldBreadcrumbComponent} trail. A crumb links via **either**
+ * an Angular `routerLink` (in-app) **or** a plain `href` (external / a non-router
+ * app); give neither for a non-interactive step. The **last** item is always
+ * rendered as the current page (never a link), whatever it carries.
+ */
+interface FoldBreadcrumbItem {
+    /** The crumb's visible text. */
+    readonly label: string;
+    /** Angular router target — a `routerLink` commands string or array. Takes
+     *  precedence over {@link href}. */
+    readonly routerLink?: string | unknown[];
+    /** Plain URL — for an external crumb, or an app that doesn't use the router. */
+    readonly href?: string;
+}
+/**
+ * `<fold-breadcrumb>` — a hierarchical trail of links to the current page. Data
+ * driven: pass `[items]`; each crumb links by `routerLink` **or** `href`, so it
+ * works in a router app and degrades to plain anchors without one (importing it
+ * never forces `@angular/router` — `RouterLink` is only instantiated on a crumb
+ * that actually sets `routerLink`). The last item renders as the current page
+ * (`aria-current="page"`), not a link. Chevron separators are decorative.
+ *
+ * ```html
+ * <fold-breadcrumb
+ *   [items]="[
+ *     { label: 'Accueil', routerLink: '/' },
+ *     { label: 'Catalogue', routerLink: '/catalogue' },
+ *     { label: 'Café d’Isère' },
+ *   ]"
+ * />
+ * ```
+ *
+ * @selector `fold-breadcrumb`
+ */
+declare class FoldBreadcrumbComponent {
+    /** The trail, root first; the last item is the current page. */
+    readonly items: _angular_core.InputSignal<readonly FoldBreadcrumbItem[]>;
+    /** Accessible name of the navigation landmark. @default 'Breadcrumb' */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldBreadcrumbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldBreadcrumbComponent, "fold-breadcrumb", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * `<fold-back-link>` — the “← Back” affordance for a detail page. Three modes,
+ * picked by which input is set:
+ * - `routerLink` — an in-app `<a routerLink>` to a specific parent route.
+ * - `href` — a plain `<a href>` (external, or a non-router app).
+ * - neither — a `<button>` that goes **back in history** (`Location.back()`).
+ *
+ * Router-coupled but degradable: importing it never forces `@angular/router`
+ * (`RouterLink` only instantiates on a `routerLink`), and the history-back mode
+ * needs no router at all.
+ *
+ * ```html
+ * <fold-back-link routerLink="/contrats" label="Tous les contrats" />
+ * <fold-back-link href="/dashboard" />
+ * <fold-back-link />            <!-- history back -->
+ * ```
+ *
+ * @selector `fold-back-link`
+ */
+declare class FoldBackLinkComponent {
+    private readonly location;
+    /** The link text. @default 'Back' */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Angular router target — takes precedence over {@link href}. When both this
+     *  and `href` are unset, the control is a history-back button. */
+    readonly routerLink: _angular_core.InputSignal<string | unknown[] | undefined>;
+    /** Plain URL target (external, or a non-router app). */
+    readonly href: _angular_core.InputSignal<string | undefined>;
+    /** Leading icon. @default 'chevron-left' */
+    readonly icon: _angular_core.InputSignal<FoldIconName>;
+    /** History-back navigation, for the button mode. */
+    protected goBack(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldBackLinkComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldBackLinkComponent, "fold-back-link", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "routerLink": { "alias": "routerLink"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 /** A tab in a {@link FoldTabsComponent} bar. */
 type FoldTabItem = {
     /** Unique key — identifies the tab / its panel, emitted on change. */
@@ -4892,8 +7075,17 @@ declare const FOLD_TOAST_CONFIG: InjectionToken<FoldToastConfig>;
  */
 declare function provideFoldToasts(config: FoldToastConfig): Provider;
 
-/** Which layout edge the panel slides in from. */
-type FoldPanelSide = "left" | "right";
+/**
+ * Which layout edge the panel slides in from.
+ * - `right` (default) / `left` — a vertical side sheet, full height.
+ * - `bottom` — a bottom sheet: full width, height driven by content up to a
+ *   max-height with internal scroll; slides up. The mobile-native shape, with a
+ *   top grabber that taps to dismiss.
+ * - `auto` — **right on a wide container, bottom on a narrow one**. The switch is
+ *   container-driven (keyed off the panel host's own width via `@container`, not
+ *   the viewport), honouring fold's "responsive on its own width" contract.
+ */
+type FoldPanelSide = "left" | "right" | "bottom" | "auto";
 /**
  * Panel surface treatment.
  * - `glass` (default) — frosted, translucent; the page shows through.
@@ -5009,9 +7201,15 @@ type FoldPanelDescriptor = FoldTemplatePanelDescriptor | FoldComponentPanelDescr
 /**
  * A component opened imperatively. Data-carrying panels declare a typed `data`
  * input; data-less panels (e.g. a help panel) simply omit it.
+ *
+ * `data` is typed as the **read** side (`Signal`), covariant, not the invariant
+ * `InputSignal` — so a panel whose data input is *optional* (`data = input<T>()`
+ * → `InputSignal<T | undefined>`) satisfies `FoldPanelContent<T>` just as a
+ * required one (`input.required<T>()`) does. That's what lets `open(Cmp, { data })`
+ * infer `T` from the value without the caller widening to `<T | undefined>`.
  */
 interface FoldPanelContent<TData> {
-    readonly data?: InputSignal<TData>;
+    readonly data?: Signal<TData | undefined>;
 }
 /** Options for `FoldPanelHostService.open()`. */
 interface FoldPanelConfig<TData> {
@@ -5079,6 +7277,7 @@ interface FoldPanelHandle {
 declare class FoldPanelHostComponent {
     private readonly host;
     private readonly scrollLock;
+    private readonly scrollRegions;
     private readonly element;
     private readonly document;
     readonly panels: _angular_core.Signal<readonly FoldPanelDescriptor[]>;
@@ -5102,6 +7301,16 @@ declare class FoldPanelHostComponent {
     shouldTrap(panel: FoldPanelDescriptor): boolean;
     /** Surface treatment for the panel shell; defaults to `glass`. */
     panelSurface(panel: FoldPanelDescriptor): FoldPanelSurface;
+    /** The edge the panel docks to; defaults to `right`. `auto` is resolved to
+     *  right/bottom by the CSS `@container` on the host's own width, not here. */
+    panelSide(panel: FoldPanelDescriptor): FoldPanelSide;
+    /** A bottom sheet (`bottom`, or `auto` which can become one on a narrow host)
+     *  gets a top grabber. Hidden by CSS when `auto` resolves to a side sheet. */
+    hasGrabber(panel: FoldPanelDescriptor): boolean;
+    /** Accessible label for the bottom-sheet grabber — the app-wide close label. */
+    protected readonly dismissLabel: string;
+    /** Tapping the grabber dismisses the sheet, unless it guards implicit close. */
+    onGrabber(panel: FoldPanelDescriptor): void;
     /**
      * The implicit dismiss gestures (Escape, backdrop) are suppressed when a panel
      * sets `disableClose` — the header close button and `FoldPanelRef.close()`
@@ -5208,6 +7417,46 @@ declare class FoldPanelHeaderComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldPanelHeaderComponent, "fold-panel-header", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["*", "[actions]"], true, never>;
 }
 
+/**
+ * `<fold-panel-footer>` — the action bar that pairs with {@link
+ * FoldPanelHeaderComponent} at the bottom of an imperative panel (or a future
+ * `fold-dialog`). It carries the tokenised top border + padding and the button
+ * alignment, so a panel no longer hand-rolls a `<footer class="foot">` with a
+ * copied flex row. Project the buttons (and any leading content) as children.
+ *
+ * It sits at the panel's bottom edge with `flex: none`, so in the standard
+ * flex-column panel — a scrolling body above it — it stays pinned there with no
+ * `position: sticky` needed; the body scrolls, the footer doesn't.
+ *
+ * `align`:
+ * - `end` (default) — buttons pushed to the trailing edge (the Annuler/Confirmer
+ *   pair). Multiple children are separated by the token gap.
+ * - `between` — space between the first and last child: a leading block (e.g. a
+ *   running total) at the start, the actions at the end.
+ * - `start` — everything at the leading edge.
+ *
+ * ```html
+ * <fold-panel-footer>
+ *   <button foldButton emphasis="outline" intent="neutral" (click)="cancel()">Annuler</button>
+ *   <button foldButton (click)="save()">Enregistrer</button>
+ * </fold-panel-footer>
+ *
+ * <!-- a running total on the left, actions on the right -->
+ * <fold-panel-footer align="between">
+ *   <span class="total">Total {{ total }}</span>
+ *   <button foldButton (click)="checkout()">Commander</button>
+ * </fold-panel-footer>
+ * ```
+ *
+ * @selector `fold-panel-footer`
+ */
+declare class FoldPanelFooterComponent {
+    /** Button alignment along the bar. @default 'end' */
+    readonly align: _angular_core.InputSignal<"start" | "end" | "between">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldPanelFooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldPanelFooterComponent, "fold-panel-footer", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
 /**
  * Handle to an imperatively-opened panel. The opener gets it back from
  * `FoldPanelHostService.open()`; the panel component gets the same instance via
@@ -5639,6 +7888,395 @@ declare class FoldPaletteRegistry {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<FoldPaletteRegistry>;
 }
 
-export { FOLD_AUTO_PALETTES, FOLD_BLUR_TOKENS, FOLD_BUILTIN_ICONS, FOLD_DATA_TABLE_DEFAULT_LABELS, FOLD_DATA_TABLE_LABELS, FOLD_INLINE_CONFIRM_DEFAULT_LABELS, FOLD_INLINE_CONFIRM_LABELS, FOLD_MOTION_TOKENS, FOLD_PAGINATOR_DEFAULT_LABELS, FOLD_PAGINATOR_LABELS, FOLD_PALETTE_DEFAULT, FOLD_PANEL_CLOSE_LABEL, FOLD_PANEL_DEFAULTS, FOLD_RADIUS_TOKENS, FOLD_SEMANTIC_COLOR_TOKENS, FOLD_SHADOW_TOKENS, FOLD_SPACE_TOKENS, FOLD_TEXT_TOKENS, FOLD_TOAST_CONFIG, FoldAppShellComponent, FoldAsideLayoutComponent, FoldAvatarComponent, FoldAvatarDetailComponent, FoldAvatarListComponent, FoldBadgeComponent, FoldButtonComponent, FoldButtonIconComponent, FoldCalloutComponent, FoldCardComponent, FoldCheckboxComponent, FoldChoiceRowComponent, FoldContextCardComponent, FoldDataTableCellDirective, FoldDataTableComponent, FoldDataTableRowCardDirective, FoldDisclosureComponent, FoldDropdownComponent, FoldDropdownItemComponent, FoldElementTitleComponent, FoldElevatedDirective, FoldEmptyStateComponent, FoldFieldComponent, FoldFieldIdDirective, FoldFieldListComponent, FoldFileDropzoneComponent, FoldHeroCardComponent, FoldHeroSectionComponent, FoldIconComponent, FoldIconRegistry, FoldIdService, FoldInlineConfirmComponent, FoldInputComponent, FoldLinkComponent, FoldListboxComponent, FoldLoadingStateComponent, FoldMenuComponent, FoldMenuItemComponent, FoldMenuSectionComponent, FoldMenuSeparatorComponent, FoldMultiselectComponent, FoldNavLauncherComponent, FoldNavLayoutComponent, FoldNavTileComponent, FoldNumberInputComponent, FoldOptionComponent, FoldPageLayoutComponent, FoldPageSectionComponent, FoldPageTitleDirective, FoldPaginatorComponent, FoldPaletteRegistry, FoldPanelComponentOutletDirective, FoldPanelHeaderComponent, FoldPanelHostComponent, FoldPanelHostService, FoldPanelRef, FoldPanelToggle, FoldPasswordFieldComponent, FoldPopoverComponent, FoldPopoverTriggerDirective, FoldRangeSliderComponent, FoldRepeatPressDirective, FoldSearchComponent, FoldSelectComponent, FoldSliderComponent, FoldSpinnerComponent, FoldStatusBadgeComponent, FoldStickyColumnDirective, FoldSurfaceDirective, FoldTabPanelComponent, FoldTabsComponent, FoldTimelineComponent, FoldToastComponent, FoldToastContainerComponent, FoldToastService, FoldToggleIconComponent, FoldViewNavComponent, FoldViewToggleComponent, autoUpdate, computePlacement, foldBlurVar, foldCardBandChrome, foldColorProperty, foldColorVar, foldDefaultPasswordRules, foldHashSeed, foldMotionVar, foldRadiusVar, foldRegexRule, foldResolvePalette, foldShadowVar, foldSpaceVar, foldTextVar, observeElementWidth, provideFoldDataTableLabels, provideFoldIcons, provideFoldInlineConfirmLabels, provideFoldPaginatorLabels, provideFoldPalette, provideFoldPanelDefaults, provideFoldPanelLabels, provideFoldToasts };
-export type { FoldAutoPaletteName, FoldAvatarListItem, FoldAvatarRing, FoldAvatarRingStyle, FoldAvatarVariant, FoldBadgeVariant, FoldBlurToken, FoldBuiltinIconName, FoldButtonEmphasis, FoldButtonIconShape, FoldButtonIconSize, FoldButtonIconTone, FoldButtonIntent, FoldButtonShape, FoldButtonSize, FoldCalloutAppearance, FoldCalloutVariant, FoldCardBandChrome, FoldCardBandChromeInput, FoldChoiceOption, FoldComponentPanelDescriptor, FoldDataTableLabels, FoldIconName, FoldIconSet, FoldIconSize, FoldIconTone, FoldInlineConfirmLabels, FoldMenuItemBadgeTone, FoldMenuLevel, FoldMenuTint, FoldMenuTogglePlacement, FoldMotionToken, FoldNumberControls, FoldNumberSpinner, FoldPageItem, FoldPaginatorLabels, FoldPaletteInput, FoldPanelConfig, FoldPanelContent, FoldPanelDefaults, FoldPanelDefaultsProvider, FoldPanelDescriptor, FoldPanelHandle, FoldPanelLabels, FoldPanelSide, FoldPanelSize, FoldPanelSurface, FoldPasswordRule, FoldPlacementInput, FoldPlacementResult, FoldPopoverAlign, FoldPopoverPlacement, FoldPopoverSide, FoldRadiusToken, FoldRangeValue, FoldRect, FoldSelectOption, FoldSemanticColorToken, FoldShadowToken, FoldSpaceToken, FoldSpinnerSize, FoldStickyColumnAnchor, FoldSurfaceName, FoldTabItem, FoldTableColumn, FoldTableEmpty, FoldTableSort, FoldTableSortDir, FoldTableTone, FoldTabsContext, FoldTemplatePanelDescriptor, FoldTextToken, FoldTimelineDatePlacement, FoldTimelineNode, FoldToast, FoldToastConfig, FoldToastVariant, FoldViewNavItem, FoldViewToggleOption };
+/**
+ * What "next" means, and what the period on display is called — the two
+ * questions a calendar toolbar asks. Both depend on the view, so they live
+ * here as pure functions rather than as a switch inside a component.
+ */
+/** The four readings the family ships. */
+type FoldCalendarBuiltInView = "month" | "week" | "day" | "list";
+/**
+ * Which reading is on screen.
+ *
+ * The four built-ins **autocomplete**, but the type is open: an app can put its
+ * own reading (a resource grid, a timeline) in the same switch without the
+ * library having to know about it. Paging and titling an unknown view falls
+ * back to month semantics — see {@link foldShiftDate}.
+ */
+type FoldCalendarView = FoldCalendarBuiltInView | (string & Record<never, never>);
+/** A view the toolbar offers, when its name is the app's own. */
+interface FoldCalendarViewOption {
+    /** What `view` is set to when this one is picked. */
+    readonly value: string;
+    /** What the switch shows. */
+    readonly label: string;
+}
+/** An inclusive span of days. */
+interface FoldCalendarRange {
+    readonly from: FoldCalendarDate;
+    readonly to: FoldCalendarDate;
+}
+/**
+ * `date` moved by `delta` periods **in the units the view reads in** — a month
+ * at a time in the month view, a week in the week view, a day in the day view.
+ * The list view follows the month, since that is the window it lists.
+ *
+ * An unrecognised view pages by month, the safest of the four to be wrong
+ * about: it always lands on a real date the other views can also show.
+ */
+declare function foldShiftDate(view: FoldCalendarView, date: FoldCalendarDate, delta: number, weekStartsOn?: FoldWeekday): FoldCalendarDate;
+/**
+ * The days `view` covers around `date` — what a caller passes to its data
+ * source, and what the list view scopes itself to.
+ *
+ * The **month** view's range is wider than its month: the grid paints the days
+ * either side of it, and they carry their events too. The **list** view's is
+ * not, because a list has no padding days — an April row in a May list is an
+ * event the reader did not ask for.
+ */
+declare function foldRangeForView(view: FoldCalendarView, date: FoldCalendarDate, weekStartsOn?: FoldWeekday): FoldCalendarRange;
+/**
+ * The heading for the period on display, localised through `Intl` — "May 2026",
+ * "18–24 May 2026", "Monday 18 May 2026". A week spanning two months or two
+ * years names both ends, which `Intl`'s range formatter handles per locale.
+ */
+declare function foldViewTitle(view: FoldCalendarView, date: FoldCalendarDate, locale?: string, weekStartsOn?: FoldWeekday): string;
+
+/**
+ * `<fold-calendar-toolbar>` — the chrome above a calendar: jump to today, page
+ * back and forward, the period's name, and the view switch.
+ *
+ * It owns no data. Both pieces of state it touches are two-way `model`s, so
+ * the page binds the same `date` and `view` it hands to whichever view is on
+ * screen, and paging keeps working without a single output handler.
+ *
+ * The step matches the reading: a month at a time under the month view, a week
+ * under the week view, a day under the day view — see `foldShiftDate`.
+ *
+ * ## Inputs
+ * | Input          | Type                     | Default | Meaning |
+ * |----------------|--------------------------|---------|---------|
+ * | `date`         | `FoldCalendarDate`       | —       | **Two-way.** The period on display. |
+ * | `view`         | `FoldCalendarView`       | `'month'` | **Two-way.** Which reading is on screen. |
+ * | `views`        | `(FoldCalendarView \| FoldCalendarViewOption)[]` | all four | Which switches to offer; pass fewer to drop one, or `{ value, label }` to add your own. |
+ * | `today`        | `FoldCalendarDate`       | local clock | Where the "today" button jumps to. |
+ * | `weekStartsOn` | `FoldWeekday`            | the locale's | How the week view snaps and names itself. |
+ * | `locale`       | `string`                 | runtime | Drives the title through `Intl`. |
+ * | `labels`       | `Partial<FoldCalendarLabels>` | — | Per-instance label overrides. |
+ *
+ * ## Slots & templates
+ * | Selector               | Region |
+ * |------------------------|--------|
+ * | `[actions]`            | Trailing edge — the page's own buttons ("New event", filters). |
+ * | `ng-template[foldCalendarTitle]` | Replaces the `<h2>` title — reword it, or give it the heading level the page's outline needs. |
+ *
+ * ## Theming
+ * | CSS variable                       | Default | Sets |
+ * |------------------------------------|---------|------|
+ * | `--fold-calendar-toolbar-step-size`| `28px`  | The back/forward buttons. |
+ *
+ * ## Extending
+ * `views` accepts an app's own reading — `[views]="['month', {value: 'rooms', label: 'Rooms'}]"`.
+ * Paging and titling an unrecognised view fall back to month semantics, so a
+ * custom view still lands on real dates.
+ *
+ * ## Accessibility
+ * The title is the toolbar's live heading: it carries `aria-live="polite"`, so
+ * paging announces the period a keyboard user just moved to instead of leaving
+ * the change silent.
+ *
+ * @selector `fold-calendar-toolbar`
+ *
+ * @example
+ * ```html
+ * <fold-calendar-toolbar [(date)]="date" [(view)]="view" [today]="today">
+ *   <button actions foldButton (click)="create()">New event</button>
+ * </fold-calendar-toolbar>
+ * ```
+ */
+declare class FoldCalendarToolbarComponent {
+    /** The period on display. */
+    readonly date: _angular_core.ModelSignal<string>;
+    /** Which reading is on screen. @default 'month' */
+    readonly view: _angular_core.ModelSignal<FoldCalendarView>;
+    /**
+     * Which switches to offer — a built-in name, or `{ value, label }` for a view
+     * the app owns. @default every built-in view
+     */
+    readonly views: _angular_core.InputSignal<readonly (FoldCalendarView | FoldCalendarViewOption)[]>;
+    /** The day the "today" button jumps to; defaults to the local clock. */
+    readonly today: _angular_core.InputSignal<string | undefined>;
+    /** Day the week starts on. @default the locale's own first day */
+    readonly weekStartsOn: _angular_core.InputSignal<FoldWeekday | undefined>;
+    /** Labels and locale — see the directive. */
+    protected readonly chrome: FoldCalendarChromeDirective;
+    /** The anchor in force: the caller's, else the one the locale declares. */
+    private readonly anchor;
+    private readonly projectedTitle;
+    /** The custom title template, when one is projected. */
+    protected readonly titleContent: _angular_core.Signal<_angular_core.TemplateRef<fold_ng.FoldCalendarTitleContext> | null>;
+    /** The period's name — "May 2026", "18–24 May 2026", "Wednesday 20 May 2026". */
+    protected readonly title: _angular_core.Signal<string>;
+    /** The period the title stands for — handed to a projected title template. */
+    protected readonly range: _angular_core.Signal<fold_ng.FoldCalendarRange>;
+    protected readonly options: _angular_core.Signal<readonly FoldViewToggleOption[]>;
+    /** Pages by one period in the units the current view reads in. */
+    protected shift(delta: number): void;
+    protected goToday(): void;
+    /** The switch emits a bare `string`; only a view it actually offers is kept. */
+    protected onViewChange(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldCalendarToolbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldCalendarToolbarComponent, "fold-calendar-toolbar", never, { "date": { "alias": "date"; "required": true; "isSignal": true; }; "view": { "alias": "view"; "required": false; "isSignal": true; }; "views": { "alias": "views"; "required": false; "isSignal": true; }; "today": { "alias": "today"; "required": false; "isSignal": true; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; "isSignal": true; }; }, { "date": "dateChange"; "view": "viewChange"; }, ["projectedTitle"], ["[actions]"], true, [{ directive: typeof FoldCalendarChromeDirective; inputs: { "locale": "locale"; "labels": "labels"; "formats": "formats"; }; outputs: {}; }]>;
+}
+
+/**
+ * The "what's next" reading: everything still ahead, grouped by the day it
+ * lands on. Pure, so the rule for *what counts as ahead* — and what counts as
+ * needing attention — can be tested without rendering a rail.
+ */
+/** Which slice of what is ahead the agenda shows. */
+type FoldCalendarAgendaMode = "todo" | "all";
+/** Whether an event is asking for something — the `todo` slice's test. */
+type FoldCalendarActionable<T = unknown> = (event: FoldCalendarEvent<T>) => boolean;
+/** One day of the agenda, with what falls on it. */
+interface FoldCalendarAgendaGroup<T = unknown> {
+    readonly date: FoldCalendarDate;
+    /** Events opening on {@link date}, earliest first. */
+    readonly events: readonly FoldCalendarEvent<T>[];
+}
+/** How to build the agenda. */
+interface FoldAgendaOptions<T = unknown> {
+    /** The day "ahead" starts from — anything ending before it is past. */
+    readonly from: FoldCalendarDate;
+    /** `todo` keeps only what asks for attention. @default 'all' */
+    readonly mode?: FoldCalendarAgendaMode;
+    /** Days to return at most, so a long horizon cannot flood a rail. @default 8 */
+    readonly limit?: number;
+    /** What counts as asking for attention. @default foldIsActionable */
+    readonly isActionable?: FoldCalendarActionable<T>;
+}
+/** What the agenda produced, and whether it had to stop short. */
+interface FoldCalendarAgenda<T = unknown> {
+    /** The days shown, earliest first. */
+    readonly groups: readonly FoldCalendarAgendaGroup<T>[];
+    /**
+     * Days that exist beyond `limit`. Non-zero means "there is more", which is a
+     * different thing to say than "there is nothing" — and the two used to render
+     * identically.
+     */
+    readonly truncated: number;
+}
+/**
+ * Whether an event is asking for something.
+ *
+ * `warning` and `alert` are the two tones that mean "attention" in this
+ * system, so they are what `todo` keeps — the agenda reads the same semantic
+ * scale the chips paint with, rather than inventing a second one. Pass
+ * `isActionable` to define it otherwise.
+ */
+declare function foldIsActionable<T>(event: FoldCalendarEvent<T>): boolean;
+/**
+ * Events still ahead of `from`, grouped by day and capped to `limit` days.
+ *
+ * An event already running is grouped under `from` rather than its real start:
+ * a three-week absence that began last Monday belongs at the top of "what's
+ * next", not buried in a past day the rail never shows.
+ */
+declare function foldBuildAgenda<T>(events: readonly FoldCalendarEvent<T>[], options: FoldAgendaOptions<T>): FoldCalendarAgenda<T>;
+/**
+ * How many events are asking for attention from `from` on — the rail's badge.
+ *
+ * Takes the same `isActionable` the agenda does, so a badge can never disagree
+ * with the list under it.
+ */
+declare function foldCountActionable<T>(events: readonly FoldCalendarEvent<T>[], from: FoldCalendarDate, isActionable?: FoldCalendarActionable<T>): number;
+
+/**
+ * `<fold-calendar-agenda>` — a rail of what is still ahead, grouped by day.
+ *
+ * The counterpart to the grids: they answer "what does this month look like",
+ * this answers "what do I do next". It carries a **`todo` slice** that keeps
+ * only the events asking for attention (the `warning` and `alert` tones — the
+ * same scale the chips paint with), so the rail doubles as a work queue with a
+ * count.
+ *
+ * ## Inputs
+ * | Input       | Type                     | Default | Meaning |
+ * |-------------|--------------------------|---------|---------|
+ * | `from`      | `FoldCalendarDate`       | —       | Where "ahead" starts; anything ending before it is past. |
+ * | `events`    | `FoldCalendarEvent<T>[]` | `[]`    | Source events. |
+ * | `mode`      | `'todo' \| 'all'`        | `'todo'` | **Two-way.** Which slice is shown. |
+ * | `collapsed` | `boolean`                | `false` | **Two-way.** Collapsed to a spine — persist it if you want it to stick. |
+ * | `limit`     | `number`                 | `8`     | Days to show at most; what it cuts off is announced, not swallowed. |
+ * | `isActionable` | `(event) => boolean`  | tones   | What the `todo` slice and the badge both count. |
+ * | `locale`    | `string`                 | runtime | Drives the day names through `Intl`. |
+ * | `labels`    | `Partial<FoldCalendarLabels>` | — | Per-instance label overrides. |
+ *
+ * ## Outputs
+ * | Output       | Payload                | Fires on |
+ * |--------------|------------------------|----------|
+ * | `dayClick`   | `FoldCalendarDate`     | A day heading activated. |
+ * | `eventClick` | `FoldCalendarEvent<T>` | A row activated. |
+ *
+ * ## Templates
+ * | Directive             | Replaces |
+ * |-----------------------|----------|
+ * | `foldCalendarEvent`   | The inside of a row. |
+ * | `foldCalendarHeading` | The day heading — where a per-day count or action goes. |
+ *
+ * ## Theming
+ * | CSS variable                            | Default | Sets |
+ * |-----------------------------------------|---------|------|
+ * | `--fold-calendar-agenda-width`          | `320px` | Width of the expanded rail. |
+ * | `--fold-calendar-agenda-height`         | `100%`  | Height — match a grid beside it, or pin it. |
+ * | `--fold-calendar-agenda-spine-width`    | `44px`  | Width once collapsed. |
+ * | `--fold-calendar-agenda-badge-size`     | `20px`  | The count badge. |
+ * | `--fold-calendar-agenda-control-size`   | `26px`  | The collapse control. |
+ *
+ * A day within the next week is named relatively — "Today", "Tomorrow", then
+ * its weekday — because that reads faster than a date at this distance.
+ *
+ * @selector `fold-calendar-agenda`
+ *
+ * @example
+ * ```html
+ * <fold-calendar-agenda
+ *   [from]="today"
+ *   [events]="events()"
+ *   [(mode)]="agendaMode"
+ *   [(collapsed)]="agendaCollapsed"
+ *   (eventClick)="open($event)"
+ * />
+ * ```
+ */
+declare class FoldCalendarAgendaComponent<T = unknown> {
+    /** The day "ahead" starts from. */
+    readonly from: _angular_core.InputSignal<string>;
+    /** Source events. */
+    readonly events: _angular_core.InputSignal<readonly FoldCalendarEvent<T>[]>;
+    /** Which slice is shown. @default 'todo' */
+    readonly mode: _angular_core.ModelSignal<FoldCalendarAgendaMode>;
+    /** Collapsed to a spine. @default false */
+    readonly collapsed: _angular_core.ModelSignal<boolean>;
+    /** Days to show at most. @default 8 */
+    readonly limit: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * What counts as asking for attention — the `todo` slice **and** the badge,
+     * from one definition, so the two can never disagree.
+     * @default the `warning` and `alert` tones
+     */
+    readonly isActionable: _angular_core.InputSignal<FoldCalendarActionable<T>>;
+    /** A day heading was activated. */
+    readonly dayClick: _angular_core.OutputEmitterRef<string>;
+    /** A row was activated. */
+    readonly eventClick: _angular_core.OutputEmitterRef<FoldCalendarEvent<T>>;
+    /** Labels, locale and the projected chip template — see the directive. */
+    protected readonly chrome: FoldCalendarChromeDirective;
+    private readonly projectedHeading;
+    /** The custom day-heading template, when one is projected. */
+    protected readonly headingContent: _angular_core.Signal<_angular_core.TemplateRef<fold_ng.FoldCalendarHeadingContext<any>> | null>;
+    private readonly agenda;
+    protected readonly groups: _angular_core.Signal<readonly FoldCalendarAgendaGroup<T>[]>;
+    /** Days `limit` cut off — "there is more" is not the same as "there is none". */
+    protected readonly truncated: _angular_core.Signal<number>;
+    /** How much is asking for attention — the rail's badge, in either mode. */
+    protected readonly todoCount: _angular_core.Signal<number>;
+    /** The rail's own name, and the one the collapsed spine repeats. */
+    protected readonly title: _angular_core.Signal<string>;
+    protected readonly emptyMessage: _angular_core.Signal<string>;
+    /** Day of the month, for the rail's number. */
+    protected dayNumber(group: FoldCalendarAgendaGroup<T>): string;
+    /**
+     * "Today", "Tomorrow", then the weekday for the rest of the week — a name
+     * beats a date while the day is still near.
+     */
+    protected relativeName(group: FoldCalendarAgendaGroup<T>): string;
+    /** The month, shown only once the weekday alone stops being enough. */
+    protected monthName(group: FoldCalendarAgendaGroup<T>): string;
+    protected toggleMode(mode: FoldCalendarAgendaMode): void;
+    protected toggleCollapsed(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldCalendarAgendaComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldCalendarAgendaComponent<any>, "fold-calendar-agenda", never, { "from": { "alias": "from"; "required": true; "isSignal": true; }; "events": { "alias": "events"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "limit": { "alias": "limit"; "required": false; "isSignal": true; }; "isActionable": { "alias": "isActionable"; "required": false; "isSignal": true; }; }, { "mode": "modeChange"; "collapsed": "collapsedChange"; "dayClick": "dayClick"; "eventClick": "eventClick"; }, ["projectedHeading"], never, true, [{ directive: typeof FoldCalendarChromeDirective; inputs: { "locale": "locale"; "labels": "labels"; "formats": "formats"; }; outputs: {}; }]>;
+}
+
+/** A source, with what it currently contributes and whether it is showing. */
+interface SourceChip {
+    readonly source: FoldCalendarSource;
+    readonly count: number;
+    readonly shown: boolean;
+}
+/**
+ * `<fold-calendar-source-filter>` — the chips that switch each feed of a
+ * merged calendar on and off.
+ *
+ * A calendar usually shows several feeds at once (a programme, staff leave,
+ * contracts). This owns the **selection** only: it counts what each feed
+ * contributes and toggles it, and the caller runs `foldFilterBySource()` over
+ * its own events. Keeping the two apart means the chips never need to know how
+ * the events are fetched, and the filtering stays a pure function.
+ *
+ * ## Inputs
+ * | Input     | Type                     | Default | Meaning |
+ * |-----------|--------------------------|---------|---------|
+ * | `sources` | `FoldCalendarSource[]`   | `[]`    | The feeds to offer. |
+ * | `events`  | `FoldCalendarEvent[]`    | `[]`    | Counted per feed — pass the window on screen for live counts. |
+ * | `active`  | `ReadonlySet<string> \| null` | `null` | **Two-way.** The keys currently shown; `null` means "all". |
+ * | `labels`  | `Partial<FoldCalendarLabels>` | — | Per-instance label overrides. |
+ *
+ * ## Outputs
+ * | Output            | Payload               | Fires on |
+ * |-------------------|-----------------------|----------|
+ * | `selectionChange` | `ReadonlySet<string>` | A chip toggled — never `null`. |
+ *
+ * `null` and an empty `Set` mean opposite things — "nothing switched off yet"
+ * versus "every feed switched off" — which is why they are not collapsed.
+ * `foldFilterBySource()` takes either.
+ *
+ * ## Accessibility
+ * Each chip is a **toggle**, so it carries `aria-pressed` in both states, and
+ * its accessible name says which feed and whether it is showing — the tick and
+ * the dot are colour, which cannot be the only carrier.
+ *
+ * @selector `fold-calendar-source-filter`
+ *
+ * @example
+ * ```html
+ * <fold-calendar-source-filter
+ *   [sources]="sources"
+ *   [events]="events()"
+ *   [(active)]="activeSources"
+ * />
+ * <fold-calendar-month [events]="visibleEvents()" [(month)]="month" />
+ * ```
+ */
+declare class FoldCalendarSourceFilterComponent {
+    /** The feeds to offer. */
+    readonly sources: _angular_core.InputSignal<readonly FoldCalendarSource[]>;
+    /** Events to count per feed; pass the window on screen for live counts. */
+    readonly events: _angular_core.InputSignal<readonly FoldCalendarEvent<unknown>[]>;
+    /**
+     * The keys currently shown. Left unset every feed shows, so the filter is
+     * useful before the caller has any selection state of its own.
+     */
+    readonly active: _angular_core.ModelSignal<ReadonlySet<string> | null>;
+    /**
+     * The selection after a chip was toggled — **never `null`**, unlike `active`,
+     * whose unset state exists only as a starting value. Handle this one and you
+     * never have to eliminate a case that cannot happen.
+     */
+    readonly selectionChange: _angular_core.OutputEmitterRef<ReadonlySet<string>>;
+    /** Labels and locale — see the directive. */
+    protected readonly chrome: FoldCalendarChromeDirective;
+    /** The effective selection — every key while `active` is unset. */
+    private readonly shownKeys;
+    protected readonly chips: _angular_core.Signal<readonly SourceChip[]>;
+    protected chipLabel(chip: SourceChip): string;
+    /** Writes the next selection rather than mutating the set in place. */
+    protected toggle(chip: SourceChip): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoldCalendarSourceFilterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoldCalendarSourceFilterComponent, "fold-calendar-source-filter", never, { "sources": { "alias": "sources"; "required": false; "isSignal": true; }; "events": { "alias": "events"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; }, { "active": "activeChange"; "selectionChange": "selectionChange"; }, never, never, true, [{ directive: typeof FoldCalendarChromeDirective; inputs: { "locale": "locale"; "labels": "labels"; "formats": "formats"; }; outputs: {}; }]>;
+}
+
+export { FOLD_AUTO_PALETTES, FOLD_BLUR_TOKENS, FOLD_BUILTIN_ICONS, FOLD_BUILTIN_ICON_CATEGORIES, FOLD_CALENDAR_DEFAULT_LABELS, FOLD_CALENDAR_FORMATS, FOLD_CALENDAR_LABELS, FOLD_DATA_TABLE_DEFAULT_LABELS, FOLD_DATA_TABLE_LABELS, FOLD_DEFAULT_WEEKEND_DAYS, FOLD_FALLBACK_WEEK_INFO, FOLD_INLINE_CONFIRM_DEFAULT_LABELS, FOLD_INLINE_CONFIRM_LABELS, FOLD_MINUTES_PER_DAY, FOLD_MOTION_TOKENS, FOLD_PAGINATOR_DEFAULT_LABELS, FOLD_PAGINATOR_LABELS, FOLD_PALETTE_DEFAULT, FOLD_PANEL_CLOSE_LABEL, FOLD_PANEL_DEFAULTS, FOLD_RADIUS_TOKENS, FOLD_SEMANTIC_COLOR_TOKENS, FOLD_SHADOW_TOKENS, FOLD_SPACE_TOKENS, FOLD_TEXT_TOKENS, FOLD_TOAST_CONFIG, FoldAppShellComponent, FoldAsideLayoutComponent, FoldAvatarComponent, FoldAvatarDetailComponent, FoldAvatarListComponent, FoldBackLinkComponent, FoldBadgeComponent, FoldBreadcrumbComponent, FoldButtonComponent, FoldButtonIconComponent, FoldCalendarAgendaComponent, FoldCalendarChromeDirective, FoldCalendarDayComponent, FoldCalendarDayDirective, FoldCalendarEventDirective, FoldCalendarHeadingDirective, FoldCalendarListComponent, FoldCalendarMonthComponent, FoldCalendarOverflowDirective, FoldCalendarSourceFilterComponent, FoldCalendarTimegridComponent, FoldCalendarTitleDirective, FoldCalendarToolbarComponent, FoldCalendarWeekComponent, FoldCalloutComponent, FoldCardComponent, FoldCheckboxComponent, FoldChoiceRowComponent, FoldContextCardComponent, FoldDangerZoneComponent, FoldDataTableCellDirective, FoldDataTableComponent, FoldDataTableRowCardDirective, FoldDateComponent, FoldDisclosureComponent, FoldDropdownComponent, FoldDropdownItemComponent, FoldElementTitleComponent, FoldElevatedDirective, FoldEmptyStateComponent, FoldFieldComponent, FoldFieldIdDirective, FoldFieldListComponent, FoldFileDropzoneComponent, FoldHeroCardComponent, FoldHeroSectionComponent, FoldIconComponent, FoldIconRegistry, FoldIdService, FoldInlineConfirmComponent, FoldInputComponent, FoldLinkComponent, FoldListboxComponent, FoldLoadingStateComponent, FoldMenuComponent, FoldMenuItemComponent, FoldMenuSectionComponent, FoldMenuSeparatorComponent, FoldMultiselectComponent, FoldNavLauncherComponent, FoldNavLayoutComponent, FoldNavTileComponent, FoldNumberInputComponent, FoldOptgroupComponent, FoldOptionComponent, FoldPageLayoutComponent, FoldPageSectionComponent, FoldPageTitleDirective, FoldPaginatorComponent, FoldPaletteRegistry, FoldPanelComponentOutletDirective, FoldPanelFooterComponent, FoldPanelHeaderComponent, FoldPanelHostComponent, FoldPanelHostService, FoldPanelRef, FoldPanelToggle, FoldPasswordFieldComponent, FoldPopoverComponent, FoldPopoverTriggerDirective, FoldRangeSliderComponent, FoldRepeatPressDirective, FoldScrollRegionDirective, FoldSearchComponent, FoldSelectComponent, FoldSliderComponent, FoldSpinnerComponent, FoldStatusBadgeComponent, FoldStickyColumnDirective, FoldSurfaceDirective, FoldTabPanelComponent, FoldTabsComponent, FoldTextareaComponent, FoldTimeComponent, FoldTimelineComponent, FoldToastComponent, FoldToastContainerComponent, FoldToastService, FoldToggleIconComponent, FoldViewNavComponent, FoldViewToggleComponent, ScrollRegionRegistry, autoUpdate, computePlacement, foldAddDays, foldAddMinutes, foldAddMonths, foldBlurVar, foldBuildAgenda, foldBuildDay, foldBuildMonthGrid, foldBuildTimeGrid, foldBuildWeek, foldCalendarNextFocus, foldCardBandChrome, foldColorProperty, foldColorVar, foldCountActionable, foldDaysBetween, foldDefaultPasswordRules, foldEndOfMonth, foldEventsInRange, foldEventsOnDay, foldFilterBySource, foldFromMinutes, foldFromNativeDate, foldFromTemporal, foldHashSeed, foldIsActionable, foldIsCalendarDate, foldIsCalendarTime, foldIsTimed, foldIsWeekend, foldIsoWeek, foldIsoWeekYear, foldLayOutOverlaps, foldLocaleWeekInfo, foldMotionVar, foldRadiusVar, foldRangeForView, foldRegexRule, foldResolvePalette, foldShadowVar, foldShiftDate, foldSpaceVar, foldStartOfMonth, foldStartOfWeek, foldTextVar, foldToMinutes, foldToNativeDate, foldToday, foldViewTitle, foldWeekdayIndex, foldWeekdayOf, isFoldSelectOptionGroup, observeElementWidth, provideFoldCalendarLabels, provideFoldDataTableLabels, provideFoldIcons, provideFoldInlineConfirmLabels, provideFoldPaginatorLabels, provideFoldPalette, provideFoldPanelDefaults, provideFoldPanelLabels, provideFoldToasts };
+export type { FoldAgendaOptions, FoldAutoPaletteName, FoldAvatarListItem, FoldAvatarRing, FoldAvatarRingStyle, FoldAvatarVariant, FoldBadgeVariant, FoldBlurToken, FoldBreadcrumbItem, FoldBuiltinIconName, FoldButtonEmphasis, FoldButtonIconShape, FoldButtonIconSize, FoldButtonIconTone, FoldButtonIntent, FoldButtonShape, FoldButtonSize, FoldCalendarActionable, FoldCalendarAgenda, FoldCalendarAgendaGroup, FoldCalendarAgendaMode, FoldCalendarBand, FoldCalendarBlock, FoldCalendarBuiltInView, FoldCalendarDate, FoldCalendarDay, FoldCalendarDayContext, FoldCalendarDayEvents, FoldCalendarDayModifiers, FoldCalendarEvent, FoldCalendarEventContext, FoldCalendarFormat, FoldCalendarHalfDay, FoldCalendarHeadingContext, FoldCalendarLabels, FoldCalendarOverflowContext, FoldCalendarRange, FoldCalendarSource, FoldCalendarTime, FoldCalendarTitleContext, FoldCalendarTone, FoldCalendarView, FoldCalendarViewOption, FoldCalendarWeek, FoldCalloutAppearance, FoldCalloutVariant, FoldCardBandChrome, FoldCardBandChromeInput, FoldChoiceOption, FoldComponentPanelDescriptor, FoldDataTableLabels, FoldDateType, FoldDayColumnsOptions, FoldIconCategoryId, FoldIconName, FoldIconSet, FoldIconSize, FoldIconTone, FoldInlineConfirmLabels, FoldIsoDateLike, FoldMenuItemBadgeTone, FoldMenuLevel, FoldMenuTint, FoldMenuTogglePlacement, FoldMonthGridOptions, FoldMotionToken, FoldNumberControls, FoldNumberSpinner, FoldOverlapInput, FoldOverlapSlot, FoldPageItem, FoldPaginatorLabels, FoldPaletteInput, FoldPanelConfig, FoldPanelContent, FoldPanelDefaults, FoldPanelDefaultsProvider, FoldPanelDescriptor, FoldPanelHandle, FoldPanelLabels, FoldPanelSide, FoldPanelSize, FoldPanelSurface, FoldPasswordRule, FoldPlacementInput, FoldPlacementResult, FoldPopoverAlign, FoldPopoverPlacement, FoldPopoverSide, FoldRadiusToken, FoldRangeValue, FoldRect, FoldScrollAxis, FoldSelectItem, FoldSelectOption, FoldSelectOptionGroup, FoldSemanticColorToken, FoldShadowToken, FoldSpaceToken, FoldSpinnerSize, FoldStickyColumnAnchor, FoldSurfaceName, FoldTabItem, FoldTableColumn, FoldTableEmpty, FoldTableSort, FoldTableSortDir, FoldTableTone, FoldTabsContext, FoldTemplatePanelDescriptor, FoldTextToken, FoldTimeGrid, FoldTimeGridColumn, FoldTimeGridOptions, FoldTimelineDatePlacement, FoldTimelineNode, FoldToast, FoldToastConfig, FoldToastVariant, FoldViewNavItem, FoldViewToggleOption, FoldWeekInfo, FoldWeekday };
 //# sourceMappingURL=fold-ng.d.ts.map