import * as _angular_core from '@angular/core';
import { InjectionToken, Signal, Provider } from '@angular/core';
import * as forty_cdk_select from 'forty-cdk/select';
import { FormValueControl } from '@angular/forms/signals';
import { WritingDirection, CollectionHandle, VetoableNativeEvent, VetoableEvent } from 'forty-cdk/core';
import { FloatingSide, FloatingAlign, ListboxOverlayContext, AnchoredFormValueControlBase, AnchoredPositioningSeedDefaults } from 'forty-cdk/core-overlay';

/**
 * 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 `compareWith`.
 */
interface ForSelectOptionHandle<T = unknown> extends CollectionHandle {
    /**
     * Narrowed from {@link CollectionHandle}'s `Node`: the root focuses the
     * option and scrolls it into view.
     */
    readonly host: HTMLElement;
    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>;
}
/**
 * The consumer-facing slice of the select's overlay surface, reached through
 * {@link ForSelectContext.overlay}: the trigger / content ids the ARIA wiring
 * points at, the reason of the last close, and the open / close commands that
 * mutate `open()` through the root's guards.
 *
 * It is narrow. The full state machine behind it — the trigger /
 * anchor / content / option registries, the DOM-focus navigation algorithm, the
 * initial-focus state, and the dismiss / auto-focus emit forwarders — is the
 * library's own wiring and is refactored without notice, so it stays on an
 * unexported surface the pieces reach through their own token.
 */
interface ForSelectOverlayFacade {
    /** The trigger's stable id, adopted from a consumer-set static id when present. */
    readonly triggerId: Signal<string>;
    /** The content surface's stable id, adopted from a consumer-set static id when present. */
    readonly contentId: Signal<string>;
    /** Reason of the most recent close, or `null` while open (or before any close). */
    readonly lastCloseReason: Signal<ForSelectCloseReason | null>;
    /**
     * Registers the element `[forSelectContent]` is positioned against, instead of
     * the trigger. The declarative `[forSelectAnchor]` covers the common case; call
     * this directly when the anchor element is only reachable imperatively — it
     * lives in an ancestor component's template, so a directive placed on it would
     * resolve DI outside this root. At most one anchor may be registered per
     * `[forSelect]`; a second one throws.
     */
    registerAnchor(el: HTMLElement): void;
    /** Unregisters the positioning anchor, falling back to the trigger. Reference-based. */
    unregisterAnchor(el: HTMLElement): void;
    /** Opens the listbox with the requested initial-focus target. */
    openOverlay(initialFocus: ForSelectInitialFocus): void;
    /** Closes the listbox, recording `reason` as the last close reason. */
    closeOverlay(reason: ForSelectCloseReason): void;
    /** Opens the listbox when closed (with `initialFocus`), closes it when open. */
    toggle(initialFocus: ForSelectInitialFocus): void;
}
/**
 * The shared overlay-listbox coordination surface backing
 * {@link ForSelectOverlayFacade}: trigger / anchor / content registries + ids,
 * DOM-focus navigation, the open / close machine, the initial-focus /
 * close-reason state, and the dismiss / auto-focus emit forwarders. Backed by
 * the shared `ListboxOverlayController`, so child directives read it here
 * instead of the root re-forwarding each member.
 *
 * Internal — never re-exported from `public-api.ts`; pieces reach it through
 * {@link SelectContext}.
 */
type ForSelectOverlayContext<T = unknown> = ListboxOverlayContext<ForSelectOptionHandle<T>, ForSelectInitialFocus, ForSelectCloseReason>;
/**
 * Coordination contract owned by `[forSelect]` — the surface a consumer reads
 * and drives. Advanced consumers inject the token to read the selection and the
 * open state and to move them through the root's guards (`activate` /
 * `selectAll`, plus the open / close commands on {@link ForSelectContext.overlay}).
 * The wiring the library's own pieces read off the root is not
 * part of it.
 *
 * 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 `compareWith` and serialized for
 * the form's hidden inputs via `itemToFormValue`; option text labels are
 * still read from the rendered `textContent`.
 */
