@angular/aria 21.0.0-rc.0 → 21.0.0-rc.2

package/types/_grid-chunk.d.ts

@@ -1,4 +1,5 @@
 import * as _angular_core from '@angular/core';
+import { WritableSignal, Signal } from '@angular/core';
 
 /**
  * Options that are applicable to all event handlers.
@@ -65,9 +66,9 @@ type KeyCode = string | SignalLike<string> | RegExp;
 declare class KeyboardEventManager<T extends KeyboardEvent> extends EventManager<T> {
     options: EventHandlerOptions;
     /** Configures this event manager to handle events with a specific key and no modifiers. */
-    on(key: KeyCode, handler: EventHandler<T>): this;
+    on(key: KeyCode, handler: EventHandler<T>, options?: Partial<EventHandlerOptions>): this;
     /**  Configures this event manager to handle events with a specific modifer and key combination. */
-    on(modifiers: ModifierInputs, key: KeyCode, handler: EventHandler<T>): this;
+    on(modifiers: ModifierInputs, key: KeyCode, handler: EventHandler<T>, options?: Partial<EventHandlerOptions>): this;
     private _normalizeInputs;
     private _isMatch;
 }
@@ -103,6 +104,111 @@ declare class PointerEventManager<T extends PointerEvent> extends EventManager<T
     _isMatch(event: PointerEvent, button: MouseButton, modifiers: ModifierInputs): boolean;
 }
 
