fold-ng 0.7.0 → 0.8.1

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 * as fold_ng from 'fold-ng';
 import { FormValueControl, ValidationError, FormCheckboxControl } from '@angular/forms/signals';
 
 /**
@@ -2103,6 +2104,1530 @@ 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>;
 }
 
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * 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`.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * @default FOLD_DEFAULT_WEEKEND_DAYS (`['sat', 'sun']`)
+ */
+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;
+}
+/**
+ * A `Temporal` value read as the plain date it starts with.
+ *
+ * `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.
+ *
+ * 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 function foldFromTemporal(value: FoldIsoDateLike): FoldCalendarDate;
+/**
+ * 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 function foldToNativeDate(date: FoldCalendarDate): Date;
+
+/**
+ * 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.
+ *
+ * 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 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;
+
+/**
+ * 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 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;
+
+/**
+ * Every string the calendar renders that does not come from the caller's data.
+ *
+ * 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.
+ */
+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;
+
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * Internal — a view exposes it, it is never applied by hand.
+ *
+ * @example
+ * ```ts
+ * @Component({
+ *   hostDirectives: [
+ *     { directive: FoldCalendarChromeDirective, inputs: ['locale', 'labels'] },
+ *   ],
+ * })
+ * export class FoldCalendarWeekComponent<T = unknown> {
+ *   protected readonly chrome = inject(FoldCalendarChromeDirective);
+ * }
+ * ```
+ */
+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;
@@ -4640,6 +6165,12 @@ 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>;
@@ -5639,6 +7170,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_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, FoldBadgeComponent, FoldButtonComponent, FoldButtonIconComponent, FoldCalendarAgendaComponent, FoldCalendarChromeDirective, FoldCalendarDayComponent, FoldCalendarDayDirective, FoldCalendarEventDirective, FoldCalendarHeadingDirective, FoldCalendarListComponent, FoldCalendarMonthComponent, FoldCalendarOverflowDirective, FoldCalendarSourceFilterComponent, FoldCalendarTimegridComponent, FoldCalendarTitleDirective, FoldCalendarToolbarComponent, FoldCalendarWeekComponent, 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, 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, observeElementWidth, provideFoldCalendarLabels, provideFoldDataTableLabels, provideFoldIcons, provideFoldInlineConfirmLabels, provideFoldPaginatorLabels, provideFoldPalette, provideFoldPanelDefaults, provideFoldPanelLabels, provideFoldToasts };
+export type { FoldAgendaOptions, FoldAutoPaletteName, FoldAvatarListItem, FoldAvatarRing, FoldAvatarRingStyle, FoldAvatarVariant, FoldBadgeVariant, FoldBlurToken, 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, FoldDayColumnsOptions, 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, FoldSelectOption, 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