interface ForSelectContext<T = unknown> {
    /**
     * The current selection, as a read-only signal. Mutate it through the guarded
     * methods (`activate` / `commitOnTab`) or the root's `[(value)]` binding — a
     * direct write would bypass the root's disabled / readonly guards and
     * `markTouched`.
     */
    readonly value: Signal<readonly T[]>;
    /**
     * Whether the listbox is open, as a read-only signal. Mutate it through
     * `overlay.toggle` / `overlay.openOverlay` / `overlay.closeOverlay` or the root's
     * `[(open)]` binding.
     */
    readonly open: Signal<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: the trigger reflects the native
     * `disabled` attribute (its single channel) and the options, which
     * must stay focusable, reflect `aria-disabled`.
     */
    readonly effectiveDisabled: Signal<boolean>;
    readonly readonly: Signal<boolean>;
    readonly required: Signal<boolean>;
    readonly invalid: Signal<boolean>;
    readonly pending: Signal<boolean>;
    readonly dir: Signal<WritingDirection>;
    readonly placeholder: Signal<string>;
    /**
     * The consumer-facing slice of the overlay surface: the trigger / content ids,
     * the last close reason, and the open / close commands. The registration and
     * navigation machinery behind it is internal — see
     * {@link ForSelectOverlayFacade}.
     */
    readonly overlay: ForSelectOverlayFacade;
    /** Resolved labels of the options whose value is in `value()`, in selection order. */
    readonly selectedLabels: Signal<readonly string[]>;
    isSelected(value: T): boolean;
    /** Toggle in multi-mode, replace + close in single-mode. No-op on disabled / readonly. */
    activate(value: T): void;
    /**
     * Multi-select only (APG range keyboard, Ctrl/Cmd+A). Select every enabled
     * option, or clear the selection when they are all already selected (toggle).
     * No-op in single mode, disabled, readonly, or the virtualized path.
     */
    selectAll(): void;
    /** Flip the `touched` model. Called by trigger on blur-to-outside and on dismiss events. */
    markTouched(): void;
}
/**
 * The select's piece-coordination surface: everything the library's own pieces
 * read off the root that a consumer has no call to touch — the positioning
 * mirrors `[forSelectContent]` feeds to floating-ui, the APG range-selection and
 * typeahead handlers `[forSelectOption]` routes its keys through, and the
 * virtualized activedescendant model.
 *
 * **Not** part of {@link ForSelectContext} and never exported from
 * `public-api.ts`: these are the members a refactor of the anatomy moves, so
 * freezing them at 1.0 would freeze the anatomy with them.
 */
