forty-cdk 0.2.0 → 0.3.0

package/types/forty-cdk-calendar.d.ts

@@ -0,0 +1,914 @@
+import * as forty_cdk_calendar from 'forty-cdk/calendar';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, Provider } from '@angular/core';
+import { DateAdapter, WritingDirection } from 'forty-cdk/core';
+export { DateAdapter, FOR_DATE_ADAPTER, TimeCapableDateAdapter, assertTimeCapable, injectDateAdapter } from 'forty-cdk/core';
+
+/** The active display mode of a `ForCalendar`. */
+type CalendarView = 'day' | 'month' | 'year';
+/**
+ * An inclusive date range where `start <= end` (day-granular). Used by
+ * `ForCalendar` and `ForDatePicker` in `selectionMode="range"`.
+ *
+ * @typeParam D The adapter's date type.
+ */
+interface CalendarDateRange<D> {
+    /** Inclusive start of the range. */
+    readonly start: D;
+    /** Inclusive end of the range (`>= start`). */
+    readonly end: D;
+}
+/** A selectable year in the year picker grid. */
+interface CalendarYearOption {
+    /** The full year (e.g. `2026`). */
+    readonly value: number;
+    /** Whether the entire year falls outside `[min, max]`. */
+    readonly disabled: boolean;
+}
+/** A row of three months in the month picker grid. */
+interface CalendarMonthRow {
+    /** Stable key for `@for` tracking. */
+    readonly key: string;
+    /** The (up to three) month options in this row. */
+    readonly months: readonly CalendarMonthOption[];
+}
+/** A row of three years in the year picker grid. */
+interface CalendarYearRow {
+    /** Stable key for `@for` tracking. */
+    readonly key: string;
+    /** The (up to three) year options in this row. */
+    readonly years: readonly CalendarYearOption[];
+}
+/**
+ * Handle a `ForCalendarMonthCell` registers with the root so the root can move
+ * DOM focus to the correct cell during keyboard navigation and view switches.
+ */
+interface ForCalendarMonthCellHandle {
+    /** The `role="gridcell"` host element. */
+    readonly host: HTMLElement;
+    /** The month this cell represents, **1-12**. */
+    readonly month: Signal<number>;
+}
+/**
+ * Handle a `ForCalendarYearCell` registers with the root so the root can move
+ * DOM focus to the correct cell during keyboard navigation and view switches.
+ */
+interface ForCalendarYearCellHandle {
+    /** The `role="gridcell"` host element. */
+    readonly host: HTMLElement;
+    /** The year this cell represents. */
+    readonly year: Signal<number>;
+}
+/** A selectable month in the visible year, for building a month dropdown. */
+interface CalendarMonthOption {
+    /** Month number, **1-12**. */
+    readonly value: number;
+    /** Localized month name via the adapter (e.g. `"June"`). */
+    readonly label: string;
+    /** Whether the whole month falls outside `[min, max]`. */
+    readonly disabled: boolean;
+}
+/** A weekday column header in the calendar grid. */
+interface CalendarWeekday {
+    /** Stable key for `@for` tracking (the **0-6** weekday index as a string). */
+    readonly key: string;
+    /** Narrow label, e.g. `"M"`. */
+    readonly narrow: string;
+    /** Short label, e.g. `"Mon"`. */
+    readonly short: string;
+    /** Long label, e.g. `"Monday"`. */
+    readonly long: string;
+}
+/** A single day cell in the calendar grid. */
+interface CalendarDayCell<D> {
+    /** Stable key for `@for` tracking (`year-month-day`). */
+    readonly key: string;
+    /** The date this cell represents. Bind to `[date]` on `[forCalendarCell]`. */
+    readonly date: D;
+    /** Day-of-month label, e.g. `"1"`. The cell's visible content. */
+    readonly label: string;
+    /**
+     * Full accessible date string for the cell, host-bound to `aria-label` by
+     * `[forCalendarCell]`. Defaults to the localized full date (e.g.
+     * `"Monday, June 15, 2026"`); outside-month padding days are suffixed so
+     * assistive tech can tell them apart from the visible month. Customize the
+     * format with `ForCalendar`'s `dateLabel` input.
+     */
+    readonly dateLabel: string;
+}
+/**
+ * Formats the full accessible date string a calendar gridcell exposes as its
+ * `aria-label`. Supplied to `ForCalendar`'s `dateLabel` input to override the
+ * default localized full date.
+ *
+ * @typeParam D The adapter's date type.
+ * @param date The cell's date.
+ * @param context Formatting context: the active {@link DateAdapter} and whether
+ *   the date falls outside the visible month.
+ */
+type CalendarDateLabelFormatter<D> = (date: D, context: {
+    readonly adapter: DateAdapter<D>;
+    readonly outsideMonth: boolean;
+}) => string;
+/** A week row in the calendar grid. */
+interface CalendarWeek<D> {
+    /** Stable key for `@for` tracking (the first day's `year-month-day`). */
+    readonly key: string;
+    /** The seven day cells of this week, starting at `firstDayOfWeek`. */
+    readonly days: readonly CalendarDayCell<D>[];
+}
+/**
+ * Handle a `ForCalendarCell` registers with the root so it can move DOM focus
+ * to the cell matching a target date after the grid re-renders (e.g. when
+ * keyboard navigation crosses a month boundary).
+ */
+interface ForCalendarCellHandle<D> {
+    /** The `role="gridcell"` host element. */
+    readonly host: HTMLElement;
+    /** The date this cell represents. */
+    readonly date: Signal<D>;
+}
+/**
+ * Coordination contract owned by `ForCalendar` (the root). Grid, header,
+ * cells, heading, and the navigation buttons all derive their state from it
+ * and route selection / navigation through it.
+ *
+ * The token is typed over `unknown`; pieces pass their own `D` into the
+ * `unknown`-typed methods (always assignable) and never need the concrete `D`
+ * back out.
+ *
+ * @typeParam D The adapter's date type.
+ */
+interface ForCalendarContext<D> {
+    /** The active date adapter. */
+    readonly adapter: DateAdapter<D>;
+    /** Resolved writing direction (`'ltr'` / `'rtl'`); flips horizontal arrows. */
+    readonly dir: Signal<WritingDirection>;
+    /** Whether the whole calendar is disabled (no focus, no selection). */
+    readonly disabled: Signal<boolean>;
+    /** Whether the calendar is read-only (focusable, but selection is blocked). */
+    readonly readonly: Signal<boolean>;
+    /** Stable id of the heading element, used for the grid's `aria-labelledby`. */
+    readonly headingId: Signal<string>;
+    /** The visible month's accessible label, e.g. `"June 2026"`. */
+    readonly visibleMonthLabel: Signal<string>;
+    /** Weekday column headers for the visible month. */
+    readonly weekDays: Signal<readonly CalendarWeekday[]>;
+    /** Week rows of the visible month, including outside-month padding days. */
+    readonly weeks: Signal<readonly CalendarWeek<D>[]>;
+    /** Whether the previous-month button should be disabled (bounded by `min`). */
+    readonly isPreviousMonthDisabled: Signal<boolean>;
+    /** Whether the next-month button should be disabled (bounded by `max`). */
+    readonly isNextMonthDisabled: Signal<boolean>;
+    /** The visible month's full year (e.g. `2026`). */
+    readonly visibleYear: Signal<number>;
+    /** The visible month, **1-12**. */
+    readonly visibleMonthNumber: Signal<number>;
+    /** Twelve localized, bounds-aware month options for the visible year. */
+    readonly monthOptions: Signal<readonly CalendarMonthOption[]>;
+    /** Set the visible month to (`year`, `month`) without selecting. `month` is **1-12**. */
+    goTo(year: number, month: number): void;
+    /** Set the visible month within the current visible year. `month` is **1-12**. */
+    goToMonth(month: number): void;
+    /** Set the visible year, keeping the current visible month. */
+    goToYear(year: number): void;
+    /** Whether every day of `month` (**1-12**) in the visible year is out of `[min, max]`. */
+    isMonthDisabled(month: number): boolean;
+    /** Whether every day of `year` is out of `[min, max]`. */
+    isYearDisabled(year: number): boolean;
+    /** Active calendar view; `'day'` (default), `'month'`, or `'year'`. */
+    readonly view: Signal<CalendarView>;
+    /** Number of years the year picker shows as an aligned block. Default `12`. */
+    readonly yearBlockSize: Signal<number>;
+    /** Rows of the month picker grid (3 columns) for the visible year. */
+    readonly monthRows: Signal<readonly CalendarMonthRow[]>;
+    /** Rows of the year picker grid (3 columns) for the aligned block containing the visible year. */
+    readonly yearRows: Signal<readonly CalendarYearRow[]>;
+    /** Label for the active view shown on the view-trigger button. */
+    readonly viewTriggerLabel: Signal<string>;
+    /** Whether the prev button should be disabled for the active view. */
+    readonly isPreviousDisabled: Signal<boolean>;
+    /** Whether the next button should be disabled for the active view. */
+    readonly isNextDisabled: Signal<boolean>;
+    /** Cycle the view one step coarser: `day → month → year`, clamped at `'year'`. */
+    cycleView(): void;
+    /** Drill into a month (1-12): navigate to it and switch to day view. No-op when disabled/read-only/out of bounds. */
+    selectMonth(month: number): void;
+    /** Drill into a year: navigate to it and switch to month view. No-op when disabled/read-only/out of bounds. */
+    selectYear(year: number): void;
+    /** Page backward by one month / year / block depending on the active view. */
+    pagePrevious(): void;
+    /** Page forward by one month / year / block depending on the active view. */
+    pageNext(): void;
+    /** Whether `month` (1-12) in the visible year is the selected date's month. */
+    isMonthSelected(month: number): boolean;
+    /** Whether `month` (1-12) is today's month in the visible year. */
+    isMonthToday(month: number): boolean;
+    /** Whether `month` (1-12) is the roving-tabindex focused month. */
+    isMonthFocused(month: number): boolean;
+    /** Whether `year` is the selected date's year. */
+    isYearSelected(year: number): boolean;
+    /** Whether `year` is today's year. */
+    isYearToday(year: number): boolean;
+    /** Whether `year` is the roving-tabindex focused year. */
+    isYearFocused(year: number): boolean;
+    /** Handle a keydown originating on a month cell. */
+    handleMonthCellKeydown(event: KeyboardEvent, month: number): void;
+    /** Handle a keydown originating on a year cell. */
+    handleYearCellKeydown(event: KeyboardEvent, year: number): void;
+    registerMonthCell(handle: ForCalendarMonthCellHandle): void;
+    unregisterMonthCell(handle: ForCalendarMonthCellHandle): void;
+    registerYearCell(handle: ForCalendarYearCellHandle): void;
+    unregisterYearCell(handle: ForCalendarYearCellHandle): void;
+    /** Whether `date` is the currently selected value. */
+    isSelected(date: D): boolean;
+    /** Whether `date` is today. */
+    isToday(date: D): boolean;
+    /** Whether `date` is the roving-tabindex focused day. */
+    isFocused(date: D): boolean;
+    /** Whether `date` falls outside the visible month. */
+    isOutsideMonth(date: D): boolean;
+    /** Whether `date` cannot be selected (`disabled`, out of `min`/`max`, or unavailable). */
+    isUnavailable(date: D): boolean;
+    /** The full accessible date string for `date`'s gridcell (`aria-label`). */
+    getDateLabel(date: D): string;
+    /**
+     * The active selection mode. `'single'` (default) keeps the existing
+     * single-date behaviour; `'range'` enables the two-click anchor → commit flow.
+     */
+    readonly selectionMode: Signal<'single' | 'range'>;
+    /**
+     * Whether `date` is the start of the effective range (committed when idle,
+     * preview when a selection is in progress).
+     */
+    isRangeStart(date: D): boolean;
+    /**
+     * Whether `date` is the end of the effective range (committed when idle,
+     * preview when a selection is in progress).
+     */
+    isRangeEnd(date: D): boolean;
+    /**
+     * Whether `date` falls within the **committed** range, inclusive (idle state
+     * only; mutually exclusive with `isRangePreview`).
+     */
+    isInRange(date: D): boolean;
+    /**
+     * Whether `date` falls within the **preview** band, inclusive (selecting
+     * state only; mutually exclusive with `isInRange`).
+     */
+    isRangePreview(date: D): boolean;
+    /**
+     * Update the pointer-hovered date for the range preview. Ignored in
+     * `selectionMode='single'`. Pass `null` on `pointerleave`.
+     */
+    setHovered(date: D | null): void;
+    /** Select `date`, unless the calendar is disabled / read-only or the date is unavailable. */
+    selectDate(date: D): void;
+    /** Page the visible month by `delta` (signed month count). Keeps DOM focus on the caller. */
+    pageMonths(delta: number): void;
+    /** Resolve and apply a keydown originating on the cell for `fromDate`. */
+    handleCellKeydown(event: KeyboardEvent, fromDate: D): void;
+    /**
+     * Move DOM focus to the roving cell (the gridcell matching the focused date).
+     * Returns `false` when no matching cell is currently rendered.
+     */
+    focusActiveCell(): boolean;
+    registerCell(handle: ForCalendarCellHandle<D>): void;
+    unregisterCell(handle: ForCalendarCellHandle<D>): void;
+    /** Adopts a consumer-set static `id` on the heading host into `headingId`. */
+    adoptHeadingId(el: HTMLElement): void;
+}
+/** Injection token for {@link ForCalendarContext}, provided by `ForCalendar`. */
+declare const FOR_CALENDAR_CONTEXT: InjectionToken<ForCalendarContext<unknown>>;
+
+/**
+ * Headless implementation of a single-date calendar grid following the
+ * [WAI-ARIA Grid pattern](https://www.w3.org/WAI/ARIA/apg/patterns/grid/), the
+ * date table at the heart of the APG
+ * [Date Picker Dialog](https://www.w3.org/WAI/ARIA/apg/patterns/dialog-modal/examples/datepicker-dialog/)
+ * example.
+ *
+ * `ForCalendar` is the root: it owns the selected value, the focused date, and
+ * the visible month, and exposes them to the grid / header / cell / heading /
+ * navigation pieces through `FOR_CALENDAR_CONTEXT`. All date math goes through
+ * a pluggable {@link DateAdapter} (`provideInternationalizedDateAdapter()` or
+ * `provideNativeDateAdapter()`), so the library hard-depends on no date
+ * library.
+ *
+ * The grid uses roving tabindex: exactly one cell (the focused date) carries
+ * `tabindex="0"`. Arrow / `Home` / `End` / `PageUp` / `PageDown` /
+ * `Shift+PageUp` / `Shift+PageDown` move the focused date, re-paging the grid
+ * when crossing a month boundary; `Enter` / `Space` select.
+ *
+ * The day / month / year views are each backed by a sub-grid collaborator
+ * ({@link CalendarDayNavigator} / {@link CalendarMonthNavigator} /
+ * {@link CalendarYearNavigator}), and range selection by
+ * {@link CalendarRangeSelection}; the root wires them together and exposes the
+ * `[(value)]` / `[(view)]` / `[(range)]` models.
+ *
+ * `ForCalendar` is the grid widget, not a form value — it exposes `[(value)]`
+ * as a `model<D | null>` in `selectionMode="single"` (default), and
+ * `[(range)]` as a `model<CalendarDateRange<D> | null>` in
+ * `selectionMode="range"`. The `FormValueControl<D>` contract arrives with the
+ * follow-up `ForDatePicker` / `ForDateField`. See the primitive's README for a
+ * complete styleless usage example.
+ *
+ * @typeParam D The adapter's immutable date type.
+ */
+declare class ForCalendar<D> implements ForCalendarContext<D> {
+    #private;
+    /** The active date adapter, resolved from `FOR_DATE_ADAPTER`. */
+    readonly adapter: DateAdapter<D>;
+    /**
+     * Two-way bindable selected date, or `null`. The `model()` change emitter
+     * (`(valueChange)`) fires only when the calendar itself updates the value
+     * (cell activation), never on consumer writes via `[(value)]`.
+     */
+    readonly value: _angular_core.ModelSignal<D | null>;
+    /** Minimum selectable date (inclusive). Dates before it are unavailable. */
+    readonly min: _angular_core.InputSignal<D | null>;
+    /** Maximum selectable date (inclusive). Dates after it are unavailable. */
+    readonly max: _angular_core.InputSignal<D | null>;
+    /**
+     * Per-date predicate marking a date as unavailable (present in the grid but
+     * not selectable, reflected as `aria-disabled` / `data-disabled`).
+     */
+    readonly isDateUnavailable: _angular_core.InputSignal<(date: D) => boolean>;
+    /**
+     * Formats the full accessible date string each gridcell exposes as its
+     * `aria-label` (the visible content stays the bare day number). Defaults to
+     * the localized full date (e.g. `"Monday, June 15, 2026"`), with
+     * outside-month padding days suffixed (`" (outside month)"`) so assistive
+     * tech can tell them apart from the visible month. Override to localize that
+     * suffix or change the format entirely.
+     */
+    readonly dateLabel: _angular_core.InputSignal<CalendarDateLabelFormatter<D>>;
+    /** Disables the whole calendar: no focus movement, no selection. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Makes the calendar read-only: dates stay focusable but selection is blocked. */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Selection mode. `'single'` (default) keeps the single-date `[(value)]`
+     * behaviour unchanged. `'range'` switches to the two-click anchor → commit
+     * flow and exposes the result through `[(range)]`.
+     */
+    readonly selectionMode: _angular_core.InputSignal<"single" | "range">;
+    /**
+     * Active calendar view. `'day'` (default) shows the date grid; `'month'` and
+     * `'year'` show the month / year picker grids. Two-way bindable; the `model()`
+     * change emitter (`(viewChange)`) fires only when the calendar itself cycles
+     * or drills the view, never on consumer writes via `[(view)]`.
+     */
+    readonly view: _angular_core.ModelSignal<CalendarView>;
+    /**
+     * Number of years the year view shows, as an aligned block containing the
+     * visible year. Default `12`.
+     */
+    readonly yearBlockSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Two-way bindable committed date range, or `null`. Only used when
+     * `selectionMode="range"`. The `model()` change emitter (`(rangeChange)`)
+     * fires only when the calendar internally commits or clears a range, never
+     * on consumer writes via `[(range)]`.
+     */
+    readonly range: _angular_core.ModelSignal<CalendarDateRange<D> | null>;
+    /**
+     * Minimum inclusive day count for a range selection. A click that would
+     * commit a range shorter than this is a no-op (anchor is preserved).
+     * `null` (default) means no minimum. Only honoured in `selectionMode="range"`.
+     */
+    readonly minRangeLength: _angular_core.InputSignal<number | null>;
+    /**
+     * Maximum inclusive day count for a range selection. A click that would
+     * commit a range longer than this is a no-op (anchor is preserved).
+     * `null` (default) means no maximum. Only honoured in `selectionMode="range"`.
+     */
+    readonly maxRangeLength: _angular_core.InputSignal<number | null>;
+    /**
+     * First day of the week as a **0-6** index (`0` = Sunday). When `null`
+     * (default, overridable via `provideForCalendarDefaults`), the adapter's
+     * `getFirstDayOfWeek()` is used.
+     */
+    readonly firstDayOfWeek: _angular_core.InputSignal<number | null>;
+    /**
+     * Writing direction. When unset (default `null`), the inherited ambient
+     * direction is resolved from the nearest ancestor carrying a `dir` attribute
+     * (or `<html dir>`), defaulting to `'ltr'`. An explicit `[dir]` always wins.
+     * The resolved value is reflected to the host `dir` attribute and swaps the
+     * `ArrowLeft` / `ArrowRight` semantics in RTL.
+     */
+    readonly _dirInput: _angular_core.InputSignal<WritingDirection | null>;
+    readonly dir: _angular_core.Signal<WritingDirection>;
+    /** Internal focused date (the roving entry point), seeded from `value ?? range.start ?? today`. */
+    readonly focusedDate: _angular_core.WritableSignal<D>;
+    /** First day of the visible month, derived from {@link focusedDate}. */
+    readonly visibleMonth: _angular_core.Signal<D>;
+    readonly headingId: _angular_core.Signal<string>;
+    /**
+     * Adopts a consumer-set static `id` on the `[forCalendarHeading]` host into
+     * `headingId` (the grid's `aria-labelledby` resolves to it) instead of
+     * letting the `[id]` host binding clobber it.
+     */
+    adoptHeadingId(el: HTMLElement): void;
+    readonly visibleMonthLabel: _angular_core.Signal<string>;
+    /** The visible month's full year (e.g. `2026`). */
+    readonly visibleYear: _angular_core.Signal<number>;
+    /** The visible month, **1-12**. */
+    readonly visibleMonthNumber: _angular_core.Signal<number>;
+    /**
+     * Twelve entries for the visible year — each a localized month name plus
+     * whether the whole month falls outside `[min, max]`. Tracks {@link visibleYear}.
+     * Build native `<select>` month dropdowns from it.
+     */
+    readonly monthOptions: _angular_core.Signal<readonly CalendarMonthOption[]>;
+    /** Rows of the month picker grid (3 columns) for the visible year. */
+    readonly monthRows: _angular_core.Signal<readonly CalendarMonthRow[]>;
+    /** Rows of the year picker grid (3 columns) for the aligned block containing the visible year. */
+    readonly yearRows: _angular_core.Signal<readonly CalendarYearRow[]>;
+    /** Label for the view trigger / heading, reflecting the active view. */
+    readonly viewTriggerLabel: _angular_core.Signal<string>;
+    readonly isPreviousDisabled: _angular_core.Signal<boolean>;
+    readonly isNextDisabled: _angular_core.Signal<boolean>;
+    /** Weekday column headers for the visible month, starting at `firstDayOfWeek`. */
+    readonly weekDays: _angular_core.Signal<readonly forty_cdk_calendar.CalendarWeekday[]>;
+    /** Week rows of the visible month, including outside-month padding days. */
+    readonly weeks: _angular_core.Signal<readonly forty_cdk_calendar.CalendarWeek<D>[]>;
+    /** Whether the previous-month button should be disabled (bounded by `min`). */
+    readonly isPreviousMonthDisabled: _angular_core.Signal<boolean>;
+    /** Whether the next-month button should be disabled (bounded by `max`). */
+    readonly isNextMonthDisabled: _angular_core.Signal<boolean>;
+    /**
+     * Whether every day of `month` (**1-12**) in the visible year falls outside
+     * `[min, max]`. Use it to disable a month in a custom dropdown.
+     */
+    isMonthDisabled(month: number): boolean;
+    /**
+     * Whether every day of `year` falls outside `[min, max]`. Use it to disable a
+     * year in a custom dropdown.
+     */
+    isYearDisabled(year: number): boolean;
+    isMonthSelected(month: number): boolean;
+    isMonthToday(month: number): boolean;
+    isMonthFocused(month: number): boolean;
+    isYearSelected(year: number): boolean;
+    isYearToday(year: number): boolean;
+    isYearFocused(year: number): boolean;
+    isSelected(date: D): boolean;
+    isRangeStart(date: D): boolean;
+    isRangeEnd(date: D): boolean;
+    isInRange(date: D): boolean;
+    isRangePreview(date: D): boolean;
+    setHovered(date: D | null): void;
+    isToday(date: D): boolean;
+    isFocused(date: D): boolean;
+    isOutsideMonth(date: D): boolean;
+    isUnavailable(date: D): boolean;
+    getDateLabel(date: D): string;
+    selectDate(date: D): void;
+    pageMonths(delta: number): void;
+    /**
+     * Set the visible month to (`year`, `month`) without selecting a date.
+     * `month` is **1-12**. Re-applies the user's intended day-of-month (clamped to
+     * the target month's length), clamps the result into `[min, max]`, and
+     * announces the new period politely when the visible month changes. Keeps DOM
+     * focus on the caller — it does not move focus into the grid. A no-op while the
+     * calendar is disabled.
+     */
+    goTo(year: number, month: number): void;
+    /** Set the visible month within the current visible year. `month` is **1-12**. */
+    goToMonth(month: number): void;
+    /** Set the visible year, keeping the current visible month. */
+    goToYear(year: number): void;
+    handleCellKeydown(event: KeyboardEvent, fromDate: D): void;
+    /**
+     * Cycle the view one step coarser: `day → month → year`, clamped at `'year'`.
+     * No-op when the whole calendar is disabled.
+     */
+    cycleView(): void;
+    /**
+     * Select a whole month (1-12): navigate to it within the current visible year
+     * and switch the view to `'day'`. No-op when the calendar is disabled /
+     * read-only or the month is out of `[min, max]`.
+     */
+    selectMonth(month: number): void;
+    /**
+     * Select a whole year: navigate to it and switch the view to `'month'`. No-op
+     * when the calendar is disabled / read-only or the year is out of `[min, max]`.
+     */
+    selectYear(year: number): void;
+    /** Page backward by one month / year / block depending on the active view. */
+    pagePrevious(): void;
+    /** Page forward by one month / year / block depending on the active view. */
+    pageNext(): void;
+    /**
+     * Move DOM focus to the roving cell — the gridcell carrying the tab stop,
+     * i.e. the one matching {@link focusedDate} (day view) or the highlighted
+     * month / year cell (month / year view). Returns `false` when no matching
+     * cell is currently rendered, so an overlay host wrapping the calendar can
+     * fall back to its own focus logic.
+     */
+    focusActiveCell(): boolean;
+    registerCell(handle: ForCalendarCellHandle<D>): void;
+    unregisterCell(handle: ForCalendarCellHandle<D>): void;
+    handleMonthCellKeydown(event: KeyboardEvent, fromMonth: number): void;
+    handleYearCellKeydown(event: KeyboardEvent, fromYear: number): void;
+    registerMonthCell(handle: ForCalendarMonthCellHandle): void;
+    unregisterMonthCell(handle: ForCalendarMonthCellHandle): void;
+    registerYearCell(handle: ForCalendarYearCellHandle): void;
+    unregisterYearCell(handle: ForCalendarYearCellHandle): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForCalendar<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForCalendar<any>, "[forCalendar]", ["forCalendar"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "isDateUnavailable": { "alias": "isDateUnavailable"; "required": false; "isSignal": true; }; "dateLabel": { "alias": "dateLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "view": { "alias": "view"; "required": false; "isSignal": true; }; "yearBlockSize": { "alias": "yearBlockSize"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "minRangeLength": { "alias": "minRangeLength"; "required": false; "isSignal": true; }; "maxRangeLength": { "alias": "maxRangeLength"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "_dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "view": "viewChange"; "range": "rangeChange"; }, never, never, true, never>;
+}
+
+/**
+ * The calendar's date table (`role="grid"`). Apply on a `<table>`. Labelled by
+ * the `[forCalendarHeading]` via `aria-labelledby`, and reflects `aria-disabled`
+ * / `aria-readonly` from the root.
+ *
+ * Exposes the month's `weekDays()` (column headers) and `weeks()` (day rows)
+ * for the consumer to iterate — bind `cell.date` to each `[forCalendarCell]`.
+ */
+declare class ForCalendarGrid {
+    protected readonly ctx: forty_cdk_calendar.ForCalendarContext<unknown>;
+    /** Weekday column headers for the visible month, starting at `firstDayOfWeek`. */
+    readonly weekDays: _angular_core.Signal<readonly forty_cdk_calendar.CalendarWeekday[]>;
+    /** Week rows of the visible month, including outside-month padding days. */
+    readonly weeks: _angular_core.Signal<readonly forty_cdk_calendar.CalendarWeek<unknown>[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForCalendarGrid, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForCalendarGrid, "[forCalendarGrid]", ["forCalendarGrid"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Marks the calendar grid's header rowgroup. Apply on a `<thead>` holding a
+ * single row of `<th scope="col">` weekday headers.
+ *
+ * Reflects `role="rowgroup"` so the weekday header is exposed as a distinct
+ * rowgroup inside the `role="grid"` table — assistive tech announces the
+ * column headers as their own group rather than folding them into the day
+ * rows. (A bare `<thead>` carries the implicit role, but the grid's explicit
+ * `role="grid"` suppresses the table's native row/rowgroup semantics, so the
+ * header must restate it.)
+ *
+ * Also exposes `weekDays()` so the header row can be iterated from this piece,
+ * as an alternative to reading it off `[forCalendarGrid]`.
+ */
+declare class ForCalendarGridHeader {
+    protected readonly ctx: forty_cdk_calendar.ForCalendarContext<unknown>;
+    /** Weekday column headers for the visible month, starting at `firstDayOfWeek`. */
+    readonly weekDays: _angular_core.Signal<readonly forty_cdk_calendar.CalendarWeekday[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForCalendarGridHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForCalendarGridHeader, "[forCalendarGridHeader]", ["forCalendarGridHeader"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * A single day cell (`role="gridcell"`). Apply on the `<td>` for each day in
+ * the grid and bind `[date]` to the cell's date from `weeks()`.
+ *
+ * Carries the roving tab stop (`tabindex="0"` only on the focused date), the
+ * full accessible date as `aria-label` (the bare day number stays the visible
+ * content), `aria-selected` (always emitted), `aria-current="date"` on today,
+ * `aria-disabled` on unavailable dates, and the boolean `data-*` styling hooks
+ * (`data-selected`, `data-today`, `data-highlighted`, `data-disabled`,
+ * `data-outside-month`). In `selectionMode="range"`, also emits
+ * `data-range-start`, `data-range-end`, `data-in-range`, and
+ * `data-range-preview` (all boolean present/absent). Click and `Enter` /
+ * `Space` select; arrow / paging keys move the focused date.
+ *
+ * @typeParam D The adapter's date type (inferred from the bound `[date]`).
+ */
+declare class ForCalendarCell<D> {
+    #private;
+    protected readonly ctx: forty_cdk_calendar.ForCalendarContext<unknown>;
+    /** The date this cell represents. */
+    readonly date: _angular_core.InputSignal<D>;
+    protected readonly selected: _angular_core.Signal<boolean>;
+    protected readonly isToday: _angular_core.Signal<boolean>;
+    protected readonly focused: _angular_core.Signal<boolean>;
+    protected readonly unavailable: _angular_core.Signal<boolean>;
+    protected readonly outsideMonth: _angular_core.Signal<boolean>;
+    protected readonly dateLabel: _angular_core.Signal<string>;
+    protected readonly rangeStart: _angular_core.Signal<boolean>;
+    protected readonly rangeEnd: _angular_core.Signal<boolean>;
+    protected readonly inRange: _angular_core.Signal<boolean>;
+    protected readonly rangePreview: _angular_core.Signal<boolean>;
+    constructor();
+    protected onClick(): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForCalendarCell<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForCalendarCell<any>, "[forCalendarCell]", ["forCalendarCell"], { "date": { "alias": "date"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The month/year heading. Apply on a heading element (e.g. `<h2>`) and render
+ * its `label()` as the content: `<h2 forCalendarHeading #h="forCalendarHeading">{{ h.label() }}</h2>`.
+ * The grid is `aria-labelledby` this element, so it names the visible period.
+ *
+ * It is **not** an `aria-live` region: paging the month announces the new
+ * period through a dedicated off-screen live region owned by `[forCalendar]`,
+ * so the grid's accessible name is re-read on demand without the heading
+ * itself double-announcing on every render.
+ */
+declare class ForCalendarHeading {
+    protected readonly ctx: forty_cdk_calendar.ForCalendarContext<unknown>;
+    /** The visible month's accessible label, e.g. `"June 2026"`. */
+    readonly label: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForCalendarHeading, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForCalendarHeading, "[forCalendarHeading]", ["forCalendarHeading"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Pages the calendar backward. In `day` view pages by one month; in `month` view
+ * pages by one year; in `year` view pages by one block. Apply on a `<button>`.
+ * Keeps DOM focus on itself while paging; the `aria-live` heading announces the
+ * new period. Auto-disabled at the view's bound, or when the whole calendar is
+ * disabled.
+ *
+ * Provide an accessible name via the `[ariaLabel]` input (e.g.
+ * `[ariaLabel]="'Previous'"`).
+ */
+declare class ForCalendarPrevButton {
+    protected readonly ctx: forty_cdk_calendar.ForCalendarContext<unknown>;
+    /** Accessible name for the button. A `null` (default) or empty value emits no attribute. */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForCalendarPrevButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForCalendarPrevButton, "[forCalendarPrevButton]", ["forCalendarPrevButton"], { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Pages the calendar forward. In `day` view pages by one month; in `month` view
+ * pages by one year; in `year` view pages by one block. Apply on a `<button>`.
+ * Keeps DOM focus on itself while paging; the `aria-live` heading announces the
+ * new period. Auto-disabled at the view's bound, or when the whole calendar is
+ * disabled.
+ *
+ * Provide an accessible name via the `[ariaLabel]` input (e.g.
+ * `[ariaLabel]="'Next'"`).
+ */
+declare class ForCalendarNextButton {
+    protected readonly ctx: forty_cdk_calendar.ForCalendarContext<unknown>;
+    /** Accessible name for the button. A `null` (default) or empty value emits no attribute. */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForCalendarNextButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForCalendarNextButton, "[forCalendarNextButton]", ["forCalendarNextButton"], { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The month picker grid (`role="grid"`). Apply on a `<table>`. Labelled by the
+ * `[forCalendarHeading]` via `aria-labelledby`. Exposes `rows()` — iterate
+ * rows then cells, binding each cell's `month` to `[forCalendarMonthCell]`.
+ *
+ * Shows the 12 months of the visible year in 3-column rows. Used when
+ * `view === 'month'`.
+ */
+declare class ForCalendarMonthGrid {
+    protected readonly ctx: forty_cdk_calendar.ForCalendarContext<unknown>;
+    /** Rows of the month picker grid (3 columns) for the visible year. */
+    readonly rows: _angular_core.Signal<readonly forty_cdk_calendar.CalendarMonthRow[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForCalendarMonthGrid, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForCalendarMonthGrid, "[forCalendarMonthGrid]", ["forCalendarMonthGrid"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * A single month cell (`role="gridcell"`) in the month picker grid. Apply on
+ * the `<td>` for each month and bind `[month]` to the month number (1-12) from
+ * `rows()`.
+ *
+ * Carries the roving tab stop (`tabindex="0"` on the focused month), reflects
+ * `aria-selected` (always emitted), `data-today`, `data-selected`,
+ * `data-highlighted`, `data-disabled`. Click and `Enter` / `Space` drill down
+ * to the day view for that month; arrow / paging keys move the roving cell.
+ */
+declare class ForCalendarMonthCell {
+    #private;
+    protected readonly ctx: forty_cdk_calendar.ForCalendarContext<unknown>;
+    /** The month this cell represents, **1-12**. */
+    readonly month: _angular_core.InputSignal<number>;
+    protected readonly selected: _angular_core.Signal<boolean>;
+    protected readonly today: _angular_core.Signal<boolean>;
+    protected readonly focused: _angular_core.Signal<boolean>;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForCalendarMonthCell, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForCalendarMonthCell, "[forCalendarMonthCell]", ["forCalendarMonthCell"], { "month": { "alias": "month"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The year picker grid (`role="grid"`). Apply on a `<table>`. Labelled by the
+ * `[forCalendarHeading]` via `aria-labelledby`. Exposes `rows()` — iterate
+ * rows then cells, binding each cell's `year` to `[forCalendarYearCell]`.
+ *
+ * Shows an aligned block of `yearBlockSize` years in 3-column rows. Used when
+ * `view === 'year'`.
+ */
+declare class ForCalendarYearGrid {
+    protected readonly ctx: forty_cdk_calendar.ForCalendarContext<unknown>;
+    /** Rows of the year picker grid (3 columns) for the aligned block containing the visible year. */
+    readonly rows: _angular_core.Signal<readonly forty_cdk_calendar.CalendarYearRow[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForCalendarYearGrid, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForCalendarYearGrid, "[forCalendarYearGrid]", ["forCalendarYearGrid"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * A single year cell (`role="gridcell"`) in the year picker grid. Apply on the
+ * `<td>` for each year and bind `[year]` to the year number from `rows()`.
+ *
+ * Carries the roving tab stop (`tabindex="0"` on the focused year), reflects
+ * `aria-selected` (always emitted), `data-today`, `data-selected`,
+ * `data-highlighted`, `data-disabled`. Click and `Enter` / `Space` drill down
+ * to the month view for that year; arrow / paging keys move the roving cell.
+ */
+declare class ForCalendarYearCell {
+    #private;
+    protected readonly ctx: forty_cdk_calendar.ForCalendarContext<unknown>;
+    /** The year this cell represents. */
+    readonly year: _angular_core.InputSignal<number>;
+    protected readonly selected: _angular_core.Signal<boolean>;
+    protected readonly today: _angular_core.Signal<boolean>;
+    protected readonly focused: _angular_core.Signal<boolean>;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForCalendarYearCell, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForCalendarYearCell, "[forCalendarYearCell]", ["forCalendarYearCell"], { "year": { "alias": "year"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The view-cycle button in the calendar header. Apply on a `<button>`. Each
+ * click advances the view one step coarser (`day → month → year`), clamped at
+ * `'year'`. Reflects `data-view` so consumers can style it per view. Disabled
+ * when the whole calendar is disabled.
+ *
+ * Bind the `label` signal to the button text to show the active view label
+ * (e.g. `"June 2026"` in day view, `"2026"` in month view, `"2024 – 2035"` in
+ * year view).
+ */
+declare class ForCalendarViewTrigger {
+    protected readonly ctx: forty_cdk_calendar.ForCalendarContext<unknown>;
+    /** Label for the active view, e.g. `"June 2026"` / `"2026"` / `"2016 – 2027"`. */
+    readonly label: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForCalendarViewTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForCalendarViewTrigger, "[forCalendarViewTrigger]", ["forCalendarViewTrigger"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Wires a native `<select>` to a `ForCalendar`'s month navigation. Apply on a
+ * `<select>` element inside `[forCalendar]`: the directive keeps the select
+ * showing the visible month and navigates the calendar when the user picks a
+ * different one, without mutating the selected date.
+ *
+ * Render the `<option>` elements yourself from {@link options} so you keep full
+ * control over their markup, labels, and any placeholder:
+ *
+ * ```html
+ * <select forCalendarMonthSelect #m="forCalendarMonthSelect">
+ *   @for (opt of m.options(); track opt.value) {
+ *     <option [value]="opt.value" [disabled]="opt.disabled">{{ opt.label }}</option>
+ *   }
+ * </select>
+ * ```
+ */
+declare class ForCalendarMonthSelect {
+    protected readonly ctx: forty_cdk_calendar.ForCalendarContext<unknown>;
+    /** The twelve localized, bounds-aware month options for the visible year. */
+    readonly options: _angular_core.Signal<readonly forty_cdk_calendar.CalendarMonthOption[]>;
+    protected onChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForCalendarMonthSelect, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForCalendarMonthSelect, "select[forCalendarMonthSelect]", ["forCalendarMonthSelect"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Wires a native `<select>` to a `ForCalendar`'s year navigation. Apply on a
+ * `<select>` element inside `[forCalendar]`: the directive keeps the select
+ * showing the visible year and navigates the calendar when the user picks a
+ * different one, without mutating the selected date.
+ *
+ * Render the `<option>` elements yourself from {@link years} so you keep full
+ * control over their markup:
+ *
+ * ```html
+ * <select forCalendarYearSelect #y="forCalendarYearSelect" [minYear]="1900" [maxYear]="2100">
+ *   @for (opt of y.years(); track opt.value) {
+ *     <option [value]="opt.value" [disabled]="opt.disabled">{{ opt.value }}</option>
+ *   }
+ * </select>
+ * ```
+ */
+declare class ForCalendarYearSelect {
+    protected readonly ctx: forty_cdk_calendar.ForCalendarContext<unknown>;
+    /**
+     * Lowest year listed in {@link years}. Defaults to 100 years before the
+     * current year when `null`.
+     */
+    readonly minYear: _angular_core.InputSignal<number | null>;
+    /**
+     * Highest year listed in {@link years}. Defaults to 10 years after the
+     * current year when `null`.
+     */
+    readonly maxYear: _angular_core.InputSignal<number | null>;
+    /**
+     * The selectable years, from {@link minYear} to {@link maxYear} inclusive.
+     * Each entry is `disabled` when the whole year falls outside the calendar's
+     * `[min, max]`. The default window is anchored to the current year (not the
+     * visible year), so navigating far away never drops the current year off the
+     * list.
+     */
+    readonly years: _angular_core.Signal<readonly CalendarYearOption[]>;
+    protected onChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForCalendarYearSelect, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForCalendarYearSelect, "select[forCalendarYearSelect]", ["forCalendarYearSelect"], { "minYear": { "alias": "minYear"; "required": false; "isSignal": true; }; "maxYear": { "alias": "maxYear"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Defaults inherited by descendant calendars in the surrounding injector
+ * scope. Configure with `provideForCalendarDefaults` at the application root
+ * or in any component's `providers`; partial overrides merge with the parent
+ * scope.
+ */
+interface ForCalendarDefaults {
+    /**
+     * First day of the week as a **0-6** index (`0` = Sunday, `1` = Monday, …).
+     * When `null` (default), each calendar falls back to its adapter's
+     * `getFirstDayOfWeek()`. A `ForCalendar`'s own `firstDayOfWeek` input always
+     * wins over this scope default.
+     */
+    firstDayOfWeek: number | null;
+}
+/** Token holding the resolved calendar defaults for the current scope. */
+declare const FOR_CALENDAR_DEFAULTS: _angular_core.InjectionToken<ForCalendarDefaults>;
+/**
+ * Configures forty-cdk calendar defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library
+ * defaults at the root).
+ */
+declare function provideForCalendarDefaults(defaults?: Partial<ForCalendarDefaults>): Provider[];
+
+/**
+ * Zero-dependency {@link DateAdapter} over the built-in `Date`. `today` and
+ * `createDate` produce days at local midnight, and the calendar grid stays
+ * day-granular. It is also **time-capable** — `Date` natively carries a
+ * wall-clock time, so the optional `getHours` / `getMinutes` / `getSeconds` /
+ * `setTime` accessors are implemented, letting `ForTimeField` use this adapter
+ * directly. Consistently with that, `compare` orders by the full instant
+ * (day *and* time), matching `InternationalizedDateTimeAdapter`, so a date-time
+ * `minDate`/`maxDate` clamps identically on both.
+ *
+ * This is the fallback adapter. Prefer `provideInternationalizedDateAdapter()`
+ * for correct date-math and locale-aware formatting (or
+ * `provideInternationalizedDateTimeAdapter()` for a time-capable one); reach
+ * for this one when adding a date library to the bundle is not worthwhile. Both
+ * `Date` and the `@internationalized/date` adapters operate on the Gregorian
+ * calendar today; non-Gregorian calendar systems are deferred to #354.
+ */
+declare class NativeDateAdapter implements DateAdapter<Date> {
+    /**
+     * Today at local midnight in the runtime time zone. Subject to the
+     * SSR/hydration caveat on {@link DateAdapter.today}.
+     */
+    today(): Date;
+    createDate(year: number, month: number, day: number): Date;
+    getYear(date: Date): number;
+    getMonth(date: Date): number;
+    getDate(date: Date): number;
+    getDayOfWeek(date: Date): number;
+    getDaysInMonth(date: Date): number;
+    getFirstDayOfWeek(): number;
+    addDays(date: Date, n: number): Date;
+    addMonths(date: Date, n: number): Date;
+    addYears(date: Date, n: number): Date;
+    compare(a: Date, b: Date): number;
+    isSameDay(a: Date, b: Date): boolean;
+    isValid(date: Date): boolean;
+    /**
+     * Formats through the runtime's default locale. Subject to the SSR/hydration
+     * caveat on {@link DateAdapter.format}.
+     */
+    format(date: Date, options: Intl.DateTimeFormatOptions): string;
+    supportsTime(): boolean;
+    getHours(date: Date): number;
+    getMinutes(date: Date): number;
+    getSeconds(date: Date): number;
+    setTime(date: Date, hours: number, minutes: number, seconds: number): Date;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NativeDateAdapter, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NativeDateAdapter>;
+}
+/**
+ * Provides the zero-dependency {@link NativeDateAdapter} as the active
+ * {@link DateAdapter}. Add to your application or component providers when
+ * `ForCalendar` should operate on native `Date` values.
+ *
+ * @example
+ * ```ts
+ * bootstrapApplication(App, {
+ *   providers: [provideNativeDateAdapter()],
+ * });
+ * ```
+ */
+declare function provideNativeDateAdapter(): Provider[];
+
+export { FOR_CALENDAR_CONTEXT, FOR_CALENDAR_DEFAULTS, ForCalendar, ForCalendarCell, ForCalendarGrid, ForCalendarGridHeader, ForCalendarHeading, ForCalendarMonthCell, ForCalendarMonthGrid, ForCalendarMonthSelect, ForCalendarNextButton, ForCalendarPrevButton, ForCalendarViewTrigger, ForCalendarYearCell, ForCalendarYearGrid, ForCalendarYearSelect, NativeDateAdapter, provideForCalendarDefaults, provideNativeDateAdapter };
+export type { CalendarDateLabelFormatter, CalendarDateRange, CalendarDayCell, CalendarMonthOption, CalendarMonthRow, CalendarView, CalendarWeek, CalendarWeekday, CalendarYearOption, CalendarYearRow, ForCalendarCellHandle, ForCalendarContext, ForCalendarDefaults, ForCalendarMonthCellHandle, ForCalendarYearCellHandle };