import * as _angular_core from '@angular/core';
import { InjectionToken, Signal, Provider } from '@angular/core';
import { FormValueControl } from '@angular/forms/signals';
import { WritingDirection, ListNavigationAction, FormUiControlBase, RovingTabindex } from 'forty-cdk/core';

interface ForListboxOptionHandle<T = unknown> {
    readonly host: HTMLElement;
    readonly value: Signal<T>;
    readonly disabled: Signal<boolean>;
    readonly id: Signal<string>;
    readonly posInSet: Signal<number | null>;
}
/**
 * Coordination contract owned by `ForListbox`. Each `ForListboxOption`
 * registers a handle on init so the group can react to disabled changes,
 * compute the first-enabled tab entry, and run typeahead matching.
 *
 * 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 `[forListboxOption][value]`; object identity is resolved
 * by the consumer-supplied `compareWith` and the form's hidden inputs
 * serialize via `itemToFormValue`. Option text labels are still read from the
 * rendered `textContent`.
 */
interface ForListboxContext<T = unknown> {
    readonly value: Signal<readonly T[]>;
    readonly multiple: Signal<boolean>;
    /**
     * The listbox's effective disabled — its own `disabled` input OR'd with a
     * surrounding disabled `[forFieldset]`. Each `ForListboxOption` ORs this into
     * its own `effectiveDisabled`, so a disabled listbox (or fieldset) disables
     * every option.
     */
    readonly effectiveDisabled: Signal<boolean>;
    readonly readonly: Signal<boolean>;
    readonly orientation: Signal<'horizontal' | 'vertical'>;
    readonly dir: Signal<WritingDirection>;
    readonly selectionFollowsFocus: Signal<boolean>;
    /** 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>;
    /**
     * Full source length when virtualizing, `undefined` in the roving-tabindex
     * path. Drives the option's `aria-setsize` / `aria-posinset` and the
     * option's focus-model branch.
     */
    readonly totalCount: Signal<number | undefined>;
    /**
     * The active option's `id` when using the activedescendant focus model,
     * `null` in the roving-tabindex path. Moved by keyboard navigation and by
     * hover alike. Options read this to compute `data-highlighted`.
     */
    readonly activeDescendantId: Signal<string | null>;
    isSelected(value: T): boolean;
    /** Toggle in multi-mode, replace in single-mode. No-op on disabled / readonly. */
    activate(value: T): void;
    /** Move focus from `currentOption` according to `action`. May also select if `selectionFollowsFocus` is on. */
    navigate(currentOption: HTMLElement, action: ListNavigationAction): void;
    /**
     * Multi-mode only. Move focus to the next/prev enabled option AND toggle its
     * selected state — APG "Shift+ArrowDown / Shift+ArrowUp toggles selection
     * while moving focus". No-op in single mode, on disabled, or when no enabled
     * neighbor exists. On `readonly` the focus still moves (matching
     * {@link navigate}); only the selection mutation is blocked.
     */
    extendByArrow(currentOption: HTMLElement, action: 'next' | 'prev'): void;
    /**
     * Multi-mode only. APG "Shift+Space": select every enabled option from the
     * anchor (set on the most recent unmodified activation) up to and including
     * `currentOption`. Existing selection outside the range is preserved. No-op
     * in single mode or when the listbox is disabled / readonly.
     */
    selectRangeToFocused(currentOption: HTMLElement): void;
    /**
     * Multi-mode only. APG "Ctrl/Cmd+A": select every enabled option. If every
     * enabled option is already selected, clears the selection (toggle).
     */
    selectAll(): void;
    /**
     * Multi-mode only. APG "Ctrl+Shift+Home / Ctrl+Shift+End": select every
     * enabled option from `currentOption` (inclusive) to the first / last
     * enabled option, and move focus to that edge.
     */
    selectFromCurrentToEdge(currentOption: HTMLElement, edge: 'first' | 'last'): void;
    /**
     * Forward a keydown to the typeahead helper. If the key is a printable
     * character, finds the first matching option and focuses it; returns true
     * to indicate the event was consumed.
     */
    handleTypeahead(event: KeyboardEvent): boolean;
    /**
     * Pre-focus tab-stop policy: with at least one selection, the first selected
     * enabled option is the sole entry point; otherwise the first enabled option
     * in DOM order. Guarantees a single `tabindex="0"` before roving takes over.
     */
    isFirstFocusableOption(el: HTMLElement): boolean;
    /**
     * `true` when `el` is the highlighted option in the roving-tabindex path
     * (reflected as `data-highlighted`): the one the pointer is over, else the
     * roving active option.
     */
    isOptionHighlighted(el: HTMLElement): boolean;
    /**
     * Roving-tabindex value for `el`: `0` for the active option once roving has
     * taken over, `-1` otherwise. Returns `null` before any option is active so
     * the caller can fall back to {@link isFirstFocusableOption}.
     */
    optionTabindex(el: HTMLElement): -1 | 0 | null;
    /**
     * Mark `el` as the roving-tabindex active option (called on option focus).
     * Also drops any pointer highlight, so the keyboard channel owns the highlight
     * again from the move that focused `el`.
     */
    setActiveOption(el: HTMLElement): void;
    /**
     * All registered options, in DOM (rendered) order. Exposed for container-level
     * coordinators that compose onto the listbox — e.g. `ForListboxReorder` reads the
     * ordered hosts to resolve drop targets and emit reorder indices — without each
     * option needing a `[forDraggable]` that would fight the listbox's own roving tabindex.
     */
    readonly options: Signal<readonly ForListboxOptionHandle<T>[]>;
    /**
     * Called by an option on click. In the virtualized path, moves
     * `aria-activedescendant` to that option and returns DOM focus to the
     * container. A no-op in the roving-tabindex path.
     */
    notifyOptionClick(optionId: string): void;
    registerOption(handle: ForListboxOptionHandle<T>): void;
    unregisterOption(handle: ForListboxOptionHandle<T>): void;
}
/**
 * DI token for the listbox's coordination surface, provided by `[forListbox]`.
 *
 * Publicly typed as the read surface {@link ForListboxContext}, which is the whole
 * of what the token promises a consumer. The options read the same token at an
 * internal type that adds the pointer-highlight channel, so a wrapper re-providing
 * it must alias it to the root: `{ provide: FOR_LISTBOX_CONTEXT, useExisting: MyListbox }`,
 * where `MyListbox` extends `ForListbox`. A value that merely satisfies the declared
 * type resolves too, and is rejected in dev mode by the first piece to reach the channel.
 */
