forty-cdk 0.2.0 → 0.3.0

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

@@ -0,0 +1,899 @@
+import * as _floating_ui_dom from '@floating-ui/dom';
+import { ReferenceElement } from '@floating-ui/dom';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, ModelSignal, Signal, Provider } from '@angular/core';
+import { FormValueControl } from '@angular/forms/signals';
+import { FloatingSide, FloatingAlign, WritingDirection, CollectionHandle, ListNavigationAction, VetoableNativeEvent, FormUiControlBase, VetoableEvent } from 'forty-cdk/core';
+import * as forty_cdk_select from 'forty-cdk/select';
+
+/**
+ * Why a select requested close. Mirrors the menu primitive vocabulary so
+ * downstream code that switches on close reasons stays consistent.
+ */
+type ForSelectCloseReason = 'escape' | 'pointerDownOutside' | 'focusOutside' | 'select' | 'tab' | 'programmatic';
+/**
+ * Where focus lands when the listbox opens. `'selected'` snaps to the first
+ * currently-selected enabled option (matches native `<select>`); falls back
+ * to `'first'` if no selection is enabled.
+ */
+type ForSelectInitialFocus = 'first' | 'last' | 'selected';
+/**
+ * Handle every `[forSelectOption]` registers with the root. The collection
+ * orders entries by DOM document order so groups, separators, and `@for`
+ * loops don't perturb keyboard navigation.
+ *
+ * Generic over the option value type `T` (default `unknown` at the contract
+ * level; `string` at the public root). The handle carries the raw value so
+ * the root can match it against `value()` via `isItemEqualToValue`.
+ */
+interface ForSelectOptionHandle<T = unknown> extends CollectionHandle {
+    readonly value: Signal<T>;
+    /**
+     * The option's resolved display label as a reactive `Signal<string>` — the
+     * trimmed `textContent` of the host. The root folds it into a persisted
+     * snapshot so `selectedLabels` and closed-state typeahead resolve labels
+     * without peeking at `textContent` from inside a `computed`.
+     */
+    readonly label: Signal<string>;
+    readonly disabled: Signal<boolean>;
+    /** Stable host `id` — the activedescendant target in the virtualized path. */
+    readonly id: Signal<string>;
+    /**
+     * Zero-based absolute position in the full source data. Required in the
+     * virtualized path (drives the position snapshot + `aria-posinset`); `null`
+     * outside it.
+     */
+    readonly posInSet: Signal<number | null>;
+}
+/**
+ * Coordination contract owned by `[forSelect]`. Trigger, content, value,
+ * options, groups and separators all inject this token to read state and
+ * delegate behavior — they don't import the root class directly.
+ *
+ * Generic over the option value type `T` (default `string` at the public
+ * root). When a consumer binds object items the directive infers `T` from
+ * `[(value)]` and the per-piece signatures specialize accordingly. Items are
+ * compared via the consumer-provided `isItemEqualToValue` and serialized for
+ * the form's hidden inputs via `itemToFormValue`; option text labels are
+ * still read from the rendered `textContent`.
+ */
+interface ForSelectContext<T = unknown> {
+    readonly value: ModelSignal<readonly T[]>;
+    readonly open: ModelSignal<boolean>;
+    readonly multiple: Signal<boolean>;
+    /**
+     * The select's effective disabled — its own `disabled` input OR'd with a
+     * surrounding disabled `[forFieldset]`. Trigger and options read this so a
+     * disabled select (or fieldset) is inert and exposes `aria-disabled`.
+     */
+    readonly effectiveDisabled: Signal<boolean>;
+    readonly readonly: Signal<boolean>;
+    readonly required: Signal<boolean>;
+    readonly invalid: Signal<boolean>;
+    readonly pending: Signal<boolean>;
+    /**
+     * When `true`, the listbox is a trapped / inert / scroll-locked modal
+     * surface (routed through `_internal/modal-shell`) instead of the anchored
+     * popover. Read once when `[forSelectContent]` mounts; all anchored-
+     * positioning state below is a no-op while modal.
+     */
+    readonly modal: Signal<boolean>;
+    readonly dismissible: Signal<boolean>;
+    readonly returnFocus: Signal<boolean>;
+    /**
+     * Positioning algorithm. `'popper'` (default) is standard floating-ui
+     * anchored placement; `'item-aligned'` overlays the listbox so the
+     * selected option's center aligns with the trigger's center (macOS-style
+     * native `<select>`). All `side`/`align`/`*Offset`/`sticky`/
+     * `hideWhenDetached`/`clipUntilPositioned`/`avoidCollisions` inputs are no-ops in
+     * `'item-aligned'` mode (only `collisionPadding` is honored).
+     */
+    readonly position: Signal<'popper' | 'item-aligned'>;
+    readonly side: Signal<FloatingSide | undefined>;
+    readonly align: Signal<FloatingAlign | undefined>;
+    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 loop: Signal<boolean>;
+    readonly orientation: Signal<'horizontal' | 'vertical'>;
+    readonly dir: Signal<WritingDirection>;
+    readonly selectionFollowsFocus: Signal<boolean>;
+    readonly placeholder: Signal<string>;
+    /** Where focus should land after the content mounts. Triggers set this before flipping `open`. */
+    readonly initialFocus: Signal<ForSelectInitialFocus>;
+    setInitialFocus(target: ForSelectInitialFocus): void;
+    readonly triggerId: Signal<string>;
+    readonly contentId: Signal<string>;
+    readonly ariaLabel: Signal<string | null>;
+    /** Compare two items for equality. Defaults to `===`; overridden for object values. */
+    readonly isItemEqualToValue: Signal<(a: T, b: T) => boolean>;
+    /** Serialize an item for the hidden input's `value` attribute. Defaults to `String(item)`. */
+    readonly itemToFormValue: Signal<(item: T) => string>;
+    /**
+     * Element floating-ui anchors the listbox against. Prefers an optional
+     * `[forSelectAnchor]` 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 listbox paints.
+     */
+    readonly anchor: Signal<ReferenceElement | null>;
+    /** The button trigger — exempt from outside-pointer checks and the focus-return target. */
+    readonly trigger: Signal<HTMLElement | null>;
+    registerTrigger(el: HTMLElement): void;
+    unregisterTrigger(el: HTMLElement): void;
+    /**
+     * Register / unregister an optional `[forSelectAnchor]` 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 `[forSelectContent]` element. */
+    readonly content: Signal<HTMLElement | null>;
+    registerContent(el: HTMLElement): void;
+    unregisterContent(el: HTMLElement): void;
+    registerOption(handle: ForSelectOptionHandle<T>): void;
+    unregisterOption(handle: ForSelectOptionHandle<T>): void;
+    /** All registered options in DOM order. */
+    readonly options: Signal<readonly ForSelectOptionHandle<T>[]>;
+    /** Resolved labels of the options whose value is in `value()`, in selection order. */
+    readonly selectedLabels: Signal<readonly string[]>;
+    /**
+     * Host element of the first enabled, currently-selected option, or `null`
+     * when no selection exists. Used by `position="item-aligned"` to anchor
+     * the listbox over the trigger; falls back to the first enabled option
+     * inside the listbox when this is `null`.
+     */
+    readonly selectedOptionEl: Signal<HTMLElement | null>;
+    isSelected(value: T): boolean;
+    /** Toggle in multi-mode, replace + close in single-mode. No-op on disabled / readonly. */
+    activate(value: T): void;
+    /** Move focus inside the open listbox in response to an arrow / Home / End key. */
+    navigate(currentOption: HTMLElement, action: ListNavigationAction): void;
+    /** Open-state typeahead: focus the first enabled option whose text matches the buffered prefix. */
+    handleTypeahead(event: KeyboardEvent): void;
+    /**
+     * Closed-state typeahead (single mode only). Selects the first matching
+     * option directly without opening the listbox — mirrors native `<select>`
+     * behavior. Returns `true` if the key was consumed by typeahead.
+     */
+    handleClosedTypeahead(event: KeyboardEvent): boolean;
+    focusFirstEnabledOption(): boolean;
+    focusLastEnabledOption(): boolean;
+    /** Focus the first enabled option whose value is currently selected. Returns `false` if none. */
+    focusSelectedOption(): boolean;
+    toggle(initialFocus?: ForSelectInitialFocus): void;
+    openMenu(initialFocus?: ForSelectInitialFocus): void;
+    closeMenu(reason: ForSelectCloseReason): void;
+    /**
+     * Reason of the most recent close, or `null` while the listbox is open
+     * (or before any close). Read by `[forSelectContent]` so `'tab'` closes
+     * skip the return-focus step — Tab needs the browser to advance focus
+     * from the trigger, and a re-focus would steal it back.
+     */
+    readonly lastCloseReason: Signal<ForSelectCloseReason | null>;
+    /**
+     * Commit the focused option's value (single mode) and close the listbox
+     * with reason `'tab'`. Moves focus to the trigger synchronously so the
+     * browser's Tab default action advances focus from there to the next
+     * (or previous) focusable in tab order. Multi-mode skips the value-set
+     * — selection toggles already happened via Space / Enter / click.
+     */
+    commitOnTab(value: T): void;
+    emitEscapeKeyDown(event: KeyboardEvent): void;
+    emitPointerDownOutside(veto: VetoableNativeEvent<PointerEvent>): void;
+    emitFocusOutside(veto: VetoableNativeEvent<FocusEvent>): void;
+    emitInteractOutside(veto: VetoableNativeEvent<PointerEvent | FocusEvent>): void;
+    /** Implicit close requested by the shell after an un-vetoed outside interaction. */
+    requestClose(reason: 'pointerDownOutside' | 'focusOutside'): void;
+    /** Modal-path Escape forwarder: emit only; the modal shell builds the veto and owns the close. */
+    forwardEscapeKeyDown(veto: VetoableNativeEvent<KeyboardEvent>): void;
+    /**
+     * Hooks into the auto-focus pipeline. Content fires these just before
+     * its imperative `.focus()` (open) or the trigger return-focus (close);
+     * `event.preventDefault()` skips the move. Returns `true` when the
+     * consumer vetoed.
+     */
+    emitAutoFocusOnOpen(): boolean;
+    emitAutoFocusOnClose(): boolean;
+    /**
+     * Full source length when virtualizing, `undefined` in the default
+     * DOM-focus path. Drives each option's `aria-setsize` / `aria-posinset`
+     * and the focus-model branch.
+     */
+    readonly totalCount: Signal<number | undefined>;
+    /**
+     * The active option's `id` in the virtualized activedescendant model,
+     * `null` in the default path. The content surface reflects it as
+     * `aria-activedescendant`; options read it for `data-highlighted`.
+     */
+    readonly activeDescendantId: Signal<string | null>;
+    /**
+     * Virtualized-path open hook. Called by `[forSelectContent]` after it
+     * focuses its own surface on open: seeds `aria-activedescendant` to the
+     * committed option (scrolling it into view via `(scrollToIndex)`), or the
+     * first enabled option when nothing is selected.
+     */
+    seedVirtualizedInitialFocus(): void;
+    /**
+     * Virtualized-path keyboard handler. Called by `[forSelectContent]`'s host
+     * keydown only when `totalCount()` is set: Arrow/Home/End navigation,
+     * Enter/Space activation of the active descendant, single-mode Tab commit,
+     * and typeahead — all in the activedescendant model.
+     */
+    handleVirtualizedKeydown(event: KeyboardEvent): void;
+    /**
+     * Called by an option on click in the virtualized path: moves
+     * `aria-activedescendant` to that option and returns DOM focus to the
+     * content surface. No-op in the default path.
+     */
+    notifyOptionClick(optionId: string): void;
+    /** Flip the `touched` model. Called by trigger on blur-to-outside and on dismiss events. */
+    markTouched(): void;
+}
+declare const FOR_SELECT_CONTEXT: InjectionToken<ForSelectContext<unknown>>;
+
+/**
+ * Headless implementation of the [WAI-ARIA select-only combobox pattern](https://www.w3.org/WAI/ARIA/apg/patterns/combobox/examples/combobox-select-only/).
+ * Implements `FormValueControl<readonly T[]>` from
+ * `@angular/forms/signals` for `[formField]` auto-wiring.
+ *
+ * Generic over the option value type `T` (default `string`). When the
+ * consumer binds object items the directive infers `T` from `[(value)]` and
+ * `[forSelectOption][value]`; object identity is resolved by the
+ * consumer-supplied `[isItemEqualToValue]` and the hidden inputs serialize
+ * via `[itemToFormValue]`. Option display text is read from the rendered
+ * `textContent`, so no separate label function is needed — supply the
+ * optional `[itemToLabel]` only when a pre-set object value must render its
+ * label before the listbox is ever opened (the documented `@if (open())`
+ * pattern).
+ *
+ * Selection is always modeled as `readonly T[]`:
+ * - In single mode (`multiple=false`, default), the array has 0 or 1 element
+ *   and option activation closes the listbox.
+ * - In multi mode, option activation toggles and the listbox stays open.
+ *
+ * Typeahead has two modes mirroring native `<select>`:
+ * - **Closed trigger** (single mode only): printable keys select the matching
+ *   option immediately without opening the listbox.
+ * - **Open listbox**: printable keys move focus to the first matching option
+ *   (selection still requires Enter / Space / click).
+ */
+declare class ForSelect<T = string> extends FormUiControlBase implements FormValueControl<readonly T[]>, ForSelectContext<T> {
+    #private;
+    /**
+     * Two-way bindable. Selected option values. Single-mode keeps 0 or 1
+     * element. The `model()` change emitter (`(valueChange)`) fires only on
+     * internal selection changes, never on consumer writes via `[(value)]`.
+     */
+    readonly value: _angular_core.ModelSignal<readonly T[]>;
+    /**
+     * Compare two items for equality. Defaults to `===`, which is the
+     * correct identity for primitive `T` (e.g. strings, numbers). Override
+     * when binding object items so the directive can locate selected entries
+     * by id (or any other stable key) instead of by reference:
+     * `[isItemEqualToValue]="(a, b) => a.id === b.id"`.
+     */
+    readonly isItemEqualToValue: _angular_core.InputSignal<(a: T, b: T) => boolean>;
+    /**
+     * Serialize an item for the hidden input that participates in native
+     * form submission. Defaults to identity for strings and to
+     * `JSON.stringify` for non-string items so the primitive works out of
+     * the box round-tripping objects. Override to emit a specific wire
+     * format — typically a per-item id — when the backend expects that:
+     * `[itemToFormValue]="(it) => it.id"`.
+     */
+    readonly itemToFormValue: _angular_core.InputSignal<(item: T) => string>;
+    /**
+     * Resolve the display label for an item without the listbox mounted.
+     * When set, {@link selectedLabels} (and therefore `[forSelectValue]`)
+     * renders this for any selected value, so a pre-set object value shows
+     * its label on first paint — before the listbox has ever been opened, in
+     * the documented `@if (forSelect.open())` pattern. Without it, object-value
+     * labels resolve from the rendered option `textContent`, which is only
+     * available once the content mounts; the serialized form value is shown as
+     * a last-resort fallback in the meantime: `[itemToLabel]="(c) => c.name"`.
+     *
+     * Defaults to `undefined` (string mode renders the value verbatim, so no
+     * label function is needed).
+     */
+    readonly itemToLabel: _angular_core.InputSignal<((item: T) => string) | undefined>;
+    /**
+     * Read-only single-select convenience view of {@link value}. Returns the
+     * sole value when exactly one is selected (regardless of `multiple`),
+     * otherwise `null` (zero, or 2+ selected). Lets single-select consumers
+     * read `selected()` instead of unwrapping `value()[0]`. The array-backed
+     * `value` model remains the source of truth and the `FormValueControl`
+     * contract; this is a derived accessor.
+     */
+    readonly selected: _angular_core.Signal<T | null>;
+    /**
+     * Two-way bindable. Whether the listbox is currently shown. The `model()`
+     * change emitter (`(openChange)`) fires only on internal transitions
+     * (trigger toggle, Escape, outside dismissal, single-mode option select),
+     * never on consumer writes via `[(open)]`.
+     */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Presentation mode. When `true`, `[forSelectContent]` mounts as a trapped /
+     * inert / scroll-locked modal surface (routed through `_internal/modal-shell`)
+     * instead of the default anchored popover — the batteries-included touch
+     * presentation a consumer opts into with `[modal]="isCoarsePointer()"`. The
+     * form-value wiring (`[(value)]`, `name`) is unchanged.
+     *
+     * Read once when the content mounts (the two shells are structurally
+     * different; switching at runtime would need a remount, and the surface
+     * mounts lazily via `@if (open())` well after `modal` settles). Every
+     * anchored-positioning input — `position`, `side`, `align`, `sideOffset`,
+     * `alignOffset`, `sticky`, `hideWhenDetached`, `clipUntilPositioned`, `avoidCollisions`,
+     * `collisionPadding`, `arrowPadding` — is a no-op in this mode. Default
+     * `false` (non-breaking). The swipe / snap-point sheet is deliberately not
+     * this mode — compose a `ForListbox` inside a `ForDrawer` for that.
+     */
+    readonly modal: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Positioning algorithm.
+     *
+     * - `'popper'` (default): standard floating-ui anchored placement using
+     *   `side` / `align` / `sideOffset` / `alignOffset`, with `flip` + `shift`
+     *   collision handling. Same path as Popover / DropdownMenu.
+     * - `'item-aligned'`: the listbox overlays the trigger so the selected
+     *   option's vertical center aligns with the trigger's vertical center
+     *   — visually the menu "snaps over" the trigger when opened, mirroring
+     *   macOS native `<select>`. Falls back to the first enabled option when
+     *   nothing is selected. `side`, `align`, `sideOffset`, `alignOffset`,
+     *   `sticky`, `hideWhenDetached`, `clipUntilPositioned`, and `avoidCollisions` are ignored in
+     *   this mode; only `collisionPadding` is honored.
+     */
+    readonly position: _angular_core.InputSignal<"popper" | "item-aligned">;
+    /**
+     * Side the listbox is anchored to. Defaults to `'bottom'`. Pair with
+     * `align` for the full positioning API. Ignored when
+     * `position="item-aligned"`.
+     */
+    readonly side: _angular_core.InputSignal<FloatingSide | undefined>;
+    /** Alignment along the chosen `side`. Defaults to `'start'`. */
+    readonly align: _angular_core.InputSignal<FloatingAlign | undefined>;
+    /**
+     * Gap (px) between trigger and listbox along the main axis. Default `4`.
+     * The default is read from
+     * `provideForSelectDefaults` for the surrounding scope.
+     */
+    readonly sideOffset: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Gap (px) along the cross axis. Default `0`. */
+    readonly alignOffset: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** When `true` (default), `flip` and `shift` keep the listbox inside the viewport. */
+    readonly avoidCollisions: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Padding (px) applied uniformly to flip / shift / size. Default `8`.
+     * The default is read from `provideForSelectDefaults` for the surrounding
+     * scope.
+     */
+    readonly collisionPadding: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Padding (px) for the `arrow` middleware. Default `0`. */
+    readonly arrowPadding: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Stickiness behaviour for `shift`. Default `'partial'`. */
+    readonly sticky: _angular_core.InputSignal<false | "partial" | "always">;
+    /** When `true`, sets `data-detached=""` while the trigger is scrolled off-screen. */
+    readonly hideWhenDetached: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * When `true` (default), the content is clipped until floating-ui resolves
+     * its first position, preventing a flash at the viewport corner. Set to
+     * `false` so a dramatic `animate.enter` plays from its first frame (the
+     * surface may flash briefly at the unresolved position while positioning
+     * computes).
+     */
+    readonly clipUntilPositioned: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    /**
+     * Total number of items in the source data. When set, switches the listbox
+     * to the virtualized `aria-activedescendant` focus model and populates
+     * `aria-setsize` on each rendered option. Leave unset (default) for the
+     * standard DOM-focus model.
+     */
+    readonly totalCount: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /**
+     * Inclusive-exclusive `[start, end)` index range of the currently rendered
+     * options, provided by `injectVirtualizer`. Used to decide whether a
+     * navigation target is in the visible window.
+     */
+    readonly visibleRange: _angular_core.InputSignal<readonly [number, number] | undefined>;
+    /**
+     * Emitted when navigation (or open-time scroll-to-selected) reaches an
+     * option outside the rendered window. Pass to `injectVirtualizer`'s
+     * `scrollToIndex` so the correct option mounts.
+     */
+    readonly scrollToIndex: _angular_core.OutputEmitterRef<number>;
+    /**
+     * 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.
+     */
+    readonly _dirInput: _angular_core.InputSignal<WritingDirection | null>;
+    readonly dir: _angular_core.Signal<WritingDirection>;
+    /**
+     * Single-mode only. When true, arrow nav also selects the focused option
+     * while the listbox is open. APG calls this optional and recommends
+     * caution — leave off unless your UX truly benefits. Default `false`.
+     */
+    readonly selectionFollowsFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Placeholder shown by `[forSelectValue]` when no option is selected. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** When true (default), Escape, pointer-down outside, and focus outside close the listbox. */
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** When true (default), focus returns to the trigger on close. */
+    readonly returnFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Manual `aria-label` on `[forSelectContent]` when the trigger isn't a meaningful name. */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly escapeKeyDown: _angular_core.OutputEmitterRef<VetoableNativeEvent<KeyboardEvent>>;
+    readonly pointerDownOutside: _angular_core.OutputEmitterRef<VetoableNativeEvent<PointerEvent>>;
+    readonly focusOutside: _angular_core.OutputEmitterRef<VetoableNativeEvent<FocusEvent>>;
+    readonly interactOutside: _angular_core.OutputEmitterRef<VetoableNativeEvent<PointerEvent | FocusEvent>>;
+    /**
+     * Fires just before the listbox sends focus to the selected option
+     * (or first / last enabled) on mount. Call `preventDefault()` on the
+     * emitted veto to skip the imperative focus move.
+     */
+    readonly autoFocusOnOpen: _angular_core.OutputEmitterRef<VetoableEvent>;
+    /**
+     * Fires just before focus returns to the trigger on unmount. Call
+     * `preventDefault()` on the veto to suppress the return-focus.
+     */
+    readonly autoFocusOnClose: _angular_core.OutputEmitterRef<VetoableEvent>;
+    readonly triggerId: _angular_core.WritableSignal<string>;
+    readonly contentId: _angular_core.WritableSignal<string>;
+    readonly initialFocus: _angular_core.Signal<ForSelectInitialFocus>;
+    readonly lastCloseReason: _angular_core.Signal<ForSelectCloseReason | null>;
+    readonly trigger: _angular_core.Signal<HTMLElement | null>;
+    /**
+     * Element floating-ui anchors the listbox against. Prefers an optional
+     * `[forSelectAnchor]` when registered, otherwise falls back to the trigger
+     * so existing selects 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 ForSelectOptionHandle<T>[]>;
+    /** The active option's `id` in the virtualized path, `null` in the default path. */
+    readonly activeDescendantId: _angular_core.Signal<string | null>;
+    /**
+     * Trimmed display labels of the selected values, in selection order. Pure
+     * derivation: when `[itemToLabel]` is supplied it is authoritative; otherwise
+     * resolve from the persisted option snapshot, then the serialized form value
+     * so non-string items still render meaningfully on a cold cache.
+     *
+     * The snapshot's labels come from each option's reactive `label` signal,
+     * which reads the rendered `textContent`. `textContent` is not a signal, so a
+     * label whose rendered text changes without a value change does not self-heal
+     * here — supply `[itemToLabel]` for a pure signal derivation that observes
+     * label changes directly.
+     */
+    readonly selectedLabels: _angular_core.Signal<readonly string[]>;
+    readonly selectedOptionEl: _angular_core.Signal<HTMLElement | null>;
+    protected fieldLabelledElement(): HTMLElement | null;
+    protected fieldLabelledElementId(): string;
+    constructor();
+    setInitialFocus(target: ForSelectInitialFocus): 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: ForSelectOptionHandle<T>): void;
+    unregisterOption(handle: ForSelectOptionHandle<T>): void;
+    isSelected(v: T): boolean;
+    activate(v: T): void;
+    navigate(currentOption: HTMLElement, action: ListNavigationAction): void;
+    handleTypeahead(event: KeyboardEvent): void;
+    handleClosedTypeahead(event: KeyboardEvent): boolean;
+    focusFirstEnabledOption(): boolean;
+    focusLastEnabledOption(): boolean;
+    focusSelectedOption(): boolean;
+    toggle(initialFocus?: ForSelectInitialFocus): void;
+    openMenu(initialFocus?: ForSelectInitialFocus): void;
+    closeMenu(reason: ForSelectCloseReason): void;
+    commitOnTab(value: T): void;
+    emitEscapeKeyDown(event: KeyboardEvent): void;
+    /**
+     * Outside-interaction emit forwarders. The shared `#pendingOutsideVeto`
+     * reuse between the specific outside channels and the composite
+     * `interactOutside` lives in `injectOverlayShell`; these only fire the
+     * matching output with the veto the shell built.
+     */
+    emitPointerDownOutside(veto: VetoableNativeEvent<PointerEvent>): void;
+    emitFocusOutside(veto: VetoableNativeEvent<FocusEvent>): void;
+    emitInteractOutside(veto: VetoableNativeEvent<PointerEvent | FocusEvent>): void;
+    /** Modal-path Escape forwarder: emit only; the modal shell owns the close. */
+    forwardEscapeKeyDown(veto: VetoableNativeEvent<KeyboardEvent>): void;
+    /**
+     * Implicit close requested by the shell after an un-vetoed outside
+     * interaction. Marks the control touched (mirroring the trigger blur) and
+     * closes with the channel's reason.
+     */
+    requestClose(reason: 'pointerDownOutside' | 'focusOutside'): void;
+    emitAutoFocusOnOpen(): boolean;
+    emitAutoFocusOnClose(): boolean;
+    markTouched(): void;
+    seedVirtualizedInitialFocus(): void;
+    handleVirtualizedKeydown(event: KeyboardEvent): void;
+    notifyOptionClick(optionId: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForSelect<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForSelect<any>, "[forSelect]", ["forSelect"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "isItemEqualToValue": { "alias": "isItemEqualToValue"; "required": false; "isSignal": true; }; "itemToFormValue": { "alias": "itemToFormValue"; "required": false; "isSignal": true; }; "itemToLabel": { "alias": "itemToLabel"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "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; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "totalCount": { "alias": "totalCount"; "required": false; "isSignal": true; }; "visibleRange": { "alias": "visibleRange"; "required": false; "isSignal": true; }; "_dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; "selectionFollowsFocus": { "alias": "selectionFollowsFocus"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "returnFocus": { "alias": "returnFocus"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "open": "openChange"; "scrollToIndex": "scrollToIndex"; "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "autoFocusOnOpen": "autoFocusOnOpen"; "autoFocusOnClose": "autoFocusOnClose"; }, never, never, true, never>;
+}
+
+/**
+ * Optional positioning anchor. When present, `[forSelectContent]` is
+ * positioned against this element instead of `[forSelectTrigger]` — useful
+ * when the trigger lives inside a decorated field box (padding, prefix icon,
+ * clear / chevron buttons) and the listbox should match 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 `[forSelectAnchor]` may be registered per `[forSelect]`; a second
+ * one throws.
+ *
+ * ```html
+ * <div forSelect [(value)]="v">
+ *   <div forSelectAnchor class="field-box">
+ *     <icon />
+ *     <button forSelectTrigger>…</button>
+ *     <button class="clear">×</button>
+ *   </div>
+ *   @if (open()) {
+ *     <div forSelectContent>…</div>
+ *   }
+ * </div>
+ * ```
+ */
+declare class ForSelectAnchor {
+    #private;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForSelectAnchor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForSelectAnchor, "[forSelectAnchor]", ["forSelectAnchor"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Combobox button that opens the listbox. Apply on a `<button>` so
+ * Space / Enter dispatch native click events that toggle via `(click)`.
+ *
+ * Wires APG select-only combobox attributes: `role="combobox"`,
+ * `aria-haspopup="listbox"`, `aria-expanded`, and `aria-controls` pointing
+ * to the listbox. The button is exempt from the listbox's dismissable
+ * layer — clicks on it route through `(click)` instead of triggering an
+ * outside-pointer dismissal race.
+ *
+ * The root is normally resolved via DI from the enclosing `[forSelect]`.
+ * When the trigger is declared inside an `ng-template` stamped into the root
+ * (e.g. via `ngTemplateOutlet`), DI resolves at the template's declaration
+ * site and misses the root — pass it explicitly through the selector input,
+ * `routerLink`-style: `[forSelectTrigger]="root"` with `#root="forSelect"`.
+ *
+ * Keyboard:
+ * - **Click / Enter / Space** — toggle (open focuses the selected option, or first).
+ * - **ArrowDown** — open + focus selected option (or first).
+ * - **ArrowUp** — open + focus selected option (or last when none selected).
+ * - **Typeahead** (single mode only) — printable keys select the matching
+ *   option immediately without opening the listbox, mirroring native
+ *   `<select>`. In multi mode the buffered key is ignored at the trigger;
+ *   open the listbox first to typeahead-focus.
+ */
+declare class ForSelectTrigger<T = unknown> {
+    #private;
+    /**
+     * Optional explicit reference to the `[forSelect]` root, named after the
+     * selector `routerLink`-style. The bare valueless attribute keeps resolving
+     * the enclosing root via DI; pass the root explicitly
+     * (`[forSelectTrigger]="root"`, with `#root="forSelect"`) when the trigger
+     * is declared in an `ng-template` stamped inside the root — DI resolves at
+     * the template's declaration site, so the enclosing root is invisible there.
+     * The empty string (what the valueless attribute yields) is treated as unset.
+     */
+    readonly forSelectTrigger: _angular_core.InputSignal<"" | ForSelectContext<T>>;
+    protected readonly ctx: _angular_core.Signal<ForSelectContext<T>>;
+    constructor();
+    protected onClick(): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onFocusOut(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForSelectTrigger<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForSelectTrigger<any>, "[forSelectTrigger]", ["forSelectTrigger"], { "forSelectTrigger": { "alias": "forSelectTrigger"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Renders the currently-selected option's text — or the configured
+ * placeholder when nothing is selected — into its host element via
+ * `textContent`. Apply on a `<span>` (or any inline element) inside
+ * `[forSelectTrigger]`:
+ *
+ * ```html
+ * <button forSelectTrigger>
+ *   <span forSelectValue placeholder="Select fruit…"></span>
+ * </button>
+ * ```
+ *
+ * In multi mode the labels are joined by `separator` (default `', '`). For
+ * fully custom rendering, drop this directive and read
+ * `forSelect.selectedLabels()` / `forSelect.value()` from your template.
+ */
+declare class ForSelectValue {
+    #private;
+    /** Text shown when nothing is selected. Falls back to `[forSelect][placeholder]`. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Joiner for multi-mode label rendering. Default `', '`. */
+    readonly separator: _angular_core.InputSignal<string>;
+    protected readonly isPlaceholder: _angular_core.Signal<boolean>;
+    protected readonly displayText: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForSelectValue, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForSelectValue, "[forSelectValue]", ["forSelectValue"], { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The listbox surface. Carries `role="listbox"`, is portaled to
+ * `document.body`, and is positioned by `@floating-ui/dom` against the
+ * trigger.
+ *
+ * Mount/unmount of the visible content is the consumer's responsibility —
+ * wrap with `@if (open())` so `animate.enter` / `animate.leave` fire on the
+ * natural mount cycle. While mounted, a `DismissableLayer` activates
+ * (Escape, pointer-down outside, focus outside); the trigger element is
+ * exempt from outside-pointer checks so trigger clicks toggle without
+ * dismissal racing.
+ *
+ * Initial focus is sent to the selected option (`'selected'`), the first
+ * enabled option (`'first'`), or the last enabled option (`'last'`)
+ * according to the trigger's hint. On destroy, focus returns to the
+ * trigger when `returnFocus` is true.
+ *
+ * The lifecycle is owned by one of the two shared shells, picked once on
+ * construction from `[forSelect].modal`:
+ *
+ * - **non-modal (default)** — `injectOverlayShell` anchors the listbox to the
+ *   trigger and branches on `[forSelect].position`:
+ *   - `'popper'` (default) — standard `injectFloating` path with full
+ *     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
+ *     anchored-placement inputs are documented as no-ops in this mode.
+ * - **modal** — `injectModalShell` traps focus, inerts the background, and
+ *   locks body scroll (a centered surface the consumer positions with CSS, not
+ *   trigger-anchored). The batteries-included touch presentation. Same Escape /
+ *   outside-pointer dismiss, `dismissible` / `returnFocus` / `ariaLabel`, and
+ *   `autoFocusOnOpen` / `autoFocusOnClose` veto hooks; every anchored-
+ *   positioning input is a no-op. `aria-modal="true"` is reflected as a hint —
+ *   the real modality comes from the `inert` siblings the shell applies (the
+ *   surface keeps `role="listbox"`, for which several screen readers ignore
+ *   `aria-modal`).
+ *
+ * Mount/unmount of the visible content is the consumer's responsibility —
+ * wrap with `@if (open())` so `animate.enter` / `animate.leave` fire on the
+ * natural mount cycle.
+ */
+declare class ForSelectContent {
+    #private;
+    protected readonly ctx: forty_cdk_select.ForSelectContext<unknown>;
+    constructor();
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForSelectContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForSelectContent, "[forSelectContent]", ["forSelectContent"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Injection key the `[forSelectIndicator]` uses to resolve its parent option,
+ * decoupled from the concrete `ForSelectOption` class. `ForSelectOption`
+ * provides itself under this token, so a design system wrapping the option by
+ * subclassing re-points it at the subclass with a single provider
+ * (`{ provide: FOR_SELECT_OPTION, useExisting: MtxSelectOption }`) and the
+ * indicator keeps resolving — see `docs/wrapping-form-primitives.md`.
+ */
+declare const FOR_SELECT_OPTION: InjectionToken<ForSelectOption<string>>;
+/**
+ * One option inside a `[forSelectContent]`. Apply on a `<button type="button">`
+ * so Space / Enter activation come from native button behavior — printable
+ * keys fall through to the listbox for typeahead matching.
+ *
+ * Generic over the option value type `T` (default `string`). Inferred from
+ * the `[value]` binding so consumers can pass either primitive ids or full
+ * objects (`[value]="city"` infers `T = City`); the parent `[forSelect]`
+ * must be parameterized over the same `T`. The parent's
+ * `[isItemEqualToValue]` decides how options are matched against the
+ * committed selection.
+ *
+ * Click activates: in single mode the value replaces `[(value)]` and the
+ * listbox closes; in multi mode the value toggles in/out and the listbox
+ * stays open.
+ *
+ * Keyboard while focused:
+ * - **Enter / Space** — activate (via native button click).
+ * - **ArrowDown / ArrowUp / Home / End** — move focus inside the listbox.
+ * - **Tab / Shift+Tab** — commit the focused option (single mode) and let
+ *   the browser advance focus to the next / previous focusable, mirroring
+ *   the WAI-ARIA select-only combobox pattern and native `<select>`.
+ * - **Escape** — close the listbox.
+ * - **Typeahead** — printable keys match by text content.
+ */
+declare class ForSelectOption<T = string> {
+    #private;
+    /**
+     * Stable identifier serialized into `[(value)]` and the hidden input.
+     * Defaults to `string` for back-compat; bind an object to specialize the
+     * parent `[forSelect]` over a richer `T`. The parent's
+     * `[isItemEqualToValue]` decides how options are matched against the
+     * committed selection.
+     */
+    readonly value: _angular_core.InputSignal<T>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Zero-based absolute position of this option in the full source data.
+     * Required in the virtualized path — drives `aria-posinset` and the parent's
+     * position snapshot. Leave unset (default `null`) outside it.
+     */
+    readonly posInSet: _angular_core.InputSignal<number | null>;
+    readonly id: _angular_core.Signal<string>;
+    readonly selected: _angular_core.Signal<boolean>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    protected readonly ariaSetSize: _angular_core.Signal<string | null>;
+    protected readonly ariaPosInSet: _angular_core.Signal<string | null>;
+    /**
+     * True when this option is the active candidate — DOM-focused in the
+     * default path, or `aria-activedescendant` in the virtualized path.
+     * Reflected as `data-highlighted`.
+     */
+    readonly highlighted: _angular_core.Signal<boolean>;
+    constructor();
+    protected onClick(): void;
+    protected onFocus(): void;
+    protected onBlur(): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onPointerDown(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForSelectOption<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForSelectOption<any>, "[forSelectOption]", ["forSelectOption"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "posInSet": { "alias": "posInSet"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Visibility helper inside a `[forSelectOption]`. The directive flips a
+ * `[hidden]` host binding so the consumer can keep the checkmark / icon
+ * inline without extra `@if` glue:
+ *
+ * ```html
+ * <button forSelectOption value="apple">
+ *   <span forSelectIndicator>✓</span>
+ *   Apple
+ * </button>
+ * ```
+ *
+ * Reflects the parent option's `data-state` (`"checked" | "unchecked"`) so
+ * the consumer can also style it from CSS. Visibility while unselected 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.
+ */
+declare class ForSelectIndicator {
+    protected readonly option: ForSelectOption<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForSelectIndicator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForSelectIndicator, "[forSelectIndicator]", ["forSelectIndicator"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Optional grouping wrapper inside a `[forSelectContent]`. Renders
+ * `role="group"` and references the descendant `[forSelectGroupLabel]`
+ * (if any) via `aria-labelledby`. Options inside a group still register
+ * with the root listbox normally, so keyboard navigation traverses across
+ * groups in DOM order without special handling.
+ */
+declare class ForSelectGroup {
+    #private;
+    /** The id of the registered group label (or `null` if none). */
+    readonly labelId: _angular_core.Signal<string | null>;
+    /** Called by `ForSelectGroupLabel` on mount. */
+    registerLabel(id: string): void;
+    /** Called by `ForSelectGroupLabel` on destroy. Idempotent. */
+    unregisterLabel(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForSelectGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForSelectGroup, "[forSelectGroup]", ["forSelectGroup"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Visible label for a `[forSelectGroup]`. Generates a stable id and
+ * registers with its parent group so the group's `aria-labelledby` points
+ * at this element. Apply on whatever heading element fits the design
+ * (often `<div>` styled as a small caption).
+ */
+declare class ForSelectGroupLabel {
+    /** Stable host id used by the parent group's `aria-labelledby`. */
+    readonly id: Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForSelectGroupLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForSelectGroupLabel, "[forSelectGroupLabel]", ["forSelectGroupLabel"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Decorative separator between options or groups inside a
+ * `[forSelectContent]`. Carries `role="separator"` and is intentionally not
+ * registered with the listbox's option collection, so keyboard navigation
+ * and typeahead skip it automatically.
+ */
+declare class ForSelectSeparator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForSelectSeparator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForSelectSeparator, "[forSelectSeparator]", ["forSelectSeparator"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Defaults inherited by descendant selects in the surrounding injector
+ * scope. Configure with `provideForSelectDefaults` either at the
+ * application root or in any component's `providers` array; partial
+ * overrides merge with the parent scope.
+ */
+interface ForSelectDefaults {
+    /**
+     * Distance (px) between the select trigger and the floating content
+     * along the resolved `side` axis.
+     */
+    sideOffset: number;
+    /**
+     * Padding (px) added to the viewport edges for collision-aware
+     * positioning. Higher values keep the floating content further from
+     * the edge when `flip` / `shift` runs.
+     */
+    collisionPadding: number;
+}
+/** Token holding the resolved select defaults for the current scope. */
+declare const FOR_SELECT_DEFAULTS: _angular_core.InjectionToken<ForSelectDefaults>;
+/**
+ * Configures forty-cdk select defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library
+ * defaults at the root).
+ */
+declare function provideForSelectDefaults(defaults?: Partial<ForSelectDefaults>): Provider[];
+
+/**
+ * Exact public names of every `ForSelect` 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: 'div[mySelect]',
+ *   template: '',
+ *   hostDirectives: [
+ *     {
+ *       directive: ForSelect,
+ *       inputs: [...FOR_SELECT_HOST_DIRECTIVE_INPUTS],
+ *       outputs: [...FOR_SELECT_HOST_DIRECTIVE_OUTPUTS],
+ *     },
+ *   ],
+ * })
+ * export class MySelect {}
+ * ```
+ */
+declare const FOR_SELECT_HOST_DIRECTIVE_INPUTS: readonly ["value", "open", "align", "alignOffset", "ariaLabel", "arrowPadding", "avoidCollisions", "clipUntilPositioned", "collisionPadding", "dir", "dirty", "disabled", "dismissible", "errors", "hideWhenDetached", "invalid", "isItemEqualToValue", "itemToFormValue", "itemToLabel", "loop", "modal", "multiple", "name", "orientation", "pending", "placeholder", "position", "readonly", "required", "returnFocus", "selectionFollowsFocus", "side", "sideOffset", "sticky", "totalCount", "touched", "visibleRange"];
+/**
+ * Exact public names of every `ForSelect` output, the Signal Forms `touch` output
+ * included. Spread it into the `outputs` array of the same `hostDirectives` entry as
+ * {@link FOR_SELECT_HOST_DIRECTIVE_INPUTS}.
+ */
+declare const FOR_SELECT_HOST_DIRECTIVE_OUTPUTS: readonly ["valueChange", "openChange", "escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside", "autoFocusOnOpen", "autoFocusOnClose", "scrollToIndex", "touchedChange", "touch"];
+
+export { FOR_SELECT_CONTEXT, FOR_SELECT_DEFAULTS, FOR_SELECT_HOST_DIRECTIVE_INPUTS, FOR_SELECT_HOST_DIRECTIVE_OUTPUTS, FOR_SELECT_OPTION, ForSelect, ForSelectAnchor, ForSelectContent, ForSelectGroup, ForSelectGroupLabel, ForSelectIndicator, ForSelectOption, ForSelectSeparator, ForSelectTrigger, ForSelectValue, provideForSelectDefaults };
+export type { ForSelectCloseReason, ForSelectContext, ForSelectDefaults, ForSelectInitialFocus, ForSelectOptionHandle };