@angular/aria 22.0.0-next.4 → 22.0.0-next.5

package/types/_combobox-chunk.d.ts

@@ -1,6 +1,6 @@
 import { KeyboardEventManager } from './_keyboard-event-manager-chunk.js';
 import { PointerEventManager } from './_pointer-event-manager-chunk.js';
-import { SignalLike, WritableSignalLike } from './_list-navigation-chunk.js';
+import { SignalLike, WritableSignalLike } from './_signal-like-chunk.js';
 import { ListItem } from './_list-chunk.js';
 
 /** Represents the required inputs for a combobox. */
@@ -29,7 +29,7 @@ interface ComboboxInputs<T extends ListItem<V>, V> {
 /** An interface that allows combobox popups to expose the necessary controls for the combobox. */
 interface ComboboxListboxControls<T extends ListItem<V>, V> {
     /** A unique identifier for the popup. */
-    id: () => string;
+    readonly id: () => string;
     /** The ARIA role for the popup. */
     role: SignalLike<'listbox' | 'tree' | 'grid'>;
     /** Whether multiple items in the popup can be selected at once. */
@@ -89,39 +89,39 @@ interface ComboboxTreeControls<T extends ListItem<V>, V> extends ComboboxListbox
 declare class ComboboxPattern<T extends ListItem<V>, V> {
     readonly inputs: ComboboxInputs<T, V>;
     /** Whether the combobox is expanded. */
-    expanded: WritableSignalLike<boolean>;
+    readonly expanded: WritableSignalLike<boolean>;
     /** Whether the combobox is disabled. */
-    disabled: () => boolean;
+    readonly disabled: () => boolean;
     /** The ID of the active item in the combobox. */
-    activeDescendant: SignalLike<string | null>;
+    readonly activeDescendant: SignalLike<string | null>;
     /** The currently highlighted item in the combobox. */
-    highlightedItem: WritableSignalLike<T | undefined>;
+    readonly highlightedItem: WritableSignalLike<T | undefined>;
     /** Whether the most recent input event was a deletion. */
-    isDeleting: boolean;
+    private _isDeleting;
     /** Whether the combobox is focused. */
-    isFocused: WritableSignalLike<boolean>;
+    readonly isFocused: WritableSignalLike<boolean>;
     /** Whether the combobox has ever been focused. */
-    hasBeenInteracted: WritableSignalLike<boolean>;
+    readonly hasBeenInteracted: WritableSignalLike<boolean>;
     /** The key used to navigate to the previous item in the list. */
-    expandKey: SignalLike<"ArrowLeft" | "ArrowRight">;
+    readonly expandKey: SignalLike<"ArrowLeft" | "ArrowRight">;
     /** The key used to navigate to the next item in the list. */
-    collapseKey: SignalLike<"ArrowLeft" | "ArrowRight">;
+    readonly collapseKey: SignalLike<"ArrowLeft" | "ArrowRight">;
     /** The ID of the popup associated with the combobox. */
-    popupId: SignalLike<string | null>;
+    readonly popupId: SignalLike<string | null>;
     /** The autocomplete behavior of the combobox. */
-    autocomplete: SignalLike<"both" | "list">;
+    readonly autocomplete: SignalLike<"both" | "list">;
     /** The ARIA role of the popup associated with the combobox. */
-    hasPopup: SignalLike<"listbox" | "tree" | "grid" | "dialog" | null>;
+    readonly hasPopup: SignalLike<"listbox" | "tree" | "grid" | "dialog" | null>;
     /** Whether the combobox is read-only. */
-    readonly: SignalLike<true | null>;
+    readonly readonly: SignalLike<true | null>;
     /** Returns the listbox controls for the combobox. */
-    listControls: () => ComboboxListboxControls<T, V> | null | undefined;
+    readonly listControls: () => ComboboxListboxControls<T, V> | null | undefined;
     /** Returns the tree controls for the combobox. */
-    treeControls: () => ComboboxTreeControls<T, V> | null;
+    readonly treeControls: () => ComboboxTreeControls<T, V> | null;
     /** The keydown event manager for the combobox. */
-    keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
+    readonly keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
     /** The click event manager for the combobox. */
-    click: SignalLike<PointerEventManager<PointerEvent>>;
+    readonly click: SignalLike<PointerEventManager<PointerEvent>>;
     constructor(inputs: ComboboxInputs<T, V>);
     /** Handles keydown events for the combobox. */
     onKeydown(event: KeyboardEvent): void;
@@ -134,7 +134,7 @@ declare class ComboboxPattern<T extends ListItem<V>, V> {
     /** Handles focus out events for the combobox. */
     onFocusOut(event: FocusEvent): void;
     /** The first matching item in the combobox. */
-    firstMatch: SignalLike<T | undefined>;
+    readonly firstMatch: SignalLike<T | undefined>;
     /** Handles filtering logic for the combobox. */
     onFilter(): void;
     /** Highlights the currently selected item in the combobox. */
@@ -178,9 +178,9 @@ declare class ComboboxDialogPattern {
         element: SignalLike<HTMLDialogElement>;
         id: SignalLike<string>;
     };
-    id: () => string;
-    role: () => "dialog";
-    keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
+    readonly id: () => string;
+    readonly role: () => "dialog";
+    readonly keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
     constructor(inputs: {
         combobox: ComboboxPattern<any, any>;
         element: SignalLike<HTMLDialogElement>;

package/types/_element-chunk.d.ts

@@ -0,0 +1,10 @@
+interface HasElement {
+    element: HTMLElement;
+}
+/**
+ * Sort directives by their document order.
+ */
+declare function sortDirectives(a: HasElement, b: HasElement): 1 | -1;
+
+export { sortDirectives };
+export type { HasElement };

package/types/_expansion-chunk.d.ts

@@ -1,4 +1,4 @@
-import { SignalLike, WritableSignalLike } from './_list-navigation-chunk.js';
+import { SignalLike, WritableSignalLike } from './_signal-like-chunk.js';
 
 /** Represents an item that can be expanded or collapsed. */
 interface ExpansionItem {

package/types/_grid-chunk.d.ts

@@ -1,4 +1,4 @@
-import { SignalLike, WritableSignalLike, ListNavigationItem, ListNavigationInputs, ListFocus, ListNavigation } from './_list-navigation-chunk.js';
+import { SignalLike, WritableSignalLike } from './_signal-like-chunk.js';
 import { KeyboardEventManager } from './_keyboard-event-manager-chunk.js';
 import { PointerEventManager } from './_pointer-event-manager-chunk.js';
 
@@ -335,7 +335,9 @@ declare class Grid<T extends GridCell> {
 }
 
 /** The inputs for the `GridCellWidgetPattern`. */
-interface GridCellWidgetInputs extends Omit<ListNavigationItem, 'index'> {
+interface GridCellWidgetInputs {
+    /** Whether the widget is disabled. */
+    disabled: SignalLike<boolean>;
     /** The `GridCellPattern` that this widget belongs to. */
     cell: SignalLike<GridCellPattern>;
     /** The html element that should receive focus. */
@@ -346,21 +348,17 @@ interface GridCellWidgetInputs extends Omit<ListNavigationItem, 'index'> {
     focusTarget: SignalLike<HTMLElement | undefined>;
 }
 /** The UI pattern for a widget inside a grid cell. */
-declare class GridCellWidgetPattern implements ListNavigationItem {
+declare class GridCellWidgetPattern {
     readonly inputs: GridCellWidgetInputs;
-    /** A unique identifier for the widget. */
-    readonly id: SignalLike<string>;
     /** The html element that should receive focus. */
     readonly element: SignalLike<HTMLElement>;
     /** The element that should receive focus. */
     readonly widgetHost: SignalLike<HTMLElement>;
-    /** The index of the widget within the cell. */
-    readonly index: SignalLike<number>;
     /** Whether the widget is disabled. */
     readonly disabled: SignalLike<boolean>;
     /** The tab index for the widget. */
     readonly tabIndex: SignalLike<-1 | 0>;
-    /** Whether the widget is the active item in the widget list. */
+    /** Whether the widget is the active widget in the cell. */
     readonly active: SignalLike<boolean>;
     /** Whether the widget is currently activated. */
     readonly isActivated: WritableSignalLike<boolean>;
@@ -386,13 +384,13 @@ declare class GridCellWidgetPattern implements ListNavigationItem {
 }
 
 /** The inputs for the `GridCellPattern`. */
-interface GridCellInputs extends GridCell, Omit<ListNavigationInputs<GridCellWidgetPattern>, 'focusMode' | 'items' | 'activeItem' | 'softDisabled' | 'element'> {
+interface GridCellInputs extends GridCell {
     /** The `GridPattern` that this cell belongs to. */
     grid: SignalLike<GridPattern>;
     /** The `GridRowPattern` that this cell belongs to. */
     row: SignalLike<GridRowPattern>;
-    /** The widget patterns contained within this cell, if any. */
-    widgets: SignalLike<GridCellWidgetPattern[]>;
+    /** The widget pattern contained within this cell, if any. */
+    widget: SignalLike<GridCellWidgetPattern | undefined>;
     /** The index of this cell's row within the grid. */
     rowIndex: SignalLike<number | undefined>;
     /** The index of this cell's column within the grid. */
@@ -433,30 +431,10 @@ declare class GridCellPattern implements GridCell {
     private readonly _tabIndex;
     /** The tab index for the cell. If the cell contains a widget, the cell's tab index is -1. */
     readonly tabIndex: SignalLike<-1 | 0>;
-    /** Whether the cell contains a single widget. */
-    readonly singleWidgetMode: SignalLike<boolean>;
-    /** Whether the cell contains multiple widgets. */
-    readonly multiWidgetMode: SignalLike<boolean>;
-    /** Whether navigation between widgets is disabled. */
-    readonly navigationDisabled: SignalLike<boolean>;
-    /** The focus behavior for the widgets in the cell. */
-    readonly focusBehavior: ListFocus<GridCellWidgetPattern>;
-    /** The navigation behavior for the widgets in the cell. */
-    readonly navigationBehavior: ListNavigation<GridCellWidgetPattern>;
-    /** The currently active widget in the cell. */
-    readonly activeWidget: WritableSignalLike<GridCellWidgetPattern | undefined>;
-    /** Whether navigation between widgets is activated. */
-    readonly navigationActivated: WritableSignalLike<boolean>;
-    /** Whether any widget within the cell is activated. */
-    readonly widgetActivated: SignalLike<boolean>;
+    /** The widget in the cell. */
+    readonly widget: SignalLike<GridCellWidgetPattern | undefined>;
     /** Whether the cell or widget inside the cell is activated. */
     readonly isActivated: SignalLike<boolean>;
-    /** The key used to navigate to the previous widget. */
-    readonly prevKey: SignalLike<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
-    /** The key used to navigate to the next widget. */
-    readonly nextKey: SignalLike<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
-    /** The keyboard event manager for the cell. */
-    readonly keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
     constructor(inputs: GridCellInputs);
     /** Handles keydown events for the cell. */
     onKeydown(event: KeyboardEvent): void;
@@ -468,12 +446,6 @@ declare class GridCellPattern implements GridCell {
     focus(): void;
     /** Gets the tab index for the widget within the cell. */
     widgetTabIndex(): -1 | 0;
-    /** Starts navigation between widgets. */
-    startNavigation(): void;
-    /** Stops navigation between widgets and restores focus to the cell. */
-    stopNavigation(): void;
-    /** Executes a navigation operation and focuses the new active widget. */
-    private _advance;
 }
 
 /** The inputs for the `GridRowPattern`. */
@@ -507,8 +479,6 @@ interface GridInputs extends Omit<GridInputs$1<GridCellPattern>, 'cells'> {
     multi: SignalLike<boolean>;
     /** The selection strategy used by the grid. */
     selectionMode: SignalLike<'follow' | 'explicit'>;
-    /** Whether enable range selection. */
-    enableRangeSelection: SignalLike<boolean>;
     /** A function that returns the grid cell associated with a given element. */
     getCell: (e: Element | null) => GridCellPattern | undefined;
 }
@@ -543,14 +513,10 @@ declare class GridPattern {
     readonly prevColKey: SignalLike<"ArrowRight" | "ArrowLeft">;
     /** The key for navigating to the next column. */
     readonly nextColKey: SignalLike<"ArrowRight" | "ArrowLeft">;
-    /** Whether the grid pattern is currently accepting `pointermove` events. */
-    readonly acceptsPointerMove: SignalLike<boolean>;
     /** The keydown event manager for the grid. */
     readonly keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
     /** The pointerdown event manager for the grid. */
     readonly pointerdown: SignalLike<PointerEventManager<PointerEvent>>;
-    /** The pointerup event manager for the grid. */
-    readonly pointerup: SignalLike<PointerEventManager<PointerEvent>>;
     /** Indicates maybe the losing focus is caused by row/cell deletion. */
     private readonly _maybeDeletion;
     /** Indicates the losing focus is certainly caused by row/cell deletion. */
@@ -562,10 +528,6 @@ declare class GridPattern {
     onKeydown(event: KeyboardEvent): void;
     /** Handles pointerdown events on the grid. */
     onPointerdown(event: PointerEvent): void;
-    /** Handles pointermove events on the grid. */
-    onPointermove(event: PointerEvent): void;
-    /** Handles pointerup events on the grid. */
-    onPointerup(event: PointerEvent): void;
     /** Handles focusin events on the grid. */
     onFocusIn(event: FocusEvent): void;
     /** Handles focusout events on the grid. */

package/types/_keyboard-event-manager-chunk.d.ts

@@ -1,4 +1,4 @@
-import { SignalLike } from './_list-navigation-chunk.js';
+import { SignalLike } from './_signal-like-chunk.js';
 
 /**
  * Options that are applicable to all event handlers.
@@ -56,7 +56,7 @@ type KeyCode = string | SignalLike<string> | RegExp;
  * propagation and prevents default on all events it handles.
  */
 declare class KeyboardEventManager<T extends KeyboardEvent> extends EventManager<T> {
-    options: EventHandlerOptions;
+    readonly options: EventHandlerOptions;
     /** Configures this event manager to handle events with a specific key and no modifiers. */
     on(key: KeyCode, handler: EventHandler<T>, options?: Partial<EventHandlerOptions>): this;
     /**  Configures this event manager to handle events with a specific modifer and key combination. */

package/types/_list-chunk.d.ts

@@ -1,4 +1,5 @@
-import { ListFocusItem, SignalLike, ListFocusInputs, WritableSignalLike, ListFocus, ListNavigationItem, ListNavigationInputs, ListNavigation } from './_list-navigation-chunk.js';
+import { SignalLike, WritableSignalLike } from './_signal-like-chunk.js';
+import { ListFocusItem, ListFocusInputs, ListFocus, ListNavigationItem, ListNavigationInputs, ListNavigation } from './_list-navigation-chunk.js';
 
 /** Represents an item in a collection, such as a listbox option, that can be selected. */
 interface ListSelectionItem<V> extends ListFocusItem {
@@ -22,11 +23,11 @@ declare class ListSelection<T extends ListSelectionItem<V>, V> {
         focusManager: ListFocus<T>;
     };
     /** The start index to use for range selection. */
-    rangeStartIndex: WritableSignalLike<number>;
+    readonly rangeStartIndex: WritableSignalLike<number>;
     /** The end index to use for range selection. */
-    rangeEndIndex: WritableSignalLike<number>;
+    readonly rangeEndIndex: WritableSignalLike<number>;
     /** The currently selected items. */
-    selectedItems: SignalLike<T[]>;
+    readonly selectedItems: SignalLike<T[]>;
     constructor(inputs: ListSelectionInputs<T, V> & {
         focusManager: ListFocus<T>;
     });
@@ -90,13 +91,13 @@ declare class ListTypeahead<T extends ListTypeaheadItem> {
     /** A reference to the timeout for resetting the typeahead search. */
     timeout?: ReturnType<typeof setTimeout> | undefined;
     /** The focus controller of the parent list. */
-    focusManager: ListFocus<T>;
+    readonly focusManager: ListFocus<T>;
     /** Whether the user is actively typing a typeahead search query. */
-    isTyping: SignalLike<boolean>;
+    readonly isTyping: SignalLike<boolean>;
     /** Keeps track of the characters that typeahead search is being called with. */
-    private _query;
+    private readonly _query;
     /** The index where that the typeahead search was initiated from. */
-    private _startIndex;
+    private readonly _startIndex;
     constructor(inputs: ListTypeaheadInputs<T> & {
         focusManager: ListFocus<T>;
     });
@@ -127,21 +128,21 @@ type ListInputs<T extends ListItem<V>, V> = ListFocusInputs<T> & ListNavigationI
 declare class List<T extends ListItem<V>, V> {
     readonly inputs: ListInputs<T, V>;
     /** Controls navigation for the list. */
-    navigationBehavior: ListNavigation<T>;
+    readonly navigationBehavior: ListNavigation<T>;
     /** Controls selection for the list. */
-    selectionBehavior: ListSelection<T, V>;
+    readonly selectionBehavior: ListSelection<T, V>;
     /** Controls typeahead for the list. */
-    typeaheadBehavior: ListTypeahead<T>;
+    readonly typeaheadBehavior: ListTypeahead<T>;
     /** Controls focus for the list. */
-    focusBehavior: ListFocus<T>;
+    readonly focusBehavior: ListFocus<T>;
     /** Whether the list is disabled. */
-    disabled: SignalLike<boolean>;
+    readonly disabled: SignalLike<boolean>;
     /** The id of the current active item. */
-    activeDescendant: SignalLike<string | undefined>;
+    readonly activeDescendant: SignalLike<string | undefined>;
     /** The tab index of the list. */
-    tabIndex: SignalLike<0 | -1>;
+    readonly tabIndex: SignalLike<0 | -1>;
     /** The index of the currently active item in the list. */
-    activeIndex: SignalLike<number>;
+    readonly activeIndex: SignalLike<number>;
     /**
      * The uncommitted index for selecting a range of options.
      *
@@ -154,9 +155,9 @@ declare class List<T extends ListItem<V>, V> {
      * In other words, "rangeStartIndex" is only set when a user commits to starting a range selection
      * while "anchorIndex" is set whenever a user indicates they may be starting a range selection.
      */
-    private _anchorIndex;
+    private readonly _anchorIndex;
     /** Whether the list should wrap. Used to disable wrapping while range selecting. */
-    private _wrap;
+    private readonly _wrap;
     constructor(inputs: ListInputs<T, V>);
     /** Returns the tab index for the given item. */
     getItemTabindex(item: T): 0 | -1;

package/types/_list-navigation-chunk.d.ts

@@ -1,14 +1,4 @@
-type SignalLike<T> = () => T;
-interface WritableSignalLike<T> extends SignalLike<T> {
-    set(value: T): void;
-    update(updateFn: (value: T) => T): void;
-    asReadonly(): SignalLike<T>;
-}
-/** Converts a getter setter style signal to a WritableSignalLike. */
-declare function convertGetterSetterToWritableSignalLike<T>(getter: () => T, setter: (v: T) => void): WritableSignalLike<T>;
-declare function computed<T>(computation: () => T): SignalLike<T>;
-declare function signal<T>(initialValue: T): WritableSignalLike<T>;
-declare function linkedSignal<T>(sourceFn: () => T): WritableSignalLike<T>;
+import { SignalLike, WritableSignalLike } from './_signal-like-chunk.js';
 
 /** Represents an item in a collection, such as a listbox option, than may receive focus. */
 interface ListFocusItem {
@@ -38,11 +28,11 @@ interface ListFocusInputs<T extends ListFocusItem> {
 declare class ListFocus<T extends ListFocusItem> {
     readonly inputs: ListFocusInputs<T>;
     /** The last item that was active. */
-    prevActiveItem: WritableSignalLike<T | undefined>;
+    readonly prevActiveItem: WritableSignalLike<T | undefined>;
     /** The index of the last item that was active. */
-    prevActiveIndex: SignalLike<number>;
+    readonly prevActiveIndex: SignalLike<number>;
     /** The current active index in the list. */
-    activeIndex: SignalLike<number>;
+    readonly activeIndex: SignalLike<number>;
     constructor(inputs: ListFocusInputs<T>);
     /** Whether the list is in a disabled state. */
     isListDisabled(): boolean;
@@ -117,5 +107,5 @@ declare class ListNavigation<T extends ListNavigationItem> {
     private _peek;
 }
 
-export { ListFocus, ListNavigation, computed, convertGetterSetterToWritableSignalLike, linkedSignal, signal };
-export type { ListFocusInputs, ListFocusItem, ListNavigationInputs, ListNavigationItem, SignalLike, WritableSignalLike };
+export { ListFocus, ListNavigation };
+export type { ListFocusInputs, ListFocusItem, ListNavigationInputs, ListNavigationItem };

package/types/_listbox-chunk.d.ts

@@ -1,4 +1,4 @@
-import { SignalLike, WritableSignalLike } from './_list-navigation-chunk.js';
+import { SignalLike, WritableSignalLike } from './_signal-like-chunk.js';
 import { ListInputs, List, ListItem } from './_list-chunk.js';
 import { KeyboardEventManager } from './_keyboard-event-manager-chunk.js';
 import { ClickEventManager } from './_click-event-manager-chunk.js';
@@ -18,27 +18,27 @@ interface OptionInputs<V> extends Omit<ListItem<V>, 'index' | 'selectable'> {
 /** Represents an option in a listbox. */
 declare class OptionPattern<V> {
     /** A unique identifier for the option. */
-    id: SignalLike<string>;
+    readonly id: SignalLike<string>;
     /** The value of the option. */
-    value: SignalLike<V>;
+    readonly value: SignalLike<V>;
     /** The position of the option in the list. */
-    index: SignalLike<number>;
+    readonly index: SignalLike<number>;
     /** Whether the option is active. */
-    active: SignalLike<boolean>;
+    readonly active: SignalLike<boolean>;
     /** Whether the option is selected. */
-    selected: SignalLike<boolean | undefined>;
+    readonly selected: SignalLike<boolean | undefined>;
     /** Whether the option is selectable. */
-    selectable: () => boolean;
+    readonly selectable: () => boolean;
     /** Whether the option is disabled. */
-    disabled: SignalLike<boolean>;
+    readonly disabled: SignalLike<boolean>;
     /** The text used by the typeahead search. */
-    searchTerm: SignalLike<string>;
+    readonly searchTerm: SignalLike<string>;
     /** A reference to the parent listbox. */
-    listbox: SignalLike<ListboxPattern$1<V> | undefined>;
+    readonly listbox: SignalLike<ListboxPattern$1<V> | undefined>;
     /** The tab index of the option. */
-    tabIndex: SignalLike<0 | -1 | undefined>;
+    readonly tabIndex: SignalLike<0 | -1 | undefined>;
     /** The html element that should receive focus. */
-    element: SignalLike<HTMLElement | undefined>;
+    readonly element: SignalLike<HTMLElement | undefined>;
     constructor(args: OptionInputs<V>);
 }
 
@@ -52,39 +52,39 @@ type ListboxInputs<V> = ListInputs<OptionPattern<V>, V> & {
 /** Controls the state of a listbox. */
 declare class ListboxPattern<V> {
     readonly inputs: ListboxInputs<V>;
-    listBehavior: List<OptionPattern<V>, V>;
+    readonly listBehavior: List<OptionPattern<V>, V>;
     /** Whether the listbox has been interacted with. */
     readonly hasBeenInteracted: WritableSignalLike<boolean>;
     /** Whether the list is vertically or horizontally oriented. */
-    orientation: SignalLike<'vertical' | 'horizontal'>;
+    readonly orientation: SignalLike<'vertical' | 'horizontal'>;
     /** Whether the listbox is disabled. */
-    disabled: SignalLike<boolean>;
+    readonly disabled: SignalLike<boolean>;
     /** Whether the listbox is readonly. */
-    readonly: SignalLike<boolean>;
+    readonly readonly: SignalLike<boolean>;
     /** The tab index of the listbox. */
-    tabIndex: SignalLike<-1 | 0>;
+    readonly tabIndex: SignalLike<-1 | 0>;
     /** The id of the current active item. */
-    activeDescendant: SignalLike<string | undefined>;
+    readonly activeDescendant: SignalLike<string | undefined>;
     /** Whether multiple items in the list can be selected at once. */
     multi: SignalLike<boolean>;
     /** The number of items in the listbox. */
-    setsize: SignalLike<number>;
+    readonly setsize: SignalLike<number>;
     /** Whether the listbox selection follows focus. */
-    followFocus: SignalLike<boolean>;
+    readonly followFocus: SignalLike<boolean>;
     /** Whether the listbox should wrap. Used to disable wrapping while range selecting. */
-    wrap: WritableSignalLike<boolean>;
+    readonly wrap: WritableSignalLike<boolean>;
     /** The key used to navigate to the previous item in the list. */
-    prevKey: SignalLike<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
+    readonly prevKey: SignalLike<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
     /** The key used to navigate to the next item in the list. */
-    nextKey: SignalLike<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
+    readonly nextKey: SignalLike<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
     /** Represents the space key. Does nothing when the user is actively using typeahead. */
-    dynamicSpaceKey: SignalLike<"" | " ">;
+    readonly dynamicSpaceKey: SignalLike<"" | " ">;
     /** The regexp used to decide if a key should trigger typeahead. */
-    typeaheadRegexp: RegExp;
+    readonly typeaheadRegexp: RegExp;
     /** The keydown event manager for the listbox. */
-    keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
+    readonly keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
     /** The click event manager for the listbox. */
-    clickManager: SignalLike<ClickEventManager<PointerEvent>>;
+    readonly clickManager: SignalLike<ClickEventManager<PointerEvent>>;
     constructor(inputs: ListboxInputs<V>);
     /** Returns a set of violations */
     validate(): string[];