declare const FOR_LISTBOX_CONTEXT: InjectionToken<ForListboxContext<unknown>>;

/**
 * Headless implementation of the [WAI-ARIA Listbox pattern](https://www.w3.org/WAI/ARIA/apg/patterns/listbox/).
 * 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
 * `[forListboxOption][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.
 *
 * Selection is always modeled as `readonly T[]`:
 * - In single mode (`multiple=false`, default), the array has 0 or 1 element.
 * - In multi mode, any number of items can be selected.
 *
 * Single-select consumers can read the sole value through the
 * {@link ForListbox.selected} convenience accessor instead of unwrapping the
 * array.
 *
 * Keyboard supports the full APG-recommended model: arrows + Home/End for
 * focus movement, Space/Enter (via native `<button>` activation) to select
 * or toggle, typeahead, plus multi-select range modifiers (Shift+Arrow,
 * Shift+Space, Ctrl/Cmd+A, Ctrl+Shift+Home/End).
 */
declare class ForListbox<T = string> extends FormUiControlBase implements FormValueControl<readonly T[]>, ForListboxContext<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 (option activation or `selectionFollowsFocus`
     * nav), never on consumer writes via `[(value)]` — observe transitions
     * without binding back.
     */
    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>;
    /**
     * 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>;
    /**
     * When true, multiple options can be selected. Single mode (default) keeps
     * the value array at 0 or 1 element.
     *
     * Multi-select range keyboard (Shift+Arrow, Shift+Space, Ctrl/Cmd+A,
     * Ctrl+Shift+Home/End) 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 roving-tabindex
     * listbox.
     */
    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Manual `aria-label` for the listbox. Use this when no visible label
     * element exists; otherwise prefer pointing `aria-labelledby` at one. A
     * `null` (default) or empty value emits no attribute.
     */
    readonly ariaLabel: _angular_core.InputSignal<string | null>;
    protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
    /**
     * Axis the arrow keys navigate. Reflected as `data-orientation`.
     */
    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
    /**
     * When true (default), arrow navigation wraps at the ends — moving past the
     * last option focuses the first and vice versa. Set `false` to stop at the
     * boundaries. Mirrors the `loop` input on `ForSelect`, `ForToggleGroup` and
     * `ForCombobox`. Range extension (Shift+Arrow) never wraps regardless of
     * this input, per the APG.
     */
    readonly loop: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Total number of items in the source data. When set, enables the
     * virtualized activedescendant focus model and populates `aria-setsize`
     * on each rendered option. Leave unset (default `undefined`) for the
     * standard roving-tabindex model.
     */
    readonly totalCount: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
    /**
     * Inclusive-exclusive `[start, end)` index range of the currently rendered
     * options. The virtualizer provides this; the listbox uses it to decide
     * whether a navigation target is in the visible window.
     */
    readonly visibleRange: _angular_core.InputSignal<readonly [number, 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 ForListbox.invalidateSnapshot} imperatively.
     */
    readonly dataVersion: _angular_core.InputSignal<unknown>;
    /**
     * Emitted when keyboard navigation reaches an option outside the rendered
     * window. The consumer passes this index 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 and swaps
     * ArrowLeft / ArrowRight semantics in RTL for horizontal listboxes.
     */
    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.
     * APG calls this optional and recommends caution — leave off unless your
     * UX truly benefits from selection following focus. Default `false`.
     * The default is read from `provideForListboxDefaults` for the surrounding
     * scope.
     *
     * 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>;
    readonly roving: RovingTabindex;
    /**
     * All registered options in DOM (rendered) order. Part of the public
     * {@link ForListboxContext} surface so container-level coordinators (e.g.
     * `ForListboxReorder`) can read the ordered hosts without each option owning a
     * `[forDraggable]` that would fight the listbox's roving tabindex.
     */
    readonly options: _angular_core.Signal<readonly ForListboxOptionHandle<T>[]>;
    /**
     * The active option's `id` when using the activedescendant focus model,
     * `null` in the roving-tabindex path. Moved by keyboard navigation and by
     * hover alike, so the highlight and the option `Enter` activates never
     * disagree. The host reflects this as `aria-activedescendant`; options read it
     * to compute `data-highlighted`.
     */
    readonly activeDescendantId: _angular_core.Signal<string | null>;
    /**
     * Tabindex for the listbox host. In the virtualized path the host is always
     * the single tab stop. In the roving path the host carries `tabindex="0"`
     * only when no option qualifies — an empty listbox or one whose options are
     * all disabled — so the control is still reachable. A disabled listbox is
     * never tabbable.
     */
    protected readonly hostTabindex: _angular_core.Signal<"0" | null>;
    /**
     * 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 listbox is not virtualized (`totalCount` unset).
     */
    invalidateSnapshot(): void;
    constructor();
    /**
     * Move focus into the listbox, implementing `FormValueControl.focus` from
     * `@angular/forms/signals`. Targets the host when it is the tab stop (the
     * virtualized activedescendant model, or an empty / all-disabled roving
     * listbox); otherwise the first selected option, else the first enabled one —
     * mirroring the roving entry point. Without this override Signal Forms'
     * focus-on-error would focus the bound host even in the roving model, where
     * the options carry the tab stops. No-op when disabled.
     */
    focus(options?: FocusOptions): void;
    isSelected(v: T): boolean;
    activate(v: T): void;
    extendByArrow(currentOption: HTMLElement, action: 'next' | 'prev'): void;
    selectRangeToFocused(currentOption: HTMLElement): void;
    selectAll(): void;
    selectFromCurrentToEdge(currentOption: HTMLElement, edge: 'first' | 'last'): void;
    navigate(currentOption: HTMLElement, action: ListNavigationAction): void;
    handleTypeahead(event: KeyboardEvent): boolean;
    isFirstFocusableOption(el: HTMLElement): boolean;
    isOptionHighlighted(el: HTMLElement): boolean;
    private highlightFromPointer;
    optionTabindex(el: HTMLElement): -1 | 0 | null;
    setActiveOption(el: HTMLElement): void;
    registerOption(handle: ForListboxOptionHandle<T>): void;
    notifyOptionClick(optionId: string): void;
    unregisterOption(handle: ForListboxOptionHandle<T>): void;
    protected onHostKeyDown(event: KeyboardEvent): void;
    protected onHostFocusIn(): void;
    protected onFocusOut(event: FocusEvent): void;
    protected onPointerLeave(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForListbox<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForListbox<any>, "[forListbox]", ["forListbox"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "itemToFormValue": { "alias": "itemToFormValue"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "totalCount": { "alias": "totalCount"; "required": false; "isSignal": true; }; "visibleRange": { "alias": "visibleRange"; "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; }; }, { "value": "valueChange"; "scrollToIndex": "scrollToIndex"; }, never, never, true, never>;
}

/**
 * Injection key the `[forListboxOptionIndicator]` uses to resolve its parent
 * option, decoupled from the concrete `ForListboxOption` class.
 * `ForListboxOption` 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_LISTBOX_OPTION, useExisting: MtxListboxOption }`)
 * and the indicator keeps resolving — see `docs/wrapping-form-primitives.md`.
 */
declare const FOR_LISTBOX_OPTION: InjectionToken<ForListboxOption<string>>;
/**
 * One option inside a `ForListbox`. Apply on a `<button type="button">` so
 * Space / Enter activation come from native button behavior — printable keys
 * fall through to the parent 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]="lang"` infers `T = Language`); the parent `[forListbox]`
 * must be parameterized over the same `T`. The parent's
 * `[compareWith]` decides how options are matched against the
 * committed selection.
 *
 * 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 the listbox hands the highlight back to the
 * keyboard's option.
 */
declare class ForListboxOption<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 `[forListbox]` 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 — the listbox uses it to build the
     * position snapshot and to emit `aria-posinset` (which is `posInSet + 1`).
     * Leave unset (default `null`) outside the virtualized path.
     */
    readonly posInSet: _angular_core.InputSignal<number | null>;
    readonly id: _angular_core.Signal<string>;
    readonly selected: _angular_core.Signal<boolean>;
    /**
     * True when this option is the active candidate — the one the pointer is over,
     * else the keyboard's. In the roving-tabindex path the keyboard channel is the
     * DOM-focused option; in the virtualized activedescendant path it is
     * `aria-activedescendant`, which hover moves too, so the highlight and the
     * option `Enter` activates never disagree there. Reflected as
     * `data-highlighted` so consumers can style it uniformly with the other
     * primitives.
     */
    readonly highlighted: _angular_core.Signal<boolean>;
    protected readonly ariaSetSize: _angular_core.Signal<string | null>;
    protected readonly ariaPosInSet: _angular_core.Signal<string | null>;
    readonly effectiveDisabled: _angular_core.Signal<boolean>;
    protected readonly tabindex: _angular_core.Signal<0 | -1>;
    constructor();
    protected onClick(): void;
    protected onPointerDown(event: PointerEvent): void;
    protected onFocus(): void;
    protected onPointerMove(): void;
    protected onKeyDown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForListboxOption<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForListboxOption<any>, "[forListboxOption]", ["forListboxOption"], { "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>;
}

/**
 * Optional indicator slot inside a `ForListboxOption`. Apply on the
 * element the consumer wants to show only while this option is selected
 * (typically a check icon to the left of the label). Mirrors `data-state`
 * and hides itself while unselected. Visibility is enforced with an inline
 * `display: none` (which beats any author `display` rule a consumer applies
 * via a class) in addition to the `hidden` attribute that removes it from
 * the a11y tree.
 */
declare class ForListboxOptionIndicator {
    protected readonly parent: ForListboxOption;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForListboxOptionIndicator, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForListboxOptionIndicator, "[forListboxOptionIndicator]", ["forListboxOptionIndicator"], {}, {}, never, never, true, never>;
}

/**
 * Optional grouping wrapper inside a `ForListbox`. Renders `role="group"`
 * and references the descendant `[forListboxGroupLabel]` (if any) via
 * `aria-labelledby`. Options inside a group still register with the
 * listbox normally, so keyboard navigation traverses across groups in DOM
 * order without special handling.
 */
declare class ForListboxGroup {
    #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 `ForListboxGroupLabel` on mount. */
    registerLabel(id: string): void;
    /** Called by `ForListboxGroupLabel` on destroy. Idempotent. */
    unregisterLabel(id: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForListboxGroup, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForListboxGroup, "[forListboxGroup]", ["forListboxGroup"], {}, {}, never, never, true, never>;
}

/**
 * Visible label for a `ForListboxGroup`. 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 — `<h3>`/`<h4>` if the
 * surrounding document has a sensible heading hierarchy).
 */
declare class ForListboxGroupLabel {
    /** Stable host id used by the parent group's `aria-labelledby`. */
    readonly id: string;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForListboxGroupLabel, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForListboxGroupLabel, "[forListboxGroupLabel]", ["forListboxGroupLabel"], {}, {}, never, never, true, never>;
}

/** Payload of `optionReorder`: the lifted option's previous and new index, both 0-based. */
interface ForListboxReorderEvent {
    /** The lifted option's index before the move, in DOM (rendered) order. */
    readonly from: number;
    /** The option's index after the move — pass to `moveItemInArray(items, from, to)`. */
    readonly to: number;
}
/**
 * Opt-in **pointer + keyboard reordering** for `ForListbox`, composed onto the same element as
 * `[forListbox]`.
 *
 * `[forDraggable]` cannot stack on a `[forListboxOption]` — both would manage the option's
 * roving tabindex and keyboard, colliding on `tabindex`, on Space / Enter activation, and on the
 * container `orientation` input. This coordinator is the listbox-side analogue of
 * `ForTreeNodeDrag` / `ForTableRowReorder`: it lives on the container, **never touches the
 * option's roving tabindex**, intercepts keys in the capture phase, and owns its own 2D drop
 * geometry — so the listbox keeps full selection + typeahead behavior while becoming sortable.
 *
 * Keyboard: focus an option, press `Ctrl+Space` (or `Cmd+Space`) to lift. While lifted, the
 * arrow keys step the target position (linearly in DOM order, so a wrapping chip grid works with
 * either axis), `Home` / `End` jump to the ends, `Space` / `Enter` drop, `Escape` / `Tab` cancel.
 *
 * Pointer: drag an option past a small threshold to reorder; a short press without movement still
 * selects (the post-drag click is suppressed). A floating preview follows the pointer; drop
 * geometry is resolved in 2D, so vertical lists, horizontal lists, and wrapping grids all work
 * without configuring `orientation`.
 *
 * It **never reorders the options itself** (BYO-data): `(optionReorder)` emits the previous / new
 * index on every committed drop; apply `moveItemInArray(items, from, to)` to your own array.
 * Intended for the standard roving-tabindex listbox; a virtualized listbox (`[totalCount]` set)
 * is left untouched, since reordering a windowed subset is ill-defined.
 *
 * @example
 * ```html
 * <ul forListbox forListboxReorder multiple [(value)]="selected" (optionReorder)="reorder($event)">
 *   @for (tag of tags(); track tag) {
 *     <li><button type="button" forListboxOption [value]="tag">{{ tag }}</button></li>
 *   }
 * </ul>
 * ```
 */
declare class ForListboxReorder {
    #private;
    /**
     * Disables reorder interactions while leaving selection / typeahead intact. Named distinctly
     * from the listbox's own `disabled` so the two never share a single `[disabled]` binding on the
     * shared host. The listbox being disabled (its own `disabled` or a surrounding `[forFieldset]`)
     * also disables reorder.
     */
    readonly reorderDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Emitted once per committed reorder gesture with the previous / new option index. */
    readonly optionReorder: _angular_core.OutputEmitterRef<ForListboxReorderEvent>;
    protected readonly _dragging: _angular_core.WritableSignal<boolean>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForListboxReorder, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForListboxReorder, "[forListboxReorder]", ["forListboxReorder"], { "reorderDisabled": { "alias": "reorderDisabled"; "required": false; "isSignal": true; }; }, { "optionReorder": "optionReorder"; }, never, never, true, never>;
}

/**
 * Defaults inherited by descendant listboxes in the surrounding injector
 * scope. Configure with `provideForListboxDefaults` either at the
 * application root or in any component's `providers` array; partial
 * overrides merge with the parent scope.
 */
interface ForListboxDefaults {
    /**
     * Single-mode only: when `true`, arrow navigation also selects the
     * focused option. APG calls this optional and recommends caution —
     * leave `false` unless the UX truly benefits from selection following
     * focus.
     */
    selectionFollowsFocus: boolean;
    /**
     * `[forListboxReorder]` announcement when an option is lifted for reorder.
     * `index` and `total` are 1-based. Override to localize.
     */
    reorderAnnounceLift: (label: string, index: number, total: number) => string;
    /**
     * `[forListboxReorder]` announcement when the reorder drop position changes.
     * `index` and `total` are 1-based. Override to localize.
     */
    reorderAnnounceMove: (label: string, index: number, total: number) => string;
    /**
     * `[forListboxReorder]` announcement on a committed reorder drop. `index` and
     * `total` are 1-based. Override to localize.
     */
    reorderAnnounceDrop: (label: string, index: number, total: number) => string;
    /**
     * `[forListboxReorder]` announcement when a reorder is cancelled. Override to
     * localize.
     */
    reorderAnnounceCancel: (label: string) => string;
}
/** Token holding the resolved listbox defaults for the current scope. */
declare const FOR_LISTBOX_DEFAULTS: _angular_core.InjectionToken<ForListboxDefaults>;
/**
 * Configures forty-cdk listbox defaults for this injector scope. Partial
 * overrides inherit unspecified keys from the parent scope (or library
 * defaults at the root).
 */
declare function provideForListboxDefaults(defaults?: Partial<ForListboxDefaults>): Provider[];

/**
 * Exact public names of every `ForListbox` 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[myListbox]',
 *   template: '',
 *   hostDirectives: [
 *     {
 *       directive: ForListbox,
 *       inputs: [...FOR_LISTBOX_HOST_DIRECTIVE_INPUTS],
 *       outputs: [...FOR_LISTBOX_HOST_DIRECTIVE_OUTPUTS],
 *     },
 *   ],
 * })
 * export class MyListbox {}
 * ```
 */
declare const FOR_LISTBOX_HOST_DIRECTIVE_INPUTS: readonly ["value", "ariaLabel", "compareWith", "dataVersion", "dir", "dirty", "disabled", "errors", "invalid", "itemToFormValue", "loop", "multiple", "name", "orientation", "pending", "readonly", "required", "selectionFollowsFocus", "totalCount", "touched", "visibleRange"];
/**
 * Exact public names of every `ForListbox` output, the Signal Forms `touch` output
 * included. Spread it into the `outputs` array of the same `hostDirectives` entry as
 * {@link FOR_LISTBOX_HOST_DIRECTIVE_INPUTS}.
 */
declare const FOR_LISTBOX_HOST_DIRECTIVE_OUTPUTS: readonly ["scrollToIndex", "touch", "touchedChange", "valueChange"];

export { FOR_LISTBOX_CONTEXT, FOR_LISTBOX_DEFAULTS, FOR_LISTBOX_HOST_DIRECTIVE_INPUTS, FOR_LISTBOX_HOST_DIRECTIVE_OUTPUTS, FOR_LISTBOX_OPTION, ForListbox, ForListboxGroup, ForListboxGroupLabel, ForListboxOption, ForListboxOptionIndicator, ForListboxReorder, provideForListboxDefaults };
export type { ForListboxContext, ForListboxDefaults, ForListboxOptionHandle, ForListboxReorderEvent };