interface SelectPieceContext<T = unknown> {
    /**
     * When `true`, the listbox is a trapped / inert / scroll-locked modal
     * surface (routed through the core 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 sticky: Signal<'partial' | 'always' | false>;
    readonly hideWhenDetached: Signal<boolean>;
    readonly clipUntilPositioned: Signal<boolean>;
    readonly loop: Signal<boolean>;
    readonly orientation: Signal<'horizontal' | 'vertical'>;
    readonly selectionFollowsFocus: Signal<boolean>;
    readonly ariaLabel: Signal<string | null>;
    /**
     * The `[forSelect]` root (wrapper) element. Lets the trigger tell a focus
     * move to a sibling *inside* the wrapper (e.g. a clear button next to the
     * trigger) apart from a genuine focus leave, so `touched` isn't flipped
     * prematurely when focus stays within the control.
     */
    readonly host: HTMLElement;
    /** Compare two items for equality. Defaults to `===`; overridden for object values. */
    readonly compareWith: 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>;
    /**
     * 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>;
    /**
     * Multi-select only (APG range keyboard). Move focus to the next / previous
     * enabled option and toggle it in/out of the selection, without moving the
     * range anchor. Non-wrapping. No-op in single mode, when disabled, or in the
     * virtualized path. Focus still moves under `readonly`; only the selection
     * mutation is blocked.
     */
    extendByArrow(currentOption: HTMLElement, action: 'next' | 'prev'): void;
    /**
     * Multi-select only (APG range keyboard, Shift+Space). Add every enabled
     * option between the range anchor and the focused option to the selection,
     * preserving any selection outside the span. Falls back to selecting just the
     * focused option when no anchor exists. No-op in single mode, disabled,
     * readonly, or the virtualized path.
     */
    selectRangeToFocused(currentOption: HTMLElement): void;
    /**
     * Multi-select only (APG range keyboard, Ctrl+Shift+Home / End). Add every
     * enabled option from the focused option to the first / last option to the
     * selection and move focus to that edge, preserving any selection outside the
     * span. No-op in single mode, disabled, or the virtualized path. Focus still
     * moves under `readonly`; only the selection mutation is blocked.
     */
    selectFromCurrentToEdge(currentOption: HTMLElement, edge: 'first' | 'last'): 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;
    /** Focus the first enabled option whose value is currently selected. Returns `false` if none. */
    focusSelectedOption(): boolean;
    /**
     * Scroll the selected option into view. Driven from `[forSelectContent]`'s
     * positioner first-resolved-position hook (`onFirstPosition`) in `'popper'`
     * mode — the only moment both prerequisites hold: the surface has been
     * portaled to `document.body` (resetting its `scrollTop` to 0) and
     * `@floating-ui/dom`'s `size` middleware has constrained it to its
     * `max-height` (so it is actually scrollable). Focusing the selected option
     * earlier scrolls before the surface is bounded, so the reveal is lost.
     * No-op while virtualizing (the navigator owns the virtualized scroll) and
     * when nothing is selected (initial focus lands on the first option, already
     * in view at the top).
     */
    scrollSelectedOptionIntoView(): void;
    /**
     * 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;
    /**
     * 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)`) when its
     * position is known — in the rendered window, previously rendered, or
     * supplied via the root's `[selectedIndex]`; otherwise focuses the first
     * enabled option.
     */
    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;
    /**
     * Host element of the option the pointer is over in the default DOM-focus
     * path, `null` when the pointer is over none. Self-heals on read: a host that
     * has left the registered set or become disabled is discounted, so the focused
     * option reclaims the highlight. Always `null` in the virtualized path, where
     * hover moves {@link SelectPieceContext.activeDescendantId} itself.
     */
    readonly pointerHighlightedOption: Signal<HTMLElement | null>;
    /**
     * Reported by `[forSelectOption]` on `pointermove` so the highlight follows
     * the pointer. Never moves DOM focus, so it never commits a selection — not
     * even under `selectionFollowsFocus`, whose commit hangs off the navigation
     * focus move — and never touches the range anchor. A move arriving inside the
     * pointer-suppression window a programmatic scroll opened is ignored, or a
     * scroll sliding a different option under a stationary cursor would hand the
     * highlight to whatever the user merely scrolled past.
     *
     * @param host The hovered option's host — the DOM-focus path's highlight target.
     * @param id The hovered option's id — the virtualized path's highlight target.
     */
    highlightFromPointer(host: HTMLElement, id: string): void;
    /**
     * Called by an option when it takes DOM focus: drops any pointer highlight, so
     * the keyboard channel owns the highlight again from the move that focused the
     * option.
     */
    notifyOptionFocus(): void;
    /**
     * Called by `[forSelectContent]` when the pointer leaves the listbox surface:
     * drops any pointer highlight, so the focused option reclaims it instead of a
     * row staying decorated with the cursor elsewhere on the page. Crossing
     * between two adjacent options is not a leave, so the highlight never blinks
     * off. No-op in the virtualized path, where the pointer's claim *is*
     * {@link SelectPieceContext.activeDescendantId} and releasing it would leave
     * the container with no active option.
     */
    releasePointerHighlight(): void;
}
/**
 * DI token for the select's coordination surface, provided by `[forSelect]`.
 *
 * Publicly typed as the read surface {@link ForSelectContext}, which is the whole of what
 * the token promises a consumer — `overlay` included, narrowed there to
 * {@link ForSelectOverlayFacade}. The pieces read the same token at an internal type that
 * widens it to the full overlay controller, so a wrapper re-providing it must alias it to
 * the root: `{ provide: FOR_SELECT_CONTEXT, useExisting: MySelect }`, where `MySelect`
 * extends `ForSelect`. A value that merely satisfies the declared type resolves too, and is
 * rejected in dev mode by the first piece to reach the controller.
 */
