forty-cdk 0.0.4 → 0.2.0

package/types/forty-cdk.d.ts

@@ -1,7 +1,8 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, Provider, Signal, Type, ModelSignal, OutputEmitterRef, TemplateRef, ElementRef, OnInit } from '@angular/core';
+import { InjectionToken, Provider, ModelSignal, Signal, EnvironmentInjector, ComponentRef, Type, Injector, OutputEmitterRef, TemplateRef, ElementRef } from '@angular/core';
 import * as forty_cdk from 'forty-cdk';
 import { ValidationError, FormValueControl, FormCheckboxControl, FieldTree } from '@angular/forms/signals';
+import * as _floating_ui_dom from '@floating-ui/dom';
 import { ReferenceElement } from '@floating-ui/dom';
 
 /**
@@ -10,7 +11,7 @@ import { ReferenceElement } from '@floating-ui/dom';
  * (close, focus move, etc.) when set.
  *
  * Replaces the prior pattern of passing a real DOM `CustomEvent`, which
- * was a Radix transplant: Angular `output()` is a synchronous in-process
+ * was a poor fit: Angular `output()` is a synchronous in-process
  * emitter — events don't bubble, don't propagate, and have no `target` /
  * `currentTarget`. `CustomEvent` cost an allocation per emit and gave
  * consumers a misleading "looks like a DOM event" surface.
@@ -63,6 +64,260 @@ declare const FOR_ID_SALT: InjectionToken<string>;
  * @param salt A stable, app-unique salt.
  */
 declare function provideForIdSalt(salt: string): Provider;