+/** Represents an item in a collection, such as a listbox option, than may receive focus. */
+interface ListFocusItem {
+    /** A unique identifier for the item. */
+    id: SignalLike<string>;
+    /** The html element that should receive focus. */
+    element: SignalLike<HTMLElement | undefined>;
+    /** Whether an item is disabled. */
+    disabled: SignalLike<boolean>;
+    /** The index of the item in the list. */
+    index: SignalLike<number>;
+}
+/** Represents the required inputs for a collection that contains focusable items. */
+interface ListFocusInputs<T extends ListFocusItem> {
+    /** The focus strategy used by the list. */
+    focusMode: SignalLike<'roving' | 'activedescendant'>;
+    /** Whether the list is disabled. */
+    disabled: SignalLike<boolean>;
+    /** The items in the list. */
+    items: SignalLike<T[]>;
+    /** The active item. */
+    activeItem: WritableSignalLike<T | undefined>;
+    /** Whether disabled items in the list should be focusable. */
+    softDisabled: SignalLike<boolean>;
+    element: SignalLike<HTMLElement | undefined>;
+}
+/** Controls focus for a list of items. */
+declare class ListFocus<T extends ListFocusItem> {
+    readonly inputs: ListFocusInputs<T>;
+    /** The last item that was active. */
+    prevActiveItem: _angular_core.WritableSignal<T | undefined>;
+    /** The index of the last item that was active. */
+    prevActiveIndex: _angular_core.Signal<number>;
+    /** The current active index in the list. */
+    activeIndex: _angular_core.Signal<number>;
+    constructor(inputs: ListFocusInputs<T>);
+    /** Whether the list is in a disabled state. */
+    isListDisabled(): boolean;
+    /** The id of the current active item. */
+    getActiveDescendant(): string | undefined;
+    /** The tab index for the list. */
+    getListTabIndex(): -1 | 0;
+    /** Returns the tab index for the given item. */
+    getItemTabIndex(item: T): -1 | 0;
+    /** Moves focus to the given item if it is focusable. */
+    focus(item: T, opts?: {
+        focusElement?: boolean;
+    }): boolean;
+    /** Returns true if the given item can be navigated to. */
+    isFocusable(item: T): boolean;
+}
+
+/** Represents an item in a collection, such as a listbox option, than can be navigated to. */
+interface ListNavigationItem extends ListFocusItem {
+}
+/** Represents the required inputs for a collection that has navigable items. */
+interface ListNavigationInputs<T extends ListNavigationItem> extends ListFocusInputs<T> {
+    /** Whether focus should wrap when navigating. */
+    wrap: SignalLike<boolean>;
+    /** Whether the list is vertically or horizontally oriented. */
+    orientation: SignalLike<'vertical' | 'horizontal'>;
+    /** The direction that text is read based on the users locale. */
+    textDirection: SignalLike<'rtl' | 'ltr'>;
+}
+/** Controls navigation for a list of items. */
+declare class ListNavigation<T extends ListNavigationItem> {
+    readonly inputs: ListNavigationInputs<T> & {
+        focusManager: ListFocus<T>;
+    };
+    constructor(inputs: ListNavigationInputs<T> & {
+        focusManager: ListFocus<T>;
+    });
+    /** Navigates to the given item. */
+    goto(item?: T, opts?: {
+        focusElement?: boolean;
+    }): boolean;
+    /** Navigates to the next item in the list. */
+    next(opts?: {
+        focusElement?: boolean;
+    }): boolean;
+    /** Peeks the next item in the list. */
+    peekNext(): T | undefined;
+    /** Navigates to the previous item in the list. */
+    prev(opts?: {
+        focusElement?: boolean;
+    }): boolean;
+    /** Peeks the previous item in the list. */
+    peekPrev(): T | undefined;
+    /** Navigates to the first item in the list. */
+    first(opts?: {
+        focusElement?: boolean;
+    }): boolean;
+    /** Navigates to the last item in the list. */
+    last(opts?: {
+        focusElement?: boolean;
+    }): boolean;
+    /** Gets the first focusable item from the given list of items. */
+    peekFirst(items?: T[]): T | undefined;
+    /** Gets the last focusable item from the given list of items. */
+    peekLast(items?: T[]): T | undefined;
+    /** Advances to the next or previous focusable item in the list based on the given delta. */
+    private _advance;
+    /** Peeks the next or previous focusable item in the list based on the given delta. */
+    private _peek;
+}
+
 /** Represents coordinates in a grid. */
 interface RowCol {
     /** The row index. */
@@ -127,8 +233,6 @@ declare class GridData<T extends BaseGridCell> {
     readonly inputs: GridDataInputs<T>;
     /** The two-dimensional array of cells that represents the grid. */
     readonly cells: SignalLike<T[][]>;
-    /** The number of rows in the grid. */
-    readonly rowCount: _angular_core.Signal<number>;
     /** The maximum number of rows in the grid, accounting for row spans. */
     readonly maxRowCount: _angular_core.Signal<number>;
     /** The maximum number of columns in the grid, accounting for column spans. */
@@ -142,6 +246,8 @@ declare class GridData<T extends BaseGridCell> {
     /** A map from a column index to the number of rows in that column. */
     private readonly _rowCountByCol;
     constructor(inputs: GridDataInputs<T>);
+    /** Whether the cell exists. */
+    hasCell(cell: T): boolean;
     /** Gets the cell at the given coordinates. */
     getCell(rowCol: RowCol): T | undefined;
     /** Gets the primary coordinates of the given cell. */
@@ -169,8 +275,8 @@ interface GridFocusInputs {
     focusMode: SignalLike<'roving' | 'activedescendant'>;
     /** Whether the grid is disabled. */
     disabled: SignalLike<boolean>;
-    /** Whether disabled cells in the grid should be skipped when navigating. */
-    skipDisabled: SignalLike<boolean>;
+    /** Whether disabled cells in the grid should be focusable. */
+    softDisabled: SignalLike<boolean>;
 }
 /** Dependencies for the `GridFocus` class. */
 interface GridFocusDeps<T extends GridFocusCell> {
@@ -181,9 +287,9 @@ interface GridFocusDeps<T extends GridFocusCell> {
 declare class GridFocus<T extends GridFocusCell> {
     readonly inputs: GridFocusInputs & GridFocusDeps<T>;
     /** The current active cell. */
-    readonly activeCell: _angular_core.WritableSignal<T | undefined>;
+    readonly activeCell: WritableSignal<T | undefined>;
     /** The current active cell coordinates. */
-    readonly activeCoords: _angular_core.WritableSignal<RowCol>;
+    readonly activeCoords: WritableSignal<RowCol>;
     /** Whether the grid active state is empty (no active cell or coordinates). */
     readonly stateEmpty: _angular_core.Signal<boolean>;
     /**
@@ -198,11 +304,11 @@ declare class GridFocus<T extends GridFocusCell> {
     readonly activeDescendant: _angular_core.Signal<string | undefined>;
     /** Whether the grid is in a disabled state. */
     readonly gridDisabled: _angular_core.Signal<boolean>;
-    /** The tabindex for the grid container. */
+    /** The tab index for the grid container. */
     readonly gridTabIndex: _angular_core.Signal<0 | -1>;
     constructor(inputs: GridFocusInputs & GridFocusDeps<T>);
-    /** Returns the tabindex for the given grid cell cell. */
-    getCellTabindex(cell: T): -1 | 0;
+    /** Returns the tab index for the given grid cell cell. */
+    getCellTabIndex(cell: T): -1 | 0;
     /** Returns true if the given cell can be navigated to. */
     isFocusable(cell: T): boolean;
     /** Focuses the given cell. */
@@ -252,7 +358,7 @@ declare class GridNavigation<T extends GridNavigationCell> {
     /**
      * Gets the coordinates of the next focusable cell in a given direction, without changing focus.
      */
-    peek(direction: Delta, fromCoords: RowCol, wrap?: WrapStrategy): RowCol | undefined;
+    peek(direction: Delta, fromCoords: RowCol, wrap?: WrapStrategy, allowDisabled?: boolean): RowCol | undefined;
     /**
      * Navigates to the next focusable cell in a given direction.
      */
@@ -261,7 +367,7 @@ declare class GridNavigation<T extends GridNavigationCell> {
      * Gets the coordinates of the first focusable cell.
      * If a row is not provided, searches the entire grid.
      */
-    peekFirst(row?: number): RowCol | undefined;
+    peekFirst(row?: number, allowDisabled?: boolean): RowCol | undefined;
     /**
      * Navigates to the first focusable cell.
      * If a row is not provided, searches the entire grid.
@@ -271,7 +377,7 @@ declare class GridNavigation<T extends GridNavigationCell> {
      * Gets the coordinates of the last focusable cell.
      * If a row is not provided, searches the entire grid.
      */
-    peekLast(row?: number): RowCol | undefined;
+    peekLast(row?: number, allowDisabled?: boolean): RowCol | undefined;
     /**
      * Navigates to the last focusable cell.
      * If a row is not provided, searches the entire grid.
@@ -303,7 +409,11 @@ interface GridSelectionDeps<T extends GridSelectionCell> {
 /** Controls selection for a grid of items. */
 declare class GridSelection<T extends GridSelectionCell> {
     readonly inputs: GridSelectionInputs & GridSelectionDeps<T>;
+    /** The list of cells that were changed in the last selection operation. */
+    private readonly _undoList;
     constructor(inputs: GridSelectionInputs & GridSelectionDeps<T>);
+    /** Reverts the last selection change. */
+    undo(): void;
     /** Selects one or more cells in a given range. */
     select(fromCoords: RowCol, toCoords?: RowCol): void;
     /** Deselects one or more cells in a given range. */
@@ -314,17 +424,40 @@ declare class GridSelection<T extends GridSelectionCell> {
     selectAll(): void;
     /** Deselects all valid cells in the grid. */
     deselectAll(): void;
-    /** A generator that yields all valid (selectable and not disabled) cells within a given range. */
+    /** Whether a cell is selctable. */
+    isSelectable(cell: T): boolean;
+    /** A generator that yields all cells within a given range. */
     _validCells(fromCoords: RowCol, toCoords: RowCol): Generator<T>;
+    /**
+     * Updates the selection state of cells in a given range and preserves previous changes
+     * to a undo list.
+     */
+    private _updateState;
 }
 
+/** The selection operations that can be performed after a navigation operation. */
+interface NavOptions {
+    /** Toggles the selection state of the active cell. */
+    toggle?: boolean;
+    /**
+     * Toggles the selection state of the active cell, and deselects all other cells if the
+     * active cell is selected. If the active cell is the only selected cell, it will be deselected.
+     */
+    toggleOne?: boolean;
+    /** Selects the active cell, preserving the selection state of other cells. */
+    select?: boolean;
+    /** Deselects all other cells and selects the active cell. */
+    selectOne?: boolean;
+    /**
+     * Moves the selection anchor to the active cell and updates the selection to include all
+     * cells between the anchor and the active cell.
+     */
+    anchor?: boolean;
+}
 /** A type that represents a cell in a grid, combining all cell-related interfaces. */
 type GridCell = BaseGridCell & GridFocusCell & GridNavigationCell & GridSelectionCell;
 /** Represents the required inputs for a grid. */
-interface GridInputs$1<T extends GridCell> extends GridDataInputs<T>, GridFocusInputs, GridNavigationInputs, GridSelectionInputs {
-    /** Whether selection is enabled for the grid. */
-    enableSelection: SignalLike<boolean>;
-}
+type GridInputs$1<T extends GridCell> = GridDataInputs<T> & GridFocusInputs & GridNavigationInputs & GridSelectionInputs;
 /** The main class that orchestrates the grid behaviors. */
 declare class Grid<T extends GridCell> {
     readonly inputs: GridInputs$1<T>;
@@ -338,132 +471,216 @@ declare class Grid<T extends GridCell> {
     readonly selectionBehavior: GridSelection<T>;
     /** The anchor point for range selection, linked to the active coordinates. */
     readonly selectionAnchor: _angular_core.WritableSignal<RowCol>;
-    /** The `tabindex` for the grid container. */
-    readonly gridTabIndex: _angular_core.Signal<0 | -1>;
+    /** The cell at the selection anchor. */
+    readonly selectionAnchorCell: _angular_core.Signal<T | undefined>;
+    /** Whether a range selection has settled. */
+    readonly selectionStabled: _angular_core.WritableSignal<boolean>;
+    /** Whether all selectable cells are selected. */
+    readonly allSelected: SignalLike<boolean>;
+    /** The tab index for the grid container. */
+    readonly gridTabIndex: SignalLike<-1 | 0>;
     /** Whether the grid is in a disabled state. */
-    readonly gridDisabled: _angular_core.Signal<boolean>;
+    readonly gridDisabled: SignalLike<boolean>;
     /** The ID of the active descendant for ARIA `activedescendant` focus management. */
-    readonly activeDescendant: _angular_core.Signal<string | undefined>;
+    readonly activeDescendant: SignalLike<string | undefined>;
     constructor(inputs: GridInputs$1<T>);
     /** Gets the 1-based row index of a cell. */
     rowIndex(cell: T): number | undefined;
     /** Gets the 1-based column index of a cell. */
     colIndex(cell: T): number | undefined;
-    /** Gets the `tabindex` for a given cell. */
+    /** Gets the tab index for a given cell. */
     cellTabIndex(cell: T): -1 | 0;
     /** Navigates to the cell above the currently active cell. */
-    up(): boolean;
-    /** Extends the selection to the cell above the selection anchor. */
-    rangeSelectUp(): void;
+    up(opts?: NavOptions): boolean;
     /** Navigates to the cell below the currently active cell. */
-    down(): boolean;
-    /** Extends the selection to the cell below the selection anchor. */
-    rangeSelectDown(): void;
+    down(opts?: NavOptions): boolean;
     /** Navigates to the cell to the left of the currently active cell. */
-    left(): boolean;
-    /** Extends the selection to the cell to the left of the selection anchor. */
-    rangeSelectLeft(): void;
+    left(opts?: NavOptions): boolean;
     /** Navigates to the cell to the right of the currently active cell. */
-    right(): boolean;
-    /** Extends the selection to the cell to the right of the selection anchor. */
-    rangeSelectRight(): void;
+    right(opts?: NavOptions): boolean;
     /** Navigates to the first focusable cell in the grid. */
-    first(): boolean;
+    first(opts?: NavOptions): boolean;
     /** Navigates to the first focusable cell in the current row. */
-    firstInRow(): boolean;
+    firstInRow(opts?: NavOptions): boolean;
     /** Navigates to the last focusable cell in the grid. */
-    last(): boolean;
+    last(opts?: NavOptions): boolean;
     /** Navigates to the last focusable cell in the current row. */
-    lastInRow(): boolean;
+    lastInRow(opts?: NavOptions): boolean;
     /** Selects all cells in the current row. */
     selectRow(): void;
     /** Selects all cells in the current column. */
     selectCol(): void;
+    /** Selects the active cell. */
+    select(): void;
+    /** Deselects the active cell. */
+    deselect(): void;
+    /**
+     * Toggles the selection state of the coordinates of the given cell
+     * or the current active coordinates.
+     */
+    toggle(): void;
+    /** Toggles the selection state of the active cell, and deselects all other cells. */
+    toggleOne(): void;
     /** Selects all selectable cells in the grid. */
     selectAll(): void;
+    /** Deselects all cells in the grid. */
+    deselectAll(): void;
     /** Navigates to and focuses the given cell. */
-    gotoCell(cell: T): boolean;
-    /** Toggles the selection state of the given cell. */
-    toggleSelect(cell: T): void;
-    /** Extends the selection from the anchor to the given cell. */
-    rangeSelect(cell: T): void;
-    /** Extends the selection to the given coordinates. */
-    private _rangeSelectCoords;
+    gotoCell(cell: T, opts?: NavOptions): boolean;
+    /** Sets the default active state of the grid. */
+    setDefaultState(): boolean;
     /** Resets the active state of the grid if it is empty or stale. */
     resetState(): boolean;
+    /** Updates the selection anchor to the given coordinates. */
+    private _updateSelectionAnchor;
+    /** Updates the selection to include all cells between the anchor and the active cell. */
+    private _updateRangeSelection;
+    /** Gets the start and end coordinates for a selection range. */
+    private _getSelectionCoords;
+    /** Executes a navigation operation and applies selection options. */
+    private _navigateWithSelection;
 }
 
 /** The inputs for the `GridCellWidgetPattern`. */
-interface GridCellWidgetInputs {
+interface GridCellWidgetInputs extends Omit<ListNavigationItem, 'index'> {
     /** The `GridCellPattern` that this widget belongs to. */
     cell: SignalLike<GridCellPattern>;
     /** The html element that should receive focus. */
     element: SignalLike<HTMLElement>;
-    /**
-     * Whether the widget is activated, which pauses grid navigation to allow interaction
-     * with the widget.
-     */
-    activate: WritableSignalLike<boolean>;
+    /** The type of widget, which determines how it is activated. */
+    widgetType: SignalLike<'simple' | 'complex' | 'editable'>;
+    /** The element that will receive focus when the widget is activated. */
+    focusTarget: SignalLike<HTMLElement | undefined>;
 }
 /** The UI pattern for a widget inside a grid cell. */
-declare class GridCellWidgetPattern {
+declare class GridCellWidgetPattern implements ListNavigationItem {
     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 `tabindex` for the widget. */
-    readonly tabIndex: SignalLike<-1 | 0>;
-    /** Whether the widget is in an active state (i.e. its containing cell is active). */
-    readonly active: SignalLike<boolean>;
+    /** The element that should receive focus. */
+    readonly widgetHost: Signal<HTMLElement>;
+    /** The index of the widget within the cell. */
+    readonly index: Signal<number>;
+    /** Whether the widget is disabled. */
+    readonly disabled: Signal<boolean>;
+    /** The tab index for the widget. */
+    readonly tabIndex: Signal<-1 | 0>;
+    /** Whether the widget is the active item in the widget list. */
+    readonly active: Signal<boolean>;
+    /** Whether the widget is currently activated. */
+    readonly isActivated: WritableSignal<boolean>;
+    /** The last event that caused the widget to be activated. */
+    readonly lastActivateEvent: WritableSignal<KeyboardEvent | FocusEvent | undefined>;
+    /** The last event that caused the widget to be deactivated. */
+    readonly lastDeactivateEvent: WritableSignal<KeyboardEvent | FocusEvent | undefined>;
+    /** The keyboard event manager for the widget. */
+    readonly keydown: Signal<KeyboardEventManager<KeyboardEvent>>;
     constructor(inputs: GridCellWidgetInputs);
+    /** Handles keydown events for the widget. */
+    onKeydown(event: KeyboardEvent): void;
+    /** Handles focusin events for the widget. */
+    onFocusIn(event: FocusEvent): void;
+    /** Handles focusout events for the widget. */
+    onFocusOut(event: FocusEvent): void;
+    /** Focuses the widget's host element. */
+    focus(): void;
+    /** Activates the widget. */
+    activate(event?: KeyboardEvent | FocusEvent): void;
+    /** Deactivates the widget and restores focus to the widget's host element. */
+    deactivate(event?: KeyboardEvent | FocusEvent): void;
 }
 
 /** The inputs for the `GridCellPattern`. */
-interface GridCellInputs extends GridCell {
+interface GridCellInputs extends GridCell, Omit<ListNavigationInputs<GridCellWidgetPattern>, 'focusMode' | 'items' | 'activeItem' | 'softDisabled' | 'element'> {
     /** The `GridPattern` that this cell belongs to. */
     grid: SignalLike<GridPattern>;
     /** The `GridRowPattern` that this cell belongs to. */
     row: SignalLike<GridRowPattern>;
-    /** The widget pattern contained within this cell, if any. */
-    widget: SignalLike<GridCellWidgetPattern | undefined>;
+    /** The widget patterns contained within this cell, if any. */
+    widgets: SignalLike<GridCellWidgetPattern[]>;
     /** The index of this cell's row within the grid. */
     rowIndex: SignalLike<number | undefined>;
     /** The index of this cell's column within the grid. */
     colIndex: SignalLike<number | undefined>;
+    /** A function that returns the cell widget associated with a given element. */
+    getWidget: (e: Element | null) => GridCellWidgetPattern | undefined;
 }
 /** The UI pattern for a grid cell. */
 declare class GridCellPattern implements GridCell {
     readonly inputs: GridCellInputs;
     /** A unique identifier for the cell. */
     readonly id: SignalLike<string>;
-    /** Whether a cell is disabled. */
-    readonly disabled: SignalLike<boolean>;
+    /** The html element that should receive focus. */
+    readonly element: SignalLike<HTMLElement>;
+    /** Whether the cell has focus. */
+    readonly isFocused: WritableSignal<boolean>;
     /** Whether the cell is selected. */
     readonly selected: WritableSignalLike<boolean>;
     /** Whether the cell is selectable. */
     readonly selectable: SignalLike<boolean>;
+    /** Whether a cell is disabled. */
+    readonly disabled: SignalLike<boolean>;
     /** The number of rows the cell should span. */
     readonly rowSpan: SignalLike<number>;
     /** The number of columns the cell should span. */
     readonly colSpan: SignalLike<number>;
+    /** Whether the cell is active. */
+    readonly active: SignalLike<boolean>;
+    /** Whether the cell is a selection anchor. */
+    readonly anchor: SignalLike<true | undefined>;
     /** The `aria-selected` attribute for the cell. */
-    readonly ariaSelected: _angular_core.Signal<boolean | undefined>;
+    readonly ariaSelected: SignalLike<boolean | undefined>;
     /** The `aria-rowindex` attribute for the cell. */
-    readonly ariaRowIndex: _angular_core.Signal<number | undefined>;
+    readonly ariaRowIndex: SignalLike<number | undefined>;
     /** The `aria-colindex` attribute for the cell. */
-    readonly ariaColIndex: _angular_core.Signal<number | undefined>;
-    /** The html element that should receive focus. */
-    readonly element: SignalLike<HTMLElement>;
-    /** Whether the cell is active. */
-    readonly active: _angular_core.Signal<boolean>;
+    readonly ariaColIndex: SignalLike<number | undefined>;
     /** The internal tab index calculation for the cell. */
     private readonly _tabIndex;
-    /** The `tabindex` for the cell. If the cell contains a widget, the cell's tabindex is -1. */
+    /** 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 widget within the cell is activated. */
+    /** 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>;
+    /** 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: _angular_core.Signal<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
+    /** The key used to navigate to the next widget. */
+    readonly nextKey: _angular_core.Signal<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
+    /** The keyboard event manager for the cell. */
+    readonly keydown: _angular_core.Signal<KeyboardEventManager<KeyboardEvent>>;
     constructor(inputs: GridCellInputs);
-    /** Gets the `tabindex` for the widget within the cell. */
+    /** Handles keydown events for the cell. */
+    onKeydown(event: KeyboardEvent): void;
+    /** Handles focusin events for the cell. */
+    onFocusIn(event: FocusEvent): void;
+    /** Handles focusout events for the cell. */
+    onFocusOut(event: FocusEvent): void;
+    /** Focuses the cell or the active widget. */
+    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`. */
@@ -489,8 +706,18 @@ interface GridInputs extends Omit<GridInputs$1<GridCellPattern>, 'cells'> {
     element: SignalLike<HTMLElement>;
     /** The rows that make up the grid. */
     rows: SignalLike<GridRowPattern[]>;
+    /** The direction that text is read based on the users locale. */
+    textDirection: SignalLike<'rtl' | 'ltr'>;
+    /** Whether selection is enabled for the grid. */
+    enableSelection: SignalLike<boolean>;
+    /** Whether multiple cell in the grid can be selected. */
+    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) => GridCellPattern | undefined;
+    getCell: (e: Element | null) => GridCellPattern | undefined;
 }
 /** The UI pattern for a grid, handling keyboard navigation, focus, and selection. */
 declare class GridPattern {
@@ -507,18 +734,32 @@ declare class GridPattern {
     readonly activeDescendant: _angular_core.Signal<string | undefined>;
     /** The currently active cell. */
     readonly activeCell: _angular_core.Signal<GridCellPattern | undefined>;
-    /** Whether to pause grid navigation. */
-    readonly pauseNavigation: _angular_core.Signal<boolean>;
+    /** The current selection anchor cell. */
+    readonly anchorCell: SignalLike<GridCellPattern | undefined>;
+    /** Whether to pause grid navigation and give the keyboard control to cell or widget. */
+    readonly pauseNavigation: SignalLike<boolean>;
     /** Whether the focus is in the grid. */
     readonly isFocused: _angular_core.WritableSignal<boolean>;
+    /** Whether the grid has been focused once. */
+    readonly hasBeenFocused: _angular_core.WritableSignal<boolean>;
     /** Whether the user is currently dragging to select a range of cells. */
     readonly dragging: _angular_core.WritableSignal<boolean>;
+    /** The key for navigating to the previous column. */
+    readonly prevColKey: _angular_core.Signal<"ArrowRight" | "ArrowLeft">;
+    /** The key for navigating to the next column. */
+    readonly nextColKey: _angular_core.Signal<"ArrowRight" | "ArrowLeft">;
     /** The keydown event manager for the grid. */
     readonly keydown: _angular_core.Signal<KeyboardEventManager<KeyboardEvent>>;
     /** The pointerdown event manager for the grid. */
     readonly pointerdown: _angular_core.Signal<PointerEventManager<PointerEvent>>;
     /** The pointerup event manager for the grid. */
     readonly pointerup: _angular_core.Signal<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. */
+    private readonly _deletion;
+    /** Whether the grid state is stale and needs to be reconciled. */
+    private readonly _stateStale;
     constructor(inputs: GridInputs);
     /** Handles keydown events on the grid. */
     onKeydown(event: KeyboardEvent): void;
@@ -530,17 +771,19 @@ declare class GridPattern {
     onPointerup(event: PointerEvent): void;
     /** Handles focusin events on the grid. */
     onFocusIn(event: FocusEvent): void;
-    /** Indicates maybe the losing focus is caused by row/cell deletion. */
-    private readonly _maybeDeletion;
     /** Handles focusout events on the grid. */
     onFocusOut(event: FocusEvent): void;
-    /** Indicates the losing focus is certainly caused by row/cell deletion. */
-    private readonly _deletion;
+    /** Sets the default active state of the grid before receiving focus the first time. */
+    setDefaultStateEffect(): void;
     /** Resets the active state of the grid if it is empty or stale. */
     resetStateEffect(): void;
-    /** Focuses on the active cell element. */
+    /** Resets the focus to the active cell element or grid element. */
+    resetFocusEffect(): void;
+    /** Restore focus when a deletion happened. */
+    restoreFocusEffect(): void;
+    /** Sets focus when active cell changed. */
     focusEffect(): void;
 }
 
-export { GridCellPattern, GridCellWidgetPattern, GridPattern, GridRowPattern, KeyboardEventManager, PointerEventManager, convertGetterSetterToWritableSignalLike };
-export type { GridCellInputs, GridCellWidgetInputs, GridInputs, GridRowInputs, SignalLike, WritableSignalLike };
+export { GridCellPattern, GridCellWidgetPattern, GridPattern, GridRowPattern, KeyboardEventManager, ListFocus, ListNavigation, PointerEventManager, convertGetterSetterToWritableSignalLike };
+export type { GridCellInputs, GridCellWidgetInputs, GridInputs, GridRowInputs, ListFocusInputs, ListFocusItem, ListNavigationInputs, ListNavigationItem, SignalLike, WritableSignalLike };