declare const FOR_SELECT_CONTEXT: InjectionToken<ForSelectContext<unknown>>;
/**
 * The select's internal coordination surface: everything {@link ForSelectContext}
 * publishes, plus the {@link SelectPieceContext} members and the full overlay
 * state machine instead of the consumer facade.
 *
 * Never exported from `public-api.ts`. It is the type the pieces read
 * {@link FOR_SELECT_CONTEXT} at, so a consumer who injects that token gets the
 * read surface while the pieces get the wiring protocol. `ForSelect` declares
 * `overlay` with the narrow public type and the piece members TS-`private`,
 * which keeps both out of the emitted `.d.ts` while `useExisting` still
 * satisfies this contract at runtime.
 */
interface SelectContext<T = unknown> extends ForSelectContext<T>, SelectPieceContext<T> {
    readonly overlay: ForSelectOverlayContext<T>;
}

/**
 * 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 `[compareWith]` 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 AnchoredFormValueControlBase implements FormValueControl<readonly T[]>, ForSelectContext<T> {
    #private;
    protected readonly positioningDefaults: forty_cdk_select.ForSelectDefaults;
    /** The `[forSelect]` root element (see `SelectPieceContext.host`). */
    private readonly host;
    /**
     * 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:
     * `[compareWith]="(a, b) => a.id === b.id"`.
     */
    readonly compareWith: _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>;
    /**
     * When true, multiple options can be selected and option activation toggles
     * without closing the listbox. Single mode (default) keeps the value array at
     * 0 or 1 element and closes on select.
     *
     * In the default (non-virtualized) path the full APG range keyboard
     * (Shift+Arrow, Shift+Space, Ctrl/Cmd+A, Ctrl+Shift+Home/End) extends the
     * selection, matching `ForListbox`.
     *
     * That range keyboard is not supported together with virtualization
     * (`totalCount` set): range selection needs the full set of enabled options
     * across the range, which is unavailable while the list is partially
     * unmounted. Pressing one of those combinations on a virtualized multi-select
     * listbox throws in dev mode. Toggle options individually with Enter, Space,
     * or click, or drop `totalCount` to use the non-virtualized DOM-focus listbox.
     */
    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` — is a no-op in this mode. Default
     * `false` (non-breaking). The swipe / snap-point sheet is 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">;
    /** Whether arrow navigation wraps past the first / last enabled option. */
    readonly loop: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Axis the arrow keys navigate. Reflected as `data-orientation` on the content. */
    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, as provided
     * by `injectVirtualizer`. Decides whether a navigation target is inside the visible window.
     */
    readonly visibleRange: _angular_core.InputSignal<readonly [number, number] | undefined>;
    /**
     * Virtualized-only open-time reveal hint: the absolute index of the currently
     * committed option within the full source dataset. Consulted on open by the
     * scroll-to-selected algorithm as the authoritative index when the committed
     * value's option lies outside the rendered window and has never been rendered
     * (so its position is absent from the navigator snapshot). Bind it from the
     * consumer's own value→index lookup.
     *
     * This is a reveal hint, **not** a selection source — `value` / `[(value)]`
     * stay authoritative; it only decides which option is scrolled into view on
     * open. It is singular: in multiple mode it seeds the first committed option.
     * Leave unset (default) for a non-virtualized select, or when the committed
     * option is always inside the initial window. An off-window committed value
     * with no `[selectedIndex]` that was never rendered falls back to focusing the
     * first enabled option; an out-of-range index (or an empty selection) is
     * silently ignored.
     */
    readonly selectedIndex: _angular_core.InputSignal<number | undefined>;
    /**
     * Optional virtualized-only seam that tells the directive the source dataset
     * changed **without** a `totalCount` transition — a same-length re-sort or
     * refresh (e.g. sorting a 1000-row list). Bind any value that changes on such
     * a refresh (a version counter, the array reference, a sort-key string); when
     * it changes the position snapshot rebuilds from empty so navigation never
     * resolves against a stale off-window entry. Leave unset (default) when the
     * dataset only ever changes length. Equivalent to calling
     * {@link ForSelect.invalidateSnapshot} imperatively.
     */
    readonly dataVersion: _angular_core.InputSignal<unknown>;
    /**
     * Emitted when navigation reaches an option outside the rendered window, or
     * on open-time scroll-to-selected when the committed option's absolute index
     * is resolvable — it is in the rendered window, was previously rendered (in
     * the snapshot), or was supplied via `[selectedIndex]`. 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`.
     *
     * Not supported together with virtualization (`totalCount` set): the
     * virtualized `aria-activedescendant` path resolves off-window navigation
     * targets asynchronously, so selection cannot follow focus there without
     * deriving the committed value from a render side effect. Keyboard-navigating
     * a virtualized listbox with it set throws in dev mode, from the move the
     * combination degrades.
     */
    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>;
    /** Emitted before Escape closes the listbox. Call `preventDefault()` to keep it open. */
    readonly escapeKeyDown: _angular_core.OutputEmitterRef<VetoableNativeEvent<KeyboardEvent>>;
    /** Emitted before an outside pointer-down closes the listbox. Vetoable with `preventDefault()`. */
    readonly pointerDownOutside: _angular_core.OutputEmitterRef<VetoableNativeEvent<PointerEvent>>;
    /** Emitted before focus leaving the surface closes the listbox. Vetoable with `preventDefault()`. */
    readonly focusOutside: _angular_core.OutputEmitterRef<VetoableNativeEvent<FocusEvent>>;
    /**
     * Emitted alongside {@link pointerDownOutside} and {@link focusOutside} for consumers that do not
     * care which one occurred. A `preventDefault()` on either channel suppresses the close.
     */
    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>;
    /**
     * The shared overlay-listbox coordination surface: trigger / anchor / content registration and
     * ids, DOM-focus navigation, the open / close machine, and the dismiss and auto-focus forwarders.
     *
     * Positioning prefers a registered `[forSelectAnchor]`, reached via `overlay.anchor`, and falls
     * back to the trigger.
     */
    readonly overlay: ForSelectOverlayFacade;
    /** The active option's `id` in the virtualized path, `null` in the default path. */
    private readonly activeDescendantId;
    private readonly pointerHighlightedOption;
    /**
     * Force the virtualized position snapshot to rebuild from empty on the next
     * fold, discarding stale off-window entries. Call after a same-length dataset
     * refresh (a re-sort / reload that keeps `totalCount` unchanged) when you
     * cannot express the change through the reactive `[dataVersion]` input. No-op
     * when the select is not virtualized (`totalCount` unset).
     */
    invalidateSnapshot(): void;
    /**
     * Trimmed display labels of the selected values, in selection order. Pure
     * derivation: when `[itemToLabel]` is supplied it is authoritative; otherwise
     * resolve from the selection-keyed label cache, then the serialized form value
     * so non-string items still render meaningfully on a cold cache.
     *
     * The cache'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[]>;
    private readonly selectedOptionEl;
    protected fieldLabelledElement(): HTMLElement | null;
    protected fieldLabelledElementId(): string;
    /**
     * Move focus to the trigger, implementing `FormValueControl.focus` from
     * `@angular/forms/signals`. Without this override Signal Forms would focus the
     * host `[forSelect]` wrapper — which carries no focusable role — so
     * focus-on-error would silently go nowhere. No-op when disabled or before the
     * trigger has registered.
     */
    focus(options?: FocusOptions): void;
    constructor();
    isSelected(v: T): boolean;
    activate(v: T): void;
    private extendByArrow;
    private selectRangeToFocused;
    selectAll(): void;
    private selectFromCurrentToEdge;
    private handleTypeahead;
    private handleClosedTypeahead;
    private focusSelectedOption;
    private scrollSelectedOptionIntoView;
    private highlightFromPointer;
    private notifyOptionFocus;
    private releasePointerHighlight;
    private commitOnTab;
    markTouched(): void;
    private seedVirtualizedInitialFocus;
    private handleVirtualizedKeydown;
    private notifyOptionClick;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForSelect<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForSelect<any>, "[forSelect]", ["forSelect"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "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; }; "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; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; "dataVersion": { "alias": "dataVersion"; "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 dismissible
 * layer — clicks on it route through `(click)` instead of triggering an
 * outside-pointer dismissal race.
 *
 * Disabling: the native `disabled` attribute is the single reflection channel
 * — no `aria-disabled` is emitted, because on a real single-purpose `<button>`
 * trigger the native attribute already conveys the state to assistive
 * technology, and it is what suppresses activation here. The
 * `role="combobox"` override does not change that: the HTML `disabled`
 * attribute maps to the unavailable state regardless of the ARIA role, and a
 * native `<select disabled>` leaves the tab order the same way. It is
 * reflected non-destructively — the directive only removes the attribute when
 * it set it itself — and `data-disabled=""` stays as the styling hook. The
 * remaining form-control state (`aria-readonly` / `aria-required` /
 * `aria-invalid` / `aria-busy`) is unaffected, and the read-only state carries
 * its own `data-readonly=""` styling hook — `readonly` is not a valid attribute
 * of `<button>`, so a `data-*` channel is the only one available there.
 *
 * 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;
    protected readonly buttonType: Signal<string | null>;
    /**
     * 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: Signal<SelectContext<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 it dismisses on Escape, pointer-down
 * outside or 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 picked once on construction from `[forSelect].modal`:
 *
 * - **non-modal (default)** — the listbox is anchored to the trigger and
 *   branches on `[forSelect].position`:
 *   - `'popper'` (default) — full anchored placement (`side`, `align`,
 *     `sideOffset`, `alignOffset`, `flip`, `shift`, `arrow`,
 *     `hideWhenDetached`).
 *   - `'item-aligned'` — the listbox overlays the trigger so the selected
 *     option's center aligns with the trigger's center. The anchored-placement
 *     inputs are no-ops in this mode.
 * - **modal** — focus is trapped, the background is inerted and body scroll is
 *   locked; the surface is centered and positioned by the consumer's CSS rather
 *   than anchored to the trigger, so every anchored-positioning input is a
 *   no-op. Escape / outside-pointer dismiss, `dismissible` / `returnFocus` /
 *   `ariaLabel` and the `autoFocusOnOpen` / `autoFocusOnClose` vetoes are
 *   unchanged. Modality is conveyed by the `inert` siblings and reflected as
 *   `data-modal` for styling; `role="listbox"` does not support `aria-modal`,
 *   so it is not emitted.
 */
declare class ForSelectContent {
    #private;
    protected readonly ctx: SelectContext;
    protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
    protected readonly labelledBy: _angular_core.Signal<string | null>;
    constructor();
    protected onKeyDown(event: KeyboardEvent): void;
    protected onPointerLeave(): 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
 * `[compareWith]` 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.
 *
 * Hovering an enabled option hands it `data-highlighted`, so pointer and
 * keyboard feed one highlight and exactly one option is ever decorated. Hover
 * never moves DOM focus and never selects — the pointer's own click activates —
 * and moving the pointer off `[forSelectContent]` hands the highlight back to
 * the focused option.
 *
 * Keyboard while focused:
 * - **Enter / Space** — activate (via native button click).
 * - **ArrowDown / ArrowUp / Home / End** — move focus inside the listbox.
 * - **Shift+Arrow / Shift+Space / Ctrl+A / Ctrl+Shift+Home / Ctrl+Shift+End**
 *   _(multi mode, non-virtualized)_ — APG range selection, matching
 *   `ForListbox`.
 * - **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;
    protected readonly buttonType: _angular_core.Signal<string | null>;
    /**
     * 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
     * `[compareWith]` decides how options are matched against the
     * committed selection.
     *
     * Mandatory — an unbound option throws in dev mode.
     */
    readonly value: _angular_core.InputSignal<T>;
    /**
     * Whether the option can be activated. A disabled option stays rendered and announced, and is
     * skipped by arrow navigation and typeahead.
     */
    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 — the one the pointer is over,
     * else the keyboard's. In the default path the keyboard channel is the
     * DOM-focused option; in the virtualized path it is `aria-activedescendant`,
     * which hover moves too, so the highlight and the option `Enter` activates
     * never disagree there. Reflected as `data-highlighted`.
     */
    readonly highlighted: _angular_core.Signal<boolean>;
    constructor();
    protected onClick(): void;
    protected onFocus(): void;
    protected onBlur(): void;
    protected onPointerMove(): 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": false; "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>;
    protected readonly labelledBy: _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: string;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForSelectGroupLabel, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForSelectGroupLabel, "[forSelectGroupLabel]", ["forSelectGroupLabel"], {}, {}, never, never, true, never>;
}

/**
 * Visual + semantic 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. Set `decorative` when the surrounding
 * options already convey the split and the line should be skipped by
 * assistive tech.
 */
declare class ForSelectSeparator {
    /**
     * Axis the separator divides along, always reflected to `data-orientation`
     * and reflected to `aria-orientation` only for `vertical` (`horizontal` is
     * the ARIA default and is omitted). `horizontal` (default) splits options
     * stacked vertically — the common case in a listbox; `vertical` splits
     * options laid out horizontally.
     */
    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
    /**
     * When true, the separator is purely visual: it gets `role="none"` and no
     * `aria-orientation`, so assistive tech treats the surrounding options as a
     * single flow. `data-orientation` is still reflected for styling.
     */
    readonly decorative: _angular_core.InputSignalWithTransform<boolean, unknown>;
    protected roleAttr(): 'separator' | 'none';
    protected ariaOrientationAttr(): 'vertical' | null;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForSelectSeparator, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForSelectSeparator, "[forSelectSeparator]", ["forSelectSeparator"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "decorative": { "alias": "decorative"; "required": false; "isSignal": true; }; }, {}, 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 extends AnchoredPositioningSeedDefaults {
    /**
     * Side the listbox is anchored to for selects that don't override `side`
     * locally. Ignored under `position="item-aligned"`. Library fallback
     * `'bottom'`.
     */
    side: FloatingSide;
    /**
     * Alignment along the chosen `side` for selects that don't override `align`
     * locally. Ignored under `position="item-aligned"`. Library fallback
     * `'start'`.
     */
    align: FloatingAlign;
    /**
     * 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", "avoidCollisions", "clipUntilPositioned", "collisionPadding", "compareWith", "dataVersion", "dir", "dirty", "disabled", "dismissible", "errors", "hideWhenDetached", "invalid", "itemToFormValue", "itemToLabel", "loop", "modal", "multiple", "name", "orientation", "pending", "placeholder", "position", "readonly", "required", "returnFocus", "selectedIndex", "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, ForSelectOverlayFacade };