+/**
+ * Generates unique string IDs scoped to the application instance.
+ *
+ * Used by primitives that need to wire `aria-controls` / `aria-labelledby`
+ * relationships between pieces — the IDs are stable for the lifetime of the
+ * primitive instance.
+ *
+ * SSR: the generator is `providedIn: 'root'`, so a fresh instance is
+ * created for each Angular application bootstrap (one per SSR request).
+ * The IDs are salted with {@link FOR_ID_SALT} (which defaults to the
+ * application's `APP_ID`) so the server and the client produce identical
+ * strings for the same render order — the property hydration relies on.
+ *
+ * IMPORTANT — multiple apps on one page need distinct salts. The default salt
+ * is `APP_ID`, and Angular's default `APP_ID` is the literal `'ng'`. Two
+ * forty-cdk apps mounted side-by-side that both keep the default salt
+ * therefore start from the same salt and the same counter, emitting identical
+ * id sequences — duplicate DOM ids that mis-resolve `aria-labelledby` /
+ * `aria-controls` across apps. A per-instance random nonce is deliberately
+ * NOT mixed in: it would diverge the salt but break SSR hydration (the server
+ * and client renders would no longer agree). When running more than one
+ * forty-cdk app on a single page, give each a distinct salt via
+ * {@link provideForIdSalt} (the per-app knob that leaves the global `APP_ID`
+ * untouched). Overriding the global `APP_ID` works too, but it also drives
+ * Angular's hydration store and event replay, so `provideForIdSalt` is the
+ * narrower choice.
+ */
+declare class IdGenerator {
+    #private;
+    /**
+     * Returns a fresh, unique ID with the given prefix.
+     *
+     * @param prefix Optional prefix for the generated ID. Defaults to `for`.
+     */
+    next(prefix?: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdGenerator, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IdGenerator>;
+}
+
+/**
+ * Pluggable, date-library-agnostic seam for `ForCalendar`. Every internal
+ * algorithm (paging, the day matrix, comparison, formatting) goes through a
+ * `DateAdapter<D>`, so the primitive never hard-depends on a date library.
+ *
+ * The library ships two adapters behind {@link FOR_DATE_ADAPTER}:
+ *
+ * - `provideInternationalizedDateAdapter()` — over `@internationalized/date`'s
+ *   immutable `CalendarDate`. Recommended for correct date-math and locale-aware
+ *   formatting; `@internationalized/date` is an optional peer dependency. Both
+ *   `@internationalized/date` adapters operate on the **Gregorian** calendar
+ *   today — non-Gregorian calendar systems are deferred to the Temporal adapter
+ *   track (#354).
+ * - `provideNativeDateAdapter()` — over the built-in `Date`. Zero-dependency
+ *   fallback.
+ *
+ * A `Temporal.PlainDate` adapter is a planned non-breaking addition once the
+ * Temporal API is broadly available across browsers (#354).
+ *
+ * Implementations must be pure with respect to their date type: every
+ * operation returns a value and never mutates its inputs. The `D` produced by
+ * mutating operations (`add*`, `createDate`) is a fresh value, which keeps it
+ * signal-friendly (reference equality changes on every change).
+ *
+ * @typeParam D The immutable date representation the adapter operates on.
+ */
+interface DateAdapter<D> {
+    /**
+     * Today's date in the runtime time zone.
+     *
+     * **SSR / hydration caveat.** The result depends on the runtime time zone, so
+     * a server render and a client hydration can disagree by up to a day near
+     * midnight — the server may compute a different calendar day than the
+     * browser. `ForCalendar` reads this once to mark the `data-today` /
+     * `aria-current="date"` cell, so a mismatch surfaces there as a hydration
+     * error and a flicker on the highlighted "today" cell.
+     *
+     * **SSR-safe pattern.** Have the consumer supply a fixed "today" (or pin a
+     * time zone) for the server render, or defer the today-highlight to
+     * `afterNextRender` so `today()` is only computed client-side. See the
+     * calendar README's "SSR / hydration" section.
+     */
+    today(): D;
+    /**
+     * Creates a date from its parts.
+     *
+     * @param year Full year (e.g. `2026`).
+     * @param month Month of year, **1-12**.
+     * @param day Day of month, **1-31** (constrained to the month's length).
+     */
+    createDate(year: number, month: number, day: number): D;
+    /** The full year of `date` (e.g. `2026`). */
+    getYear(date: D): number;
+    /** The month of `date`, **1-12**. */
+    getMonth(date: D): number;
+    /** The day of month of `date`, **1-31**. */
+    getDate(date: D): number;
+    /** The day of week of `date`, **0-6** where `0` is Sunday and `6` is Saturday. */
+    getDayOfWeek(date: D): number;
+    /** The number of days in `date`'s month. */
+    getDaysInMonth(date: D): number;
+    /**
+     * The first day of the week as a **0-6** index (`0` = Sunday). Used as the
+     * default when `ForCalendar`'s `firstDayOfWeek` input is `null`. Adapters
+     * return a locale-independent default (`0`); consumers localise it through
+     * the `firstDayOfWeek` input or `provideForCalendarDefaults`.
+     */
+    getFirstDayOfWeek(): number;
+    /** Returns a new date `n` days after `date` (negative goes backwards). */
+    addDays(date: D, n: number): D;
+    /**
+     * Returns a new date `n` months after `date` (negative goes backwards). The
+     * day of month is constrained to the target month's length (e.g. Jan 31 + 1
+     * month is Feb 28/29, never Mar 3).
+     */
+    addMonths(date: D, n: number): D;
+    /**
+     * Returns a new date `n` years after `date` (negative goes backwards). The
+     * day of month is constrained (e.g. Feb 29 + 1 year is Feb 28 in a common
+     * year).
+     */
+    addYears(date: D, n: number): D;
+    /**
+     * Compares two dates by their natural ordering — **the full instant**,
+     * including any time component the adapter's `D` carries. Returns a negative
+     * number when `a` is before `b`, `0` when they are equal, and a positive
+     * number when `a` is after `b`.
+     *
+     * This is the canonical comparator and the only one an adapter must
+     * implement. Time-capable adapters (`Date`, `@internationalized/date`'s
+     * `CalendarDateTime`) order by day *and* time; day-only adapters
+     * (`CalendarDate`) order by day alone because that is all their `D` carries.
+     *
+     * **Bounds granularity.** `minDate` / `maxDate` clamping in the date
+     * primitives compares the full instant through `compare`, so a date-time
+     * `min`/`max` clamps identically on every time-capable adapter (e.g. native
+     * `Date` and `CalendarDateTime` produce the same result for the same input).
+     * For the *calendar grid*, where availability is day-granular so the boundary
+     * day of a date-time `min`/`max` stays selectable, use {@link compareDateOf}
+     * (which honours {@link compareDate} when present and otherwise derives a
+     * day-only comparison from the y/m/d getters).
+     */
+    compare(a: D, b: D): number;
+    /**
+     * Optionally compares two dates by calendar day only, ignoring any time
+     * component. Returns a negative number when `a`'s day is before `b`'s, `0`
+     * when they fall on the same calendar day, and a positive number when `a`'s
+     * day is after `b`'s.
+     *
+     * Adapters may **omit** this method: {@link compareDateOf} then derives the
+     * day-only comparison from the {@link getYear} / {@link getMonth} /
+     * {@link getDate} getters, which is correct for any adapter. Implement it only
+     * to override that default (e.g. for a non-Gregorian ordering). Day-only
+     * adapters whose {@link compare} already ignores time need not implement it.
+     */
+    compareDate?(a: D, b: D): number;
+    /** Whether `a` and `b` fall on the same calendar day. */
+    isSameDay(a: D, b: D): boolean;
+    /** Whether `date` is a valid date of this adapter's type. */
+    isValid(date: D): boolean;
+    /**
+     * Formats `date` for display using the runtime's default locale.
+     *
+     * **SSR / hydration caveat.** The result resolves against the runtime's
+     * default locale, so a server render and a client hydration can produce
+     * different strings when the server and browser locales differ — surfacing as
+     * a hydration mismatch on every formatted value (heading, weekday headers,
+     * cell labels). The runtime time zone applies too for adapters that format
+     * through a wall-clock instant.
+     *
+     * **SSR-safe pattern.** Pin a locale (or format client-side) for the server
+     * render so both environments resolve the same locale. See the calendar
+     * README's "SSR / hydration" section.
+     *
+     * @param options Standard `Intl.DateTimeFormat` options (e.g.
+     *   `{ month: 'long', year: 'numeric' }` for a calendar heading,
+     *   `{ weekday: 'short' }` for a column header).
+     */
+    format(date: D, options: Intl.DateTimeFormatOptions): string;
+    /**
+     * Whether this adapter's `D` can carry a wall-clock time component (hour /
+     * minute / second). Day-only adapters omit the optional time accessors below
+     * and return `false` (or omit this method); time-capable adapters implement
+     * them and return `true`. `ForTimeField` — and the time granularity of the
+     * date primitives — require a time-capable adapter.
+     */
+    supportsTime?(): boolean;
+    /** The hour of `date`, **0-23** (24-hour clock). Time-capable adapters only. */
+    getHours?(date: D): number;
+    /** The minute of `date`, **0-59**. Time-capable adapters only. */
+    getMinutes?(date: D): number;
+    /** The second of `date`, **0-59**. Time-capable adapters only. */
+    getSeconds?(date: D): number;
+    /**
+     * Returns a new date with its time set to the given parts, preserving the
+     * calendar day. Time-capable adapters only.
+     *
+     * @param hours Hour of day, **0-23**.
+     * @param minutes Minute of hour, **0-59**.
+     * @param seconds Second of minute, **0-59**.
+     */
+    setTime?(date: D, hours: number, minutes: number, seconds: number): D;
+}
+/**
+ * A {@link DateAdapter} narrowed to one that implements the optional time
+ * accessors. Produced by {@link assertTimeCapable} so time primitives can call
+ * `getHours` / `setTime` / etc. without optional-chaining.
+ *
+ * @typeParam D The adapter's immutable date-time representation.
+ */
+type TimeCapableDateAdapter<D> = DateAdapter<D> & Required<Pick<DateAdapter<D>, 'getHours' | 'getMinutes' | 'getSeconds' | 'setTime'>>;
+/**
+ * Injection token holding the active {@link DateAdapter}. Provide it with
+ * `provideInternationalizedDateAdapter()` or `provideNativeDateAdapter()`.
+ * There is no application-wide default — a calendar with no adapter in scope
+ * throws a descriptive error.
+ */
+declare const FOR_DATE_ADAPTER: InjectionToken<DateAdapter<unknown>>;
+/**
+ * Injects the active {@link DateAdapter}, throwing a descriptive,
+ * primitive-prefixed error when no adapter has been provided.
+ *
+ * @param piece Name of the calling directive, used in the error message.
+ */
+declare function injectDateAdapter<D>(piece: string): DateAdapter<D>;
+/**
+ * Asserts that `adapter` implements the optional time accessors, returning it
+ * narrowed to {@link TimeCapableDateAdapter}. Throws a descriptive,
+ * primitive-prefixed error when the active adapter is day-only — the
+ * zero-dependency `provideNativeDateAdapter()` is time-capable, as is
+ * `provideInternationalizedDateTimeAdapter()`, but the day-pure
+ * `provideInternationalizedDateAdapter()` (`CalendarDate`) is not.
+ *
+ * @param adapter The active adapter, typically from {@link injectDateAdapter}.
+ * @param piece Name of the calling directive, used in the error message.
+ */
+declare function assertTimeCapable<D>(adapter: DateAdapter<D>, piece: string): TimeCapableDateAdapter<D>;
+
+/**
+ * Shared contract implemented by both `ForTimeField` and `ForTimePicker`. The
+ * `ForDatePicker` time bridge queries this token via `contentChild` so it can
+ * observe whichever time-editing primitive the consumer projects — without a
+ * hard import of either, keeping date-picker tree-shaking intact.
+ *
+ * @typeParam D The adapter's date-time type.
+ */
+interface TimeValueSource<D> {
+    readonly value: ModelSignal<D | null>;
+    readonly adapter: DateAdapter<D>;
+}
+/**
+ * Token provided by `ForTimeField` and `ForTimePicker`. `ForDatePicker`
+ * queries descendants for this token to locate the projected time source.
+ */
+declare const FOR_TIME_VALUE_SOURCE: InjectionToken<TimeValueSource<unknown>>;
 
 /**
  * Shared state contract between the pieces of a Disclosure primitive.
@@ -322,7 +577,13 @@ declare class ForAccordionItem implements ForAccordionItemContext {
     protected readonly parent: forty_cdk.ForAccordionContext;
     /** Unique identifier of this item within the accordion. Required. */
     readonly value: _angular_core.InputSignal<string>;
-    /** When true, the trigger ignores clicks and reflects `disabled`. */
+    /**
+     * When true, the trigger ignores clicks and reflects the native `disabled`
+     * attribute (not `aria-disabled`). The trigger is therefore dropped from the
+     * Tab order and skipped by arrow-key navigation, but stays in the
+     * accessibility tree so screen readers still announce it. See
+     * `ForAccordionTrigger` for the rationale (rule #561 D2).
+     */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly triggerId: _angular_core.Signal<string>;
     readonly contentId: _angular_core.Signal<string>;
@@ -360,7 +621,16 @@ declare class ForAccordionTrigger {
     /**
      * APG: aria-disabled is true only when the panel is open AND the accordion
      * disallows collapse. A real `disabled` item is reflected via the native
-     * `disabled` attribute instead.
+     * `disabled` attribute instead — the sanctioned exception in rule #561 (D2):
+     * the trigger is a real single-purpose `<button>`, not a roving collection
+     * item (every trigger stays independently in the Tab order; the arrow-key
+     * navigation is an APG-optional enhancement layered on top, not a
+     * roving-tabindex collection), so native `disabled` is correct here. The
+     * button stays in the accessibility tree — screen readers still announce it
+     * as unavailable in browse mode — while being dropped from the Tab order and
+     * the arrow-key navigation (which `focusByOffset` already skips), keeping
+     * disabled triggers uniformly unreachable. The APG Accordion pattern does not
+     * require disabled headers to remain focusable.
      */
     protected readonly ariaDisabled: _angular_core.Signal<boolean>;
     constructor();
@@ -544,8 +814,7 @@ declare function injectFieldWiring(handle?: Omit<FieldControlHandle, 'host'>): v
 
 /**
  * Headless form-field container that wires accessible labelling, description,
- * and error association for a single control — the styleless counterpart to
- * Radix `Label` + `Form` / Base UI `Field`. It renders nothing and imposes no
+ * and error association for a single control. It renders nothing and imposes no
  * layout: its only job is to connect a `[forLabel]`, `[forFieldDescription]`,
  * and `[forFieldError]` to the control via `id` / `aria-labelledby` /
  * `aria-describedby` / `aria-errormessage`, and to reflect the control's
@@ -651,7 +920,7 @@ declare class ForField implements ForFieldContext {
  * is not re-forwarded, so a label-wrapping layout toggles once, matching native
  * `<label>` semantics.
  *
- * Usable standalone (Radix-style) outside a field — there it is an inert
+ * Usable standalone outside a field — there it is an inert
  * marker and the consumer wires native `for` themselves.
  *
  * @example
@@ -799,8 +1068,7 @@ declare const FOR_FIELDSET_CONTEXT: InjectionToken<ForFieldsetContext>;
 /**
  * Headless grouping container that gives a set of related fields a shared
  * accessible name — the styleless counterpart to a native `<fieldset>` +
- * `<legend>`, and the grouping companion to `ForField`. Mirrors Base UI
- * `Fieldset`.
+ * `<legend>`, and the grouping companion to `ForField`.
  *
  * On a native `<fieldset>` it relies on the implicit grouping and emits no
  * role; on any other element it emits `role="group"` + `aria-labelledby`
@@ -1010,6 +1278,16 @@ declare abstract class FormUiControlBase {
      * `touched` directly, so both channels always fire together.
      */
     protected markTouched(): void;
+    /**
+     * The element the four form-state `data-*` booleans (`data-touched` /
+     * `data-dirty` / `data-pending` / `data-invalid`) are reflected onto. Defaults
+     * to the directive host — correct when the host carries the control's styling
+     * surface. Override (returning `null` until it exists) when the reflected
+     * element is a child the directive injects, e.g. `ForOtpInput`'s real
+     * `<input>` rather than its `role="group"` host. Read reactively inside the
+     * reflection effect, so a returned signal re-targets once the element appears.
+     */
+    protected fieldStateReflectionTarget(): HTMLElement | null;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormUiControlBase, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FormUiControlBase, never, never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "touched": "touchedChange"; "touch": "touch"; }, never, never, true, never>;
@@ -1097,15 +1375,23 @@ declare class ForInput extends TextValueControlBase implements FormValueControl<
  * Apply on a native `<textarea>`. The element keeps its own caret, wrapping,
  * IME composition, and native form submission — the directive only bridges the
  * value to a signal and reflects validation state. The string-valued sibling
- * of `[forInput]`; auto-resize is intentionally out of scope.
+ * of `[forInput]`.
  *
  * The host gets `data-empty` (while the value is `''`), `data-disabled`, and
  * `data-readonly` for CSS hooks.
  *
+ * With `[autosize]` the host grows and shrinks its height to fit the content on
+ * every edit, programmatic value change, and width reflow, and reflects
+ * `data-autosize` for styling (pair it with `resize: none; overflow: hidden;`).
+ * Autosize is a DOM side effect gated to the browser, so it is inert under SSR.
+ *
  * @example
  * ```html
  * <textarea forTextarea [(value)]="bio" placeholder="About you"></textarea>
  *
+ * <!-- Grow to content: -->
+ * <textarea forTextarea autosize [(value)]="bio"></textarea>
+ *
  * <!-- With Signal Forms + Field (auto-wired): -->
  * <div forField>
  *   <label forLabel>Bio</label>
@@ -1114,8 +1400,17 @@ declare class ForInput extends TextValueControlBase implements FormValueControl<
  * ```
  */
 declare class ForTextarea extends TextValueControlBase implements FormValueControl<string> {
+    #private;
+    /**
+     * Opt into height auto-sizing. When `true` the textarea's height tracks its
+     * content: it grows as the value gets taller and shrinks back as it gets
+     * shorter, recomputed on every edit, on programmatic `value` writes, and on
+     * width reflow. Defaults to `false`, leaving the element's height to CSS.
+     */
+    readonly autosize: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTextarea, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTextarea, "[forTextarea]", ["forTextarea"], {}, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTextarea, "[forTextarea]", ["forTextarea"], { "autosize": { "alias": "autosize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -1195,7 +1490,7 @@ declare const FOR_INPUT_HOST_DIRECTIVE_OUTPUTS: readonly ["valueChange", "touche
  * export class MyTextarea {}
  * ```
  */
-declare const FOR_TEXTAREA_HOST_DIRECTIVE_INPUTS: readonly ["value", "dirty", "disabled", "errors", "invalid", "name", "pending", "readonly", "required", "touched"];
+declare const FOR_TEXTAREA_HOST_DIRECTIVE_INPUTS: readonly ["value", "autosize", "dirty", "disabled", "errors", "invalid", "name", "pending", "readonly", "required", "touched"];
 /**
  * Exact public names of every `ForTextarea` output, the Signal Forms `touch` output
  * included. Spread it into the `outputs` array of the same `hostDirectives` entry as
@@ -1203,6 +1498,141 @@ declare const FOR_TEXTAREA_HOST_DIRECTIVE_INPUTS: readonly ["value", "dirty", "d
  */
 declare const FOR_TEXTAREA_HOST_DIRECTIVE_OUTPUTS: readonly ["valueChange", "touchedChange", "touch"];
 
+/**
+ * Headless `role="searchbox"` text input implementing Angular's
+ * `FormValueControl<string>` from `@angular/forms/signals`, so it auto-wires
+ * with `[formField]` and auto-associates inside a `[forField]` (label /
+ * description / error) with no extra markup. Reuses the exact form-value
+ * wiring of `[forInput]` — same IME handling, same value mirror, same
+ * validation reflection.
+ *
+ * Apply on a native `<input>`. The element keeps its own `type`, caret, IME
+ * composition, and native form submission — the directive only bridges the
+ * value to a signal, reflects validation state, and emits `role="searchbox"`.
+ *
+ * Pair with `[forSearchClear]` (passing the exported instance) for an inline
+ * clear-button affordance that hides itself while the value is empty.
+ *
+ * @example
+ * ```html
+ * <input forSearch #s="forSearch" [(value)]="q" />
+ * <button [forSearchClear]="s">×</button>
+ *
+ * <!-- With Signal Forms + Field (auto-wired): -->
+ * <div forField>
+ *   <label forLabel>Search</label>
+ *   <input forSearch [formField]="search.query" />
+ * </div>
+ * ```
+ */
+declare class ForSearch extends TextValueControlBase implements FormValueControl<string> {
+    #private;
+    /**
+     * Resets the value to `''`. Typically called by `[forSearchClear]` when the
+     * user activates the clear button, but can also be called programmatically.
+     */
+    clear(): void;
+    /**
+     * Moves focus to the native input element. Called by `[forSearchClear]`
+     * after clearing so the user can continue typing without chasing the caret.
+     */
+    focusInput(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForSearch, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForSearch, "input[forSearch]", ["forSearch"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Optional clear button for `[forSearch]`. Apply on a `<button>` element and
+ * pass the exported search instance through the selector input:
+ * `[forSearchClear]="s"` where `#s="forSearch"` is on the `<input>`.
+ *
+ * The button self-hides while the value is `''`, so consumers can leave it
+ * inline in the template without an extra `@if`. Visibility is enforced with
+ * an inline `display: none` (which beats any author `display` rule applied via
+ * a class) in addition to the `hidden` attribute that removes the element from
+ * the accessibility tree. This mirrors `[forComboboxClear]`'s approach.
+ *
+ * On activation (click) the button clears the value to `''` and refocuses the
+ * input so the user can continue typing without chasing the caret.
+ *
+ * The `aria-label="Clear"` default is set as a static host attribute. Consumers
+ * who want a different label can override it with their own `aria-label` on the
+ * same element — the consumer's attribute wins per Angular's host-binding
+ * precedence rules.
+ *
+ * The button stays in the natural tab order (no `tabindex="-1"`) unlike
+ * `[forComboboxClear]`, which lives inside an `aria-activedescendant` flow.
+ */
+declare class ForSearchClear {
+    /**
+     * The `[forSearch]` instance to operate on. Pass the exported reference:
+     * `<input forSearch #s="forSearch" /> <button [forSearchClear]="s">`.
+     */
+    readonly search: _angular_core.InputSignal<ForSearch>;
+    /** `true` while there is text to clear; drives the self-hide logic. */
+    protected readonly hasContent: _angular_core.Signal<boolean>;
+    /**
+     * Disabled when the search field is disabled or read-only — the clear action
+     * is unavailable in those states.
+     */
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForSearchClear, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForSearchClear, "[forSearchClear]", ["forSearchClear"], { "search": { "alias": "forSearchClear"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Defaults inherited by descendant `[forSearch]` controls in the surrounding
+ * injector scope. Configure with `provideForSearchDefaults`. The shape is a
+ * stub today — present so future per-scope tuning can land without churning
+ * the public surface.
+ */
+interface ForSearchDefaults {
+}
+/** Token holding the resolved search-field defaults for the current scope. */
+declare const FOR_SEARCH_DEFAULTS: _angular_core.InjectionToken<ForSearchDefaults>;
+/**
+ * Configures forty-cdk search-field defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library
+ * defaults at the root).
+ */
+declare function provideForSearchDefaults(defaults?: Partial<ForSearchDefaults>): Provider[];
+
+/**
+ * Exact public names of every `ForSearch` input, its models included. Spread it into the
+ * `inputs` array of a `hostDirectives` entry so a wrapper component re-exposes the
+ * primitive's full surface — the Signal Forms members `[formField]` binds among them —
+ * without hand-maintaining the list. Always spread into an inline object literal as shown
+ * below: the literal is what keeps the entry statically analyzable for consumers compiling
+ * against the published package. An anti-drift spec fails when this list no longer matches
+ * the directive's actual API. See `docs/wrapping-form-primitives.md` for both supported
+ * wrapping patterns.
+ *
+ * @example
+ * ```ts
+ * @Component({
+ *   selector: 'input[mySearch]',
+ *   template: '',
+ *   hostDirectives: [
+ *     {
+ *       directive: ForSearch,
+ *       inputs: [...FOR_SEARCH_HOST_DIRECTIVE_INPUTS],
+ *       outputs: [...FOR_SEARCH_HOST_DIRECTIVE_OUTPUTS],
+ *     },
+ *   ],
+ * })
+ * export class MySearch {}
+ * ```
+ */
+declare const FOR_SEARCH_HOST_DIRECTIVE_INPUTS: readonly ["value", "dirty", "disabled", "errors", "invalid", "name", "pending", "readonly", "required", "touched"];
+/**
+ * Exact public names of every `ForSearch` output, the Signal Forms `touch` output
+ * included. Spread it into the `outputs` array of the same `hostDirectives` entry as
+ * {@link FOR_SEARCH_HOST_DIRECTIVE_INPUTS}.
+ */
+declare const FOR_SEARCH_HOST_DIRECTIVE_OUTPUTS: readonly ["valueChange", "touchedChange", "touch"];
+
 /**
  * Headless on/off switch implementing the
  * [WAI-ARIA Switch pattern](https://www.w3.org/WAI/ARIA/apg/patterns/switch/)
@@ -1335,7 +1765,7 @@ declare class ForCheckbox extends FormUiControlBase implements FormCheckboxContr
      * children with mixed selection).
      */
     readonly indeterminate: _angular_core.ModelSignal<boolean>;
-    protected readonly ariaChecked: _angular_core.Signal<"true" | "false" | "mixed">;
+    protected readonly ariaChecked: _angular_core.Signal<"mixed" | "true" | "false">;
     /**
      * Logical state reflected on `data-state`: `'checked'`, `'unchecked'`, or
      * `'indeterminate'`. Exposed so `ForCheckboxIndicator` can mirror it without
@@ -2362,16 +2792,46 @@ type FloatingSide = 'top' | 'right' | 'bottom' | 'left';
 /** Alignment along the side axis: at the start edge, centered, or at the end edge. */
 type FloatingAlign = 'start' | 'center' | 'end';
 
-/** Reason a show / hide was scheduled — escape bypasses the close delay. */
-type TooltipScheduleReason = 'hover' | 'focus' | 'escape';
 /**
- * Coordination contract owned by `ForTooltip`. Trigger and content register
- * their host elements so floating-ui can compute position; the optional arrow
- * registers itself so the `arrow` middleware can offset it inside the bubble.
+ * Pointer-grace ("safe triangle") helper.
+ *
+ * When a mouse leaves a submenu trigger heading toward the submenu content,
+ * a naive "close on pointer-leave" would dismiss the submenu the moment the
+ * cursor crosses the gap between the trigger and the content. The fix native
+ * desktop menus use is a *safe triangle*: a polygon drawn
+ * from the cursor's exit point to the near edge of the submenu content. While
+ * the pointer stays inside that polygon it is assumed to be travelling toward
+ * the submenu, so the close is held off.
+ *
+ * This module keeps no Angular DI surface — the geometry is pure functions
+ * (unit-tested in `pointer-grace.spec.ts`) and {@link attachPointerGrace} is a
+ * plain `addEventListener` wrapper returning a cleanup, wired by the directive
+ * through its `DestroyRef`. The DOM-measured inputs (cursor position, content
+ * rect, resolved side) are supplied by the caller, so the geometry stays
+ * testable without faking layout.
+ */
+/** A point in client (viewport) coordinates. */
+interface Point {
+    readonly x: number;
+    readonly y: number;
+}
+
+/**
+ * The resolved floating-ui positioning surface every trigger-anchored overlay
+ * root publishes on its context. `ForPopoverContext`, `ForTooltipContext`, and
+ * `ForHoverCardContext` all `extends` this so the 12-member positioning half of
+ * each context interface is single-sourced rather than copied verbatim.
+ *
+ * Each member is the *effective* value — the per-instance input merged with the
+ * scope default — so a content directive forwards it straight into
+ * `injectOverlayShell` via `toFloatingPositioner` without re-resolving defaults.
+ *
+ * `open` is included because the floating positioner gates `autoUpdate` on it;
+ * it is published by every root's open `model()` (a `ModelSignal` is a
+ * `Signal`), so a single `extends` covers the whole positioner surface.
  */
-interface ForTooltipContext {
+interface AnchoredPositioningContext {
     readonly open: Signal<boolean>;
-    readonly disabled: Signal<boolean>;
     readonly side: Signal<FloatingSide>;
     readonly align: Signal<FloatingAlign>;
     readonly sideOffset: Signal<number>;
@@ -2382,18 +2842,55 @@ interface ForTooltipContext {
     readonly sticky: Signal<'partial' | 'always' | false>;
     readonly hideWhenDetached: Signal<boolean>;
     readonly clipUntilPositioned: Signal<boolean>;
+    readonly arrow: Signal<HTMLElement | null>;
+}
+
+/** Reason a show / hide was scheduled — escape bypasses the close delay. */
+type TooltipScheduleReason = 'hover' | 'focus' | 'escape';
+/**
+ * Coordination contract owned by `ForTooltip`. Trigger and content register
+ * their host elements so floating-ui can compute position; the optional arrow
+ * registers itself so the `arrow` middleware can offset it inside the bubble.
+ *
+ * The trigger and content forward their host hover / focus events through the
+ * `pointerEnter*` / `pointerLeave*` / `focusTrigger` / `blurTrigger` methods;
+ * the root owns the single open / close decision so all keep-alive sources
+ * (trigger hover, trigger focus, and — under `hoverableContent` — content
+ * hover) are reconciled in one place.
+ */
+interface ForTooltipContext extends AnchoredPositioningContext {
+    readonly open: Signal<boolean>;
+    readonly disabled: Signal<boolean>;
+    /** Whether the pointer may move into the content without dismissing the tooltip. */
+    readonly hoverableContent: Signal<boolean>;
+    /** Whether `prefers-reduced-motion: reduce` is active — reflected as `data-reduced-motion`. */
+    readonly reducedMotion: Signal<boolean>;
     /** Trigger element id — a consumer-set host `id` is adopted, else a generated one. */
     readonly triggerId: Signal<string>;
     /** Content element id — a consumer-set host `id` is adopted, else a generated one. Referenced by the trigger's `aria-describedby` while open. */
     readonly contentId: Signal<string>;
     readonly trigger: Signal<HTMLElement | null>;
-    readonly arrow: Signal<HTMLElement | null>;
     registerTrigger(el: HTMLElement): void;
     unregisterTrigger(el: HTMLElement): void;
+    /** Registers the content host element so the hoverable-content grace polygon can measure it. */
+    registerContent(el: HTMLElement): void;
+    unregisterContent(el: HTMLElement): void;
     /** Adopts a consumer-set static `id` on the content host into `contentId`. */
     adoptContentId(el: HTMLElement): void;
     registerArrow(el: HTMLElement): void;
     unregisterArrow(el: HTMLElement): void;
+    /** The pointer entered the trigger; opens after the resolved open delay (gated by `showOnOverflow`). */
+    pointerEnterTrigger(): void;
+    /** The pointer left the trigger; closes, or arms the hoverable-content bridge from `cursor`. */
+    pointerLeaveTrigger(cursor: Point): void;
+    /** The trigger received focus; opens after the resolved open delay (gated by `showOnOverflow`). */
+    focusTrigger(): void;
+    /** The trigger lost focus; closes when nothing else keeps the tooltip alive. */
+    blurTrigger(): void;
+    /** The pointer entered the content (`hoverableContent`); holds the tooltip open. */
+    pointerEnterContent(): void;
+    /** The pointer left the content (`hoverableContent`); closes when nothing else keeps it alive. */
+    pointerLeaveContent(): void;
     /** Schedule the tooltip to open after `openDelay` ms (instant when delay is 0). */
     scheduleOpen(reason: TooltipScheduleReason): void;
     /** Schedule the tooltip to close after `closeDelay` ms (instant on `escape`). */
@@ -2450,7 +2947,7 @@ declare class ForTooltip implements ForTooltipContext {
     readonly align: _angular_core.Signal<FloatingAlign>;
     /**
      * Per-tooltip override for the gap (px) between trigger and content along
-     * the main axis. Mirrors Radix's `sideOffset`. When `undefined` (default),
+     * the main axis. When `undefined` (default),
      * falls back to `ForTooltipDefaults.sideOffset` from the surrounding
      * `provideForTooltipDefaults` scope (`8` unless configured).
      *
@@ -2516,6 +3013,50 @@ declare class ForTooltip implements ForTooltipContext {
     readonly closeDelay: _angular_core.InputSignal<number | undefined>;
     /** When true, all hover / focus interaction is ignored and any open tooltip is forced closed. */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Per-tooltip override for whether the tooltip shows only when the
+     * trigger's own text is truncated (`scrollWidth > clientWidth`) — the
+     * common pattern for ellipsized labels where the tooltip adds nothing once
+     * the full text is visible. When `undefined` (default), falls back to
+     * `ForTooltipDefaults.showOnOverflow` from the surrounding
+     * `provideForTooltipDefaults` scope (`false` unless configured).
+     *
+     * The input is aliased to `showOnOverflow`; consumers bind
+     * `[showOnOverflow]="..."` (or the bare attribute) and read the effective
+     * value via the public `showOnOverflow` computed below.
+     */
+    readonly _showOnOverflowInput: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /** Effective overflow gate: the `showOnOverflow` input when set, else the scope default. */
+    readonly showOnOverflow: _angular_core.Signal<boolean>;
+    /**
+     * Per-tooltip override for whether the pointer may move into the content
+     * without dismissing the tooltip. When `true`, the content drops its
+     * default `pointer-events: none` while open and a pointer-grace "safe
+     * triangle" bridges the gap between trigger and content so a slow diagonal
+     * traversal doesn't close it. When `undefined` (default), falls back to
+     * `ForTooltipDefaults.hoverableContent` from the surrounding
+     * `provideForTooltipDefaults` scope (`false` unless configured).
+     *
+     * Per APG the content must stay non-interactive; this only allows the
+     * pointer to rest over descriptive text (e.g. to select it).
+     *
+     * The input is aliased to `hoverableContent`; consumers bind
+     * `[hoverableContent]="..."` (or the bare attribute) and read the effective
+     * value via the public `hoverableContent` computed below.
+     */
+    readonly _hoverableContentInput: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /** Effective hoverable-content flag: the `hoverableContent` input when set, else the scope default. */
+    readonly hoverableContent: _angular_core.Signal<boolean>;
+    /**
+     * Whether the user has requested reduced motion via the OS
+     * `prefers-reduced-motion: reduce` media query. Reflected as the boolean
+     * `data-reduced-motion` attribute on the root and content so consumers can
+     * disable their own `animate.enter` / `animate.leave` and CSS transitions
+     * without re-deriving the media query. Tooltip's JS-coordinated timing (the
+     * open / close hover-intent delays) is intent debouncing, not motion, so it
+     * is deliberately unchanged under reduced motion.
+     */
+    readonly reducedMotion: _angular_core.Signal<boolean>;
     /**
      * Id of the trigger element. A consumer-set `id` on the trigger host is
      * adopted at registration and preserved; the generated
@@ -2534,21 +3075,55 @@ declare class ForTooltip implements ForTooltipContext {
      */
     registerTrigger(el: HTMLElement): void;
     unregisterTrigger(el: HTMLElement): void;
+    /** Registers the content host element so the hoverable-content grace polygon can measure it. */
+    registerContent(el: HTMLElement): void;
+    unregisterContent(el: HTMLElement): void;
     /** Adopts a consumer-set static `id` on the content host into `contentId`. */
     adoptContentId(el: HTMLElement): void;
     registerArrow(el: HTMLElement): void;
     unregisterArrow(el: HTMLElement): void;
+    pointerEnterTrigger(): void;
+    pointerLeaveTrigger(cursor: Point): void;
+    focusTrigger(): void;
+    blurTrigger(): void;
+    pointerEnterContent(): void;
+    pointerLeaveContent(): void;
     scheduleOpen(_reason: TooltipScheduleReason): void;
     scheduleClose(reason: TooltipScheduleReason): void;
     cancelPending(): void;
+    /**
+     * Imperatively opens the tooltip — for programmatic control beyond hover and
+     * focus (e.g. a design-system wrapper driving the tooltip from a
+     * text-truncation observer). Schedules the show after the resolved
+     * `openDelay` (instant when the delay is `0` or the scope's skip-delay window
+     * is active) and applies the same gates as a hover / focus open: a no-op
+     * while `disabled`, and a no-op under `showOnOverflow` when the trigger's own
+     * text is not truncated. For an instant, unconditional open that bypasses the
+     * delay and both gates, write the `[(open)]` model directly (`open.set(true)`).
+     */
+    show(): void;
+    /**
+     * Imperatively closes the tooltip, mirroring a hover-leave / blur close:
+     * schedules the hide after the resolved `closeDelay` (instant when the delay
+     * is `0`) and disarms the hoverable-content grace bridge. For an instant
+     * close that ignores `closeDelay`, write the `[(open)]` model directly
+     * (`open.set(false)`).
+     */
+    hide(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTooltip, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTooltip, "[forTooltip]", ["forTooltip"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "_sideInput": { "alias": "side"; "required": false; "isSignal": true; }; "_alignInput": { "alias": "align"; "required": false; "isSignal": true; }; "_sideOffsetInput": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "_collisionPaddingInput": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "clipUntilPositioned": { "alias": "clipUntilPositioned"; "required": false; "isSignal": true; }; "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTooltip, "[forTooltip]", ["forTooltip"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "_sideInput": { "alias": "side"; "required": false; "isSignal": true; }; "_alignInput": { "alias": "align"; "required": false; "isSignal": true; }; "_sideOffsetInput": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "_collisionPaddingInput": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "clipUntilPositioned": { "alias": "clipUntilPositioned"; "required": false; "isSignal": true; }; "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "_showOnOverflowInput": { "alias": "showOnOverflow"; "required": false; "isSignal": true; }; "_hoverableContentInput": { "alias": "hoverableContent"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, never, true, never>;
 }
 
 /**
- * Element that activates the tooltip on hover or focus. Apply on a focusable
- * element — preferably a `<button>` so keyboard users can reach it. Receives
- * `aria-describedby` only while the tooltip is open, per APG.
+ * Element that activates the tooltip on mouse hover or keyboard focus. Apply on
+ * a focusable element — preferably a `<button>` so keyboard users can reach it.
+ * Receives `aria-describedby` only while the tooltip is open, per APG.
+ *
+ * A touch tap does NOT open the tooltip: touch pointers are filtered out of
+ * both the hover-open path and the focus-open path, because a tap is not a
+ * hover and the APG flags hover-tooltips as problematic on touch (no hover, no
+ * separate focus affordance, no obvious dismiss). Keyboard focus stays the
+ * touch-accessible fallback for descriptive content.
  *
  * The root is normally resolved via DI from the enclosing `[forTooltip]`.
  * When the trigger is declared inside an `ng-template` stamped into the root
@@ -2570,8 +3145,9 @@ declare class ForTooltipTrigger {
     readonly forTooltipTrigger: _angular_core.InputSignal<"" | ForTooltipContext>;
     protected readonly ctx: _angular_core.Signal<ForTooltipContext>;
     constructor();
-    protected onPointerEnter(): void;
-    protected onPointerLeave(): void;
+    protected onPointerEnter(event: PointerEvent): void;
+    protected onPointerDown(event: PointerEvent): void;
+    protected onPointerLeave(event: PointerEvent): void;
     protected onFocus(): void;
     protected onBlur(): void;
     protected onEscape(event: Event): void;
@@ -2585,8 +3161,10 @@ declare class ForTooltipTrigger {
  * `injectOverlayShell` helper) while mounted.
  *
  * Default `pointer-events: none` is applied via host styles so the bubble
- * layers above content without intercepting hover. Override with your own
- * CSS if needed — but per APG, do not put interactive elements inside.
+ * layers above content without intercepting hover. When the root opts in with
+ * `hoverableContent`, `pointer-events` is dropped while open so the pointer
+ * can rest over the bubble without dismissing it. Override with your own CSS
+ * if needed — but per APG, do not put interactive elements inside.
  *
  * The directive does not manage DOM presence — wrap with
  * `@if (tip.open())` (using a template ref on `[forTooltip]`) so the
@@ -2647,7 +3225,7 @@ interface ForTooltipDefaults {
     align: FloatingAlign;
     /**
      * Gap (px) between trigger and content along the main axis for tooltips
-     * that don't override `sideOffset` locally. Mirrors Radix's `sideOffset`.
+     * that don't override `sideOffset` locally.
      * Library fallback `8`.
      */
     sideOffset: number;
@@ -2657,6 +3235,18 @@ interface ForTooltipDefaults {
      * locally. Library fallback `8`.
      */
     collisionPadding: number;
+    /**
+     * Whether tooltips show only when the trigger's own text is truncated
+     * (`scrollWidth > clientWidth`), for tooltips that don't override
+     * `showOnOverflow` locally. Library fallback `false`.
+     */
+    showOnOverflow: boolean;
+    /**
+     * Whether the pointer may move into the content without dismissing the
+     * tooltip, for tooltips that don't override `hoverableContent` locally.
+     * Library fallback `false`.
+     */
+    hoverableContent: boolean;
 }
 /** Token holding the resolved tooltip defaults for the current scope. */
 declare const FOR_TOOLTIP_DEFAULTS: _angular_core.InjectionToken<ForTooltipDefaults>;
@@ -2757,8 +3347,8 @@ declare const FOR_DIALOG_CONTEXT: InjectionToken<ForDialogContext>;
  * `data-state` is a static `"open"`: because mount is the consumer's
  * responsibility (the host only exists inside `@if (open())`), the element is
  * present iff the dialog is open, so the attribute can never be `"closed"`.
- * This intentionally diverges from Radix, which keeps the node mounted and
- * flips `data-state="closed"` to drive an exit transition. Here, exit styling
+ * This is a deliberate choice: rather than keeping the node mounted and
+ * flipping `data-state="closed"` to drive an exit transition, exit styling
  * is the consumer's `animate.leave` (see the usage example above), not a
  * `data-state="closed"` selector — so a `[data-state="closed"]` rule would
  * never match and is not a bug.
@@ -2985,14 +3575,17 @@ declare class ForDialogBackdrop {
 }
 
 /**
- * Handle returned by `ForDialogManager.open()`. Inject inside the opened
- * component to drive close imperatively. Both reactive (`isClosed`, `result`)
- * and awaitable (`closed`) APIs are exposed — pick what fits the call site.
+ * Shared handle returned by an imperative overlay manager's `open()`.
+ * `ForDialogRef` / `ForDrawerRef` extend this verbatim to keep their public
+ * class identity (and DI token) while the close engine lives here once.
  *
- * `R` is the close-result type. Default `unknown`; specify it on
- * `manager.open<C, R>(...)` to get type safety.
+ * Both reactive (`isClosed`, `result`) and awaitable (`closed`) APIs are
+ * exposed — pick what fits the call site. `R` is the close-result type.
+ *
+ * Internal — not re-exported from `public-api.ts`; the public surface is
+ * `ForDialogRef` / `ForDrawerRef`.
  */
-declare class ForDialogRef<R = unknown> {
+declare class OverlayRef<R = unknown> {
     #private;
     /** Reactive: `true` once `close()` has been called. */
     readonly isClosed: _angular_core.Signal<boolean>;
@@ -3001,12 +3594,124 @@ declare class ForDialogRef<R = unknown> {
     /** Awaitable: resolves with the close result the first time `close()` runs. */
     readonly closed: Promise<R | undefined>;
     /**
-     * Close the dialog, optionally returning a result. Idempotent — calling
+     * Close the overlay, optionally returning a result. Idempotent — calling
      * twice is a no-op.
      */
     close(result?: R): void;
 }
 
+/**
+ * Handle returned by `ForDialogManager.open()`. Inject inside the opened
+ * component to drive close imperatively. Both reactive (`isClosed`, `result`)
+ * and awaitable (`closed`) APIs are exposed — pick what fits the call site.
+ *
+ * `R` is the close-result type. Default `unknown`; specify it on
+ * `manager.open<C, R>(...)` to get type safety.
+ */
+declare class ForDialogRef<R = unknown> extends OverlayRef<R> {
+}
+
+/**
+ * Minimal shape every overlay entry must satisfy so the shared core can index,
+ * render, and tear it down. Per-primitive entries (`ForDialogEntry`,
+ * `ForDrawerEntry`) extend this with their own directive-input fields.
+ *
+ * Internal — not re-exported from `public-api.ts`.
+ */
+interface OverlayManagerEntry {
+    readonly id: string;
+    readonly ref: OverlayRef<unknown>;
+}
+/**
+ * The reactive surface a manager's outlet component is wired with on first
+ * `open()`. Mirrors `ForDialogOutletHost` / `ForDrawerOutletHost`.
+ *
+ * Internal — not re-exported from `public-api.ts`.
+ */
+interface OverlayManagerOutletHost<TEntry extends OverlayManagerEntry> {
+    readonly entries: Signal<readonly TEntry[]>;
+    closeAllForDestroy(): void;
+}
+/**
+ * The minimal surface a manager's outlet component exposes so the core can
+ * wire it on first `open()`. Mirrors `ForDialogOutlet` / `ForDrawerOutlet`.
+ *
+ * Internal — not re-exported from `public-api.ts`.
+ */
+interface OverlayManagerOutlet<TEntry extends OverlayManagerEntry> {
+    init(host: OverlayManagerOutletHost<TEntry>): void;
+}
+/**
+ * Per-primitive bindings the shared core needs: how to name ids and the
+ * exit-animation host / backdrop attributes, and how to create the outlet
+ * component that renders the entries.
+ *
+ * Internal — not re-exported from `public-api.ts`.
+ */
+interface OverlayManagerConfig<TEntry extends OverlayManagerEntry> {
+    /**
+     * Per-instance id prefix passed to `IdGenerator.next` (e.g.
+     * `'for-dialog-instance'`).
+     */
+    readonly idPrefix: string;
+    /**
+     * Attribute the overlay root + backdrop reflect their per-instance id on
+     * (e.g. `'data-for-dialog-id'`), matched during exit animation.
+     */
+    readonly idAttribute: string;
+    /**
+     * Attribute marking the portaled backdrop element (e.g.
+     * `'data-for-dialog-backdrop'`), matched during exit animation.
+     */
+    readonly backdropAttribute: string;
+    /** Creates the manager-owned outlet component (e.g. `ForDialogOutlet`). */
+    createOutlet(environmentInjector: EnvironmentInjector): ComponentRef<OverlayManagerOutlet<TEntry>>;
+}
+/**
+ * Shared imperative-overlay engine behind `ForDialogManager` and
+ * `ForDrawerManager`. Owns the entries signal, the reactive `openCount`, the
+ * lazily-created outlet, the destroy-time close-all sweep, the exit-animation
+ * `beginLeave` driver, and the parent-cached per-component `Injector` factory.
+ * The two managers differ only in their entry shape and directive-input
+ * mapping; everything structural lives here once.
+ *
+ * Internal — not re-exported from `public-api.ts`; the public surface is
+ * `ForDialogManager` / `ForDrawerManager`.
+ */
+declare class OverlayManagerCore<TEntry extends OverlayManagerEntry> {
+    #private;
+    protected readonly idGen: IdGenerator;
+    /** Reactive count of currently open programmatic overlays. */
+    readonly openCount: Signal<number>;
+    constructor(config: OverlayManagerConfig<TEntry>);
+}
+
+/**
+ * Shape of a single open dialog entry stored in the manager.
+ *
+ * Internal — not re-exported from `public-api.ts`.
+ */
+interface ForDialogEntry extends OverlayManagerEntry {
+    readonly component: Type<unknown>;
+    readonly hostClass: string;
+    readonly dismissible: boolean | undefined;
+    readonly modal: boolean | undefined;
+    readonly alert: boolean | undefined;
+    readonly returnFocus: boolean | undefined;
+    readonly initialFocus: 'first' | 'container' | undefined;
+    readonly ariaLabel: string | undefined;
+    readonly container: HTMLElement | null | undefined;
+    readonly animateEnter: string | undefined;
+    readonly autoFocusOnOpen: ((e: VetoableEvent) => void) | undefined;
+    readonly autoFocusOnClose: ((e: VetoableEvent) => void) | undefined;
+    readonly escapeKeyDown: ((e: VetoableNativeEvent<KeyboardEvent>) => void) | undefined;
+    readonly pointerDownOutside: ((e: VetoableNativeEvent<PointerEvent>) => void) | undefined;
+    readonly focusOutside: ((e: VetoableNativeEvent<FocusEvent>) => void) | undefined;
+    readonly interactOutside: ((e: VetoableNativeEvent<PointerEvent | FocusEvent>) => void) | undefined;
+    handleClose(value: unknown): void;
+    injectorFor(parent: Injector): Injector;
+}
+
 /**
  * Injection token for the `data` payload passed to `ForDialogManager.open(component, { data })`.
  * The manager always provides this token, falling back to `null` when no `data`
@@ -3147,8 +3852,8 @@ interface ForDialogOpenConfig<D = unknown> {
     interactOutside?: (event: VetoableNativeEvent<PointerEvent | FocusEvent>) => void;
 }
 /**
- * Programmatic dialog opener — the headless equivalent of CDK's `Dialog`.
- * Inject anywhere, call `open(MyComponent, { data, ... })` and get a
+ * Programmatic dialog opener — open a component as a modal dialog from
+ * TypeScript. Inject anywhere, call `open(MyComponent, { data, ... })` and get a
  * `ForDialogRef<R>` back. Internally the manager renders the user component
  * inside a manager-owned `@for` outlet, so Angular's control-flow unmount
  * fires `animate.leave` before the node leaves the DOM — identical to the
@@ -3162,10 +3867,9 @@ interface ForDialogOpenConfig<D = unknown> {
  * Inject `ForDialogRef` to drive close imperatively and `FOR_DIALOG_DATA` (or
  * `injectDialogData<T>()`) for the payload.
  */
-declare class ForDialogManager {
+declare class ForDialogManager extends OverlayManagerCore<ForDialogEntry> {
     #private;
-    /** Reactive count of currently open programmatic dialogs (useful for diagnostics). */
-    readonly openCount: _angular_core.Signal<number>;
+    constructor();
     open<C, R = unknown, D = unknown>(component: Type<C>, config?: ForDialogOpenConfig<D>): ForDialogRef<R>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDialogManager, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<ForDialogManager>;
@@ -3226,7 +3930,7 @@ declare function provideForDialogDefaults(defaults?: Partial<ForDialogDefaults>)
 type ForDrawerSide = 'top' | 'right' | 'bottom' | 'left';
 
 /**
- * A snap point. Three accepted shapes (Vaul-aligned):
+ * A snap point. Three accepted shapes:
  *
  * - `number ∈ [0, 1]` — fraction of the dimension along the dismissal axis.
  * - `'NN%'` — equivalent to a fraction, e.g. `'50%' === 0.5`.
@@ -3346,7 +4050,7 @@ interface ForDrawerReleaseEvent {
 /**
  * Headless implementation of the [WAI-ARIA Modal Dialog pattern](https://www.w3.org/WAI/ARIA/apg/patterns/dialog-modal/),
  * specialised as a side / bottom-sheet drawer with optional swipe-to-dismiss
- * and Vaul-style snap points.
+ * and snap points.
  *
  * Apply `[forDrawer]` on the drawer surface itself — not on a wrapper. The
  * directive moves the host to `document.body` (portal), traps focus, locks
@@ -3421,7 +4125,7 @@ declare class ForDrawer implements ForDrawerContext {
     readonly swipeToDismiss: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * Fraction past which a release dismisses instead of snapping back.
-     * Vaul-aligned default `0.25`. Without `snapPoints` it is a fraction of the
+     * Default `0.25`. Without `snapPoints` it is a fraction of the
      * full drawer dimension along the dismissal axis (dragged > 25% of the
      * surface size toward the edge dismisses); with `snapPoints` it is a
      * fraction of the **lowest snap's** extent, so a small "peek" snap stays
@@ -3436,7 +4140,7 @@ declare class ForDrawer implements ForDrawerContext {
     readonly handleOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * When true, asks the registered `[forDrawerWrapper]` to scale and
-     * translate behind this drawer (Vaul-style "shouldScaleBackground"). No
+     * translate behind this drawer (the "scale background" effect). No
      * effect under `prefers-reduced-motion: reduce`, and a no-op if no
      * wrapper is mounted. Default `false` so existing consumers are
      * untouched.
@@ -3450,7 +4154,7 @@ declare class ForDrawer implements ForDrawerContext {
      */
     readonly setBackgroundColorOnScale: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
-     * Snap points (Vaul semantics): each entry is a `number ∈ [0, 1]`,
+     * Snap points: each entry is a `number ∈ [0, 1]`,
      * a `'NN%'` string, or a `'NNpx'` string. Strictly increasing
      * (closest-to-edge first). The surface settles at the nearest snap on
      * release; dragging past the lowest snap by `closeThreshold` of that
@@ -3495,30 +4199,38 @@ declare class ForDrawer implements ForDrawerContext {
     readonly release: _angular_core.OutputEmitterRef<ForDrawerReleaseEvent>;
     readonly labelledBy: _angular_core.Signal<string | null>;
     readonly describedBy: _angular_core.Signal<string | null>;
+    readonly activeSnapPointAttr: _angular_core.Signal<string | null>;
+    readonly fadeFromActive: _angular_core.Signal<boolean>;
+    /**
+     * `true` while a pointer drag gesture is in flight. Mirrors the host's
+     * `data-dragging` attribute; surfaced through `ForDrawerContext` so pieces
+     * portaled away from the surface (the backdrop) can suppress their own
+     * transitions during the gesture.
+     */
     readonly dragging: _angular_core.Signal<boolean>;
+    /**
+     * Progress of the current drag toward the anchored edge, `∈ [0, 1]`.
+     * Surfaced through `ForDrawerContext` so the backdrop can publish it as the
+     * `--for-drawer-drag-progress` custom property.
+     */
     readonly dragProgress: _angular_core.Signal<number>;
-    readonly activeSnapPointAttr: _angular_core.Signal<string | null>;
     /**
      * Live drag displacement as a CSS `translate` value (`"<x> <y>"`),
      * published on the host as the `--for-drawer-translate` custom property by
-     * an effect in the constructor. The consumer composes it on the surface
-     * with `translate: var(--for-drawer-translate, 0px 0px)`.
+     * the gesture engine. The consumer composes it on the surface with
+     * `translate: var(--for-drawer-translate, 0px 0px)`.
      *
-     * A **custom property** is used (rather than writing the `translate` /
-     * `transform` property directly) for two reasons: `transform` is reserved
-     * for `ForDrawerScaleCoordinator`'s nested / scale-background effect, and
-     * a directly-written inline `translate` is silently dropped by Angular
-     * when the consumer also binds a template `[style.*]` on the same host —
-     * custom properties survive because Angular's style bindings never touch
-     * them. `"0px 0px"` at rest. The write rides the same change-detection
-     * pass as the `data-dragging` removal and the `data-active-snap-point`
-     * change on release, so the consumer's `transition: translate` animates
-     * the drag delta back to zero in lockstep with the snap-position
-     * transition, instead of the surface jumping to the old rest position
-     * before sliding to the new snap.
+     * A **custom property** is used (rather than writing `translate` /
+     * `transform` directly) because `transform` is reserved for
+     * `ForDrawerScaleCoordinator` and a directly-written inline `translate` is
+     * dropped by Angular when the consumer also binds a template `[style.*]` on
+     * the same host. `"0px 0px"` at rest; the write rides the same change-
+     * detection pass as the `data-dragging` / `data-active-snap-point` changes
+     * on release so the consumer's `transition: translate` animates back in
+     * lockstep with the snap transition rather than jumping to the old rest
+     * position first.
      */
     readonly dragTranslate: _angular_core.Signal<string>;
-    readonly fadeFromActive: _angular_core.Signal<boolean>;
     /** Host element of this drawer surface — exposed via `ForDrawerContext`. */
     get hostElement(): HTMLElement;
     readonly depthAttr: _angular_core.Signal<string>;
@@ -3607,13 +4319,13 @@ declare class ForDrawerTrigger {
  *
  * Reflects `data-fade-from-active` when `fadeFromIndex` on the drawer root
  * is set and the active snap point is at or past that index — consumers
- * tie this to a CSS opacity transition for the Vaul-style "backdrop fades
+ * tie this to a CSS opacity transition for the "backdrop fades
  * in once you snap up past N" effect.
  *
  * Publishes the live drag progress toward the anchored edge as the
  * `--for-drawer-drag-progress` custom property (`0` at rest → `1` fully
  * dragged off-screen) and mirrors the surface's `data-dragging` attribute.
- * Together these drive the Vaul-style "backdrop fades out as you swipe to
+ * Together these drive the "backdrop fades out as you swipe to
  * dismiss" effect with pure CSS:
  *
  * ```css
@@ -3705,9 +4417,7 @@ declare class ForDrawerClose {
 /**
  * Marks the consumer's app-shell wrapper so {@link ForDrawer}'s
  * `scaleBackground` effect can transform the rest of the page when a
- * drawer opens — inspired by Vaul's `[data-vaul-drawer-wrapper]` and
- * Base UI's `Drawer.Indent`, but wired through Angular DI instead of a
- * global selector.
+ * drawer opens — applied through Angular DI rather than a global selector.
  *
  * Apply on the element that contains everything the drawer should appear
  * to recede behind (typically the root shell). Reflects
@@ -3737,19 +4447,45 @@ declare class ForDrawerWrapper {
  * `R` is the close-result type. Default `unknown`; specify it on
  * `manager.open<C, R>(...)` to get type safety.
  */
-declare class ForDrawerRef<R = unknown> {
-    #private;
-    /** Reactive: `true` once `close()` has been called. */
-    readonly isClosed: _angular_core.Signal<boolean>;
-    /** Reactive: the close result. `undefined` while open. */
-    readonly result: _angular_core.Signal<R | undefined>;
-    /** Awaitable: resolves with the close result the first time `close()` runs. */
-    readonly closed: Promise<R | undefined>;
-    /**
-     * Close the drawer, optionally returning a result. Idempotent — calling
-     * twice is a no-op.
-     */
-    close(result?: R): void;
+declare class ForDrawerRef<R = unknown> extends OverlayRef<R> {
+}
+
+/**
+ * Shape of a single open drawer entry stored in the manager.
+ *
+ * Internal — not re-exported from `public-api.ts`.
+ */
+interface ForDrawerEntry extends OverlayManagerEntry {
+    readonly component: Type<unknown>;
+    readonly hostClass: string;
+    readonly side: ForDrawerSide | undefined;
+    readonly dismissible: boolean | undefined;
+    readonly modal: boolean | undefined;
+    readonly alert: boolean | undefined;
+    readonly returnFocus: boolean | undefined;
+    readonly initialFocus: 'first' | 'container' | undefined;
+    readonly ariaLabel: string | undefined;
+    readonly container: HTMLElement | null | undefined;
+    readonly animateEnter: string | undefined;
+    readonly autoFocusOnOpen: ((e: VetoableEvent) => void) | undefined;
+    readonly autoFocusOnClose: ((e: VetoableEvent) => void) | undefined;
+    readonly swipeToDismiss: boolean | undefined;
+    readonly closeThreshold: number | undefined;
+    readonly handleOnly: boolean | undefined;
+    readonly scaleBackground: boolean | undefined;
+    readonly setBackgroundColorOnScale: boolean | undefined;
+    readonly snapPoints: ReadonlyArray<ForDrawerSnapPoint> | undefined;
+    readonly activeSnapPoint: ForDrawerSnapPoint | undefined;
+    readonly fadeFromIndex: number | undefined;
+    readonly escapeKeyDown: ((e: VetoableNativeEvent<KeyboardEvent>) => void) | undefined;
+    readonly pointerDownOutside: ((e: VetoableNativeEvent<PointerEvent>) => void) | undefined;
+    readonly focusOutside: ((e: VetoableNativeEvent<FocusEvent>) => void) | undefined;
+    readonly interactOutside: ((e: VetoableNativeEvent<PointerEvent | FocusEvent>) => void) | undefined;
+    readonly onDrag: ((e: ForDrawerDragEvent) => void) | undefined;
+    readonly onRelease: ((e: ForDrawerReleaseEvent) => void) | undefined;
+    readonly onActiveSnapPointChange: ((snap: ForDrawerSnapPoint | null) => void) | undefined;
+    handleClose(value: unknown): void;
+    injectorFor(parent: Injector): Injector;
 }
 
 /**
@@ -3824,13 +4560,13 @@ interface ForDrawerOpenConfig<D = unknown> {
     backdropAnimateLeave?: string;
     /** When true (default), pointer drag past `closeThreshold` dismisses. */
     swipeToDismiss?: boolean;
-    /** Vaul-style fraction of dimension past which a release dismisses. Default `0.25`. */
+    /** Fraction of dimension past which a release dismisses. Default `0.25`. */
     closeThreshold?: number;
     /** When true, swipe only arms on a registered handle element. Default `false`. */
     handleOnly?: boolean;
     /**
      * When true, asks the registered `[forDrawerWrapper]` to scale and translate
-     * behind this drawer (Vaul-style "shouldScaleBackground"). No effect under
+     * behind this drawer (the "scale background" effect). No effect under
      * `prefers-reduced-motion: reduce`, and a no-op if no wrapper is mounted.
      */
     scaleBackground?: boolean;
@@ -3840,7 +4576,7 @@ interface ForDrawerOpenConfig<D = unknown> {
      * viewport edge does not show through.
      */
     setBackgroundColorOnScale?: boolean;
-    /** Snap points (Vaul semantics). Optional. */
+    /** Snap points. Optional. */
     snapPoints?: ReadonlyArray<ForDrawerSnapPoint>;
     /** Initial snap point at open time. Defaults to `snapPoints?.[0]`. */
     defaultSnapPoint?: ForDrawerSnapPoint;
@@ -3945,10 +4681,9 @@ interface ForDrawerOpenConfig<D = unknown> {
  * Inject `ForDrawerRef` to drive close imperatively and `FOR_DRAWER_DATA` (or
  * `injectDrawerData<T>()`) for the payload.
  */
-declare class ForDrawerManager {
+declare class ForDrawerManager extends OverlayManagerCore<ForDrawerEntry> {
     #private;
-    /** Reactive count of currently open programmatic drawers. */
-    readonly openCount: _angular_core.Signal<number>;
+    constructor();
     open<C, R = unknown, D = unknown>(component: Type<C>, config?: ForDrawerOpenConfig<D>): ForDrawerRef<R>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDrawerManager, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<ForDrawerManager>;
@@ -3972,8 +4707,8 @@ interface ForDrawerDefaults {
     /**
      * Default `0.25`. Fraction past which a release dismisses instead of
      * snapping back: of the full dimension without snap points, of the lowest
-     * snap's extent with them. Vaul semantics (see
-     * `_internal/swipe-dismiss/resolveSnapTarget`).
+     * snap's extent with them (see
+     * `_internal/snap-points/resolveSnapTarget`).
      */
     closeThreshold?: number;
     /** Default `'first'`. Where to send focus on mount. */
@@ -3987,8 +4722,8 @@ interface ForDrawerDefaults {
     handleOnly?: boolean;
     /**
      * Default `false`. When `true`, an open drawer asks
-     * `[forDrawerWrapper]` to scale + translate behind it (Vaul-style
-     * "shouldScaleBackground"). Suppressed under
+     * `[forDrawerWrapper]` to scale + translate behind it (the "scale
+     * background" effect). Suppressed under
      * `prefers-reduced-motion: reduce`.
      */
     scaleBackground?: boolean;
@@ -4067,25 +4802,17 @@ declare function provideForDrawerDefaults(defaults?: Partial<ForDrawerDefaults>)
  * is published here so descendant pieces can react without each subscribing
  * to the directive instance directly.
  */
-interface ForPopoverContext {
+interface ForPopoverContext extends AnchoredPositioningContext {
     readonly open: ModelSignal<boolean>;
     readonly disabled: Signal<boolean>;
     readonly dismissible: Signal<boolean>;
     readonly returnFocus: Signal<boolean>;
     readonly initialFocus: Signal<'first' | 'container'>;
-    readonly side: Signal<FloatingSide>;
-    readonly align: Signal<FloatingAlign>;
-    readonly sideOffset: Signal<number>;
-    readonly alignOffset: Signal<number>;
-    readonly avoidCollisions: Signal<boolean>;
-    readonly collisionPadding: Signal<number>;
-    readonly arrowPadding: Signal<number>;
-    readonly sticky: Signal<'partial' | 'always' | false>;
-    readonly hideWhenDetached: Signal<boolean>;
-    readonly clipUntilPositioned: Signal<boolean>;
     readonly triggerId: Signal<string>;
     readonly contentId: Signal<string>;
     readonly ariaLabel: Signal<string | null>;
+    /** Whether `prefers-reduced-motion: reduce` is active — reflected as `data-reduced-motion`. */
+    readonly reducedMotion: Signal<boolean>;
     readonly labelledBy: Signal<string | null>;
     readonly describedBy: Signal<string | null>;
     readonly trigger: Signal<HTMLElement | null>;
@@ -4098,7 +4825,6 @@ interface ForPopoverContext {
      * the popover paints.
      */
     readonly reference: Signal<HTMLElement | null>;
-    readonly arrow: Signal<HTMLElement | null>;
     registerTrigger(el: HTMLElement): void;
     unregisterTrigger(el: HTMLElement): void;
     /** Adopts a consumer-set static `id` on the content host into `contentId`. */
@@ -4203,7 +4929,7 @@ declare class ForPopover implements ForPopoverContext {
     /**
      * Per-popover override for the gap (px) between trigger and content along
      * the *main* axis (perpendicular to `side`). Forwarded to floating-ui's
-     * `offset` middleware. Mirrors Radix's `sideOffset`. When `undefined`
+     * `offset` middleware. When `undefined`
      * (default), falls back to `ForPopoverDefaults.sideOffset` from the
      * surrounding `provideForPopoverDefaults` scope (`8` unless configured).
      *
@@ -4222,8 +4948,8 @@ declare class ForPopover implements ForPopoverContext {
     readonly avoidCollisions: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * Per-popover override for the padding (px) applied uniformly to the
-     * `flip`, `shift`, and `size` middlewares. Mirrors Radix's
-     * `collisionPadding`. When `undefined` (default), falls back to
+     * `flip`, `shift`, and `size` middlewares. When `undefined` (default),
+     * falls back to
      * `ForPopoverDefaults.collisionPadding` from the surrounding
      * `provideForPopoverDefaults` scope (`8` unless configured).
      *
@@ -4282,6 +5008,15 @@ declare class ForPopover implements ForPopoverContext {
     readonly initialFocus: _angular_core.InputSignal<"first" | "container">;
     /** Manual `aria-label` on the content. Use this when no visible title element exists. */
     readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /**
+     * Whether the user has requested reduced motion via the OS
+     * `prefers-reduced-motion: reduce` media query. Reflected as the boolean
+     * `data-reduced-motion` attribute on the root and content so consumers can
+     * disable their own `animate.enter` / `animate.leave` and CSS transitions
+     * without re-deriving the media query. The popover toggles open / closed
+     * synchronously on trigger click, so it has no JS-coordinated timing to skip.
+     */
+    readonly reducedMotion: _angular_core.Signal<boolean>;
     /**
      * Fires when the user presses Escape while this popover is the topmost
      * dismissable layer. Call `preventDefault()` on the emitted veto to
@@ -4539,7 +5274,7 @@ interface ForPopoverDefaults {
     align: FloatingAlign;
     /**
      * Gap (px) between trigger and content along the main axis for popovers
-     * that don't override `sideOffset` locally. Mirrors Radix's `sideOffset`.
+     * that don't override `sideOffset` locally.
      * Library fallback `8`.
      */
     sideOffset: number;
@@ -4651,7 +5386,7 @@ declare const FOR_TOGGLE_GROUP_CONTEXT: InjectionToken<ForToggleGroupContext>;
  * Headless group of toggle buttons: a `role="group"` container whose items
  * each carry `aria-pressed`, modelled on the
  * [WAI-ARIA Button pattern](https://www.w3.org/WAI/ARIA/apg/patterns/button/)
- * (toggle-button variant) — mirroring Radix's ToggleGroup. Owns the
+ * (toggle-button variant). Owns the
  * selected-values set, navigation policy, and the registry of
  * `[forToggleGroupItem]` children. Implements
  * `FormValueControl<readonly string[]>` from `@angular/forms/signals` for
@@ -4870,6 +5605,81 @@ declare const FOR_TOGGLE_GROUP_HOST_DIRECTIVE_INPUTS: readonly ["value", "dir",
  */
 declare const FOR_TOGGLE_GROUP_HOST_DIRECTIVE_OUTPUTS: readonly ["valueChange", "touchedChange", "touch"];
 
+/**
+ * Headless implementation of the [WAI-ARIA Button pattern](https://www.w3.org/WAI/ARIA/apg/patterns/button/).
+ *
+ * Works on a native `<button>` host and on any arbitrary host element (e.g. `<div>`, `<span>`).
+ * On a native button the platform handles Enter/Space → click synthesis and no `role` or
+ * `tabindex` is emitted (the platform owns those). On a non-button host, `role="button"` and
+ * `tabindex="0"` are applied, and keydown for Enter/Space synthesizes a click so the directive's
+ * single `onClick` path handles all activations.
+ *
+ * Disabled stays focusable: per the APG a disabled button must remain reachable by assistive
+ * technology, so the native `disabled` attribute is never set. Instead `aria-disabled="true"` and
+ * `data-disabled=""` are reflected and the activation handler becomes a no-op.
+ *
+ * Interaction state is reflected as `data-pressed`, `data-hovered`, and `data-focus-visible`
+ * (present/absent boolean attributes). There is no `data-state` — this primitive has no
+ * open/closed or checked/unchecked logical state.
+ *
+ * @example
+ * ```html
+ * <!-- Native button — platform handles Enter/Space -->
+ * <button forButton (activate)="doSomething()">Click me</button>
+ *
+ * <!-- Non-button host — role, tabindex, and keyboard handling added automatically -->
+ * <div forButton (activate)="doSomething()">Click me</div>
+ *
+ * <!-- Disabled: stays focusable, activation is a no-op -->
+ * <button forButton [disabled]="true" (activate)="doSomething()">Disabled</button>
+ * ```
+ */
+declare class ForButton {
+    #private;
+    /**
+     * When `true`, activation (click, Enter, Space) is suppressed and the element
+     * reflects `aria-disabled="true"` + `data-disabled=""`. The element remains
+     * focusable so assistive technology can announce it.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Emitted once per user activation: a pointer click on any host, or Enter / Space
+     * on a non-native-button host (native buttons synthesize click from keyboard). The
+     * name `activate` is chosen deliberately to avoid colliding with the native `click`
+     * event (which would trip `@angular-eslint/no-output-native` on wrapping consumers).
+     */
+    readonly activate: _angular_core.OutputEmitterRef<void>;
+    protected readonly hovered: _angular_core.Signal<boolean>;
+    protected readonly pressed: _angular_core.Signal<boolean>;
+    protected readonly focusVisible: _angular_core.Signal<boolean>;
+    protected readonly resolvedType: _angular_core.Signal<string | null>;
+    protected readonly resolvedRole: _angular_core.Signal<"button" | null>;
+    protected readonly resolvedTabindex: _angular_core.Signal<"0" | null>;
+    protected onClick(event: MouseEvent): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onFocusIn(): void;
+    protected onFocusOut(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForButton, "[forButton]", ["forButton"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "activate": "activate"; }, never, never, true, never>;
+}
+
+/**
+ * Defaults inherited by descendant buttons in the surrounding injector
+ * scope. Configure with `provideForButtonDefaults`. The shape is a stub
+ * today — present so future per-scope tuning can land without churning the
+ * public surface.
+ */
+interface ForButtonDefaults {
+}
+/** Token holding the resolved button defaults for the current scope. */
+declare const FOR_BUTTON_DEFAULTS: _angular_core.InjectionToken<ForButtonDefaults>;
+/**
+ * Configures forty-cdk button defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library
+ * defaults at the root).
+ */
+declare function provideForButtonDefaults(defaults?: Partial<ForButtonDefaults>): Provider[];
+
 /**
  * The menu surface. Carries `role="menu"`, is portaled to `document.body`,
  * and is positioned by `@floating-ui/dom` against the registered anchor —
@@ -5343,7 +6153,7 @@ declare class MenuOverlay<H extends MenuOverlayItemHandle = MenuOverlayItemHandl
     /**
      * Clears `data-highlighted` from every item without moving focus. The shared
      * `[forMenuContent]` calls this on `pointerleave` so the hover highlight
-     * follows the pointer off the surface (Radix-style).
+     * follows the pointer off the surface.
      */
     clearItemHighlights(): void;
     /**
@@ -5446,30 +6256,6 @@ declare abstract class MenuOverlayHost<H extends MenuOverlayItemHandle = MenuOve
     emitAutoFocusOnClose(): boolean;
 }
 
-/**
- * Pointer-grace ("safe triangle") helper.
- *
- * When a mouse leaves a submenu trigger heading toward the submenu content,
- * a naive "close on pointer-leave" would dismiss the submenu the moment the
- * cursor crosses the gap between the trigger and the content. Radix, Base UI,
- * and native desktop menus solve this with a *safe triangle*: a polygon drawn
- * from the cursor's exit point to the near edge of the submenu content. While
- * the pointer stays inside that polygon it is assumed to be travelling toward
- * the submenu, so the close is held off.
- *
- * This module keeps no Angular DI surface — the geometry is pure functions
- * (unit-tested in `pointer-grace.spec.ts`) and {@link attachPointerGrace} is a
- * plain `addEventListener` wrapper returning a cleanup, wired by the directive
- * through its `DestroyRef`. The DOM-measured inputs (cursor position, content
- * rect, resolved side) are supplied by the caller, so the geometry stays
- * testable without faking layout.
- */
-/** A point in client (viewport) coordinates. */
-interface Point {
-    readonly x: number;
-    readonly y: number;
-}
-
 /**
  * Minimal upward contract a menu uses to move between sibling menus of an
  * enclosing menubar. Implemented by the menubar root; keeps the generic menu
@@ -5480,8 +6266,8 @@ interface MenuSiblingNavigator {
     switchToSibling(direction: 'next' | 'prev'): void;
 }
 /**
- * Why a menu requested close. Mirrors Radix's `onCloseAutoFocus` reasons
- * but without the focus-routing decision baked in. `'programmatic'` also
+ * Why a menu requested close. Enumerates the close reasons without the
+ * focus-routing decision baked in. `'programmatic'` also
  * covers the user-initiated trigger toggle-close (clicking an open menu's
  * trigger): the toggle path reuses this reason by design rather than
  * exposing a distinct `'trigger'` reason.
@@ -5601,7 +6387,7 @@ interface ForMenuContext {
     /**
      * Clear `data-highlighted` from every item without moving focus. Called by
      * `[forMenuContent]` on `pointerleave` so the hover highlight follows the
-     * pointer off the surface (Radix-style hover-follows-pointer).
+     * pointer off the surface (hover-follows-pointer).
      */
     clearItemHighlights(): void;
     /** Returns `true` if focus moved; `false` when no enabled items exist. */
@@ -5959,7 +6745,7 @@ interface ForMenuDefaults {
     subMenuPointerGraceDuration: number;
     /**
      * Distance (px) between the sub-trigger and the submenu content along the
-     * resolved `side` axis. Mirrors Radix's `sideOffset`. Default `0` — a
+     * resolved `side` axis. Default `0` — a
      * submenu sits flush against its parent item.
      */
     sideOffset: number;
@@ -6033,7 +6819,7 @@ declare class ForDropdownMenu extends MenuOverlayHost implements ForMenuContext
     readonly align: _angular_core.InputSignal<FloatingAlign | undefined>;
     /**
      * Gap (px) between trigger and menu along the main axis. Default `4`.
-     * Mirrors Radix's `sideOffset`. The default is read from
+     * The default is read from
      * `provideForDropdownMenuDefaults` for the surrounding scope.
      */
     readonly sideOffset: _angular_core.InputSignalWithTransform<number, unknown>;
@@ -6194,7 +6980,7 @@ declare class ForDropdownMenuTrigger {
 interface ForDropdownMenuDefaults {
     /**
      * Distance (px) between the dropdown trigger and the floating content
-     * along the resolved `side` axis. Mirrors Radix's `sideOffset`.
+     * along the resolved `side` axis.
      */
     sideOffset: number;
     /**
@@ -6498,8 +7284,8 @@ declare class ForContextMenuTrigger {
 interface ForContextMenuDefaults {
     /**
      * Distance (px) between the virtual anchor (pointer position) and the
-     * floating content along the resolved `side` axis. Mirrors Radix's
-     * `sideOffset`. Defaults to `0` since context menus open at the cursor.
+     * floating content along the resolved `side` axis. Defaults to `0`
+     * since context menus open at the cursor.
      */
     sideOffset: number;
     /**
@@ -6598,7 +7384,7 @@ interface ForMenubarContext extends MenuSiblingNavigator {
     /**
      * Hover-after-open. When some menu is open and pointer enters a sibling
      * trigger, that sibling's menu opens immediately. No-op while no menu
-     * is open (per Radix: first open requires keyboard / click).
+     * is open (first open requires keyboard / click).
      */
     pointerEnterTrigger(value: string): void;
     /** Typeahead at the trigger row matches sibling trigger labels. */
@@ -6641,8 +7427,11 @@ interface MenubarMenuHost extends MenuSiblingNavigator {
  * context shape transparently covers whichever trigger's menu is mounted.
  *
  * Item navigation reuses the shared `MenuItemList` (the same item-collection /
- * typeahead / navigate / focus mechanics that back `MenuOverlay`), so this only
- * has to cover the parts the single-owner overlay can't.
+ * typeahead / navigate / focus mechanics that back `MenuOverlay`), and the
+ * initial-focus / highlight-consume protocol and the close-reason record reuse
+ * the shared `InitialFocusState` / `CloseReasonState` micro-helpers (also
+ * composed by `MenuOverlay`), so this only has to cover the parts the
+ * single-owner overlay can't — the `activeTrigger`-derived multiplexing.
  *
  * A bar-level menu has no per-trigger dismiss / auto-focus outputs and no
  * per-context trigger registration (triggers register with the bar directly),
@@ -6802,6 +7591,16 @@ declare class ForMenubar implements ForMenubarContext {
      * as its return-focus `trigger`.
      */
     readonly lastTriggerHost: _angular_core.Signal<HTMLElement | null>;
+    /**
+     * Roving-tabindex tracker shared by every menubar trigger, mirroring
+     * `ForToolbar` / `ForTabs`. Triggers promote themselves to active on
+     * `(focus)` (via {@link setFocusedTrigger}) and read `active()` through
+     * {@link tabindexFor}, so re-entry restores the last focused trigger. Before
+     * any focus — and on every close — `active()` is `null`/stale and the tab
+     * stop falls back to the first enabled trigger. The active pointer is
+     * self-healing (a detached / disabled trigger no longer owns the stop).
+     */
+    readonly roving: RovingTabindex;
     constructor();
     /**
      * Single `ForMenuContext` provided to descendant `[forMenuContent]` and
@@ -6875,7 +7674,7 @@ declare class ForMenubar implements ForMenubarContext {
  *   starts with the buffered string.
  *
  * While some other trigger's menu is open, hovering this trigger opens it
- * immediately (no delay) — Radix-style "first open is intentional, subsequent
+ * immediately (no delay) — "first open is intentional, subsequent
  * are hover". Keyboard focus alone never opens a menu.
  *
  * Pointer-driven opens (click — detected by the `pointerdown` preceding it —
@@ -7304,7 +8103,7 @@ declare class ForSelect<T = string> extends FormUiControlBase implements FormVal
     readonly align: _angular_core.InputSignal<FloatingAlign | undefined>;
     /**
      * Gap (px) between trigger and listbox along the main axis. Default `4`.
-     * Mirrors Radix's `sideOffset`. The default is read from
+     * The default is read from
      * `provideForSelectDefaults` for the surrounding scope.
      */
     readonly sideOffset: _angular_core.InputSignalWithTransform<number, unknown>;
@@ -7403,11 +8202,11 @@ declare class ForSelect<T = string> extends FormUiControlBase implements FormVal
      * focus return, and its dismissal exemption regardless of where the listbox
      * paints.
      */
-    readonly anchor: _angular_core.Signal<ReferenceElement | null>;
+    readonly anchor: _angular_core.Signal<_floating_ui_dom.ReferenceElement | null>;
     readonly content: _angular_core.Signal<HTMLElement | null>;
+    readonly options: _angular_core.Signal<readonly ForSelectOptionHandle<T>[]>;
     /** The active option's `id` in the virtualized path, `null` in the default path. */
     readonly activeDescendantId: _angular_core.Signal<string | null>;
-    readonly options: _angular_core.Signal<readonly ForSelectOptionHandle<T>[]>;
     /**
      * Trimmed display labels of the selected values, in selection order. Pure
      * derivation: when `[itemToLabel]` is supplied it is authoritative; otherwise
@@ -7606,7 +8405,7 @@ declare class ForSelectValue {
  * - **non-modal (default)** — `injectOverlayShell` anchors the listbox to the
  *   trigger and branches on `[forSelect].position`:
  *   - `'popper'` (default) — standard `injectFloating` path with full
- *     Radix-style anchored placement (`side`, `align`, `sideOffset`,
+ *     anchored placement (`side`, `align`, `sideOffset`,
  *     `alignOffset`, `flip`, `shift`, `arrow`, `hideWhenDetached`).
  *   - `'item-aligned'` — `injectItemAlignedPositioner` overlays the listbox so
  *     the selected option's center aligns with the trigger's center. The
@@ -7783,7 +8582,7 @@ declare class ForSelectSeparator {
 interface ForSelectDefaults {
     /**
      * Distance (px) between the select trigger and the floating content
-     * along the resolved `side` axis. Mirrors Radix's `sideOffset`.
+     * along the resolved `side` axis.
      */
     sideOffset: number;
     /**
@@ -8037,6 +8836,15 @@ interface ForComboboxContext<T = unknown> {
     isSelected(value: T): boolean;
     /** True when `id` is the activedescendant. */
     isActive(id: string): boolean;
+    /**
+     * Whether a pointer-suppression window is currently open. Opened whenever the
+     * directive scrolls the active option into view during keyboard navigation,
+     * so a synthetic `pointermove` fired because the scroll slid a different
+     * option under a stationary cursor does not hijack the activedescendant.
+     * Options consult this from their hover handler and skip the move while it
+     * returns `true`.
+     */
+    isPointerSuppressed(): boolean;
     /**
      * Activate by handle. Single mode replaces + closes + commits label. Multi
      * mode toggles in/out + stays open + (when `commitOnSelect`) clears the
@@ -8224,9 +9032,8 @@ declare class ForCombobox<T = string> extends FormUiControlBase implements FormV
     /**
      * Auto-highlight the first enabled option whenever the listbox is open
      * and no activedescendant is set (e.g. after the consumer's filter
-     * removed the previously-active option). On by default — matches the
-     * Headless UI / Material Autocomplete behavior. Set `false` for
-     * Radix-style "user must arrow before anything is highlighted".
+     * removed the previously-active option). On by default. Set `false` for
+     * "user must arrow before anything is highlighted" behavior.
      */
     readonly autoHighlight: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
@@ -8394,6 +9201,7 @@ declare class ForCombobox<T = string> extends FormUiControlBase implements FormV
     unregisterChip(handle: ForComboboxChipHandle<T>): void;
     isSelected(v: T): boolean;
     isActive(id: string): boolean;
+    isPointerSuppressed(): boolean;
     activate(handle: ForComboboxOptionHandle<T>): void;
     removeValue(v: T): void;
     activateActive(): boolean;
@@ -8475,7 +9283,7 @@ declare class ForComboboxAnchor {
 /**
  * Button that opens the listbox and keeps showing the committed selection
  * (label + icon) while the search input lives **inside** the panel — the
- * "combobox with trigger" / picker anatomy (shadcn / cmdk / Base UI). Apply on
+ * "combobox with trigger" / picker anatomy. Apply on
  * a real `<button>` so Space / Enter dispatch native click events that toggle
  * via `(click)`.
  *
@@ -8538,6 +9346,7 @@ declare class ForComboboxTrigger<T = unknown> {
  * Keyboard:
  * - **ArrowDown / ArrowUp** — open + move activedescendant.
  * - **Home / End** (when open) — first / last enabled option.
+ * - **PageUp / PageDown** (when open) — first / last enabled option.
  * - **Enter** (when open) — activate the activedescendant; no-op otherwise.
  * - **Escape** (when open) — close (focus stays in input). On the
  *   open→closed transition the input value is re-synced to `query()` even
@@ -8685,7 +9494,7 @@ declare const FOR_COMBOBOX_OPTION: InjectionToken<ForComboboxOption<string>>;
  * `data-state="checked" | "unchecked"` always reflects membership in
  * `value()` regardless of mode, so consumers can paint a checkmark with
  * pure CSS in either mode. `data-highlighted` marks the option that is
- * the current activedescendant — Radix-aligned and shared across the
+ * the current activedescendant — shared across the
  * library's roving / activedescendant primitives.
  *
  * Hovering an option also makes it the activedescendant, mirroring native
@@ -9289,8 +10098,8 @@ declare class ForSlider extends FormUiControlBase implements Omit<FormValueContr
     /**
      * Emitted at the end of a value-changing interaction — pointerup /
      * pointercancel after a drag, or keyup after one or more keyboard
-     * adjustments — with the final value array. Mirrors Radix / Base UI
-     * `onValueCommit`. Use it to defer expensive work (network calls,
+     * adjustments — with the final value array. Use it to defer expensive work
+     * (network calls,
      * history entries) to the trailing edge of the interaction instead of
      * running it per step. Stays silent when nothing changed (e.g. press +
      * release without movement, or a non-navigation key on a focused thumb).
@@ -9491,8 +10300,8 @@ declare const FOR_SLIDER_HOST_DIRECTIVE_OUTPUTS: readonly ["valueChange", "value
 /**
  * Pointer-based swipe-to-dismiss helper.
  *
- * Used by `ForToast` (and any future primitive that wants Radix-style
- * swipe semantics: a horizontal/vertical drag that, when released past
+ * Used by `ForToast` (and any future primitive that wants swipe-to-dismiss
+ * semantics: a horizontal/vertical drag that, when released past
  * the configured threshold, triggers a dismissal).
  *
  * The helper keeps no Angular DI surface — it's a plain function that
@@ -9634,6 +10443,27 @@ interface ForToastConfig<D = unknown> {
      * {@link class} and with the directive's own host attributes.
      */
     classList?: string | readonly string[];
+    /**
+     * CSS class applied via `animate.enter` to the rendered toast root, so it
+     * plays an enter animation on mount. Optional and symmetric with
+     * {@link animateLeave}: a plain CSS `@keyframes` / `animation` declared on
+     * `[forToast]` already plays on mount without this, so this is only needed
+     * for class-applied entrances. When unset, falls through to the
+     * viewport-level `[animateEnter]`.
+     */
+    animateEnter?: string;
+    /**
+     * CSS class applied via `animate.leave` to the rendered toast root, so it
+     * plays an exit animation before the toast leaves the DOM on dismiss. When
+     * unset, falls through to the viewport-level `[animateLeave]`.
+     *
+     * This is the only way to express a toast exit animation on the programmatic
+     * path: the viewport renders the toast inside its own `@for`, and a pure-CSS
+     * exit cannot defer the unmount — Angular needs `animate.leave` on the node to
+     * keep it mounted until the animation settles. Leaving it unset keeps the
+     * existing synchronous unmount on dismiss.
+     */
+    animateLeave?: string;
     /** Arbitrary payload passed to `template` context as `data`. */
     data?: D;
     /** Override the default rendering with a `TemplateRef`. */
@@ -9767,7 +10597,7 @@ declare class ForToast implements ForToastContext {
     readonly swipeDirection: _angular_core.InputSignal<ForToastSwipeDirection>;
     /**
      * Pixels of pointer travel along the active swipe direction needed
-     * to commit a dismissal. Defaults to `50` — matches Radix.
+     * to commit a dismissal. Defaults to `50`.
      */
     readonly swipeThreshold: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Emitted when the toast wants to be unmounted. The consumer reacts by removing it from the rendered list. */
@@ -9780,15 +10610,15 @@ declare class ForToast implements ForToastContext {
     readonly swipeEnd: _angular_core.OutputEmitterRef<SwipeEventDetail>;
     /** Fired on pointer-up before the threshold, or on `pointercancel`. */
     readonly swipeCancel: _angular_core.OutputEmitterRef<SwipeEventDetail>;
-    readonly paused: _angular_core.Signal<boolean>;
-    protected readonly swipeState: _angular_core.Signal<SwipeState | null>;
-    protected readonly swipeActiveDirection: _angular_core.Signal<SwipeDirection | null>;
-    protected readonly swipeMovementX: _angular_core.Signal<number>;
-    protected readonly swipeMovementY: _angular_core.Signal<number>;
-    readonly labelledBy: _angular_core.Signal<string | null>;
-    readonly describedBy: _angular_core.Signal<string | null>;
-    protected readonly computedRole: _angular_core.Signal<"alert" | "status">;
-    protected readonly ariaLive: _angular_core.Signal<"off" | "polite" | "assertive">;
+    readonly paused: Signal<boolean>;
+    protected readonly swipeState: Signal<SwipeState | null>;
+    protected readonly swipeActiveDirection: Signal<SwipeDirection | null>;
+    protected readonly swipeMovementX: Signal<number>;
+    protected readonly swipeMovementY: Signal<number>;
+    readonly labelledBy: Signal<string | null>;
+    readonly describedBy: Signal<string | null>;
+    protected readonly computedRole: Signal<"alert" | "status">;
+    protected readonly ariaLive: Signal<"off" | "polite" | "assertive">;
     constructor();
     registerLabel(handle: ForToastTextHandle): void;
     unregisterLabel(handle: ForToastTextHandle): void;
@@ -9832,6 +10662,12 @@ declare class ForToast implements ForToastContext {
  * Per-toast classes: a config's `class` / `classList` is applied to the
  * rendered toast root, merged with the directive's own host attributes.
  *
+ * Enter / exit animations: a toast renders inside this viewport's `@for`, so a
+ * `[animate.leave]` on the row defers the unmount natively — the toast stays
+ * mounted until its exit animation settles. Supply the class per-toast with
+ * `show({ animateLeave })` or set a viewport-wide default with `[animateLeave]`
+ * (per-toast wins); `[animateEnter]` mirrors it for class-applied entrances.
+ *
  * Hotkey: pressing the configured `hotkey` (default `F6`) anywhere in the
  * document focuses the first toast. Override per-viewport with `[hotkey]`
  * or globally with `provideForToastDefaults({ hotkey: '…' })`. The listener
@@ -9892,6 +10728,21 @@ declare class ForToastViewport {
      * that doesn't override `swipeThreshold` in its own config.
      */
     readonly swipeThreshold: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Default `animate.enter` class applied to every programmatic toast that
+     * doesn't set `animateEnter` in its own config. Empty (default) plays no
+     * class-applied enter animation — a plain CSS `@keyframes` on `[forToast]`
+     * already runs on mount without it.
+     */
+    readonly animateEnter: _angular_core.InputSignal<string>;
+    /**
+     * Default `animate.leave` class applied to every programmatic toast that
+     * doesn't set `animateLeave` in its own config. Empty (default) unmounts the
+     * toast synchronously on dismiss; set it (or per-toast `animateLeave`) to
+     * keep the toast mounted until its exit animation settles before it leaves
+     * the DOM.
+     */
+    readonly animateLeave: _angular_core.InputSignal<string>;
     protected readonly defaultDuration: Signal<number>;
     /**
      * Resolved `maxVisible` limit: the per-viewport `[maxVisible]` when set,
@@ -9908,8 +10759,20 @@ declare class ForToastViewport {
      * attributes untouched.
      */
     protected toastClass(toast: ForToastInstance): string;
+    /**
+     * `animate.enter` class for a toast row: its per-toast `animateEnter` config
+     * when set, otherwise the viewport-level `[animateEnter]`. Empty when neither
+     * is set.
+     */
+    protected toastAnimateEnter(toast: ForToastInstance): string;
+    /**
+     * `animate.leave` class for a toast row: its per-toast `animateLeave` config
+     * when set, otherwise the viewport-level `[animateLeave]`. Empty when neither
+     * is set, which keeps the toast's unmount synchronous on dismiss.
+     */
+    protected toastAnimateLeave(toast: ForToastInstance): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForToastViewport, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ForToastViewport, "for-toast-viewport, [forToastViewport]", ["forToastViewport"], { "label": { "alias": "label"; "required": false; "isSignal": true; }; "region": { "alias": "region"; "required": false; "isSignal": true; }; "hotkey": { "alias": "hotkey"; "required": false; "isSignal": true; }; "maxVisible": { "alias": "maxVisible"; "required": false; "isSignal": true; }; "swipeDirection": { "alias": "swipeDirection"; "required": false; "isSignal": true; }; "swipeThreshold": { "alias": "swipeThreshold"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ForToastViewport, "for-toast-viewport, [forToastViewport]", ["forToastViewport"], { "label": { "alias": "label"; "required": false; "isSignal": true; }; "region": { "alias": "region"; "required": false; "isSignal": true; }; "hotkey": { "alias": "hotkey"; "required": false; "isSignal": true; }; "maxVisible": { "alias": "maxVisible"; "required": false; "isSignal": true; }; "swipeDirection": { "alias": "swipeDirection"; "required": false; "isSignal": true; }; "swipeThreshold": { "alias": "swipeThreshold"; "required": false; "isSignal": true; }; "animateEnter": { "alias": "animateEnter"; "required": false; "isSignal": true; }; "animateLeave": { "alias": "animateLeave"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -10028,7 +10891,7 @@ declare class ForToastRef<R = unknown, D = unknown> {
 }
 
 /**
- * Programmatic toast opener — the headless equivalent of CDK's snackbar.
+ * Programmatic toast opener — show a transient notification from TypeScript.
  * Inject anywhere, call `show({ title, ... })` and get a `ForToastRef`
  * back. Toasts render through `<for-toast-viewport>`, which the consumer
  * mounts once near the root of their app.
@@ -10995,21 +11858,10 @@ declare function provideForToolbarDefaults(defaults?: Partial<ForToolbarDefaults
 
 /** Why an open / close was scheduled. */
 type HoverCardScheduleReason = 'hover-trigger' | 'hover-content' | 'focus' | 'escape';
-interface ForHoverCardContext {
+interface ForHoverCardContext extends AnchoredPositioningContext {
     readonly open: Signal<boolean>;
     readonly disabled: Signal<boolean>;
-    readonly side: Signal<FloatingSide>;
-    readonly align: Signal<FloatingAlign>;
-    readonly sideOffset: Signal<number>;
-    readonly alignOffset: Signal<number>;
-    readonly avoidCollisions: Signal<boolean>;
-    readonly collisionPadding: Signal<number>;
-    readonly arrowPadding: Signal<number>;
-    readonly sticky: Signal<'partial' | 'always' | false>;
-    readonly hideWhenDetached: Signal<boolean>;
-    readonly clipUntilPositioned: Signal<boolean>;
     readonly trigger: Signal<HTMLElement | null>;
-    readonly arrow: Signal<HTMLElement | null>;
     readonly content: Signal<HTMLElement | null>;
     registerTrigger(el: HTMLElement): void;
     unregisterTrigger(el: HTMLElement): void;
@@ -11095,7 +11947,7 @@ declare class ForHoverCard implements ForHoverCardContext {
     readonly align: _angular_core.Signal<FloatingAlign>;
     /**
      * Per-card override for the gap (px) between trigger and card along the
-     * main axis. Mirrors Radix's `sideOffset`. When `undefined` (default),
+     * main axis. When `undefined` (default),
      * falls back to `ForHoverCardDefaults.sideOffset` from the surrounding
      * `provideForHoverCardDefaults` scope (`8` unless configured).
      *
@@ -11185,7 +12037,7 @@ declare class ForHoverCard implements ForHoverCardContext {
  *
  * **Intentional ARIA exception.** The trigger exposes no `aria-controls`,
  * `aria-expanded`, or `aria-describedby`, and `[forHoverCardContent]` carries
- * no role. This is deliberate, mirroring Radix: the trigger must already be
+ * no role. This is deliberate: the trigger must already be
  * self-meaningful (a link or button that conveys the underlying action on its
  * own — the card adds preview, not meaning), and the card is non-essential
  * supplementary content that is hover/focus-revealed and not part of the
@@ -11244,7 +12096,7 @@ declare class ForHoverCardTrigger {
  *
  * **Intentional ARIA exception.** The content carries no role (only
  * `data-state` for styling) and the trigger exposes no ARIA linkage — the
- * card is non-essential supplementary content, mirroring Radix. See
+ * card is non-essential supplementary content. See
  * `ForHoverCardTrigger` for the full rationale.
  */
 declare class ForHoverCardContent {
@@ -11296,7 +12148,7 @@ interface ForHoverCardDefaults {
     align: FloatingAlign;
     /**
      * Gap (px) between trigger and card along the main axis for cards that
-     * don't override `sideOffset` locally. Mirrors Radix's `sideOffset`.
+     * don't override `sideOffset` locally.
      * Library fallback `8`.
      */
     sideOffset: number;
@@ -11333,8 +12185,8 @@ interface ForNavigationMenuContentHandle extends CollectionHandle {
     readonly id: Signal<string>;
 }
 /**
- * Per-viewport handle. Only one viewport is expected per menu (Radix
- * mirror). The host element is the destination for re-parented active
+ * Per-viewport handle. Only one viewport is expected per menu. The host
+ * element is the destination for re-parented active
  * content panels, and the viewport owns their ordering.
  */
 interface ForNavigationMenuViewportHandle {
@@ -11433,7 +12285,7 @@ declare const FOR_NAVIGATION_MENU_ITEM_CONTEXT: InjectionToken<ForNavigationMenu
  * item's id, or `''` when nothing is open). The `model()` change emitter
  * fires only on internal transitions, never on consumer writes.
  *
- * Submenús anidados (Radix-style `Sub`) están fuera de scope para v1.
+ * Submenús anidados están fuera de scope para v1.
  *
  * @example
  * ```html
@@ -11544,7 +12396,7 @@ declare class ForNavigationMenu implements ForNavigationMenuContext {
     /**
      * `data-motion` direction for the content with the given `value`.
      *
-     * Mirrors Radix's `NavigationMenu.Content` convention: when the user
+     * Sets the slide direction by index comparison: when the user
      * moves rightward from A (index 0) to B (index 2), the entering panel
      * slides in from the end side (`from-end`) and the leaving panel slides
      * out to the start side (`to-start`) — both shift in the same logical
@@ -11731,7 +12583,7 @@ declare class ForNavigationMenuIndicator {
  * Optional shared surface for mega-menu style navigation. When present,
  * `[forNavigationMenuContent]` re-parents itself into this host on mount,
  * so all active content panels live inside a single visual container that
- * can animate width/height between trigger groups (Radix `Viewport`).
+ * can animate width/height between trigger groups.
  *
  * The viewport exposes the active content's natural size as CSS custom
  * properties:
@@ -11889,7 +12741,7 @@ declare class ForScrollArea implements ForScrollAreaContext {
      *   self-hides when the content fits.
      * - `always`: the scrollbar (and corner) stay mounted and
      *   `data-state="visible"` regardless of overflow — a stable, always-painted
-     *   track, matching Radix. When the axis does not overflow the thumb fills
+     *   track. When the axis does not overflow the thumb fills
      *   the full track and dragging is a no-op. The library is headless and does
      *   not own layout, so to actually *reserve* the gutter (no content shift
      *   when crossing the overflow boundary) the consumer lays the scrollbar out
@@ -11984,7 +12836,7 @@ interface ElementBox {
  * The element is fully removed (`hidden`) when the corresponding axis has
  * no overflow *and* `type` is not `'always'` — there is no scrollbar to
  * render. Under `type="always"` the track stays painted regardless of
- * overflow (Radix parity), so the consumer's reserved gutter is never empty.
+ * overflow, so the consumer's reserved gutter is never empty.
  * Visibility is enforced with an inline `display: none` (which beats any
  * author `display` rule a consumer applies via a class) in addition to the
  * `hidden` attribute that removes it from the a11y tree.
@@ -12007,7 +12859,7 @@ declare class ForScrollAreaScrollbar {
     readonly hasOverflow: _angular_core.Signal<boolean>;
     /**
      * Whether the track is rendered at all. `'always'` keeps it painted
-     * unconditionally (a stable, always-present track — Radix parity); every
+     * unconditionally (a stable, always-present track); every
      * other `type` paints only the axis that actually overflows. An in-flight
      * thumb drag also pins it painted so the gesture is never aborted by the
      * track self-removing. Gates both the `hidden` attribute and the inline
@@ -12405,9 +13257,9 @@ declare class ForTree implements ForTreeContext, ForTreeContainerContext {
     checkState(value: string): 'true' | 'false' | 'mixed';
     setExpanded(value: string, open: boolean): void;
     select(value: string): void;
-    navigate(currentItem: HTMLElement, action: ListNavigationAction): void;
-    expandOrEnter(currentItem: HTMLElement): void;
-    collapseOrLeave(currentItem: HTMLElement): void;
+    navigate(_currentItem: HTMLElement, action: ListNavigationAction): void;
+    expandOrEnter(_currentItem: HTMLElement): void;
+    collapseOrLeave(_currentItem: HTMLElement): void;
     expandSiblings(currentItem: HTMLElement): void;
     extendByArrow(currentItem: HTMLElement, action: 'next' | 'prev'): void;
     selectRangeToFocused(currentItem: HTMLElement): void;
@@ -12480,7 +13332,7 @@ declare class ForTreeItem implements ForTreeItemContext {
      * when cascade is on and only some descendants are checked. Drives the
      * checkbox anatomy; meaningful only in `selectionMode="checkbox"`.
      */
-    readonly checkState: _angular_core.Signal<"true" | "false" | "mixed">;
+    readonly checkState: _angular_core.Signal<"mixed" | "true" | "false">;
     /**
      * True when this node is the current keyboard-focused / active candidate.
      * In the roving-tabindex path tracks DOM focus; in the virtualized
@@ -12489,6 +13341,12 @@ declare class ForTreeItem implements ForTreeItemContext {
      */
     readonly highlighted: _angular_core.Signal<boolean>;
     readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    /**
+     * Drop-indicator hook for `[forTreeNodeDrag]`: `'before'` / `'after'` when a live drag would
+     * land adjacent to this row, `null` otherwise (and always `null` without a drag coordinator).
+     * Reflected as `data-drop-position`.
+     */
+    protected readonly _dropPosition: _angular_core.Signal<"before" | "after" | null>;
     readonly level: _angular_core.Signal<number>;
     readonly posinset: _angular_core.Signal<number>;
     readonly setsize: _angular_core.Signal<number>;
@@ -12662,12 +13520,25 @@ interface ForTreeDragDropEvent {
     readonly currentIndex: number;
 }
 
+/**
+ * Where the lifted node will land, for rendering an insertion indicator. `null` when idle.
+ */
+interface ForTreeDropIndicator {
+    /** The visible row the indicator anchors to (the node value). */
+    readonly anchor: string;
+    /** Whether the line sits just before or just after the anchor row in DOM order. */
+    readonly position: 'before' | 'after';
+    /** Resolved 1-based depth of the drop (mirror of `--for-tree-drop-level`). */
+    readonly level: number;
+}
 /** The coordination contract the handle uses to register with the coordinator. */
 interface ForTreeNodeDragContext {
     /** Register a drag handle element for the item that contains it. */
     registerHandle(el: HTMLElement): void;
     /** Unregister a previously registered handle element. */
     unregisterHandle(el: HTMLElement): void;
+    /** Resolved drop indicator while a drag is live; `null` when idle. */
+    readonly dropIndicator: Signal<ForTreeDropIndicator | null>;
 }
 /** InjectionToken for the `[forTreeNodeDrag]` coordinator. */
 declare const FOR_TREE_NODE_DRAG_CONTEXT: InjectionToken<ForTreeNodeDragContext>;
@@ -12698,6 +13569,8 @@ declare class ForTreeNodeDrag implements ForTreeNodeDragContext {
     protected readonly _dragging: _angular_core.WritableSignal<boolean>;
     protected readonly _dropTargetValid: _angular_core.WritableSignal<boolean>;
     protected readonly _dropLevel: _angular_core.WritableSignal<number | null>;
+    /** Resolved drop indicator while a drag is live; `null` when idle. */
+    readonly dropIndicator: Signal<ForTreeDropIndicator | null>;
     constructor();
     registerHandle(el: HTMLElement): void;
     unregisterHandle(el: HTMLElement): void;
@@ -13101,9 +13974,9 @@ declare const OTP_REGEXP_ONLY_CHARS: RegExp;
 declare const OTP_REGEXP_ONLY_DIGITS_AND_CHARS: RegExp;
 
 /**
- * Headless OTP / PIN input following the **single-input** model (shadcn
- * `input-otp` / Spartan `BrnInputOtp`): one real `<input maxlength=N>` carries
- * the whole code as a `string`, and the `[forOtpInputSlot]` pieces are a pure
+ * Headless OTP / PIN input following the **single-input** model: one real
+ * `<input maxlength=N>` carries the whole code as a `string`, and the
+ * `[forOtpInputSlot]` pieces are a pure
  * styling surface painted over it. There is **no** WAI-ARIA APG pattern for
  * OTP; this gives the cleanest screen-reader experience (one ordinary text
  * field, not "edit text, 1 of 6" announced N times), native mobile SMS autofill
@@ -13117,9 +13990,12 @@ declare const OTP_REGEXP_ONLY_DIGITS_AND_CHARS: RegExp;
  * (label / description / error) with no extra markup.
  *
  * Because the focusable, submittable control is the injected `<input>` and not
- * the `role="group"` host, `ForOtpInput` wires form-control reflection, the
- * field association, and native `name` submission onto that input itself rather
- * than extending `FormUiControlBase` (whose helpers target the directive host).
+ * the `role="group"` host, `ForOtpInput` redirects `FormUiControlBase`'s
+ * host-targeted helpers onto that input: it overrides `fieldLabelledElement()`
+ * (so the field association lands on the input) and `fieldStateReflectionTarget()`
+ * (so the form-state `data-*` reflect there), and reflects the OTP-specific input
+ * attributes (`maxLength` / `inputmode` / `autocomplete` / `pattern` / `name`)
+ * and ARIA on the input itself.
  *
  * The host gets `data-complete` (while every slot is filled) and `data-disabled`
  * for CSS hooks; the real input carries `data-disabled` / `data-readonly` plus
@@ -13143,7 +14019,7 @@ declare const OTP_REGEXP_ONLY_DIGITS_AND_CHARS: RegExp;
  * </div>
  * ```
  */
-declare class ForOtpInput implements FormValueControl<string>, ForOtpInputContext {
+declare class ForOtpInput extends FormUiControlBase implements FormValueControl<string>, ForOtpInputContext {
     #private;
     /**
      * The current code. Required by `FormValueControl<string>`. Two-way bindable;
@@ -13170,47 +14046,9 @@ declare class ForOtpInput implements FormValueControl<string>, ForOtpInputContex
      * Accessible name for the group, also reflected as `aria-label` on the
      * injected real `<input>` whenever no field-provided `aria-labelledby`
      * applies (standalone usage, or a `[forField]` without a label). Emits
-     * `aria-label` only when truthy; a field label always wins on the input.
-     */
-    readonly ariaLabel: _angular_core.InputSignal<string | null>;
-    /**
-     * When true, interaction is ignored and `aria-disabled` / `data-disabled` are
-     * reflected. Behavior and ARIA gate off {@link effectiveDisabled}, which also
-     * folds in a surrounding disabled `[forFieldset]`.
-     */
-    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /**
-     * The control's own {@link disabled} OR'd with a surrounding disabled
-     * `[forFieldset]`. Drives interaction gating and `aria-disabled` /
-     * `data-disabled`, so a disabled group disables the OTP input too.
-     */
-    readonly effectiveDisabled: _angular_core.Signal<boolean>;
-    /** When true, interaction is ignored but the control stays focusable; `aria-readonly="true"`. */
-    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Reflected as `aria-required="true"` when truthy. */
-    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Reflected as `aria-invalid="true"` and `data-invalid` when truthy. */
-    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Reflected as `aria-busy="true"` and `data-pending` when truthy. */
-    readonly pending: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Reflected as `data-dirty` when truthy. */
-    readonly dirty: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** When non-empty, reflected as the real input's `name` for native form submission. */
-    readonly name: _angular_core.InputSignal<string>;
-    /** Validation errors surfaced by Signal Forms. */
-    readonly errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    /**
-     * Set to true on blur. Two-way bindable for standalone consumers; under
-     * `[formField]` the directive pushes the field's touched state down through
-     * this input.
-     */
-    readonly touched: _angular_core.ModelSignal<boolean>;
-    /**
-     * Emitted on blur alongside the `touched` flip. `[formField]` listens to
-     * this output to mark the field touched — since Signal Forms v22 the
-     * `touched` input is write-only from the form's perspective.
+     * `aria-label` only when truthy; a field label always wins on the input.
      */
-    readonly touch: _angular_core.OutputEmitterRef<void>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
     /** Fires when every slot is filled (by typing or paste). */
     readonly valueComplete: _angular_core.OutputEmitterRef<string>;
     /** Fires when an entered / pasted character is rejected by `type` / `allowedPattern`. */
@@ -13222,6 +14060,19 @@ declare class ForOtpInput implements FormValueControl<string>, ForOtpInputContex
     /** The slot indices, for the consumer's `@for`. */
     readonly slots: _angular_core.Signal<readonly number[]>;
     constructor();
+    /**
+     * The injected real `<input>` is the focusable, submittable control, so the
+     * surrounding `[forField]` associates with it rather than the `role="group"`
+     * host. Returns `null` until the input is created (after hydration), at which
+     * point the field-wiring effect re-targets it. See the Select precedent.
+     */
+    protected fieldLabelledElement(): HTMLElement | null;
+    /**
+     * The four form-state `data-*` booleans reflect onto the injected real
+     * `<input>`, alongside the OTP-specific `data-disabled` / `data-readonly`,
+     * rather than the `role="group"` host. `null` until the input exists.
+     */
+    protected fieldStateReflectionTarget(): HTMLElement | null;
     /** Move focus to the real input. Implements `FormUiControl.focus`. */
     focus(options?: FocusOptions): void;
     /** The character in slot `index` (masked when `mask`), or `null` when empty. */
@@ -13231,12 +14082,12 @@ declare class ForOtpInput implements FormValueControl<string>, ForOtpInputContex
     /** Whether slot `index` should render a fake caret. */
     hasFakeCaret(index: number): boolean;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForOtpInput, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForOtpInput, "[forOtpInput]", ["forOtpInput"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "length": { "alias": "length"; "required": true; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "allowedPattern": { "alias": "allowedPattern"; "required": false; "isSignal": true; }; "mask": { "alias": "mask"; "required": false; "isSignal": true; }; "oneTimeCode": { "alias": "oneTimeCode"; "required": false; "isSignal": true; }; "pasteTransformer": { "alias": "pasteTransformer"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; "touch": "touch"; "valueComplete": "valueComplete"; "valueInvalid": "valueInvalid"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForOtpInput, "[forOtpInput]", ["forOtpInput"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "length": { "alias": "length"; "required": true; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "allowedPattern": { "alias": "allowedPattern"; "required": false; "isSignal": true; }; "mask": { "alias": "mask"; "required": false; "isSignal": true; }; "oneTimeCode": { "alias": "oneTimeCode"; "required": false; "isSignal": true; }; "pasteTransformer": { "alias": "pasteTransformer"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueComplete": "valueComplete"; "valueInvalid": "valueInvalid"; }, never, never, true, never>;
 }
 
 /**
  * One slot of a `[forOtpInput]` — a pure **styling surface** painted over the
- * single real input, mirroring Spartan `BrnInputOtpSlot`. Apply one per index
+ * single real input. Apply one per index
  * inside the `[forOtpInput]` wrapper, passing the 0-based `index`. It renders
  * nothing structural: it exposes the slot's character and active state, and
  * reflects boolean `data-active` / `data-empty` for CSS.
@@ -13318,204 +14169,6 @@ declare const FOR_OTP_INPUT_HOST_DIRECTIVE_INPUTS: readonly ["value", "allowedPa
  */
 declare const FOR_OTP_INPUT_HOST_DIRECTIVE_OUTPUTS: readonly ["valueChange", "touchedChange", "touch", "valueComplete", "valueInvalid"];
 
-/**
- * Pluggable, date-library-agnostic seam for `ForCalendar`. Every internal
- * algorithm (paging, the day matrix, comparison, formatting) goes through a
- * `DateAdapter<D>`, so the primitive never hard-depends on a date library.
- *
- * The library ships two adapters behind {@link FOR_DATE_ADAPTER}:
- *
- * - `provideInternationalizedDateAdapter()` — over `@internationalized/date`'s
- *   immutable `CalendarDate`. Recommended for correct date-math and locale-aware
- *   formatting; `@internationalized/date` is an optional peer dependency. Both
- *   `@internationalized/date` adapters operate on the **Gregorian** calendar
- *   today — non-Gregorian calendar systems are deferred to the Temporal adapter
- *   track (#354).
- * - `provideNativeDateAdapter()` — over the built-in `Date`. Zero-dependency
- *   fallback.
- *
- * A `Temporal.PlainDate` adapter is a planned non-breaking addition once the
- * Temporal API is broadly available across browsers (#354).
- *
- * Implementations must be pure with respect to their date type: every
- * operation returns a value and never mutates its inputs. The `D` produced by
- * mutating operations (`add*`, `createDate`) is a fresh value, which keeps it
- * signal-friendly (reference equality changes on every change).
- *
- * @typeParam D The immutable date representation the adapter operates on.
- */
-interface DateAdapter<D> {
-    /**
-     * Today's date in the runtime time zone.
-     *
-     * **SSR / hydration caveat.** The result depends on the runtime time zone, so
-     * a server render and a client hydration can disagree by up to a day near
-     * midnight — the server may compute a different calendar day than the
-     * browser. `ForCalendar` reads this once to mark the `data-today` /
-     * `aria-current="date"` cell, so a mismatch surfaces there as a hydration
-     * error and a flicker on the highlighted "today" cell.
-     *
-     * **SSR-safe pattern.** Have the consumer supply a fixed "today" (or pin a
-     * time zone) for the server render, or defer the today-highlight to
-     * `afterNextRender` so `today()` is only computed client-side. See the
-     * calendar README's "SSR / hydration" section.
-     */
-    today(): D;
-    /**
-     * Creates a date from its parts.
-     *
-     * @param year Full year (e.g. `2026`).
-     * @param month Month of year, **1-12**.
-     * @param day Day of month, **1-31** (constrained to the month's length).
-     */
-    createDate(year: number, month: number, day: number): D;
-    /** The full year of `date` (e.g. `2026`). */
-    getYear(date: D): number;
-    /** The month of `date`, **1-12**. */
-    getMonth(date: D): number;
-    /** The day of month of `date`, **1-31**. */
-    getDate(date: D): number;
-    /** The day of week of `date`, **0-6** where `0` is Sunday and `6` is Saturday. */
-    getDayOfWeek(date: D): number;
-    /** The number of days in `date`'s month. */
-    getDaysInMonth(date: D): number;
-    /**
-     * The first day of the week as a **0-6** index (`0` = Sunday). Used as the
-     * default when `ForCalendar`'s `firstDayOfWeek` input is `null`. Adapters
-     * return a locale-independent default (`0`); consumers localise it through
-     * the `firstDayOfWeek` input or `provideForCalendarDefaults`.
-     */
-    getFirstDayOfWeek(): number;
-    /** Returns a new date `n` days after `date` (negative goes backwards). */
-    addDays(date: D, n: number): D;
-    /**
-     * Returns a new date `n` months after `date` (negative goes backwards). The
-     * day of month is constrained to the target month's length (e.g. Jan 31 + 1
-     * month is Feb 28/29, never Mar 3).
-     */
-    addMonths(date: D, n: number): D;
-    /**
-     * Returns a new date `n` years after `date` (negative goes backwards). The
-     * day of month is constrained (e.g. Feb 29 + 1 year is Feb 28 in a common
-     * year).
-     */
-    addYears(date: D, n: number): D;
-    /**
-     * Compares two dates by their natural ordering — **the full instant**,
-     * including any time component the adapter's `D` carries. Returns a negative
-     * number when `a` is before `b`, `0` when they are equal, and a positive
-     * number when `a` is after `b`.
-     *
-     * This is the canonical comparator and the only one an adapter must
-     * implement. Time-capable adapters (`Date`, `@internationalized/date`'s
-     * `CalendarDateTime`) order by day *and* time; day-only adapters
-     * (`CalendarDate`) order by day alone because that is all their `D` carries.
-     *
-     * **Bounds granularity.** `minDate` / `maxDate` clamping in the date
-     * primitives compares the full instant through `compare`, so a date-time
-     * `min`/`max` clamps identically on every time-capable adapter (e.g. native
-     * `Date` and `CalendarDateTime` produce the same result for the same input).
-     * For the *calendar grid*, where availability is day-granular so the boundary
-     * day of a date-time `min`/`max` stays selectable, use {@link compareDateOf}
-     * (which honours {@link compareDate} when present and otherwise derives a
-     * day-only comparison from the y/m/d getters).
-     */
-    compare(a: D, b: D): number;
-    /**
-     * Optionally compares two dates by calendar day only, ignoring any time
-     * component. Returns a negative number when `a`'s day is before `b`'s, `0`
-     * when they fall on the same calendar day, and a positive number when `a`'s
-     * day is after `b`'s.
-     *
-     * Adapters may **omit** this method: {@link compareDateOf} then derives the
-     * day-only comparison from the {@link getYear} / {@link getMonth} /
-     * {@link getDate} getters, which is correct for any adapter. Implement it only
-     * to override that default (e.g. for a non-Gregorian ordering). Day-only
-     * adapters whose {@link compare} already ignores time need not implement it.
-     */
-    compareDate?(a: D, b: D): number;
-    /** Whether `a` and `b` fall on the same calendar day. */
-    isSameDay(a: D, b: D): boolean;
-    /** Whether `date` is a valid date of this adapter's type. */
-    isValid(date: D): boolean;
-    /**
-     * Formats `date` for display using the runtime's default locale.
-     *
-     * **SSR / hydration caveat.** The result resolves against the runtime's
-     * default locale, so a server render and a client hydration can produce
-     * different strings when the server and browser locales differ — surfacing as
-     * a hydration mismatch on every formatted value (heading, weekday headers,
-     * cell labels). The runtime time zone applies too for adapters that format
-     * through a wall-clock instant.
-     *
-     * **SSR-safe pattern.** Pin a locale (or format client-side) for the server
-     * render so both environments resolve the same locale. See the calendar
-     * README's "SSR / hydration" section.
-     *
-     * @param options Standard `Intl.DateTimeFormat` options (e.g.
-     *   `{ month: 'long', year: 'numeric' }` for a calendar heading,
-     *   `{ weekday: 'short' }` for a column header).
-     */
-    format(date: D, options: Intl.DateTimeFormatOptions): string;
-    /**
-     * Whether this adapter's `D` can carry a wall-clock time component (hour /
-     * minute / second). Day-only adapters omit the optional time accessors below
-     * and return `false` (or omit this method); time-capable adapters implement
-     * them and return `true`. `ForTimeField` — and the time granularity of the
-     * date primitives — require a time-capable adapter.
-     */
-    supportsTime?(): boolean;
-    /** The hour of `date`, **0-23** (24-hour clock). Time-capable adapters only. */
-    getHours?(date: D): number;
-    /** The minute of `date`, **0-59**. Time-capable adapters only. */
-    getMinutes?(date: D): number;
-    /** The second of `date`, **0-59**. Time-capable adapters only. */
-    getSeconds?(date: D): number;
-    /**
-     * Returns a new date with its time set to the given parts, preserving the
-     * calendar day. Time-capable adapters only.
-     *
-     * @param hours Hour of day, **0-23**.
-     * @param minutes Minute of hour, **0-59**.
-     * @param seconds Second of minute, **0-59**.
-     */
-    setTime?(date: D, hours: number, minutes: number, seconds: number): D;
-}
-/**
- * A {@link DateAdapter} narrowed to one that implements the optional time
- * accessors. Produced by {@link assertTimeCapable} so time primitives can call
- * `getHours` / `setTime` / etc. without optional-chaining.
- *
- * @typeParam D The adapter's immutable date-time representation.
- */
-type TimeCapableDateAdapter<D> = DateAdapter<D> & Required<Pick<DateAdapter<D>, 'getHours' | 'getMinutes' | 'getSeconds' | 'setTime'>>;
-/**
- * Injection token holding the active {@link DateAdapter}. Provide it with
- * `provideInternationalizedDateAdapter()` or `provideNativeDateAdapter()`.
- * There is no application-wide default — a calendar with no adapter in scope
- * throws a descriptive error.
- */
-declare const FOR_DATE_ADAPTER: InjectionToken<DateAdapter<unknown>>;
-/**
- * Injects the active {@link DateAdapter}, throwing a descriptive,
- * primitive-prefixed error when no adapter has been provided.
- *
- * @param piece Name of the calling directive, used in the error message.
- */
-declare function injectDateAdapter<D>(piece: string): DateAdapter<D>;
-/**
- * Asserts that `adapter` implements the optional time accessors, returning it
- * narrowed to {@link TimeCapableDateAdapter}. Throws a descriptive,
- * primitive-prefixed error when the active adapter is day-only — the
- * zero-dependency `provideNativeDateAdapter()` is time-capable, as is
- * `provideInternationalizedDateTimeAdapter()`, but the day-pure
- * `provideInternationalizedDateAdapter()` (`CalendarDate`) is not.
- *
- * @param adapter The active adapter, typically from {@link injectDateAdapter}.
- * @param piece Name of the calling directive, used in the error message.
- */
-declare function assertTimeCapable<D>(adapter: DateAdapter<D>, piece: string): TimeCapableDateAdapter<D>;
-
 /** The active display mode of a `ForCalendar`. */
 type CalendarView = 'day' | 'month' | 'year';
 /**
@@ -13812,42 +14465,20 @@ declare const FOR_CALENDAR_CONTEXT: InjectionToken<ForCalendarContext<unknown>>;
  * `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`.
+ * follow-up `ForDatePicker` / `ForDateField`. See the primitive's README for a
+ * complete styleless usage example.
  *
  * @typeParam D The adapter's immutable date type.
- *
- * @example
- * ```html
- * <div forCalendar [(value)]="date">
- *   <header>
- *     <button forCalendarPrevButton [ariaLabel]="'Previous month'">‹</button>
- *     <h2 forCalendarHeading #heading="forCalendarHeading">{{ heading.label() }}</h2>
- *     <button forCalendarNextButton [ariaLabel]="'Next month'">›</button>
- *   </header>
- *   <table forCalendarGrid #grid="forCalendarGrid">
- *     <thead forCalendarGridHeader>
- *       <tr>
- *         @for (day of grid.weekDays(); track day.key) {
- *           <th scope="col" [attr.aria-label]="day.long">{{ day.short }}</th>
- *         }
- *       </tr>
- *     </thead>
- *     <tbody>
- *       @for (week of grid.weeks(); track week.key) {
- *         <tr>
- *           @for (cell of week.days; track cell.key) {
- *             <td forCalendarCell [date]="cell.date">{{ cell.label }}</td>
- *           }
- *         </tr>
- *       }
- *     </tbody>
- *   </table>
- * </div>
- * ```
  */
 declare class ForCalendar<D> implements ForCalendarContext<D> {
     #private;
@@ -13963,9 +14594,13 @@ declare class ForCalendar<D> implements ForCalendarContext<D> {
     readonly viewTriggerLabel: _angular_core.Signal<string>;
     readonly isPreviousDisabled: _angular_core.Signal<boolean>;
     readonly isNextDisabled: _angular_core.Signal<boolean>;
-    readonly weekDays: _angular_core.Signal<readonly CalendarWeekday[]>;
-    readonly weeks: _angular_core.Signal<readonly CalendarWeek<D>[]>;
+    /** Weekday column headers for the visible month, starting at `firstDayOfWeek`. */
+    readonly weekDays: _angular_core.Signal<readonly forty_cdk.CalendarWeekday[]>;
+    /** Week rows of the visible month, including outside-month padding days. */
+    readonly weeks: _angular_core.Signal<readonly forty_cdk.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
@@ -14592,7 +15227,7 @@ declare const FOR_DATE_FIELD_CONTEXT: InjectionToken<SegmentEditorContext>;
  * counterpart to `ForCalendar`. There is no single WAI-ARIA APG pattern for a
  * date field; it is a composition of
  * [Spinbuttons](https://www.w3.org/WAI/ARIA/apg/patterns/spinbutton/) inside a
- * labelled `role="group"`, exactly as React Aria's `useDateField` models it.
+ * labelled `role="group"`.
  * Each day / month / year part is an independent `role="spinbutton"` segment
  * (`[forDateFieldSegment]`) so entry is unambiguous and locale-correct — no
  * free-text parsing, no `03/04`-is-it-March-4th guesswork.
@@ -14925,12 +15560,26 @@ interface ForDatePickerContext {
     readonly formattedValue: Signal<string | null>;
     /** Placeholder shown by `[forDatePickerValue]` when no date is selected. */
     readonly placeholder: Signal<string>;
-    /** Element floating-ui anchors against (the trigger). */
+    /**
+     * Element floating-ui anchors the surface against. Prefers an optional
+     * `[forDatePickerAnchor]` when registered, otherwise falls back to the
+     * trigger. Decoupled from `trigger` so the trigger keeps driving
+     * `aria-controls`, the click toggle, focus return, and its outside-pointer
+     * exemption regardless of where the surface paints.
+     */
     readonly reference: Signal<ReferenceElement | null>;
     /** The trigger button — exempt from outside-pointer checks and the return-focus target. */
     readonly trigger: Signal<HTMLElement | null>;
     registerTrigger(el: HTMLElement): void;
     unregisterTrigger(el: HTMLElement): void;
+    /**
+     * Register / unregister an optional `[forDatePickerAnchor]` positioning
+     * element. At most one anchor per root; a second registration throws.
+     * Reference-based unregister, so an anchor torn down inside `@if` restores
+     * the trigger fallback cleanly.
+     */
+    registerAnchor(el: HTMLElement): void;
+    unregisterAnchor(el: HTMLElement): void;
     /** The mounted `[forDatePickerContent]` element. */
     readonly content: Signal<HTMLElement | null>;
     registerContent(el: HTMLElement): void;
@@ -14983,8 +15632,7 @@ declare const FOR_DATE_PICKER_CONTEXT: InjectionToken<ForDatePickerContext>;
 type DatePickerGranularity = 'day' | 'hour' | 'minute' | 'second';
 /**
  * Headless date picker — the [WAI-ARIA Date Picker Dialog pattern](https://www.w3.org/WAI/ARIA/apg/patterns/dialog-modal/examples/datepicker-dialog/)
- * reinterpreted idiomatically for modern Angular, the way React Aria's
- * `DatePicker` and Ark UI's `DatePicker` do it: a focusable trigger that opens
+ * reinterpreted idiomatically for modern Angular: a focusable trigger that opens
  * a floating surface wrapping a projected `ForCalendar`.
  *
  * `ForDatePicker` is the root and the form value: it implements
@@ -14994,9 +15642,8 @@ type DatePickerGranularity = 'day' | 'hour' | 'minute' | 'second';
  * state flows root → projected calendar via `[(value)]`.
  *
  * The surface defaults to a **non-modal popover** (anchored to the trigger,
- * dismiss on Escape / outside-pointer, return focus on close), matching React
- * Aria / Ark UI; set `modal` for the trapped / inert / scroll-locked dialog
- * variant. Mount/unmount of the surface is the consumer's job — wrap
+ * dismiss on Escape / outside-pointer, return focus on close); set `modal`
+ * for the trapped / inert / scroll-locked dialog variant. Mount/unmount of the surface is the consumer's job — wrap
  * `[forDatePickerContent]` with `@if (open())`.
  *
  * The projected `ForCalendar` is two-way bound by the consumer (`[(value)]`)
@@ -15198,6 +15845,14 @@ declare class ForDatePicker<D> extends FormUiControlBase implements FormValueCon
     readonly triggerId: _angular_core.WritableSignal<string>;
     readonly contentId: _angular_core.WritableSignal<string>;
     readonly trigger: _angular_core.Signal<HTMLElement | null>;
+    /**
+     * Element floating-ui anchors the surface against. Prefers an optional
+     * `[forDatePickerAnchor]` when registered, otherwise falls back to the
+     * trigger so existing pickers without an anchor keep their behavior.
+     * Decoupled from `trigger` so the trigger keeps driving `aria-controls`, the
+     * click toggle, focus return, and its dismissal exemption regardless of where
+     * the surface paints.
+     */
     readonly reference: _angular_core.Signal<ReferenceElement | null>;
     readonly content: _angular_core.Signal<HTMLElement | null>;
     /** Formatted current value via the adapter, or `null` when empty. */
@@ -15230,6 +15885,8 @@ declare class ForDatePicker<D> extends FormUiControlBase implements FormValueCon
     constructor();
     registerTrigger(el: HTMLElement): void;
     unregisterTrigger(el: HTMLElement): void;
+    registerAnchor(el: HTMLElement): void;
+    unregisterAnchor(el: HTMLElement): void;
     registerContent(el: HTMLElement): void;
     unregisterContent(el: HTMLElement): void;
     toggle(): void;
@@ -15262,6 +15919,45 @@ declare class ForDatePicker<D> extends FormUiControlBase implements FormValueCon
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDatePicker<any>, "[forDatePicker]", ["forDatePicker"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "isDateUnavailable": { "alias": "isDateUnavailable"; "required": false; "isSignal": true; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "returnFocus": { "alias": "returnFocus"; "required": false; "isSignal": true; }; "formatOptions": { "alias": "formatOptions"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "rangeSeparator": { "alias": "rangeSeparator"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "clipUntilPositioned": { "alias": "clipUntilPositioned"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "_dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "open": "openChange"; "range": "rangeChange"; "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "autoFocusOnOpen": "autoFocusOnOpen"; "autoFocusOnClose": "autoFocusOnClose"; }, ["calendar", "timeSource"], never, true, never>;
 }
 
+/**
+ * Optional positioning anchor. When present, `[forDatePickerContent]` is
+ * positioned against this element instead of `[forDatePickerTrigger]` — useful
+ * when the trigger lives inside a decorated field box (padding, prefix icon,
+ * clear / chevron buttons) and the surface should align to the visible field
+ * rather than the inner button.
+ *
+ * Only positioning changes: the trigger still owns `aria-controls`,
+ * `aria-expanded`, the click toggle, focus return on close, and its exemption
+ * from outside-pointer dismissal. If no anchor is registered the surface falls
+ * back to anchoring against the trigger, so existing usages are unaffected.
+ *
+ * A date picker's calendar has its own intrinsic width and ignores
+ * `--for-anchor-width`, so the practical effect is mostly start / side
+ * alignment to the box edge.
+ *
+ * At most one `[forDatePickerAnchor]` may be registered per `[forDatePicker]`;
+ * a second one throws.
+ *
+ * ```html
+ * <div forDatePicker [(value)]="date">
+ *   <div forDatePickerAnchor class="field-box">
+ *     <icon />
+ *     <button forDatePickerTrigger><span forDatePickerValue>…</span></button>
+ *     <button class="clear">×</button>
+ *   </div>
+ *   @if (open()) {
+ *     <div forDatePickerContent>…</div>
+ *   }
+ * </div>
+ * ```
+ */
+declare class ForDatePickerAnchor {
+    #private;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDatePickerAnchor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDatePickerAnchor, "[forDatePickerAnchor]", ["forDatePickerAnchor"], {}, {}, never, never, true, never>;
+}
+
 /**
  * The button that opens the date-picker surface — and the focusable form
  * control the picker exposes for `[formField]`. Apply on a `<button>` so
@@ -15369,7 +16065,7 @@ declare class ForDatePickerValue {
 interface ForDatePickerDefaults {
     /**
      * Distance (px) between the trigger and the floating surface along the
-     * resolved `side` axis. Mirrors Radix's `sideOffset`. Ignored in `modal`
+     * resolved `side` axis. Ignored in `modal`
      * mode (the dialog is centered, not anchored).
      */
     sideOffset: number;
@@ -15456,7 +16152,7 @@ declare const FOR_TIME_FIELD_CONTEXT: InjectionToken<SegmentEditorContext>;
  * to `ForDateField`. There is no single WAI-ARIA APG pattern for a time field;
  * it is a composition of
  * [Spinbuttons](https://www.w3.org/WAI/ARIA/apg/patterns/spinbutton/) inside a
- * labelled `role="group"`, exactly as React Aria's `useTimeField` models it.
+ * labelled `role="group"`.
  * Each hour / minute / second / AM·PM part is an independent
  * `role="spinbutton"` segment (`[forTimeFieldSegment]`) so entry is unambiguous
  * and locale-correct.
@@ -15831,6 +16527,8 @@ interface ForTimePickerContext<D = unknown> {
     readonly trigger: Signal<HTMLElement | null>;
     registerTrigger(el: HTMLElement): void;
     unregisterTrigger(el: HTMLElement): void;
+    registerAnchor(el: HTMLElement): void;
+    unregisterAnchor(el: HTMLElement): void;
     readonly content: Signal<HTMLElement | null>;
     registerContent(el: HTMLElement): void;
     unregisterContent(el: HTMLElement): void;
@@ -16019,7 +16717,15 @@ declare class ForTimePicker<D> extends FormUiControlBase implements FormValueCon
     readonly initialFocus: _angular_core.Signal<ForTimePickerInitialFocus>;
     readonly lastCloseReason: _angular_core.Signal<ForTimePickerCloseReason | null>;
     readonly trigger: _angular_core.Signal<HTMLElement | null>;
-    readonly anchor: _angular_core.Signal<ReferenceElement | null>;
+    /**
+     * Element floating-ui anchors the listbox against. Prefers an optional
+     * `[forTimePickerAnchor]` when registered, otherwise falls back to the
+     * trigger so existing pickers without an anchor keep their behavior.
+     * Decoupled from `trigger` so the trigger keeps driving `aria-controls`, the
+     * click toggle, focus return, and its dismissal exemption regardless of where
+     * the listbox paints.
+     */
+    readonly anchor: _angular_core.Signal<_floating_ui_dom.ReferenceElement | null>;
     readonly content: _angular_core.Signal<HTMLElement | null>;
     readonly options: _angular_core.Signal<readonly ForTimePickerOptionHandle[]>;
     /**
@@ -16038,6 +16744,8 @@ declare class ForTimePicker<D> extends FormUiControlBase implements FormValueCon
     setInitialFocus(target: ForTimePickerInitialFocus): void;
     registerTrigger(el: HTMLElement): void;
     unregisterTrigger(el: HTMLElement): void;
+    registerAnchor(el: HTMLElement): void;
+    unregisterAnchor(el: HTMLElement): void;
     registerContent(el: HTMLElement): void;
     unregisterContent(el: HTMLElement): void;
     registerOption(handle: ForTimePickerOptionHandle): void;
@@ -16065,6 +16773,41 @@ declare class ForTimePicker<D> extends FormUiControlBase implements FormValueCon
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTimePicker<any>, "[forTimePicker]", ["forTimePicker"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "minTime": { "alias": "minTime"; "required": false; "isSignal": true; }; "maxTime": { "alias": "maxTime"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "returnFocus": { "alias": "returnFocus"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "formatOptions": { "alias": "formatOptions"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "clipUntilPositioned": { "alias": "clipUntilPositioned"; "required": false; "isSignal": true; }; "_dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "open": "openChange"; "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "autoFocusOnOpen": "autoFocusOnOpen"; "autoFocusOnClose": "autoFocusOnClose"; }, never, never, true, never>;
 }
 
+/**
+ * Optional positioning anchor. When present, `[forTimePickerContent]` is
+ * positioned against this element instead of `[forTimePickerTrigger]` — useful
+ * when the trigger lives inside a decorated field box (padding, prefix icon,
+ * clear / chevron buttons) and the listbox should align to the visible field
+ * rather than the inner button.
+ *
+ * Only positioning changes: the trigger still owns `aria-controls`,
+ * `aria-expanded`, the click toggle, focus return on close, and its exemption
+ * from outside-pointer dismissal. If no anchor is registered the listbox falls
+ * back to anchoring against the trigger, so existing usages are unaffected.
+ *
+ * At most one `[forTimePickerAnchor]` may be registered per `[forTimePicker]`;
+ * a second one throws.
+ *
+ * ```html
+ * <div forTimePicker [(value)]="time">
+ *   <div forTimePickerAnchor class="field-box">
+ *     <icon />
+ *     <button forTimePickerTrigger><span forTimePickerValue>…</span></button>
+ *     <button class="clear">×</button>
+ *   </div>
+ *   @if (open()) {
+ *     <div forTimePickerContent>…</div>
+ *   }
+ * </div>
+ * ```
+ */
+declare class ForTimePickerAnchor {
+    #private;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTimePickerAnchor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTimePickerAnchor, "[forTimePickerAnchor]", ["forTimePickerAnchor"], {}, {}, never, never, true, never>;
+}
+
 /**
  * Combobox button that opens the time picker listbox. Apply on a `<button>` so
  * Space / Enter dispatch native click events that toggle via `(click)`.
@@ -16190,7 +16933,7 @@ declare class ForTimePickerOption<D = unknown> {
 interface ForTimePickerDefaults {
     /**
      * Distance (px) between the time picker trigger and the floating content
-     * along the resolved `side` axis. Mirrors Radix's `sideOffset`.
+     * along the resolved `side` axis.
      */
     sideOffset: number;
     /**
@@ -16458,6 +17201,10 @@ declare class ForCarousel implements ForCarouselContext {
      * Returns `true` when at least one registered, non-disabled indicator
      * matches the current `activeIndex`. Used by the tabindex ladder to decide
      * whether the first-enabled fallback must reclaim the tab stop.
+     *
+     * Assumes the one-indicator-per-slide mapping the rest of the picker is built
+     * on: the indicator at DOM index `i` targets slide `i`. A mismatched indicator
+     * count is dev-guarded by a `console.warn` at construction.
      */
     hasCurrentIndicator(): boolean;
     /** Start auto-rotation (explicit, sticky). Overrides the reduced-motion auto-start gate. */
@@ -16761,6 +17508,21 @@ declare const FOR_CAROUSEL_DEFAULTS: _angular_core.InjectionToken<ForCarouselDef
  */
 declare function provideForCarouselDefaults(defaults?: Partial<ForCarouselDefaults>): Provider[];
 
+/** A floating clone of the dragged element that follows the pointer. */
+interface DragPreview {
+    /** Position the preview's top-left at `(x, y)` in viewport coordinates. */
+    moveTo(x: number, y: number): void;
+    /**
+     * Transition the preview's top-left to `(x, y)`, then `destroy()` it once the transform
+     * transition ends (with a timeout fallback). Marks the element `data-settling` so a consumer
+     * CSS rule keyed on it governs duration / easing. If no transition is configured, destroys
+     * immediately. Caller must pass the browser `Window`.
+     */
+    settle(x: number, y: number, win: Window): void;
+    /** Remove the preview from the DOM. Idempotent. */
+    destroy(): void;
+}
+
 /** A registered draggable item, as seen by its drop list. */
 interface ForDraggableHandle {
     readonly host: HTMLElement;
@@ -16777,7 +17539,7 @@ interface ForDraggableHandle {
  */
 interface ForDropListContext {
     readonly host: HTMLElement;
-    readonly orientation: Signal<'horizontal' | 'vertical'>;
+    readonly orientation: Signal<'horizontal' | 'vertical' | 'mixed'>;
     readonly dir: Signal<WritingDirection>;
     /** Effective disabled of the whole list. */
     readonly disabled: Signal<boolean>;
@@ -16807,13 +17569,14 @@ interface ForDropListContext {
     /**
      * Begin a pointer drag for `el` at viewport point `point`. Sets up the same session state as a
      * keyboard lift. `preview` is the floating element supplied by the draggable (a consumer
-     * `[forDragPreview]` template); when omitted, the list creates the default cloned preview.
+     * `[forDragPreview]` template) — either a full {@link DragPreview} or the minimal
+     * `{ moveTo, destroy }` shape; when omitted, the list creates the default cloned preview.
      * Returns the source index, or `-1` if it could not lift.
      */
     pointerLift(el: HTMLElement, point: {
         x: number;
         y: number;
-    }, preview?: {
+    }, preview?: DragPreview | {
         moveTo(x: number, y: number): void;
         destroy(): void;
     } | null): number;
@@ -16848,13 +17611,25 @@ interface ForDragEndEvent {
     /** `true` on a committed drop, `false` on cancel. */
     readonly dropped: boolean;
 }
-/** Internal coordination surface a `ForDraggable` exposes to its `[forDragHandle]` children. */
+/**
+ * Internal coordination surface a `ForDraggable` / `ForFreeDrag` exposes to its
+ * `[forDragHandle]` children.
+ */
 interface ForDraggableContext {
     /** Register a handle element; while any handle is registered, pointer drags may only start on one. */
     registerHandle(el: HTMLElement): void;
     unregisterHandle(el: HTMLElement): void;
 }
 
+/**
+ * Optional DI seam overriding the fallback `orientation` of every `[forDropList]` in scope.
+ * `ForDropList`'s `orientation` input falls back to this token's value (`'vertical'` when the
+ * token is not provided); a consumer `orientation` binding always wins over it. Wrappers
+ * compose a horizontal list without leaking `orientation="horizontal"` boilerplate into the
+ * consumer's template — `ForTableColumnReorder` provides `'horizontal'` so column reordering
+ * resolves along the row axis out of the box.
+ */
+declare const FOR_DROP_LIST_DEFAULT_ORIENTATION: InjectionToken<"horizontal" | "vertical" | "mixed">;
 /**
  * Root directive of the drag-drop primitive. Apply on any container element to
  * create a reorderable list. Items inside are declared with `[forDraggable]`.
@@ -16863,8 +17638,19 @@ interface ForDraggableContext {
  */
 declare class ForDropList implements ForDropListContext {
     #private;
-    /** Layout orientation of the list. Affects which arrow keys move focus and the lifted item. */
-    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    /**
+     * Layout orientation of the list. Affects which arrow keys move focus and the lifted item, and
+     * how a pointer drag resolves the live drop index. Defaults to `'vertical'`, or to
+     * `FOR_DROP_LIST_DEFAULT_ORIENTATION` when an in-scope provider sets it (e.g.
+     * `ForTableColumnReorder` defaults it to `'horizontal'`).
+     *
+     * `'mixed'` is for wrapping grids (`flex-wrap` / CSS grid) of uniformly-sized items: the drop
+     * index is resolved in 2D so an item flowing across rows lands in the slot under the pointer's
+     * row and column, and every arrow key steps the lifted item linearly in DOM order. A `'mixed'`
+     * list that happens to render as a single row or single column resolves identically to
+     * `'horizontal'` / `'vertical'`.
+     */
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical" | "mixed">;
     /**
      * Writing direction. When unset (default `null`), the inherited ambient direction is
      * resolved from the nearest ancestor carrying a `dir` attribute (or `<html dir>`),
@@ -16892,6 +17678,10 @@ declare class ForDropList implements ForDropListContext {
      * reveal where the item will land. When false (the default), the placeholder stays in the
      * dragged item's source slot (the #806 behaviour). Has no effect without a
      * `[forDragPlaceholder]` template, and none on keyboard dragging.
+     *
+     * A `dragDisabled` sibling acts as a hard fence: the placeholder stops at the first
+     * pinned item instead of travelling past it. This is purely visual — the committed drop
+     * index emitted by `dragDrop` is resolved separately and unaffected.
      */
     readonly liveSort: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
@@ -16944,7 +17734,7 @@ declare class ForDropList implements ForDropListContext {
     pointerLift(el: HTMLElement, point: {
         x: number;
         y: number;
-    }, preview?: {
+    }, preview?: DragPreview | {
         moveTo(x: number, y: number): void;
         destroy(): void;
     } | null): number;
@@ -17001,7 +17791,11 @@ declare class ForDraggable implements ForDraggableContext {
     protected readonly placeholderActive: _angular_core.WritableSignal<boolean>;
     /** Data payload handed back in the `dragDrop` event when this item is dropped. */
     readonly dragData: _angular_core.InputSignal<unknown>;
-    /** When true, this item cannot be lifted. The item remains focusable. */
+    /**
+     * When true, this item cannot be lifted. The item remains focusable. It also acts as a
+     * hard fence for the `liveSort` placeholder: a sibling being dragged cannot move its
+     * placeholder across a pinned item (the committed drop index is unaffected).
+     */
     readonly dragDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Emitted when a drag (keyboard or pointer) starts from this item. */
     readonly dragStart: _angular_core.OutputEmitterRef<ForDragStartEvent>;
@@ -17027,6 +17821,73 @@ declare class ForDraggable implements ForDraggableContext {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDraggable, "[forDraggable]", ["forDraggable"], { "dragData": { "alias": "dragData"; "required": true; "isSignal": true; }; "dragDisabled": { "alias": "dragDisabled"; "required": false; "isSignal": true; }; }, { "dragStart": "dragStart"; "dragEnd": "dragEnd"; }, ["previewTpl", "placeholderTpl"], never, true, never>;
 }
 
+/**
+ * Standalone free-drag directive: repositions its host (or a resolved `rootElement`) by pointer
+ * drag via a CSS `transform: translate(...)`, with **no** `[forDropList]` dependency. Unlike
+ * `[forDraggable]`, it never commits a reorder — it only moves an arbitrary element around,
+ * optionally confined to a `boundary` and locked to one axis. Composes the shared
+ * `createPointerDragSession` transport and accepts `[forDragHandle]` children.
+ *
+ * Pointer-only: there is no WAI-ARIA APG pattern for "freely reposition an element", so this is
+ * a documented headless exception (see `.claude/rules/conventions.md`). It owns no role or ARIA
+ * state and must not destroy the moved element's semantics — the consumer keeps the moved
+ * element operable at its default position (e.g. a repositionable dialog stays usable by
+ * keyboard); dragging is a pointer convenience, not the only way to use it.
+ */
+declare class ForFreeDrag implements ForDraggableContext {
+    #private;
+    /** When true, the element can't be dragged (it stays focusable; the transform doesn't change). */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The element actually moved: an `HTMLElement`, or a selector resolved via `closest()` from the
+     * host. `null` (the default) moves the host itself. Mirrors CDK's `cdkDragRootElement` — drag a
+     * child handle, move an ancestor (e.g. drag a whole dialog by its header).
+     */
+    readonly rootElement: _angular_core.InputSignal<string | HTMLElement | null>;
+    /**
+     * Confine movement within an `HTMLElement`, a `closest()` selector resolved from the host, or
+     * `null` (the default) for unbounded movement. Unlike `[forDropList]`'s boundary (which clamps a
+     * floating clone), this clamps the **real moved element** so its box stays fully inside.
+     */
+    readonly boundary: _angular_core.InputSignal<string | HTMLElement | null>;
+    /**
+     * Constrain movement to one axis. `'x'` pins the element at its lift-time `y` (horizontal-only);
+     * `'y'` pins it at its lift-time `x` (vertical-only). `null` (the default) is free.
+     */
+    readonly lockAxis: _angular_core.InputSignal<"x" | "y" | null>;
+    /** Two-way translate offset (px) from the element's natural position. Controllable / restorable. */
+    readonly position: _angular_core.ModelSignal<{
+        x: number;
+        y: number;
+    }>;
+    /** Emitted when a pointer drag starts, with the lift-time position. */
+    readonly dragStart: _angular_core.OutputEmitterRef<{
+        x: number;
+        y: number;
+    }>;
+    /**
+     * Emitted on every armed move with the live position. (Non-native verb — `dragMove`, not
+     * `drag` / `dragMoved` — so `@angular-eslint/no-output-native` stays clear.)
+     */
+    readonly dragMove: _angular_core.OutputEmitterRef<{
+        x: number;
+        y: number;
+    }>;
+    /** Emitted when the drag ends, with the final position. */
+    readonly dragEnd: _angular_core.OutputEmitterRef<{
+        x: number;
+        y: number;
+    }>;
+    /** True while a pointer drag is armed. Reflected as `data-dragging`. */
+    readonly dragging: _angular_core.Signal<boolean>;
+    protected readonly touchAction: _angular_core.Signal<"none" | null>;
+    constructor();
+    registerHandle(el: HTMLElement): void;
+    unregisterHandle(el: HTMLElement): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForFreeDrag, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForFreeDrag, "[forFreeDrag]", ["forFreeDrag"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "rootElement": { "alias": "rootElement"; "required": false; "isSignal": true; }; "boundary": { "alias": "boundary"; "required": false; "isSignal": true; }; "lockAxis": { "alias": "lockAxis"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, { "position": "positionChange"; "dragStart": "dragStart"; "dragMove": "dragMove"; "dragEnd": "dragEnd"; }, never, never, true, never>;
+}
+
 /**
  * Optional drag handle inside a `[forDraggable]`. When at least one handle is present on an item, a pointer
  * drag may only start from within a handle (keyboard dragging is unaffected). Apply on a child element.
@@ -17699,7 +18560,7 @@ declare class ForStepperProgress {
     protected readonly ctx: forty_cdk.ForStepperContext;
     /**
      * Basis for the reported percent. `'index'` (default) derives progress from
-     * the current step index (matches Ark UI's `Steps.Progress`); `'completed'`
+     * the current step index; `'completed'`
      * derives it from the count of steps whose resolved state is `completed`.
      */
     readonly valueBy: _angular_core.InputSignal<"index" | "completed">;
@@ -17757,7 +18618,7 @@ declare function provideForStepperDefaults(defaults?: Partial<ForStepperDefaults
 type TableMode = 'table' | 'grid' | 'treegrid';
 /** Row-selection mode for `ForTable`. `'none'` disables selection. */
 type TableSelectionMode = 'none' | 'single' | 'multiple';
-/** How a row click mutates selection. `'toggle'` flips it; `'replace'` replaces (modifier-aware), React-Aria semantics. */
+/** How a row click mutates selection. `'toggle'` flips it; `'replace'` replaces (modifier-aware). */
 type TableSelectionBehavior = 'toggle' | 'replace';
 /** Aggregate selection state across the table's selectable rows, for the select-all tri-state. */
 type TableSelectAllState = 'none' | 'some' | 'all';
@@ -17803,6 +18664,12 @@ interface TableVirtualRowNavigation {
      * column)`, scrolling that row into the window first when it is not mounted.
      */
     navigateTo(rowIndex: number, column: number): void;
+    /**
+     * Scroll the virtualizer so the row at the absolute `index` is in the window.
+     * Used by `[forTableRowReorder]` to follow a keyboard reorder target across
+     * the rendered window without taking a direct dependency on `ForTableVirtualized`.
+     */
+    scrollToRow(index: number): void;
 }
 /** Coordination contract owned by `ForTable`, injected by every descendant piece. */
 interface ForTableContext {
@@ -17873,6 +18740,13 @@ interface ForTableContext {
      * targeting an unmounted row are handled by the virtualization bridge.
      */
     registerVirtualNavigation(navigation: TableVirtualRowNavigation | null): void;
+    /**
+     * The currently registered cross-window row-navigation delegate, or `null`
+     * when the table is not virtualized. `[forTableRowReorder]` reads this to gate
+     * keyboard reordering to virtualized tables and to scroll the reorder target
+     * into view, without taking a direct dependency on `ForTableVirtualized`.
+     */
+    readonly virtualRowNavigation: Signal<TableVirtualRowNavigation | null>;
     /**
      * Absolute index of the row currently being pointer-reordered (set by
      * `[forTableRowReorder]` on lift, cleared on release), or `null` when no row is
@@ -17948,7 +18822,7 @@ declare class ForTable implements ForTableContext {
      * The resolved value is reflected to the host `dir` attribute.
      */
     readonly _dirInput: _angular_core.InputSignal<WritingDirection | null>;
-    readonly dir: _angular_core.Signal<WritingDirection>;
+    readonly dir: Signal<WritingDirection>;
     /**
      * True total number of data rows for `aria-rowcount`, e.g. for a server-paged or
      * (later) virtualized table that renders only a window of rows. Defaults to the
@@ -17993,24 +18867,25 @@ declare class ForTable implements ForTableContext {
      * consumer writes through `[(expanded)]`. Ignored outside `treegrid` mode.
      */
     readonly expanded: _angular_core.ModelSignal<readonly unknown[]>;
-    protected readonly headerSize: _angular_core.Signal<ElementBox | null>;
+    protected readonly headerSize: Signal<ElementBox | null>;
     /** Live registered data rows, exposed to `[forTableVirtualized]`'s cross-window navigation bridge. */
-    readonly rows: _angular_core.Signal<readonly ForTableRowHandle[]>;
+    readonly rows: Signal<readonly ForTableRowHandle[]>;
     /**
      * Absolute index of the row currently being pointer-reordered, or `null`. Set by
      * `[forTableRowReorder]` and read by `[forTableVirtualized]` to keep the lifted
      * row mounted across recycling during a drag.
      */
-    readonly reorderingRowIndex: _angular_core.Signal<number | null>;
-    readonly selectAllState: _angular_core.Signal<TableSelectAllState>;
+    readonly reorderingRowIndex: Signal<number | null>;
+    readonly virtualRowNavigation: Signal<TableVirtualRowNavigation | null>;
+    readonly selectAllState: Signal<TableSelectAllState>;
     /**
      * Absolute index of the row that owns the currently roving-focused cell, or `null`
      * when no cell is focused (or the focused row carries no `virtualIndex`). Used by
      * `[forTableVirtualized]` to keep the focused row mounted across recycling.
      */
-    readonly focusedRowIndex: _angular_core.Signal<number | null>;
-    protected readonly rowCountAttr: _angular_core.Signal<number | null>;
-    protected readonly colCountAttr: _angular_core.Signal<number | null>;
+    readonly focusedRowIndex: Signal<number | null>;
+    protected readonly rowCountAttr: Signal<number | null>;
+    protected readonly colCountAttr: Signal<number | null>;
     constructor();
     registerHeaderRow(el: HTMLElement): void;
     setColumnWidth(column: string, width: number): void;
@@ -18186,7 +19061,7 @@ declare class ForTableSelectAll {
     protected readonly ctx: forty_cdk.ForTableContext;
     /** Accessible label for the control (e.g. "Select all rows"). Truthy-only. */
     readonly ariaLabel: _angular_core.InputSignal<string | null>;
-    protected readonly ariaChecked: _angular_core.Signal<"true" | "false" | "mixed">;
+    protected readonly ariaChecked: _angular_core.Signal<"mixed" | "true" | "false">;
     protected readonly dataState: _angular_core.Signal<"checked" | "unchecked" | "indeterminate">;
     protected onClick(): void;
     protected onKeyDown(event: KeyboardEvent): void;
@@ -18215,8 +19090,13 @@ interface TableSortDescriptor {
  * the host attribute; `aria-sort` / `data-sorted` and click / keyboard activation stay
  * on the cell.
  *
- * Cycle: `none → ascending → descending → none` (default).
+ * Cycle (default `firstClickDirection='ascending'`): `none → ascending → descending → none`.
  * With `disableClear`: `none → ascending → descending → ascending`.
+ *
+ * `firstClickDirection='descending'` flips the entry pole, so a freshly activated
+ * column starts descending: `none → descending → ascending → none` (and with
+ * `disableClear`: `none → descending → ascending → descending`) — the descending-first
+ * behavior used by single-always-active sort descriptors.
  */
 declare class ForTableSortHeader {
     #private;
@@ -18236,6 +19116,13 @@ declare class ForTableSortHeader {
      * Useful when clearing the sort is not allowed.
      */
     readonly disableClear: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Direction a previously-unsorted column enters on its first activation (the
+     * `'none' → ?` step of the cycle). Defaults to `'ascending'`. Set to `'descending'`
+     * for descending-first columns. The toggle between the two sorted directions and the
+     * optional `'none'` step (`disableClear`) are unchanged.
+     */
+    readonly firstClickDirection: _angular_core.InputSignal<"ascending" | "descending">;
     /**
      * When `false`, the header is fully inert: no `tabindex`, no `aria-sort`, and click /
      * keyboard handlers are no-ops. Defaults to `true`.
@@ -18257,7 +19144,7 @@ declare class ForTableSortHeader {
     /** Handles Enter and Space keyboard events, forwarding to `activate()`. */
     protected onKeyDown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableSortHeader, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableSortHeader, "[forTableSortHeader]", ["forTableSortHeader"], { "column": { "alias": "column"; "required": true; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "disableClear": { "alias": "disableClear"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; }, { "direction": "directionChange"; "sortChange": "sortChange"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableSortHeader, "[forTableSortHeader]", ["forTableSortHeader"], { "column": { "alias": "column"; "required": true; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "disableClear": { "alias": "disableClear"; "required": false; "isSignal": true; }; "firstClickDirection": { "alias": "firstClickDirection"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; }, { "direction": "directionChange"; "sortChange": "sortChange"; }, never, never, true, never>;
 }
 
 /** Payload of `resizeCommit`: which column was resized and its committed width (px). */
@@ -18278,7 +19165,10 @@ interface TableResizeDescriptor {
  *
  * Reflects `data-resizing` (empty string) while a pointer drag is active. Carries
  * `role="separator"` with `aria-orientation="vertical"` and live `aria-value*`,
- * mirroring `[forPaneResizer]`. The consumer supplies `aria-label`.
+ * mirroring `[forPaneResizer]`. The consumer supplies `aria-label`. Before the first
+ * gesture, `aria-valuenow` falls back to the header-cell width measured once on mount
+ * (browser-only), so a separator with no `[width]` is never announced without a
+ * current value; an explicit `[width]` always takes precedence.
  *
  * @example
  * ```html
@@ -18318,6 +19208,12 @@ declare class ForTableColumnResizer {
     protected readonly ariaValueMax: _angular_core.Signal<number | null>;
     /** Whether a pointer drag is currently active (drives `data-resizing`). */
     protected readonly resizing: _angular_core.Signal<boolean>;
+    /**
+     * Header-cell width measured once on mount (browser-only). Backs `aria-valuenow`
+     * before any explicit `[width]` so the focusable separator never ships without a
+     * current value on the measured-fallback path; an explicit `[width]` still wins.
+     */
+    protected readonly measuredWidth: _angular_core.Signal<number | null>;
     constructor();
     protected onPointerDown(event: PointerEvent): void;
     protected onKeyDown(event: KeyboardEvent): void;
@@ -18346,18 +19242,13 @@ interface TableColumnReorderDescriptor {
  * new column-name order; the consumer applies it to their own column array. **It never
  * reorders columns itself** (BYO-data).
  *
- * Angular cannot fix a host-directive input to a constant, so set
- * `orientation="horizontal"` on this element so the wrapped list resolves drops along
- * the row (horizontal) axis.
+ * The wrapped list defaults to `orientation="horizontal"` (a column reorder is always along
+ * the row axis), so no `orientation` binding is needed. Bind `orientation="vertical"` to
+ * override for the rare case.
  *
  * @example
  * ```html
- * <div
- *   forTableHeaderRow
- *   forTableColumnReorder
- *   orientation="horizontal"
- *   (columnReorder)="columns.set($event.columns)"
- * >
+ * <div forTableHeaderRow forTableColumnReorder (columnReorder)="columns.set($event.columns)">
  *   @for (col of columns(); track col) {
  *     <div forTableHeaderCell [name]="col" forDraggable [dragData]="col">{{ col }}</div>
  *   }
@@ -18422,302 +19313,432 @@ declare class ForTableRowReorder {
 }
 
 /**
- * Configuration for {@link injectVirtualizer}. The consumer owns the data and
- * the DOM; the virtualizer only computes which slice of the data is visible.
+ * Defaults inherited by descendant tables in the surrounding injector scope.
+ * Configure with `provideForTableDefaults`. The shape is a stub today — present
+ * so future per-scope tuning can land without churning the public surface.
  */
-interface VirtualizerOptions {
-    /** Reactive total number of items in the list. */
-    readonly count: Signal<number>;
-    /**
-     * Estimated size, in CSS pixels, of the item at `index` along the scroll
-     * axis (height when vertical, width when horizontal). Used until an item is
-     * measured. Should be a stable function reference.
-     */
-    readonly estimateSize: (index: number) => number;
-    /** Reactive reference to the scroll container element (e.g. a `viewChild`). */
-    readonly scrollElement: Signal<HTMLElement | null>;
-    /** Scroll axis. Defaults to `'vertical'`. */
-    readonly orientation?: 'vertical' | 'horizontal';
-    /**
-     * Number of items to render beyond the visible window on each side, to
-     * reduce blank flashes while scrolling. Defaults to `5`.
-     */
-    readonly overscan?: number;
-    /** Stable key for the item at `index`. Defaults to the index itself. */
-    readonly getItemKey?: (index: number) => string | number;
+interface ForTableDefaults {
 }
-/** A single item in the currently rendered window. */
-interface VirtualItem {
-    /** Index of the item in the full list. */
-    readonly index: number;
-    /** Stable key (from `getItemKey`, or the index). */
-    readonly key: string | number;
-    /** Offset of the item from the start of the scroll container, in pixels. */
-    readonly start: number;
-    /** Size of the item along the scroll axis, in pixels. */
-    readonly size: number;
-}
-/** Reactive handle returned by {@link injectVirtualizer}. */
-interface ForVirtualizer {
-    /** The items in the currently visible window plus overscan. */
-    readonly virtualItems: Signal<readonly VirtualItem[]>;
-    /** Total scroll size of all items, in pixels (drives the spacer element). */
-    readonly totalSize: Signal<number>;
-    /**
-     * The inclusive-exclusive `[firstIndex, lastIndex + 1)` index window currently
-     * rendered (visible window plus overscan), or `[0, 0]` when nothing is rendered.
-     * Plugs straight into a list primitive's `[visibleRange]`-style input (e.g.
-     * `[forCombobox][visibleRange]`) so windowing composes without the consumer
-     * re-deriving the range from {@link ForVirtualizer.virtualItems}.
-     */
-    readonly range: Signal<readonly [number, number]>;
-    /** Scroll the container so the item at `index` is in view. */
-    scrollToIndex(index: number, options?: {
-        align?: 'start' | 'center' | 'end' | 'auto';
-    }): void;
-    /** Scroll the container to an absolute pixel offset. */
-    scrollToOffset(offset: number): void;
-    /** Record the measured size of a rendered item element (dynamic sizes). */
-    measureElement(element: HTMLElement): void;
+/** Token holding the resolved table defaults for the current scope. */
+declare const FOR_TABLE_DEFAULTS: _angular_core.InjectionToken<ForTableDefaults>;
+/**
+ * Configures forty-cdk table defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library
+ * defaults at the root).
+ */
+declare function provideForTableDefaults(defaults?: Partial<ForTableDefaults>): Provider[];
+
+/**
+ * One entry in the computed visible-page list: either a clickable page number
+ * or an ellipsis gap standing in for a collapsed run of pages.
+ */
+interface PaginationItem {
+    /** Discriminator: a real page button, or a non-interactive ellipsis gap. */
+    readonly type: 'page' | 'ellipsis';
+    /** 1-based page number. Present only when `type` is `'page'`. */
+    readonly value?: number;
 }
+
 /**
- * Headless windowing core: given a reactive item count, a size estimator and a
- * scroll container, returns the slice of items currently visible (plus
- * overscan), the total scroll size, and imperative scroll/measure helpers. The
- * consumer renders the items with their own `@for` and applies the position
- * transform — this primitive owns no DOM.
- *
- * Backed by `@tanstack/virtual-core`. SSR-safe: off-browser it returns an empty
- * window and the estimate-based total without touching `document`/`window`; the
- * first real window is produced after the first browser render.
- *
- * Must be called from an injection context (a component/directive constructor
- * or field initializer).
- *
- * @param options Reactive count, size estimator, scroll element and tuning.
- * @returns A {@link ForVirtualizer} handle of signals + imperative methods.
+ * Coordination contract owned by `ForPagination`. Page buttons, previous, and
+ * next pieces inject it to read the current page / derived list and drive
+ * navigation from a single source of truth.
  */
-declare function injectVirtualizer(options: VirtualizerOptions): ForVirtualizer;
+interface ForPaginationContext {
+    /** Current 1-based page. */
+    readonly page: Signal<number>;
+    /** Total number of pages. */
+    readonly count: Signal<number>;
+    /** Whether the whole control is disabled. */
+    readonly disabled: Signal<boolean>;
+    /** The computed visible-page list (page numbers + ellipsis gaps). */
+    readonly items: Signal<readonly PaginationItem[]>;
+    /** Whether the current page is the first (no previous page). */
+    readonly isFirst: Signal<boolean>;
+    /** Whether the current page is the last (no next page). */
+    readonly isLast: Signal<boolean>;
+    /** Navigate to `page`, clamped to `[1, count]`. No-op when disabled. */
+    goToPage(page: number): void;
+    /** Navigate to the previous page. No-op at the first page or when disabled. */
+    previous(): void;
+    /** Navigate to the next page. No-op at the last page or when disabled. */
+    next(): void;
+}
+/** DI token providing the pagination context to descendant pieces. */
+declare const FOR_PAGINATION_CONTEXT: InjectionToken<ForPaginationContext>;
 
 /**
- * Opt-in row-virtualization companion for `[forTable]` in `<div role>` grid mode. Place it on the
- * same element as `[forTable]`; it builds the windowing core from the table's `[rowCount]` and
- * exposes the visible window for the consumer to render with their own `@for` + position transform.
+ * Headless pagination navigation landmark, implementing the
+ * [WAI-ARIA `navigation` landmark](https://www.w3.org/WAI/ARIA/apg/patterns/landmarks/examples/navigation.html)
+ * with [`aria-current="page"`](https://www.w3.org/TR/wai-aria-1.2/#aria-current) on the active page.
  *
- * Tree-shakeable: `ForTable` never imports the virtualization core — only consumers that import
- * `ForTableVirtualized` bundle `@tanstack/virtual-core`.
+ * Derives the visible page list (with ellipsis gaps) from `page`, `count`,
+ * `siblingCount`, and `boundaryCount`. Exposes `items()`, `isFirst()`,
+ * `isLast()`, and navigation methods for the consumer template to render.
  *
- * The focused row is kept mounted even when scrolled out of the window so the roving-focused
- * `gridcell` is never unmounted (React Aria pattern). SSR-safe: off-browser the window is empty and
- * `totalSize` is the estimate-based total.
+ * There is no roving tabindex — each page button, previous, and next are their
+ * own tab stops. RTL is visual-only: the resolved `dir` reflects on the host
+ * for CSS; navigation semantics (previous = decrement, next = increment) never
+ * change based on direction.
  *
- * Also drives cross-window keyboard navigation: when an Arrow / Page / Ctrl+Home / Ctrl+End grid
- * action resolves a row outside the rendered window, it scrolls that row into view and moves roving
- * focus onto the target cell once it mounts (preserving the current column). `ForTable` stays
- * unaware of virtualization — it delegates the row-crossing move through the table context.
+ * @example
+ * ```html
+ * <nav forPagination [(page)]="page" [count]="20" ariaLabel="Pagination" #pg="forPagination">
+ *   <button forPaginationPrevious ariaLabel="Previous page">‹</button>
+ *   @for (item of pg.items(); track $index) {
+ *     @if (item.type === 'page') {
+ *       <button forPaginationItem [page]="item.value!">{{ item.value }}</button>
+ *     } @else {
+ *       <span aria-hidden="true">…</span>
+ *     }
+ *   }
+ *   <button forPaginationNext ariaLabel="Next page">›</button>
+ * </nav>
+ * ```
  */
-declare class ForTableVirtualized {
+declare class ForPagination implements ForPaginationContext {
     #private;
-    /** Estimated row size in px along the scroll axis (the fixed-size fast path). Read for the size estimate. */
-    readonly estimateRowSize: _angular_core.InputSignalWithTransform<number, unknown>;
-    /** Scroll container. Defaults to the table root element (the scroll container in `<div>` grid mode). */
-    readonly scrollElement: _angular_core.InputSignal<HTMLElement | null>;
-    constructor();
     /**
-     * The rows in the visible window plus overscan, augmented to always include the focused row and
-     * the row being reordered even when they are scrolled out of view (so the roving-focused cell
-     * stays mounted, and a pointer reorder drag never unmounts the lifted row). Render these with
-     * `@for (vrow of v.virtualRows(); track vrow.index)` and position each row absolutely with
-     * `transform: translateY(vrow.start + 'px')`. Bind each row's `[virtualIndex]="vrow.index"`.
+     * Current 1-based page number. Two-way bindable via `[(page)]`. The implicit
+     * `pageChange` output emits whenever the directive updates this value (via
+     * clicks, previous, or next). Do not add a separate `pageChange` output.
      */
-    readonly virtualRows: _angular_core.Signal<readonly VirtualItem[]>;
-    /** Total scroll size of all rows in px. Bind to the body container's height to size the scroll range. */
-    readonly totalSize: _angular_core.Signal<number>;
+    readonly page: _angular_core.ModelSignal<number>;
     /**
-     * Scroll the container so the row at `index` is in view. Cross-window keyboard
-     * navigation calls this internally; consumers may also call it to scroll
-     * programmatically.
+     * Total number of pages. Always bind as `[count]="n"` (a number, not a
+     * string). Required.
      */
-    scrollToRow(index: number, options?: {
-        align?: 'start' | 'center' | 'end' | 'auto';
-    }): void;
-    /** Record the measured size of a rendered row element (dynamic / measured row heights). */
-    measureRow(element: HTMLElement): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableVirtualized, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableVirtualized, "[forTableVirtualized]", ["forTableVirtualized"], { "estimateRowSize": { "alias": "estimateRowSize"; "required": false; "isSignal": true; }; "scrollElement": { "alias": "scrollElement"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    readonly count: _angular_core.InputSignal<number>;
+    /**
+     * Pages shown on each side of the current page before collapsing to an
+     * ellipsis. Default read from `provideForPaginationDefaults` for the
+     * surrounding scope (library fallback: `1`).
+     */
+    readonly siblingCount: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Pages always shown at each end (first and last). Default read from
+     * `provideForPaginationDefaults` for the surrounding scope (library
+     * fallback: `1`).
+     */
+    readonly boundaryCount: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Whether the entire pagination control is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * 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. RTL affects
+     * visual layout only — previous/next semantics do not change.
+     */
+    readonly _dirInput: _angular_core.InputSignal<WritingDirection | null>;
+    readonly dir: _angular_core.Signal<WritingDirection>;
+    /**
+     * Accessible label for the navigation landmark. Supply this (or point
+     * `aria-labelledby` at a visible label element) when the page contains more
+     * than one `<nav>`. A `null` or empty value emits no attribute.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /** The computed visible-page list (page numbers + ellipsis gaps). */
+    readonly items: _angular_core.Signal<readonly PaginationItem[]>;
+    /** Whether the current page is the first (no previous page). */
+    readonly isFirst: _angular_core.Signal<boolean>;
+    /** Whether the current page is the last (no next page). */
+    readonly isLast: _angular_core.Signal<boolean>;
+    /**
+     * Navigate to `page`, clamped to `[1, count]`. No-op when disabled.
+     */
+    goToPage(page: number): void;
+    /** Navigate to the previous page. No-op at the first page or when disabled. */
+    previous(): void;
+    /** Navigate to the next page. No-op at the last page or when disabled. */
+    next(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForPagination, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForPagination, "[forPagination]", ["forPagination"], { "page": { "alias": "page"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": true; "isSignal": true; }; "siblingCount": { "alias": "siblingCount"; "required": false; "isSignal": true; }; "boundaryCount": { "alias": "boundaryCount"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "_dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "page": "pageChange"; }, never, never, true, never>;
 }
 
 /**
- * Defaults inherited by descendant tables in the surrounding injector scope.
- * Configure with `provideForTableDefaults`. The shape is a stub today — present
- * so future per-scope tuning can land without churning the public surface.
+ * Page number button. Apply on a `<button>` so Enter/Space activation is
+ * native. Reflects `aria-current="page"` when this button represents the
+ * currently active page. Clicking calls `ctx.goToPage(page)`.
  */
-interface ForTableDefaults {
+declare class ForPaginationItem {
+    protected readonly ctx: forty_cdk.ForPaginationContext;
+    /** The 1-based page number this button navigates to. */
+    readonly page: _angular_core.InputSignal<number>;
+    /** Per-item disabled override (in addition to the root's `disabled`). */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether this item is effectively disabled (own or root disabled). */
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    /** Whether this button represents the currently active page. */
+    readonly isCurrent: _angular_core.Signal<boolean>;
+    constructor();
+    protected activate(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForPaginationItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForPaginationItem, "[forPaginationItem]", ["forPaginationItem"], { "page": { "alias": "page"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
-/** Token holding the resolved table defaults for the current scope. */
-declare const FOR_TABLE_DEFAULTS: _angular_core.InjectionToken<ForTableDefaults>;
+
 /**
- * Configures forty-cdk table defaults for this injector scope. Partial
- * overrides inherit unspecified keys from the parent scope (or library
- * defaults at the root).
+ * Previous-page button. Apply on a `<button>` so Enter/Space activation is
+ * native. Disabled (via the native `disabled` attribute) when the current page
+ * is the first page or the root is disabled. Clicking calls `ctx.previous()`.
  */
-declare function provideForTableDefaults(defaults?: Partial<ForTableDefaults>): Provider[];
+declare class ForPaginationPrevious {
+    protected readonly ctx: forty_cdk.ForPaginationContext;
+    /**
+     * Accessible label for this button (e.g. "Previous page"). When `null`
+     * (default), no `aria-label` is emitted — the consumer should supply a
+     * visible label or set this input.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForPaginationPrevious, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForPaginationPrevious, "[forPaginationPrevious]", ["forPaginationPrevious"], { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
 
 /**
- * Configuration for {@link injectInfiniteScroll}. The consumer owns the data and
- * the fetch; this core only decides *when* to ask for more.
+ * Next-page button. Apply on a `<button>` so Enter/Space activation is
+ * native. Disabled (via the native `disabled` attribute) when the current page
+ * is the last page or the root is disabled. Clicking calls `ctx.next()`.
  */
-interface InfiniteScrollOptions {
+declare class ForPaginationNext {
+    protected readonly ctx: forty_cdk.ForPaginationContext;
     /**
-     * The rendered window, `[firstIndex, lastIndex + 1)` — e.g.
-     * `injectVirtualizer(...).range`. An empty `[0, 0]` window never fires.
+     * Accessible label for this button (e.g. "Next page"). When `null`
+     * (default), no `aria-label` is emitted — the consumer should supply a
+     * visible label or set this input.
      */
-    readonly range: Signal<readonly [number, number]>;
-    /** Reactive total number of currently-loaded items. */
-    readonly count: Signal<number>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForPaginationNext, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForPaginationNext, "[forPaginationNext]", ["forPaginationNext"], { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Defaults inherited by descendant paginations in the surrounding injector
+ * scope. Configure with `provideForPaginationDefaults` at the application root
+ * or in any component's `providers`; partial overrides merge with the parent.
+ */
+interface ForPaginationDefaults {
+    /** Pages shown on each side of the current page before collapsing to an ellipsis. */
+    siblingCount: number;
+    /** Pages always shown at each end (first/last). */
+    boundaryCount: number;
+}
+/** Token holding the resolved pagination defaults for the current scope. */
+declare const FOR_PAGINATION_DEFAULTS: _angular_core.InjectionToken<ForPaginationDefaults>;
+/**
+ * Configures forty-cdk pagination defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library defaults
+ * at the root).
+ */
+declare function provideForPaginationDefaults(defaults?: Partial<ForPaginationDefaults>): Provider[];
+
+/**
+ * Headless breadcrumb trail implementing the
+ * [WAI-ARIA Breadcrumb pattern](https://www.w3.org/WAI/ARIA/apg/patterns/breadcrumb/):
+ * a `navigation` landmark wrapping a set of links that reveal the page's
+ * position within the site hierarchy.
+ *
+ * The directive contributes only the landmark role + accessible name; the
+ * consumer owns the markup structure (an `<ol>` of `<li>` links is the APG
+ * recommendation) and applies their own styles. Each link decorated with
+ * `[forBreadcrumbItem]` can mark itself the current page via `current`, and
+ * visual dividers decorated with `[forBreadcrumbSeparator]` are hidden from
+ * assistive technology.
+ *
+ * There is no keyboard interaction or focus management beyond what the native
+ * links provide — breadcrumb links are ordinary tab stops.
+ *
+ * @example
+ * ```html
+ * <nav forBreadcrumbs>
+ *   <ol>
+ *     <li><a forBreadcrumbItem href="/">Home</a></li>
+ *     <li forBreadcrumbSeparator aria-hidden="true">/</li>
+ *     <li><a forBreadcrumbItem href="/library">Library</a></li>
+ *     <li forBreadcrumbSeparator aria-hidden="true">/</li>
+ *     <li><a forBreadcrumbItem href="/library/data" current>Data</a></li>
+ *   </ol>
+ * </nav>
+ * ```
+ */
+declare class ForBreadcrumbs {
     /**
-     * Fire when the window's last index comes within this many items of `count`.
-     * Defaults to `5` (mirrors the windowing core's default overscan).
+     * Accessible label for the navigation landmark. Defaults to `'Breadcrumb'`
+     * so a bare `<nav forBreadcrumbs>` is already a correctly labelled landmark —
+     * the conventional name for this pattern. Override it (or point a native
+     * `aria-labelledby` at a visible heading) when the page hosts more than one
+     * breadcrumb trail and they need to be told apart.
      */
-    readonly threshold?: number;
-    /** When this resolves to `true` the detector never fires. */
-    readonly disabled?: Signal<boolean>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForBreadcrumbs, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForBreadcrumbs, "[forBreadcrumbs]", ["forBreadcrumbs"], { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A single link within a breadcrumb trail. Apply on an `<a>` so navigation is
+ * native. Set `current` on the link that points to the page the user is on —
+ * it reflects [`aria-current="page"`](https://www.w3.org/TR/wai-aria-1.2/#aria-current)
+ * so assistive technology announces it as the current location.
+ */
+declare class ForBreadcrumbItem {
     /**
-     * Called once per threshold crossing. If it returns a promise, the next fire
-     * is suppressed until that promise settles (`pending` reflects the in-flight
-     * state); the detector re-arms when `count` grows.
+     * Whether this item represents the page the user is currently on. The
+     * current item reflects `aria-current="page"`; all others emit no
+     * `aria-current` attribute.
      */
-    readonly onLoadMore: () => void | Promise<unknown>;
+    readonly current: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForBreadcrumbItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForBreadcrumbItem, "[forBreadcrumbItem]", ["forBreadcrumbItem"], { "current": { "alias": "current"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
-/** Reactive handle returned by {@link injectInfiniteScroll}. */
-interface ForInfiniteScroll {
-    /** True while an `onLoadMore` promise is in flight. */
-    readonly pending: Signal<boolean>;
+
+/**
+ * Decorative divider rendered between breadcrumb items (a `/`, `>`, chevron,
+ * etc.). Reflects `aria-hidden="true"` so assistive technology skips it — the
+ * trail's structure is already conveyed by the list and the links, making the
+ * visual separator redundant in the accessibility tree.
+ */
+declare class ForBreadcrumbSeparator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForBreadcrumbSeparator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForBreadcrumbSeparator, "[forBreadcrumbSeparator]", ["forBreadcrumbSeparator"], {}, {}, never, never, true, never>;
 }
+
 /**
- * Headless infinite-scroll detector: composes on top of any windowed list's
- * `range` + `count` signals and fires `onLoadMore` once per threshold crossing,
- * suppressing re-fire while a returned promise is pending and re-arming when
- * `count` grows (a page was appended). It owns no DOM, adds no scroll listener —
- * the trigger rides the existing reactive recompute — and is SSR-safe by
- * construction: off-browser the window is `[0, 0]`, so it never fires.
- *
- * Must be called from an injection context (a component/directive constructor
- * or field initializer).
- *
- * @param options Reactive `range` + `count`, an optional `threshold`/`disabled`,
- *   and the `onLoadMore` callback.
- * @returns A {@link ForInfiniteScroll} handle exposing the `pending` signal.
+ * Defaults inherited by descendant breadcrumbs in the surrounding injector
+ * scope. Configure with `provideForBreadcrumbsDefaults`. The shape is a stub
+ * today — present so future per-scope tuning can land without churning the
+ * public surface.
+ */
+interface ForBreadcrumbsDefaults {
+}
+/** Token holding the resolved breadcrumbs defaults for the current scope. */
+declare const FOR_BREADCRUMBS_DEFAULTS: _angular_core.InjectionToken<ForBreadcrumbsDefaults>;
+/**
+ * Configures forty-cdk breadcrumbs defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library
+ * defaults at the root).
  */
-declare function injectInfiniteScroll(options: InfiniteScrollOptions): ForInfiniteScroll;
+declare function provideForBreadcrumbsDefaults(defaults?: Partial<ForBreadcrumbsDefaults>): Provider[];
 
 /**
- * Coordination surface a {@link ForVirtualViewport} exposes to the
- * `*forVirtualFor` structural directive nested inside it.
+ * Shared state contract between the pieces of a FileUpload primitive.
+ * Provided by `ForFileUpload`, consumed by `ForFileUploadInput` and
+ * `ForFileUploadTrigger`.
  */
-interface ForVirtualViewportContext {
-    /** The items in the currently visible window plus overscan. */
-    readonly virtualItems: Signal<readonly VirtualItem[]>;
-    /** The total number of items in the full (non-windowed) list. */
-    readonly count: Signal<number>;
-    /** Scroll axis, resolved once when the viewport initializes. */
-    readonly orientation: Signal<'vertical' | 'horizontal'>;
+interface ForFileUploadContext {
+    readonly accept: Signal<string | null>;
+    readonly multiple: Signal<boolean>;
+    readonly directory: Signal<boolean>;
+    readonly disabled: Signal<boolean>;
+    /** Registers the native `<input type="file">` so the root can open the dialog and sync dropped files. */
+    registerInput(el: HTMLInputElement): void;
+    /** Opens the native file chooser dialog by programmatically clicking the registered input. */
+    openFileDialog(): void;
+    /** Emits `filesChange` with the given `FileList` if it is non-empty. */
+    emitFiles(files: FileList): void;
 }
-/** DI token carrying the {@link ForVirtualViewportContext}. */
-declare const FOR_VIRTUAL_VIEWPORT_CONTEXT: InjectionToken<ForVirtualViewportContext>;
+declare const FOR_FILE_UPLOAD_CONTEXT: InjectionToken<ForFileUploadContext>;
 
 /**
- * Scroll viewport for the ergonomic virtualization layer. Decorate a fixed-size
- * scroll container with `[forVirtualViewport]`, give it `[virtualCount]` and an
- * `[estimateSize]`, and nest a single `*forVirtualFor` inside it — the viewport
- * owns the scroll container, the total-size sizer, and the windowing core, so
- * the consumer writes no manual spacer or position transform.
- *
- * Built on the headless {@link injectVirtualizer} core; for full manual control
- * (custom DOM, dynamic measurement, window/document scroller) use that directly.
+ * Root drop zone for the FileUpload primitive. Composes with
+ * `[forFileUploadInput]` (the accessible native file input) and
+ * `[forFileUploadTrigger]` (the button that opens the dialog).
  *
- * The viewport forces `overflow: auto` on its host and renders a relatively
- * positioned sizer whose main-axis size tracks `totalSize()`; `*forVirtualFor`
- * projects its rows into that sizer and positions each one absolutely.
+ * `filesChange` is a plain `output<FileList>()` — this primitive is not a
+ * Signal Forms control; the native `<input type="file">` is the form participant.
  *
- * `orientation` and `overscan` are read once when the viewport initializes;
- * change them before first render, not at runtime.
+ * Reflects `data-dragging` while files are dragged over the zone and
+ * `data-disabled` when the input is disabled.
  */
-declare class ForVirtualViewport implements ForVirtualViewportContext, OnInit {
+declare class ForFileUpload implements ForFileUploadContext {
     #private;
-    /** Total number of items in the full list. */
-    readonly virtualCount: _angular_core.InputSignal<number>;
-    /** Estimated item size in px along the scroll axis: a number or a per-index estimator. */
-    readonly estimateSize: _angular_core.InputSignal<number | ((index: number) => number)>;
-    /** Scroll axis. Resolved once on init; runtime changes are not tracked by the core. */
-    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
-    /** Items rendered beyond the visible window on each side. Resolved once on init. */
-    readonly overscan: _angular_core.InputSignal<number>;
-    /** Stable key for the item at `index`. Defaults to the index. */
-    readonly getItemKey: _angular_core.InputSignal<((index: number) => string | number) | undefined>;
-    /**
-     * Emits when the rendered window comes within ~`overscan` items of the end of
-     * the list, signalling the consumer to load the next page. Built on
-     * {@link injectInfiniteScroll}; fires once per threshold crossing and re-arms
-     * when the bound count grows. The consumer owns the fetch (e.g. via `resource()`).
-     */
-    readonly endReached: _angular_core.OutputEmitterRef<void>;
-    /** The total number of items in the full (non-windowed) list. */
-    readonly count: Signal<number>;
-    /** The items in the currently visible window plus overscan. */
-    readonly virtualItems: Signal<readonly VirtualItem[]>;
-    /** Total scroll size of all items, in pixels (drives the sizer). */
-    readonly totalSize: Signal<number>;
-    protected readonly sizerWidth: Signal<string>;
-    protected readonly sizerHeight: Signal<string>;
-    ngOnInit(): void;
-    /** Scroll the container so the item at `index` is in view. No-op until initialized. */
-    scrollToIndex(index: number, options?: {
-        align?: 'start' | 'center' | 'end' | 'auto';
-    }): void;
-    /** Scroll the container to an absolute pixel offset. No-op until initialized. */
-    scrollToOffset(offset: number): void;
-    /** Record the measured size of a rendered item element. No-op until initialized. */
-    measureElement(element: HTMLElement): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForVirtualViewport, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ForVirtualViewport, "for-virtual-viewport, [forVirtualViewport]", ["forVirtualViewport"], { "virtualCount": { "alias": "virtualCount"; "required": true; "isSignal": true; }; "estimateSize": { "alias": "estimateSize"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "overscan": { "alias": "overscan"; "required": false; "isSignal": true; }; "getItemKey": { "alias": "getItemKey"; "required": false; "isSignal": true; }; }, { "endReached": "endReached"; }, never, ["*"], true, never>;
-}
-
-/** Template context exposed to each row rendered by `*forVirtualFor`. */
-interface ForVirtualForContext<T> {
-    /** The row data at this index (`let row`). */
-    $implicit: T;
-    /** The virtual item metadata: index, key, start offset, size (`let item = virtualItem`). */
-    virtualItem: VirtualItem;
-    /** The item's index in the full list (`let i = index`). */
-    index: number;
-    /** The total number of items in the full list (`let n = count`). */
-    count: number;
-}
-/**
- * Structural directive that renders only the visible window of a list inside a
- * `[forVirtualViewport]`. Pass the full data array; the directive iterates the
- * viewport's `virtualItems()`, exposes each row plus its `virtualItem` to the
- * template, positions it absolutely (so the consumer writes no transform), and
- * binds `aria-setsize` (true total) / `aria-posinset` (`index + 1`) so screen
- * readers announce the real list size.
+    /** MIME types or file extensions accepted by the file chooser (e.g. `"image/*,.pdf"`). */
+    readonly accept: _angular_core.InputSignal<string | null>;
+    /** Whether multiple files can be selected at once. */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * When `true`, the native picker selects a whole folder; the emitted
+     * `FileList` then contains every file inside it (each carrying a
+     * `webkitRelativePath` so the consumer can reconstruct the tree).
+     */
+    readonly directory: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the file upload zone and all its pieces are disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emitted when files are chosen via the dialog or dropped onto the zone. */
+    readonly filesChange: _angular_core.OutputEmitterRef<FileList>;
+    protected readonly dragging: _angular_core.Signal<boolean>;
+    /** Registers the native input so the root can open the dialog and sync dropped files. */
+    registerInput(el: HTMLInputElement): void;
+    /** Opens the native file chooser dialog if not disabled. */
+    openFileDialog(): void;
+    /** Emits `filesChange` with the provided `FileList` if it contains at least one file. */
+    emitFiles(files: FileList): void;
+    protected onDragEnter(event: DragEvent): void;
+    protected onDragOver(event: DragEvent): void;
+    protected onDragLeave(): void;
+    protected onDrop(event: DragEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForFileUpload, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForFileUpload, "[forFileUpload]", ["forFileUpload"], { "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "directory": { "alias": "directory"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "filesChange": "filesChange"; }, never, never, true, never>;
+}
+
+/**
+ * The native `<input type="file">` piece of the FileUpload primitive.
+ * Apply on a real `<input>` element inside `[forFileUpload]`.
+ *
+ * The directive forces `type="file"` and mirrors `accept`, `multiple`,
+ * `directory` (as `webkitdirectory`), and `disabled` from the root context.
+ * When the user selects files via the native dialog the `change` event emits
+ * `filesChange` on the root.
+ *
+ * Consumers are expected to visually hide this input with their own CSS
+ * (e.g. an `sr-only` / `visually-hidden` utility) while keeping it focusable
+ * so keyboard users and assistive technology can activate it directly. The
+ * directive never sets `hidden`, `display:none`, or `visibility:hidden` — it
+ * remains strictly headless.
+ */
+declare class ForFileUploadInput {
+    #private;
+    protected readonly ctx: forty_cdk.ForFileUploadContext;
+    constructor();
+    protected onChange(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForFileUploadInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForFileUploadInput, "input[forFileUploadInput]", ["forFileUploadInput"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Trigger button that opens the native file chooser dialog.
+ * Apply on a native `<button>` inside `[forFileUpload]`.
  *
- * ```html
- * <div forVirtualViewport [virtualCount]="rows().length" [estimateSize]="44">
- *   <div *forVirtualFor="let row of rows(); let item = virtualItem">{{ row.label }}</div>
- * </div>
- * ```
+ * `type="button"` is forced to prevent accidental form submission.
+ * The native `disabled` attribute is reflected imperatively so the button
+ * is visually and functionally disabled when the root zone is disabled.
  */
-declare class ForVirtualFor<T> {
-    #private;
-    /** The full list of items to virtualize. */
-    readonly forVirtualForOf: _angular_core.InputSignal<readonly T[]>;
+declare class ForFileUploadTrigger {
+    protected readonly ctx: forty_cdk.ForFileUploadContext;
     constructor();
-    /** Narrows the template context type for `let row of …` strict template checking. */
-    static ngTemplateContextGuard<T>(_directive: ForVirtualFor<T>, _context: unknown): _context is ForVirtualForContext<T>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForVirtualFor<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForVirtualFor<any>, "[forVirtualFor][forVirtualForOf]", never, { "forVirtualForOf": { "alias": "forVirtualForOf"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForFileUploadTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForFileUploadTrigger, "[forFileUploadTrigger]", ["forFileUploadTrigger"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Defaults inherited by descendant file-upload zones in the surrounding
+ * injector scope. Configure with `provideForFileUploadDefaults`. The shape
+ * is a stub today — present so future per-scope tuning can land without
+ * churning the public surface.
+ */
+interface ForFileUploadDefaults {
 }
+/** Token holding the resolved file-upload defaults for the current scope. */
+declare const FOR_FILE_UPLOAD_DEFAULTS: _angular_core.InjectionToken<ForFileUploadDefaults>;
+/**
+ * Configures forty-cdk file-upload defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library
+ * defaults at the root).
+ */
+declare function provideForFileUploadDefaults(defaults?: Partial<ForFileUploadDefaults>): Provider[];
 
-export { DEFAULT_DATE_FIELD_SEGMENT_LABELS, DEFAULT_TIME_FIELD_SEGMENT_LABELS, DEFAULT_TOAST_REGION, FOR_ACCORDION_CONTEXT, FOR_ACCORDION_DEFAULTS, FOR_ACCORDION_ITEM_CONTEXT, FOR_ASPECT_RATIO_DEFAULTS, FOR_AVATAR_CONTEXT, FOR_AVATAR_DEFAULTS, FOR_CALENDAR_CONTEXT, FOR_CALENDAR_DEFAULTS, FOR_CAROUSEL_CONTEXT, FOR_CAROUSEL_DEFAULTS, FOR_CHECKBOX, FOR_CHECKBOX_DEFAULTS, FOR_CHECKBOX_HOST_DIRECTIVE_INPUTS, FOR_CHECKBOX_HOST_DIRECTIVE_OUTPUTS, FOR_COMBOBOX_CONTEXT, FOR_COMBOBOX_DEFAULTS, FOR_COMBOBOX_HOST_DIRECTIVE_INPUTS, FOR_COMBOBOX_HOST_DIRECTIVE_OUTPUTS, FOR_COMBOBOX_OPTION, FOR_CONTEXT_MENU_CONTEXT, FOR_CONTEXT_MENU_DEFAULTS, FOR_DATE_ADAPTER, FOR_DATE_FIELD_CONTEXT, FOR_DATE_FIELD_DEFAULTS, FOR_DATE_FIELD_HOST_DIRECTIVE_INPUTS, FOR_DATE_FIELD_HOST_DIRECTIVE_OUTPUTS, FOR_DATE_PICKER_CONTEXT, FOR_DATE_PICKER_DEFAULTS, FOR_DATE_PICKER_HOST_DIRECTIVE_INPUTS, FOR_DATE_PICKER_HOST_DIRECTIVE_OUTPUTS, FOR_DIALOG_CONTEXT, FOR_DIALOG_DATA, FOR_DIALOG_DEFAULTS, FOR_DISCLOSURE_CONTEXT, FOR_DISCLOSURE_DEFAULTS, FOR_DRAG_DROP_CONTEXT, FOR_DRAG_DROP_DEFAULTS, FOR_DRAWER_CONTEXT, FOR_DRAWER_DATA, FOR_DRAWER_DEFAULTS, FOR_DROPDOWN_MENU_DEFAULTS, FOR_DROP_LIST_GROUP, FOR_FIELDSET_CONTEXT, FOR_FIELDSET_DEFAULTS, FOR_FIELD_CONTEXT, FOR_FIELD_DEFAULTS, FOR_HOVER_CARD_CONTEXT, FOR_HOVER_CARD_DEFAULTS, FOR_ID_SALT, FOR_INPUT_DEFAULTS, FOR_INPUT_HOST_DIRECTIVE_INPUTS, FOR_INPUT_HOST_DIRECTIVE_OUTPUTS, FOR_LISTBOX_CONTEXT, FOR_LISTBOX_DEFAULTS, FOR_LISTBOX_HOST_DIRECTIVE_INPUTS, FOR_LISTBOX_HOST_DIRECTIVE_OUTPUTS, FOR_LISTBOX_OPTION, FOR_MENUBAR_CONTEXT, FOR_MENUBAR_DEFAULTS, FOR_MENU_CHECKBOX_ITEM, FOR_MENU_CONTEXT, FOR_MENU_DEFAULTS, FOR_MENU_GROUP_CONTEXT, FOR_MENU_RADIO_GROUP_CONTEXT, FOR_MENU_RADIO_ITEM, FOR_METER_CONTEXT, FOR_METER_DEFAULTS, FOR_NAVIGATION_MENU_CONTEXT, FOR_NAVIGATION_MENU_DEFAULTS, FOR_NAVIGATION_MENU_ITEM_CONTEXT, FOR_NUMBER_INPUT_DEFAULTS, FOR_NUMBER_INPUT_GROUP, FOR_NUMBER_INPUT_HOST_DIRECTIVE_INPUTS, FOR_NUMBER_INPUT_HOST_DIRECTIVE_OUTPUTS, FOR_OTP_INPUT_CONTEXT, FOR_OTP_INPUT_DEFAULTS, FOR_OTP_INPUT_HOST_DIRECTIVE_INPUTS, FOR_OTP_INPUT_HOST_DIRECTIVE_OUTPUTS, FOR_PANE_RESIZER_DEFAULTS, FOR_POPOVER_CONTEXT, FOR_POPOVER_DEFAULTS, FOR_PROGRESS_CONTEXT, FOR_PROGRESS_DEFAULTS, FOR_RADIO, FOR_RADIO_GROUP_CONTEXT, FOR_RADIO_GROUP_DEFAULTS, FOR_RADIO_GROUP_HOST_DIRECTIVE_INPUTS, FOR_RADIO_GROUP_HOST_DIRECTIVE_OUTPUTS, FOR_SCROLL_AREA_CONTEXT, FOR_SCROLL_AREA_DEFAULTS, FOR_SELECT_CONTEXT, FOR_SELECT_DEFAULTS, FOR_SELECT_HOST_DIRECTIVE_INPUTS, FOR_SELECT_HOST_DIRECTIVE_OUTPUTS, FOR_SELECT_OPTION, FOR_SEPARATOR_DEFAULTS, FOR_SLIDER_CONTEXT, FOR_SLIDER_DEFAULTS, FOR_SLIDER_HOST_DIRECTIVE_INPUTS, FOR_SLIDER_HOST_DIRECTIVE_OUTPUTS, FOR_STEPPER_CONTEXT, FOR_STEPPER_DEFAULTS, FOR_STEPPER_ITEM_CONTEXT, FOR_SWITCH_DEFAULTS, FOR_SWITCH_HOST_DIRECTIVE_INPUTS, FOR_SWITCH_HOST_DIRECTIVE_OUTPUTS, FOR_TABLE_CONTEXT, FOR_TABLE_DEFAULTS, FOR_TABS_CONTEXT, FOR_TABS_DEFAULTS, FOR_TEXTAREA_HOST_DIRECTIVE_INPUTS, FOR_TEXTAREA_HOST_DIRECTIVE_OUTPUTS, FOR_TIME_FIELD_CONTEXT, FOR_TIME_FIELD_DEFAULTS, FOR_TIME_FIELD_HOST_DIRECTIVE_INPUTS, FOR_TIME_FIELD_HOST_DIRECTIVE_OUTPUTS, FOR_TIME_PICKER_CONTEXT, FOR_TIME_PICKER_DEFAULTS, FOR_TIME_PICKER_HOST_DIRECTIVE_INPUTS, FOR_TIME_PICKER_HOST_DIRECTIVE_OUTPUTS, FOR_TOAST_CONTEXT, FOR_TOAST_DEFAULTS, FOR_TOGGLE_DEFAULTS, FOR_TOGGLE_GROUP_CONTEXT, FOR_TOGGLE_GROUP_HOST_DIRECTIVE_INPUTS, FOR_TOGGLE_GROUP_HOST_DIRECTIVE_OUTPUTS, FOR_TOGGLE_HOST_DIRECTIVE_INPUTS, FOR_TOGGLE_HOST_DIRECTIVE_OUTPUTS, FOR_TOOLBAR_CONTEXT, FOR_TOOLBAR_DEFAULTS, FOR_TOOLTIP_CONTEXT, FOR_TOOLTIP_DEFAULTS, FOR_TREE_CONTAINER_CONTEXT, FOR_TREE_CONTEXT, FOR_TREE_DEFAULTS, FOR_TREE_ITEM_CONTEXT, FOR_TREE_NODE_DRAG_CONTEXT, FOR_VIRTUAL_VIEWPORT_CONTEXT, ForAccordion, ForAccordionContent, ForAccordionItem, ForAccordionTrigger, ForAspectRatio, ForAvatar, ForAvatarFallback, ForAvatarImage, ForCalendar, ForCalendarCell, ForCalendarGrid, ForCalendarGridHeader, ForCalendarHeading, ForCalendarMonthCell, ForCalendarMonthGrid, ForCalendarMonthSelect, ForCalendarNextButton, ForCalendarPrevButton, ForCalendarViewTrigger, ForCalendarYearCell, ForCalendarYearGrid, ForCalendarYearSelect, ForCarousel, ForCarouselDrag, ForCarouselIndicator, ForCarouselIndicators, ForCarouselNext, ForCarouselPrevious, ForCarouselRotationControl, ForCarouselSlide, ForCarouselTrack, ForCarouselViewport, ForCheckbox, ForCheckboxIndicator, ForCombobox, ForComboboxAnchor, ForComboboxChip, ForComboboxChipRemove, ForComboboxChips, ForComboboxClear, ForComboboxContent, ForComboboxEmpty, ForComboboxGroup, ForComboboxGroupLabel, ForComboboxIndicator, ForComboboxInput, ForComboboxList, ForComboboxOption, ForComboboxSeparator, ForComboboxStatus, ForComboboxTrigger, ForContextMenu, ForContextMenuTrigger, ForDateField, ForDateFieldLiteral, ForDateFieldSegment, ForDatePicker, ForDatePickerContent, ForDatePickerTrigger, ForDatePickerValue, ForDialog, ForDialogBackdrop, ForDialogClose, ForDialogDescription, ForDialogManager, ForDialogRef, ForDialogTitle, ForDialogTrigger, ForDisclosure, ForDisclosureContent, ForDisclosureTrigger, ForDragHandle, ForDragPlaceholder, ForDragPreview, ForDraggable, ForDrawer, ForDrawerBackdrop, ForDrawerClose, ForDrawerDescription, ForDrawerHandle, ForDrawerManager, ForDrawerRef, ForDrawerTitle, ForDrawerTrigger, ForDrawerWrapper, ForDropList, ForDropListGroup, ForDropdownMenu, ForDropdownMenuTrigger, ForField, ForFieldControl, ForFieldDescription, ForFieldError, ForFieldset, ForFieldsetLegend, ForHoverCard, ForHoverCardArrow, ForHoverCardContent, ForHoverCardTrigger, ForInput, ForLabel, ForListbox, ForListboxGroup, ForListboxGroupLabel, ForListboxOption, ForListboxOptionIndicator, ForMenuCheckboxItem, ForMenuContent, ForMenuGroup, ForMenuGroupLabel, ForMenuItem, ForMenuItemIndicator, ForMenuRadioGroup, ForMenuRadioItem, ForMenuSeparator, ForMenuSub, ForMenuSubTrigger, ForMenubar, ForMenubarTrigger, ForMeter, ForMeterIndicator, ForNavigationMenu, ForNavigationMenuContent, ForNavigationMenuIndicator, ForNavigationMenuItem, ForNavigationMenuLink, ForNavigationMenuList, ForNavigationMenuTrigger, ForNavigationMenuViewport, ForNumberInput, ForNumberInputDecrement, ForNumberInputGroup, ForNumberInputIncrement, ForOtpInput, ForOtpInputSlot, ForPaneResizer, ForPopover, ForPopoverAnchor, ForPopoverArrow, ForPopoverClose, ForPopoverContent, ForPopoverDescription, ForPopoverTitle, ForPopoverTrigger, ForProgress, ForProgressIndicator, ForRadio, ForRadioGroup, ForRadioIndicator, ForScrollArea, ForScrollAreaContent, ForScrollAreaCorner, ForScrollAreaScrollbar, ForScrollAreaThumb, ForScrollAreaViewport, ForSelect, ForSelectAnchor, ForSelectContent, ForSelectGroup, ForSelectGroupLabel, ForSelectIndicator, ForSelectOption, ForSelectSeparator, ForSelectTrigger, ForSelectValue, ForSeparator, ForSlider, ForSliderRange, ForSliderThumb, ForSliderTrack, ForStepper, ForStepperCompletedContent, ForStepperContent, ForStepperIndicator, ForStepperItem, ForStepperList, ForStepperNext, ForStepperPrevious, ForStepperProgress, ForStepperSeparator, ForStepperTrigger, ForSwitch, ForTable, ForTableCell, ForTableColumnReorder, ForTableColumnResizer, ForTableHeaderCell, ForTableHeaderRow, ForTableRow, ForTableRowReorder, ForTableRowSelector, ForTableSelectAll, ForTableSortHeader, ForTableVirtualized, ForTabs, ForTabsContent, ForTabsList, ForTabsTrigger, ForTextarea, ForTimeField, ForTimeFieldLiteral, ForTimeFieldSegment, ForTimePicker, ForTimePickerContent, ForTimePickerOption, ForTimePickerTrigger, ForTimePickerValue, ForToast, ForToastAction, ForToastClose, ForToastDescription, ForToastManager, ForToastRef, ForToastTitle, ForToastViewport, ForToggle, ForToggleGroup, ForToggleGroupItem, ForToolbar, ForToolbarButton, ForToolbarLink, ForToolbarSeparator, ForTooltip, ForTooltipArrow, ForTooltipContent, ForTooltipTrigger, ForTree, ForTreeGroup, ForTreeItem, ForTreeItemCheckbox, ForTreeItemCheckboxIndicator, ForTreeItemLabel, ForTreeItemToggle, ForTreeNodeDrag, ForTreeNodeDragHandle, ForVirtualFor, ForVirtualViewport, NativeDateAdapter, OTP_REGEXP_ONLY_CHARS, OTP_REGEXP_ONLY_DIGITS, OTP_REGEXP_ONLY_DIGITS_AND_CHARS, assertTimeCapable, buildTimeSlots, expandToReveal, forSingleValueField, injectDateAdapter, injectDialogData, injectDrawerData, injectFieldWiring, injectInfiniteScroll, injectNumberInputGroup, injectVirtualizer, moveItemInArray, moveTreeNode, provideForAccordionDefaults, provideForAspectRatioDefaults, provideForAvatarDefaults, provideForCalendarDefaults, provideForCarouselDefaults, provideForCheckboxDefaults, provideForComboboxDefaults, provideForContextMenuDefaults, provideForDateFieldDefaults, provideForDatePickerDefaults, provideForDialogDefaults, provideForDisclosureDefaults, provideForDragDropDefaults, provideForDrawerDefaults, provideForDropdownMenuDefaults, provideForFieldDefaults, provideForFieldsetDefaults, provideForHoverCardDefaults, provideForIdSalt, provideForInputDefaults, provideForListboxDefaults, provideForMenuDefaults, provideForMenubarDefaults, provideForMeterDefaults, provideForNavigationMenuDefaults, provideForNumberInputDefaults, provideForOtpInputDefaults, provideForPaneResizerDefaults, provideForPopoverDefaults, provideForProgressDefaults, provideForRadioGroupDefaults, provideForScrollAreaDefaults, provideForSelectDefaults, provideForSeparatorDefaults, provideForSliderDefaults, provideForStepperDefaults, provideForSwitchDefaults, provideForTableDefaults, provideForTabsDefaults, provideForTimeFieldDefaults, provideForTimePickerDefaults, provideForToastDefaults, provideForToggleDefaults, provideForToolbarDefaults, provideForTooltipDefaults, provideForTreeDefaults, provideNativeDateAdapter, transferArrayItem };
-export type { CalendarDateLabelFormatter, CalendarDateRange, CalendarDayCell, CalendarMonthOption, CalendarMonthRow, CalendarView, CalendarWeek, CalendarWeekday, CalendarYearOption, CalendarYearRow, CarouselAlign, DateAdapter, DateFieldSegment, DateSegmentType, SegmentType as DateTimeSegmentType, FieldControlHandle, FieldGranularity, ForAccordionContext, ForAccordionDefaults, ForAccordionItemContext, ForAspectRatioDefaults, ForAvatarContext, ForAvatarDefaults, ForAvatarStatus, ForCalendarCellHandle, ForCalendarContext, ForCalendarDefaults, ForCalendarMonthCellHandle, ForCalendarYearCellHandle, ForCarouselContext, ForCarouselDefaults, ForCheckboxDefaults, ForComboboxAutocomplete, ForComboboxChipHandle, ForComboboxCloseReason, ForComboboxContext, ForComboboxDefaults, ForComboboxInitialFocus, ForComboboxOptionHandle, ForContextMenuContext, ForContextMenuDefaults, ForDateFieldContext, ForDateFieldDefaults, ForDateFieldSegmentHandle, ForDateFieldSegmentLabels, ForDatePickerContext, ForDatePickerDefaults, ForDialogCloseReason, ForDialogContext, ForDialogDefaults, ForDialogOpenConfig, ForDisclosureContext, ForDisclosureDefaults, ForDragDropDefaults, ForDragDropEvent, ForDragEndEvent, ForDragStartEvent, ForDraggableHandle, ForDrawerCloseReason, ForDrawerContext, ForDrawerDefaults, ForDrawerDragEvent, ForDrawerOpenConfig, ForDrawerReleaseEvent, ForDrawerSide, ForDrawerSnapPoint, ForDropListContext, ForDropdownMenuDefaults, ForFieldContext, ForFieldDefaults, ForFieldsetContext, ForFieldsetDefaults, ForHoverCardContext, ForHoverCardDefaults, ForInfiniteScroll, ForInputDefaults, ForListboxContext, ForListboxDefaults, ForMenuCloseReason, ForMenuContext, ForMenuDefaults, ForMenuGroupContext, ForMenuItemHandle, ForMenuRadioGroupContext, ForMenubarContext, ForMenubarDefaults, ForMenubarTriggerHandle, ForMeterContext, ForMeterDefaults, ForMeterQuality, ForNavigationMenuContentHandle, ForNavigationMenuContext, ForNavigationMenuDefaults, ForNavigationMenuItemContext, ForNavigationMenuMotion, ForNavigationMenuTriggerHandle, ForNavigationMenuViewportHandle, ForNumberInputContext, ForNumberInputDefaults, ForNumberInputGroupContext, ForOtpInputContext, ForOtpInputDefaults, ForPaneResizerDefaults, ForPopoverContext, ForPopoverDefaults, ForProgressContext, ForProgressDefaults, ForProgressState, ForRadioGroupContext, ForRadioGroupDefaults, ForScrollAreaContext, ForScrollAreaDefaults, ForScrollAreaType, ForScrollbarOrientation, ForSelectCloseReason, ForSelectContext, ForSelectDefaults, ForSelectInitialFocus, ForSelectOptionHandle, ForSeparatorDefaults, ForSliderContext, ForSliderDefaults, ForSliderThumbHandle, ForStepperContentHandle, ForStepperContext, ForStepperDefaults, ForStepperItemContext, ForStepperItemHandle, ForStepperTriggerHandle, ForSwitchDefaults, ForTableCellHandle, ForTableContext, ForTableDefaults, ForTableRowHandle, ForTabsContext, ForTabsDefaults, ForTimeFieldContext, ForTimeFieldDefaults, ForTimeFieldSegmentHandle, ForTimeFieldSegmentLabels, ForTimePickerCloseReason, ForTimePickerContext, ForTimePickerDefaults, ForTimePickerInitialFocus, ForTimePickerOptionHandle, ForTimeSlot, ForToastCloseReason, ForToastConfig, ForToastContext, ForToastDefaults, ForToastInstance, ForToastSwipeDirection, ForToastTemplateContext, ForToastVariant, ForToggleDefaults, ForToggleGroupContext, ForToggleGroupItemHandle, ForToolbarContext, ForToolbarDefaults, ForToolbarItemHandle, ForTooltipContext, ForTooltipDefaults, ForTreeContainerContext, ForTreeContext, ForTreeDefaults, ForTreeDragDropEvent, ForTreeItemContext, ForTreeItemHandle, ForTreeNodeDragContext, ForTreeVisibleNode, ForVirtualForContext, ForVirtualViewportContext, ForVirtualizer, HoverCardScheduleReason, InfiniteScrollOptions, MenuActivationModality, MoveTreeNodeOptions, NavigationMenuScheduleReason, OtpInputType, SliderArrowKey, StepperActivationMode, StepperMode, SwipeDirection, SwipeEventDetail, TableColumnReorderDescriptor, TableMode, TableResizeDescriptor, TableRowReorderDescriptor, TableSelectAllState, TableSelectionBehavior, TableSelectionMode, TableSortDescriptor, TableSortDirection, TableStickyValue, TabsActivationMode, TimeCapableDateAdapter, TimeFieldSegment, TimeGranularity, TimePickerGranularity, TimeSegmentType, TooltipScheduleReason, VetoableEvent, VetoableNativeEvent, VirtualItem, VirtualizerOptions };
+export { DEFAULT_DATE_FIELD_SEGMENT_LABELS, DEFAULT_TIME_FIELD_SEGMENT_LABELS, DEFAULT_TOAST_REGION, FOR_ACCORDION_CONTEXT, FOR_ACCORDION_DEFAULTS, FOR_ACCORDION_ITEM_CONTEXT, FOR_ASPECT_RATIO_DEFAULTS, FOR_AVATAR_CONTEXT, FOR_AVATAR_DEFAULTS, FOR_BREADCRUMBS_DEFAULTS, FOR_BUTTON_DEFAULTS, FOR_CALENDAR_CONTEXT, FOR_CALENDAR_DEFAULTS, FOR_CAROUSEL_CONTEXT, FOR_CAROUSEL_DEFAULTS, FOR_CHECKBOX, FOR_CHECKBOX_DEFAULTS, FOR_CHECKBOX_HOST_DIRECTIVE_INPUTS, FOR_CHECKBOX_HOST_DIRECTIVE_OUTPUTS, FOR_COMBOBOX_CONTEXT, FOR_COMBOBOX_DEFAULTS, FOR_COMBOBOX_HOST_DIRECTIVE_INPUTS, FOR_COMBOBOX_HOST_DIRECTIVE_OUTPUTS, FOR_COMBOBOX_OPTION, FOR_CONTEXT_MENU_CONTEXT, FOR_CONTEXT_MENU_DEFAULTS, FOR_DATE_ADAPTER, FOR_DATE_FIELD_CONTEXT, FOR_DATE_FIELD_DEFAULTS, FOR_DATE_FIELD_HOST_DIRECTIVE_INPUTS, FOR_DATE_FIELD_HOST_DIRECTIVE_OUTPUTS, FOR_DATE_PICKER_CONTEXT, FOR_DATE_PICKER_DEFAULTS, FOR_DATE_PICKER_HOST_DIRECTIVE_INPUTS, FOR_DATE_PICKER_HOST_DIRECTIVE_OUTPUTS, FOR_DIALOG_CONTEXT, FOR_DIALOG_DATA, FOR_DIALOG_DEFAULTS, FOR_DISCLOSURE_CONTEXT, FOR_DISCLOSURE_DEFAULTS, FOR_DRAG_DROP_CONTEXT, FOR_DRAG_DROP_DEFAULTS, FOR_DRAWER_CONTEXT, FOR_DRAWER_DATA, FOR_DRAWER_DEFAULTS, FOR_DROPDOWN_MENU_DEFAULTS, FOR_DROP_LIST_DEFAULT_ORIENTATION, FOR_DROP_LIST_GROUP, FOR_FIELDSET_CONTEXT, FOR_FIELDSET_DEFAULTS, FOR_FIELD_CONTEXT, FOR_FIELD_DEFAULTS, FOR_FILE_UPLOAD_CONTEXT, FOR_FILE_UPLOAD_DEFAULTS, FOR_HOVER_CARD_CONTEXT, FOR_HOVER_CARD_DEFAULTS, FOR_ID_SALT, FOR_INPUT_DEFAULTS, FOR_INPUT_HOST_DIRECTIVE_INPUTS, FOR_INPUT_HOST_DIRECTIVE_OUTPUTS, FOR_LISTBOX_CONTEXT, FOR_LISTBOX_DEFAULTS, FOR_LISTBOX_HOST_DIRECTIVE_INPUTS, FOR_LISTBOX_HOST_DIRECTIVE_OUTPUTS, FOR_LISTBOX_OPTION, FOR_MENUBAR_CONTEXT, FOR_MENUBAR_DEFAULTS, FOR_MENU_CHECKBOX_ITEM, FOR_MENU_CONTEXT, FOR_MENU_DEFAULTS, FOR_MENU_GROUP_CONTEXT, FOR_MENU_RADIO_GROUP_CONTEXT, FOR_MENU_RADIO_ITEM, FOR_METER_CONTEXT, FOR_METER_DEFAULTS, FOR_NAVIGATION_MENU_CONTEXT, FOR_NAVIGATION_MENU_DEFAULTS, FOR_NAVIGATION_MENU_ITEM_CONTEXT, FOR_NUMBER_INPUT_DEFAULTS, FOR_NUMBER_INPUT_GROUP, FOR_NUMBER_INPUT_HOST_DIRECTIVE_INPUTS, FOR_NUMBER_INPUT_HOST_DIRECTIVE_OUTPUTS, FOR_OTP_INPUT_CONTEXT, FOR_OTP_INPUT_DEFAULTS, FOR_OTP_INPUT_HOST_DIRECTIVE_INPUTS, FOR_OTP_INPUT_HOST_DIRECTIVE_OUTPUTS, FOR_PAGINATION_CONTEXT, FOR_PAGINATION_DEFAULTS, FOR_PANE_RESIZER_DEFAULTS, FOR_POPOVER_CONTEXT, FOR_POPOVER_DEFAULTS, FOR_PROGRESS_CONTEXT, FOR_PROGRESS_DEFAULTS, FOR_RADIO, FOR_RADIO_GROUP_CONTEXT, FOR_RADIO_GROUP_DEFAULTS, FOR_RADIO_GROUP_HOST_DIRECTIVE_INPUTS, FOR_RADIO_GROUP_HOST_DIRECTIVE_OUTPUTS, FOR_SCROLL_AREA_CONTEXT, FOR_SCROLL_AREA_DEFAULTS, FOR_SEARCH_DEFAULTS, FOR_SEARCH_HOST_DIRECTIVE_INPUTS, FOR_SEARCH_HOST_DIRECTIVE_OUTPUTS, FOR_SELECT_CONTEXT, FOR_SELECT_DEFAULTS, FOR_SELECT_HOST_DIRECTIVE_INPUTS, FOR_SELECT_HOST_DIRECTIVE_OUTPUTS, FOR_SELECT_OPTION, FOR_SEPARATOR_DEFAULTS, FOR_SLIDER_CONTEXT, FOR_SLIDER_DEFAULTS, FOR_SLIDER_HOST_DIRECTIVE_INPUTS, FOR_SLIDER_HOST_DIRECTIVE_OUTPUTS, FOR_STEPPER_CONTEXT, FOR_STEPPER_DEFAULTS, FOR_STEPPER_ITEM_CONTEXT, FOR_SWITCH_DEFAULTS, FOR_SWITCH_HOST_DIRECTIVE_INPUTS, FOR_SWITCH_HOST_DIRECTIVE_OUTPUTS, FOR_TABLE_CONTEXT, FOR_TABLE_DEFAULTS, FOR_TABS_CONTEXT, FOR_TABS_DEFAULTS, FOR_TEXTAREA_HOST_DIRECTIVE_INPUTS, FOR_TEXTAREA_HOST_DIRECTIVE_OUTPUTS, FOR_TIME_FIELD_CONTEXT, FOR_TIME_FIELD_DEFAULTS, FOR_TIME_FIELD_HOST_DIRECTIVE_INPUTS, FOR_TIME_FIELD_HOST_DIRECTIVE_OUTPUTS, FOR_TIME_PICKER_CONTEXT, FOR_TIME_PICKER_DEFAULTS, FOR_TIME_PICKER_HOST_DIRECTIVE_INPUTS, FOR_TIME_PICKER_HOST_DIRECTIVE_OUTPUTS, FOR_TIME_VALUE_SOURCE, FOR_TOAST_CONTEXT, FOR_TOAST_DEFAULTS, FOR_TOGGLE_DEFAULTS, FOR_TOGGLE_GROUP_CONTEXT, FOR_TOGGLE_GROUP_HOST_DIRECTIVE_INPUTS, FOR_TOGGLE_GROUP_HOST_DIRECTIVE_OUTPUTS, FOR_TOGGLE_HOST_DIRECTIVE_INPUTS, FOR_TOGGLE_HOST_DIRECTIVE_OUTPUTS, FOR_TOOLBAR_CONTEXT, FOR_TOOLBAR_DEFAULTS, FOR_TOOLTIP_CONTEXT, FOR_TOOLTIP_DEFAULTS, FOR_TREE_CONTAINER_CONTEXT, FOR_TREE_CONTEXT, FOR_TREE_DEFAULTS, FOR_TREE_ITEM_CONTEXT, FOR_TREE_NODE_DRAG_CONTEXT, ForAccordion, ForAccordionContent, ForAccordionItem, ForAccordionTrigger, ForAspectRatio, ForAvatar, ForAvatarFallback, ForAvatarImage, ForBreadcrumbItem, ForBreadcrumbSeparator, ForBreadcrumbs, ForButton, ForCalendar, ForCalendarCell, ForCalendarGrid, ForCalendarGridHeader, ForCalendarHeading, ForCalendarMonthCell, ForCalendarMonthGrid, ForCalendarMonthSelect, ForCalendarNextButton, ForCalendarPrevButton, ForCalendarViewTrigger, ForCalendarYearCell, ForCalendarYearGrid, ForCalendarYearSelect, ForCarousel, ForCarouselDrag, ForCarouselIndicator, ForCarouselIndicators, ForCarouselNext, ForCarouselPrevious, ForCarouselRotationControl, ForCarouselSlide, ForCarouselTrack, ForCarouselViewport, ForCheckbox, ForCheckboxIndicator, ForCombobox, ForComboboxAnchor, ForComboboxChip, ForComboboxChipRemove, ForComboboxChips, ForComboboxClear, ForComboboxContent, ForComboboxEmpty, ForComboboxGroup, ForComboboxGroupLabel, ForComboboxIndicator, ForComboboxInput, ForComboboxList, ForComboboxOption, ForComboboxSeparator, ForComboboxStatus, ForComboboxTrigger, ForContextMenu, ForContextMenuTrigger, ForDateField, ForDateFieldLiteral, ForDateFieldSegment, ForDatePicker, ForDatePickerAnchor, ForDatePickerContent, ForDatePickerTrigger, ForDatePickerValue, ForDialog, ForDialogBackdrop, ForDialogClose, ForDialogDescription, ForDialogManager, ForDialogRef, ForDialogTitle, ForDialogTrigger, ForDisclosure, ForDisclosureContent, ForDisclosureTrigger, ForDragHandle, ForDragPlaceholder, ForDragPreview, ForDraggable, ForDrawer, ForDrawerBackdrop, ForDrawerClose, ForDrawerDescription, ForDrawerHandle, ForDrawerManager, ForDrawerRef, ForDrawerTitle, ForDrawerTrigger, ForDrawerWrapper, ForDropList, ForDropListGroup, ForDropdownMenu, ForDropdownMenuTrigger, ForField, ForFieldControl, ForFieldDescription, ForFieldError, ForFieldset, ForFieldsetLegend, ForFileUpload, ForFileUploadInput, ForFileUploadTrigger, ForFreeDrag, ForHoverCard, ForHoverCardArrow, ForHoverCardContent, ForHoverCardTrigger, ForInput, ForLabel, ForListbox, ForListboxGroup, ForListboxGroupLabel, ForListboxOption, ForListboxOptionIndicator, ForMenuCheckboxItem, ForMenuContent, ForMenuGroup, ForMenuGroupLabel, ForMenuItem, ForMenuItemIndicator, ForMenuRadioGroup, ForMenuRadioItem, ForMenuSeparator, ForMenuSub, ForMenuSubTrigger, ForMenubar, ForMenubarTrigger, ForMeter, ForMeterIndicator, ForNavigationMenu, ForNavigationMenuContent, ForNavigationMenuIndicator, ForNavigationMenuItem, ForNavigationMenuLink, ForNavigationMenuList, ForNavigationMenuTrigger, ForNavigationMenuViewport, ForNumberInput, ForNumberInputDecrement, ForNumberInputGroup, ForNumberInputIncrement, ForOtpInput, ForOtpInputSlot, ForPagination, ForPaginationItem, ForPaginationNext, ForPaginationPrevious, ForPaneResizer, ForPopover, ForPopoverAnchor, ForPopoverArrow, ForPopoverClose, ForPopoverContent, ForPopoverDescription, ForPopoverTitle, ForPopoverTrigger, ForProgress, ForProgressIndicator, ForRadio, ForRadioGroup, ForRadioIndicator, ForScrollArea, ForScrollAreaContent, ForScrollAreaCorner, ForScrollAreaScrollbar, ForScrollAreaThumb, ForScrollAreaViewport, ForSearch, ForSearchClear, ForSelect, ForSelectAnchor, ForSelectContent, ForSelectGroup, ForSelectGroupLabel, ForSelectIndicator, ForSelectOption, ForSelectSeparator, ForSelectTrigger, ForSelectValue, ForSeparator, ForSlider, ForSliderRange, ForSliderThumb, ForSliderTrack, ForStepper, ForStepperCompletedContent, ForStepperContent, ForStepperIndicator, ForStepperItem, ForStepperList, ForStepperNext, ForStepperPrevious, ForStepperProgress, ForStepperSeparator, ForStepperTrigger, ForSwitch, ForTable, ForTableCell, ForTableColumnReorder, ForTableColumnResizer, ForTableHeaderCell, ForTableHeaderRow, ForTableRow, ForTableRowReorder, ForTableRowSelector, ForTableSelectAll, ForTableSortHeader, ForTabs, ForTabsContent, ForTabsList, ForTabsTrigger, ForTextarea, ForTimeField, ForTimeFieldLiteral, ForTimeFieldSegment, ForTimePicker, ForTimePickerAnchor, ForTimePickerContent, ForTimePickerOption, ForTimePickerTrigger, ForTimePickerValue, ForToast, ForToastAction, ForToastClose, ForToastDescription, ForToastManager, ForToastRef, ForToastTitle, ForToastViewport, ForToggle, ForToggleGroup, ForToggleGroupItem, ForToolbar, ForToolbarButton, ForToolbarLink, ForToolbarSeparator, ForTooltip, ForTooltipArrow, ForTooltipContent, ForTooltipTrigger, ForTree, ForTreeGroup, ForTreeItem, ForTreeItemCheckbox, ForTreeItemCheckboxIndicator, ForTreeItemLabel, ForTreeItemToggle, ForTreeNodeDrag, ForTreeNodeDragHandle, NativeDateAdapter, OTP_REGEXP_ONLY_CHARS, OTP_REGEXP_ONLY_DIGITS, OTP_REGEXP_ONLY_DIGITS_AND_CHARS, assertTimeCapable, buildTimeSlots, expandToReveal, forSingleValueField, injectDateAdapter, injectDialogData, injectDrawerData, injectFieldWiring, injectNumberInputGroup, moveItemInArray, moveTreeNode, provideForAccordionDefaults, provideForAspectRatioDefaults, provideForAvatarDefaults, provideForBreadcrumbsDefaults, provideForButtonDefaults, provideForCalendarDefaults, provideForCarouselDefaults, provideForCheckboxDefaults, provideForComboboxDefaults, provideForContextMenuDefaults, provideForDateFieldDefaults, provideForDatePickerDefaults, provideForDialogDefaults, provideForDisclosureDefaults, provideForDragDropDefaults, provideForDrawerDefaults, provideForDropdownMenuDefaults, provideForFieldDefaults, provideForFieldsetDefaults, provideForFileUploadDefaults, provideForHoverCardDefaults, provideForIdSalt, provideForInputDefaults, provideForListboxDefaults, provideForMenuDefaults, provideForMenubarDefaults, provideForMeterDefaults, provideForNavigationMenuDefaults, provideForNumberInputDefaults, provideForOtpInputDefaults, provideForPaginationDefaults, provideForPaneResizerDefaults, provideForPopoverDefaults, provideForProgressDefaults, provideForRadioGroupDefaults, provideForScrollAreaDefaults, provideForSearchDefaults, provideForSelectDefaults, provideForSeparatorDefaults, provideForSliderDefaults, provideForStepperDefaults, provideForSwitchDefaults, provideForTableDefaults, provideForTabsDefaults, provideForTimeFieldDefaults, provideForTimePickerDefaults, provideForToastDefaults, provideForToggleDefaults, provideForToolbarDefaults, provideForTooltipDefaults, provideForTreeDefaults, provideNativeDateAdapter, transferArrayItem };
+export type { CalendarDateLabelFormatter, CalendarDateRange, CalendarDayCell, CalendarMonthOption, CalendarMonthRow, CalendarView, CalendarWeek, CalendarWeekday, CalendarYearOption, CalendarYearRow, CarouselAlign, DateAdapter, DateFieldSegment, DateSegmentType, SegmentType as DateTimeSegmentType, FieldControlHandle, FieldGranularity, ForAccordionContext, ForAccordionDefaults, ForAccordionItemContext, ForAspectRatioDefaults, ForAvatarContext, ForAvatarDefaults, ForAvatarStatus, ForBreadcrumbsDefaults, ForButtonDefaults, ForCalendarCellHandle, ForCalendarContext, ForCalendarDefaults, ForCalendarMonthCellHandle, ForCalendarYearCellHandle, ForCarouselContext, ForCarouselDefaults, ForCheckboxDefaults, ForComboboxAutocomplete, ForComboboxChipHandle, ForComboboxCloseReason, ForComboboxContext, ForComboboxDefaults, ForComboboxInitialFocus, ForComboboxOptionHandle, ForContextMenuContext, ForContextMenuDefaults, ForDateFieldContext, ForDateFieldDefaults, ForDateFieldSegmentHandle, ForDateFieldSegmentLabels, ForDatePickerContext, ForDatePickerDefaults, ForDialogCloseReason, ForDialogContext, ForDialogDefaults, ForDialogOpenConfig, ForDisclosureContext, ForDisclosureDefaults, ForDragDropDefaults, ForDragDropEvent, ForDragEndEvent, ForDragStartEvent, ForDraggableHandle, ForDrawerCloseReason, ForDrawerContext, ForDrawerDefaults, ForDrawerDragEvent, ForDrawerOpenConfig, ForDrawerReleaseEvent, ForDrawerSide, ForDrawerSnapPoint, ForDropListContext, ForDropdownMenuDefaults, ForFieldContext, ForFieldDefaults, ForFieldsetContext, ForFieldsetDefaults, ForFileUploadContext, ForFileUploadDefaults, ForHoverCardContext, ForHoverCardDefaults, ForInputDefaults, ForListboxContext, ForListboxDefaults, ForMenuCloseReason, ForMenuContext, ForMenuDefaults, ForMenuGroupContext, ForMenuItemHandle, ForMenuRadioGroupContext, ForMenubarContext, ForMenubarDefaults, ForMenubarTriggerHandle, ForMeterContext, ForMeterDefaults, ForMeterQuality, ForNavigationMenuContentHandle, ForNavigationMenuContext, ForNavigationMenuDefaults, ForNavigationMenuItemContext, ForNavigationMenuMotion, ForNavigationMenuTriggerHandle, ForNavigationMenuViewportHandle, ForNumberInputContext, ForNumberInputDefaults, ForNumberInputGroupContext, ForOtpInputContext, ForOtpInputDefaults, ForPaginationContext, ForPaginationDefaults, ForPaneResizerDefaults, ForPopoverContext, ForPopoverDefaults, ForProgressContext, ForProgressDefaults, ForProgressState, ForRadioGroupContext, ForRadioGroupDefaults, ForScrollAreaContext, ForScrollAreaDefaults, ForScrollAreaType, ForScrollbarOrientation, ForSearchDefaults, ForSelectCloseReason, ForSelectContext, ForSelectDefaults, ForSelectInitialFocus, ForSelectOptionHandle, ForSeparatorDefaults, ForSliderContext, ForSliderDefaults, ForSliderThumbHandle, ForStepperContentHandle, ForStepperContext, ForStepperDefaults, ForStepperItemContext, ForStepperItemHandle, ForStepperTriggerHandle, ForSwitchDefaults, ForTableCellHandle, ForTableContext, ForTableDefaults, ForTableRowHandle, ForTabsContext, ForTabsDefaults, ForTimeFieldContext, ForTimeFieldDefaults, ForTimeFieldSegmentHandle, ForTimeFieldSegmentLabels, ForTimePickerCloseReason, ForTimePickerContext, ForTimePickerDefaults, ForTimePickerInitialFocus, ForTimePickerOptionHandle, ForTimeSlot, ForToastCloseReason, ForToastConfig, ForToastContext, ForToastDefaults, ForToastInstance, ForToastSwipeDirection, ForToastTemplateContext, ForToastVariant, ForToggleDefaults, ForToggleGroupContext, ForToggleGroupItemHandle, ForToolbarContext, ForToolbarDefaults, ForToolbarItemHandle, ForTooltipContext, ForTooltipDefaults, ForTreeContainerContext, ForTreeContext, ForTreeDefaults, ForTreeDragDropEvent, ForTreeDropIndicator, ForTreeItemContext, ForTreeItemHandle, ForTreeNodeDragContext, ForTreeVisibleNode, HoverCardScheduleReason, MenuActivationModality, MoveTreeNodeOptions, NavigationMenuScheduleReason, OtpInputType, PaginationItem, SliderArrowKey, StepperActivationMode, StepperMode, SwipeDirection, SwipeEventDetail, TableColumnReorderDescriptor, TableMode, TableResizeDescriptor, TableRowReorderDescriptor, TableSelectAllState, TableSelectionBehavior, TableSelectionMode, TableSortDescriptor, TableSortDirection, TableStickyValue, TabsActivationMode, TimeCapableDateAdapter, TimeFieldSegment, TimeGranularity, TimePickerGranularity, TimeSegmentType, TimeValueSource, TooltipScheduleReason, VetoableEvent, VetoableNativeEvent };