@fundamental-ngx/core 0.65.0-rc.9 → 0.65.0

package/types/fundamental-ngx-core-menu.d.ts

@@ -486,6 +486,8 @@ declare class MenuService implements OnDestroy {
     private _emitActivePath;
     /** @hidden Depending on direction returns closest enabled sibling of given node */
     private _closestEnabled;
+    /** @hidden Returns first/last enabled sibling for Home/End keyboard support */
+    private _boundaryEnabled;
     static ɵfac: i0.ɵɵFactoryDeclaration<MenuService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MenuService>;
 }
@@ -701,12 +703,17 @@ declare class MenuKeyboardService {
     focusEscapeAfterList: () => void;
     /** Function that should be called every time, keydown event is used on some menu item,
      * it provides whole functionality for handling
-     * ArrowDown - focus, ArrowUp - focus, Space bar - simulate click, Enter key - simulate click.
+     * ArrowDown - focus, ArrowUp - focus, Home - focus first enabled item, End - focus last enabled item,
+     * Space bar - simulate click, Enter key - simulate click.
      * @param event KeyboardEvent
      * @param index index of items starts from 0
      * @param menuItems array of menu item directives
      * */
     keyDownHandler(event: KeyboardEvent, index: number, menuItems: DefaultMenuItem[] | ListItemComponent[]): void;
+    /** @hidden Returns index of first/last enabled item. Falls back to first/last if disabled state is unavailable. */
+    private _findBoundaryEnabledIndex;
+    /** @hidden Detects disabled state if supported by the item implementation. */
+    private _isItemDisabled;
     static ɵfac: i0.ɵɵFactoryDeclaration<MenuKeyboardService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MenuKeyboardService>;
 }

package/types/fundamental-ngx-core-mobile-mode.d.ts

@@ -5,6 +5,8 @@ import { InjectionToken, DestroyRef, ElementRef } from '@angular/core';
 interface MobileModeConfig {
     /** Dialog Title */
     title?: string;
+    /** Short instruction text rendered below the dialog title to guide the user. */
+    instruction?: string;
     /** Approve Button Label. If empty, button will not appear */
     approveButtonText?: string;
     /** Cancel Button Label. If empty, button will not appear */

package/types/fundamental-ngx-core-multi-combobox.d.ts

@@ -341,7 +341,7 @@ declare abstract class BaseMultiCombobox<T = any> {
      */
     protected _emitChangeEvent(): void;
     /** @hidden */
-    protected _setSelectedSuggestions(): void;
+    protected _setSelectedSuggestions(selectedItems?: T[]): void;
     /**
      * Convert original data to SelectableOptionItems Interface
      * @hidden

package/types/fundamental-ngx-core-popover.d.ts

@@ -923,23 +923,18 @@ declare class PopoverService {
     private _focusLastActiveElementBeforeOpen;
     /**
      * @hidden
-     * Starts a MutationObserver on the nearest scrollable ancestor of the trigger element (falling
-     * back to document.body) to detect layout shifts that would invalidate the overlay position.
-     * Two mutation types are observed within the subtree:
-     *  - `childList`: catches elements being added to or removed from the DOM (e.g. a banner/toast
-     *    that is fully removed after its timer expires).
-     *  - `attributes` with `attributeFilter: ['style', 'class']`: catches visibility toggling via
-     *    CSS (e.g. `display: none` applied inline or through a utility class, as the
-     *    `fd-message-strip` autoDismiss directive does).
-     * The callback is debounced through `requestAnimationFrame` so that rapid batched mutations
-     * (Angular rendering a whole subtree at once) only trigger a single `updatePosition()` call.
-     */
-    private _startAncestorResizeObserver;
-    /**
-     * @hidden
-     * Returns the nearest scrollable ancestor, or document.body when none is found.
+     * Starts a MutationObserver on document.body to detect any layout shift that could
+     * invalidate the overlay position — including mutations in elements outside the trigger's
+     * nearest scroll container (e.g. a collapsible header above a table pushing the trigger down).
+     *
+     * Observed mutation types:
+     *  - `childList`: elements added/removed from the DOM (Angular `@if`, ngIf, toast dismissed).
+     *  - `attributes` with `attributeFilter: ['style', 'class']`: visibility toggled via CSS.
+     *
+     * The callback is debounced through `requestAnimationFrame` so rapid batched mutations
+     * only trigger a single `updatePosition()` call per frame.
      */
-    private _findScrollableAncestor;
+    private _startLayoutShiftObserver;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<PopoverService>;
 }

package/types/fundamental-ngx-core-table.d.ts

@@ -1,163 +1,141 @@
-import * as i0 from '@angular/core';
-import { AfterContentInit, QueryList, OnDestroy, ElementRef, OnChanges, OnInit, AfterViewInit, DestroyRef, NgZone } from '@angular/core';
+import * as _angular_core from '@angular/core';
+import { AfterContentInit, ElementRef, OnInit, AfterViewInit } from '@angular/core';
 import * as i1 from '@fundamental-ngx/cdk/utils';
-import { FocusableItemDirective, ResizeObserverService, CssClassBuilder, FocusableListDirective, Nullable } from '@fundamental-ngx/cdk/utils';
-import { CheckboxComponent } from '@fundamental-ngx/core/checkbox';
+import { FocusableItemDirective, ResizeObserverService, FocusableListDirective } from '@fundamental-ngx/cdk/utils';
 import { IconFont } from '@fundamental-ngx/core/icon';
-import { ContentDensityObserver, ContentDensityMode } from '@fundamental-ngx/core/content-density';
+import { ContentDensityMode } from '@fundamental-ngx/core/content-density';
 
 declare class TableBodyDirective {
-    /** @hidden */
-    fdTableBodyClass: boolean;
+    /** ARIA role for the table body */
+    readonly role: _angular_core.InputSignal<string>;
     /**  Whether to show the table body's horizontal borders */
-    noBorderX: boolean;
+    readonly noBorderX: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**  Whether to show the table body's vertical borders */
-    noBorderY: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableBodyDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TableBodyDirective, "[fdTableBody], [fd-table-body]", never, { "noBorderX": { "alias": "noBorderX"; "required": false; }; "noBorderY": { "alias": "noBorderY"; "required": false; }; }, {}, never, never, true, never>;
+    readonly noBorderY: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableBodyDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableBodyDirective, "[fdTableBody], [fd-table-body]", never, { "role": { "alias": "role"; "required": false; "isSignal": true; }; "noBorderX": { "alias": "noBorderX"; "required": false; "isSignal": true; }; "noBorderY": { "alias": "noBorderY"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class TableCellDirective extends FocusableItemDirective implements AfterContentInit {
+    /** ARIA role for the table cell (only used if explicitly provided) */
+    readonly role: _angular_core.InputSignal<string | undefined>;
     /** Whether to show the table cell's horizontal borders */
-    noBorderX: boolean;
+    readonly noBorderX: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether to show the table cell's vertical borders */
-    noBorderY: boolean;
+    readonly noBorderY: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the table cell is activable */
-    activable: boolean;
-    /** @hidden */
-    set focusable(value: boolean);
-    get focusable(): boolean;
+    readonly activable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the table cell is focusable.
+     * This input syncs with the parent FocusableItemDirective's focusable state.
+     */
+    readonly focusable: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the table cell is hoverable */
-    hoverable: boolean;
+    readonly hoverable: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the table cell's width should fit to content  */
-    fitContent: boolean;
+    readonly fitContent: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the table cell shouldn't have padding on sides */
-    noPadding: boolean;
+    readonly noPadding: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the table cell indicates that there is no data */
-    noData: boolean;
+    readonly noData: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the table cell inside table header should be non-interactive */
-    nonInteractive: boolean;
+    readonly nonInteractive: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Key of a cell element, it's used to identify this cell with certain column */
-    key: string;
+    readonly key: _angular_core.InputSignal<string | undefined>;
     /** @hidden */
-    _checkboxes: QueryList<CheckboxComponent>;
-    /** @hidden */
-    _fdTableCellClass: boolean;
+    readonly _checkboxes: _angular_core.Signal<readonly unknown[]>;
+    /** @hidden Computed scope attribute for th elements in tbody */
+    protected readonly scope: _angular_core.Signal<"row" | null>;
+    /** @hidden Computed role based on element type and parent context */
+    protected readonly computedRole: _angular_core.Signal<string>;
     /** @hidden */
     private _parentPreviousTabIndex;
     /** @hidden */
     constructor();
     /** @hidden */
+    ngAfterContentInit(): void;
+    /** @hidden */
     protected _focusIn(): void;
     /** @hidden */
     protected _focusOut(): void;
-    /** @hidden */
-    ngAfterContentInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TableCellDirective, "[fdTableCell], [fd-table-cell]", never, { "noBorderX": { "alias": "noBorderX"; "required": false; }; "noBorderY": { "alias": "noBorderY"; "required": false; }; "activable": { "alias": "activable"; "required": false; }; "focusable": { "alias": "focusable"; "required": false; }; "hoverable": { "alias": "hoverable"; "required": false; }; "fitContent": { "alias": "fitContent"; "required": false; }; "noPadding": { "alias": "noPadding"; "required": false; }; "noData": { "alias": "noData"; "required": false; }; "nonInteractive": { "alias": "nonInteractive"; "required": false; }; "key": { "alias": "key"; "required": false; }; }, {}, ["_checkboxes"], never, true, never>;
-    static ngAcceptInputType_focusable: unknown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableCellDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableCellDirective, "[fdTableCell], [fd-table-cell]", never, { "role": { "alias": "role"; "required": false; "isSignal": true; }; "noBorderX": { "alias": "noBorderX"; "required": false; "isSignal": true; }; "noBorderY": { "alias": "noBorderY"; "required": false; "isSignal": true; }; "activable": { "alias": "activable"; "required": false; "isSignal": true; }; "focusable": { "alias": "focusable"; "required": false; "isSignal": true; }; "hoverable": { "alias": "hoverable"; "required": false; "isSignal": true; }; "fitContent": { "alias": "fitContent"; "required": false; "isSignal": true; }; "noPadding": { "alias": "noPadding"; "required": false; "isSignal": true; }; "noData": { "alias": "noData"; "required": false; "isSignal": true; }; "nonInteractive": { "alias": "nonInteractive"; "required": false; "isSignal": true; }; "key": { "alias": "key"; "required": false; "isSignal": true; }; }, {}, ["_checkboxes"], never, true, never>;
 }
 
-declare class TableContainerDirective implements OnDestroy {
+declare class TableContainerDirective {
     /** Whether the scroll is applied on the page and not on the table */
-    outerScroll: boolean;
+    readonly outerScroll: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** @hidden */
-    set toolbar(toolbarElRef: ElementRef);
+    readonly toolbar: _angular_core.Signal<ElementRef<any> | undefined>;
     /** @hidden */
-    set tableHeader(tableHeaderEl: ElementRef);
+    readonly tableHeader: _angular_core.Signal<ElementRef<any> | undefined>;
     /** @hidden */
     readonly resizeObserverService: ResizeObserverService;
     /** @hidden */
     private readonly _renderer;
     /** @hidden */
-    private _tableHeaderEl;
-    /** @hidden */
-    private _resizeSubscription;
+    private readonly _destroyRef;
     /** @hidden */
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableContainerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TableContainerDirective, "[fdTableContainer], [fd-table-container]", never, { "outerScroll": { "alias": "outerScroll"; "required": false; }; }, {}, ["toolbar", "tableHeader"], never, true, never>;
-    static ngAcceptInputType_outerScroll: unknown;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableContainerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableContainerDirective, "[fdTableContainer], [fd-table-container]", never, { "outerScroll": { "alias": "outerScroll"; "required": false; "isSignal": true; }; }, {}, ["toolbar", "tableHeader"], never, true, never>;
 }
 
 declare class TableFixedDirective {
-    /** @hidden */
-    fdTableFixedClass: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableFixedDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TableFixedDirective, "[fdTableFixed], [fd-table-fixed]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableFixedDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableFixedDirective, "[fdTableFixed], [fd-table-fixed]", never, {}, {}, never, never, true, never>;
 }
 
 declare class TableFooterDirective {
-    /** @hidden */
-    fdTableFooterClass: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableFooterDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TableFooterDirective, "[fdTableFooter], [fd-table-footer]", never, {}, {}, never, never, true, never>;
+    /** ARIA role for the table footer */
+    readonly role: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableFooterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableFooterDirective, "[fdTableFooter], [fd-table-footer]", never, { "role": { "alias": "role"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class TableHeaderDirective {
-    /** @hidden */
-    fdTableHeaderClass: boolean;
+    /** ARIA role for the table header */
+    readonly role: _angular_core.InputSignal<string>;
     /** Whether or not to show the table header's horizontal borders */
-    noBorderX: boolean;
+    readonly noBorderX: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether or not to show the table header's vertical borders */
-    noBorderY: boolean;
+    readonly noBorderY: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * Whether or not the header cells should be interactive
      * (have hover and active states)
      * default: false
      */
-    nonInteractive: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeaderDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TableHeaderDirective, "[fdTableHeader], [fd-table-header]", never, { "noBorderX": { "alias": "noBorderX"; "required": false; }; "noBorderY": { "alias": "noBorderY"; "required": false; }; "nonInteractive": { "alias": "nonInteractive"; "required": false; }; }, {}, never, never, true, never>;
+    readonly nonInteractive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableHeaderDirective, "[fdTableHeader], [fd-table-header]", never, { "role": { "alias": "role"; "required": false; "isSignal": true; }; "noBorderX": { "alias": "noBorderX"; "required": false; "isSignal": true; }; "noBorderY": { "alias": "noBorderY"; "required": false; "isSignal": true; }; "nonInteractive": { "alias": "nonInteractive"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class TableIconDirective implements OnChanges, CssClassBuilder, OnInit {
-    /** @hidden */
-    fdTableIconClass: boolean;
-    /** The property allows user to pass additional css classes
-     */
-    class: string;
+declare class TableIconDirective {
     /** The icon to include in the button. See the icon page for the list of icons.
      * Setter is used to control when css class have to be rebuilded.
      * Default value is set to ''.
      */
-    glyph: string;
+    readonly glyph: _angular_core.InputSignal<string>;
     /** Glyph font family */
-    glyphFont: IconFont;
+    readonly glyphFont: _angular_core.InputSignal<IconFont>;
     /** Whether or no icon is used as navigation  */
-    navigation: boolean;
+    readonly navigation: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** @hidden */
     readonly elementRef: ElementRef<any>;
-    /**
-     * @hidden
-     * CssClassBuilder interface implementation
-     * function must return single string
-     * function is responsible for order which css classes are applied
-     */
-    buildComponentCssClass(): string[];
-    /** Function runs when component is initialized
-     * function should build component css class
-     * function should build css style
-     */
-    ngOnChanges(): void;
     /** @hidden */
-    ngOnInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableIconDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TableIconDirective, "[fdTableIcon], [fd-table-icon]", never, { "class": { "alias": "class"; "required": false; }; "glyph": { "alias": "glyph"; "required": false; }; "glyphFont": { "alias": "glyphFont"; "required": false; }; "navigation": { "alias": "navigation"; "required": false; }; }, {}, never, never, true, never>;
+    protected readonly cssClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableIconDirective, "[fdTableIcon], [fd-table-icon]", never, { "glyph": { "alias": "glyph"; "required": false; "isSignal": true; }; "glyphFont": { "alias": "glyphFont"; "required": false; "isSignal": true; }; "navigation": { "alias": "navigation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class TableInnerDirective {
-    /** @hidden */
-    fdTableInnerClass: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableInnerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TableInnerDirective, "[fdTableInner], [fd-table-inner]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableInnerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableInnerDirective, "[fdTableInner], [fd-table-inner]", never, {}, {}, never, never, true, never>;
 }
 
 declare class TablePopoverDirective {
-    /** @hidden */
-    fdTablePopoverClass: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TablePopoverDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TablePopoverDirective, "[fdTablePopover], [fd-table-popover]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TablePopoverDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TablePopoverDirective, "[fdTablePopover], [fd-table-popover]", never, {}, {}, never, never, true, never>;
 }
 
 /**
@@ -171,32 +149,29 @@ declare class TablePopoverDirective {
  * ```
  */
 declare class TableResponsiveWrapperDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableResponsiveWrapperDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TableResponsiveWrapperDirective, "[fd-table-responsive-wrapper]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableResponsiveWrapperDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableResponsiveWrapperDirective, "[fd-table-responsive-wrapper]", never, {}, {}, never, never, true, never>;
 }
 
 declare const HIDDEN_CLASS_NAME = "fd-table--hidden";
-declare class TableRowDirective extends FocusableListDirective implements AfterViewInit, OnInit {
+declare class TableRowDirective extends FocusableListDirective implements OnInit, AfterViewInit {
+    /** ARIA role for the table row */
+    readonly role: _angular_core.InputSignal<string>;
     /** @hidden */
-    cells: QueryList<TableCellDirective>;
-    /** @hidden */
-    fdTableRowClass: boolean;
+    readonly cells: _angular_core.Signal<readonly TableCellDirective[]>;
     /** Whether the table row is activable */
-    activable: boolean;
+    readonly activable: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the table row is hoverable */
     /** Whether to highlight active row when clicked. */
-    highlightActive: boolean;
+    readonly highlightActive: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**  Whether the table row is hoverable */
-    hoverable: boolean;
-    /** Whether the table row is focusable */
-    set focusable(value: boolean);
-    get focusable(): boolean;
+    readonly hoverable: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the table row is main row, it's concerned only on pop in mode */
-    main: boolean;
+    readonly main: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the table row is secondary row, it's concerned only on pop in mode */
-    secondary: boolean;
+    readonly secondary: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the table row is active. */
-    active: boolean;
+    readonly active: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** @hidden */
     elementRef: ElementRef<HTMLTableRowElement>;
     /** @hidden */
@@ -219,32 +194,31 @@ declare class TableRowDirective extends FocusableListDirective implements AfterV
     private _changeVisibility;
     /** @hidden */
     private _hideElement;
-    /** @hidden */
-    private _setupCellsSubscription;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TableRowDirective, "[fdTableRow], [fd-table-row]", never, { "activable": { "alias": "activable"; "required": false; }; "highlightActive": { "alias": "highlightActive"; "required": false; }; "hoverable": { "alias": "hoverable"; "required": false; }; "focusable": { "alias": "focusable"; "required": false; }; "main": { "alias": "main"; "required": false; }; "secondary": { "alias": "secondary"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, ["cells"], never, true, never>;
-    static ngAcceptInputType_focusable: unknown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableRowDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableRowDirective, "[fdTableRow], [fd-table-row]", never, { "role": { "alias": "role"; "required": false; "isSignal": true; }; "activable": { "alias": "activable"; "required": false; "isSignal": true; }; "highlightActive": { "alias": "highlightActive"; "required": false; "isSignal": true; }; "hoverable": { "alias": "hoverable"; "required": false; "isSignal": true; }; "main": { "alias": "main"; "required": false; "isSignal": true; }; "secondary": { "alias": "secondary"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; }, {}, ["cells"], never, true, never>;
 }
 
 type TableStatuses = 'valid' | 'warning' | 'information' | 'error';
 declare class TableStatusIndicatorDirective {
     /** The type of indicator. Options are 'valid', 'warning', 'information' and 'error'. */
-    status: Nullable<TableStatuses>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableStatusIndicatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TableStatusIndicatorDirective, "[fdTableStatusIndicator], [fd-table-status-indicator]", never, { "status": { "alias": "status"; "required": false; }; }, {}, never, never, true, never>;
+    readonly status: _angular_core.InputSignal<TableStatuses | null | undefined>;
+    /** @hidden */
+    protected readonly cssClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableStatusIndicatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableStatusIndicatorDirective, "[fdTableStatusIndicator], [fd-table-status-indicator]", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class TableTextDirective {
     /** Whether the text should have shadow (halo) & overflow should be hidden. */
-    fdTableTextClass: boolean;
+    readonly fdTableTextClass: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the text should wrap when the text is too long for 1 line */
-    noWrap: boolean;
+    readonly noWrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the text should be bolded and marked as a title */
-    title: boolean;
+    readonly title: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Maximum width of a text element */
-    maxWidth: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableTextDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TableTextDirective, "[fdTableText], [fd-table-text]", never, { "fdTableTextClass": { "alias": "fdTableTextClass"; "required": false; }; "noWrap": { "alias": "noWrap"; "required": false; }; "title": { "alias": "title"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; }, {}, never, never, true, never>;
+    readonly maxWidth: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableTextDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableTextDirective, "[fdTableText], [fd-table-text]", never, { "fdTableTextClass": { "alias": "fdTableTextClass"; "required": false; "isSignal": true; }; "noWrap": { "alias": "noWrap"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -256,26 +230,19 @@ declare class TableTextDirective {
  * </table-wrapper>
  * ```
  */
-declare class TableWrapperComponent implements AfterContentInit, OnDestroy {
-    private elementRef;
-    private _contentDensityObserver;
-    /** @hidden */
-    private _contentDensitySettings;
+declare class TableWrapperComponent implements AfterContentInit {
     /** @hidden */
-    constructor(elementRef: ElementRef, _contentDensityObserver: ContentDensityObserver);
+    private readonly _elementRef;
     /** @hidden */
-    ngAfterContentInit(): void;
+    private readonly _renderer;
     /** @hidden */
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableWrapperComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TableWrapperComponent, "fd-table-wrapper", never, {}, {}, never, ["*"], true, never>;
-}
-
-declare class TableService {
+    private readonly _contentDensityObserver;
     /** @hidden */
-    propagateKeys$: i0.WritableSignal<string[]>;
+    constructor();
     /** @hidden */
-    changeKeys(keys: string[]): void;
+    ngAfterContentInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableWrapperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableWrapperComponent, "fd-table-wrapper", never, {}, {}, never, ["*"], true, never>;
 }
 
 declare const FdTableContentDensityProviderParams: {
@@ -288,49 +255,44 @@ declare const FdTableContentDensityProviderParams: {
  * <table fd-table></table>
  * ```
  */
-declare class TableComponent implements AfterContentInit, AfterViewInit {
-    private readonly _tableService;
-    private readonly _contentDensityObserver;
-    private readonly _destroyRef;
-    private readonly _ngZone;
-    /** @hidden */
-    fdTableClass: boolean;
+declare class TableComponent {
+    /** ARIA role for the table */
+    readonly role: _angular_core.InputSignal<string>;
     /** Whether or not to show the table's horizontal borders */
-    noBorderX: boolean;
+    readonly noBorderX: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether or not to show the table's vertical borders */
-    noBorderY: boolean;
+    readonly noBorderY: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether or not to show the table's outer border */
-    noOuterBorder: boolean;
+    readonly noOuterBorder: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether or not to show the table's top border */
-    topBorder: boolean;
+    readonly topBorder: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether or not to display the table in pop in mode, it also require change of markup */
-    popIn: boolean;
+    readonly popIn: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether or not to display the table in responsive mode. */
-    responsive: boolean;
+    readonly responsive: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** List of keys that identifies single columns */
-    keys: string[];
+    readonly keys: _angular_core.InputSignal<string[] | undefined>;
     /** Applies `focusable` to all cells within this table */
-    set allCellsFocusable(value: boolean);
-    get allCellsFocusable(): boolean;
-    /** @hidden */
-    readonly _cells: QueryList<TableCellDirective>;
-    /** @hidden */
-    private _allCellsFocusable;
+    readonly allCellsFocusable: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** @hidden */
-    constructor(_tableService: TableService, _contentDensityObserver: ContentDensityObserver, _destroyRef: DestroyRef, _ngZone: NgZone);
+    readonly _cells: _angular_core.Signal<readonly TableCellDirective[]>;
+    /**
+     * @hidden
+     * Computed aria-colcount attribute - total number of columns in the grid
+     * Required when aria-colindex is set on cells */
+    protected readonly ariaColCount: _angular_core.Signal<number | null>;
     /** @hidden */
-    ngAfterContentInit(): void;
+    private readonly _tableService;
+    /** @hidden Injected to activate content density CSS class effects */
+    private readonly _contentDensityObserver;
     /** @hidden */
-    ngAfterViewInit(): void;
+    constructor();
     /** Method that sorts and changes visible state of particular cells  */
     reset(keys: string[]): void;
     /** @hidden */
     private _propagateKeys;
-    /** @hidden */
-    private _updateCells;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "table[fd-table]", ["fd-table"], { "noBorderX": { "alias": "noBorderX"; "required": false; }; "noBorderY": { "alias": "noBorderY"; "required": false; }; "noOuterBorder": { "alias": "noOuterBorder"; "required": false; }; "topBorder": { "alias": "topBorder"; "required": false; }; "popIn": { "alias": "popIn"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; "keys": { "alias": "keys"; "required": false; }; "allCellsFocusable": { "alias": "allCellsFocusable"; "required": false; }; }, {}, ["_cells"], ["*"], true, [{ directive: typeof i1.FocusableGridDirective; inputs: {}; outputs: {}; }]>;
-    static ngAcceptInputType_allCellsFocusable: unknown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableComponent, "table[fd-table]", ["fd-table"], { "role": { "alias": "role"; "required": false; "isSignal": true; }; "noBorderX": { "alias": "noBorderX"; "required": false; "isSignal": true; }; "noBorderY": { "alias": "noBorderY"; "required": false; "isSignal": true; }; "noOuterBorder": { "alias": "noOuterBorder"; "required": false; "isSignal": true; }; "topBorder": { "alias": "topBorder"; "required": false; "isSignal": true; }; "popIn": { "alias": "popIn"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "keys": { "alias": "keys"; "required": false; "isSignal": true; }; "allCellsFocusable": { "alias": "allCellsFocusable"; "required": false; "isSignal": true; }; }, {}, ["_cells"], ["*"], true, [{ directive: typeof i1.FocusableGridDirective; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -338,9 +300,16 @@ declare class TableComponent implements AfterContentInit, AfterViewInit {
  * Use direct imports of components and directives.
  */
 declare class TableModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<TableModule, never, [typeof TableComponent, typeof TableResponsiveWrapperDirective, typeof TableWrapperComponent, typeof TableHeaderDirective, typeof TableFooterDirective, typeof TableBodyDirective, typeof TableRowDirective, typeof TableCellDirective, typeof TableStatusIndicatorDirective, typeof TablePopoverDirective, typeof TableInnerDirective, typeof TableTextDirective, typeof TableIconDirective, typeof TableFixedDirective, typeof TableContainerDirective], [typeof TableComponent, typeof TableResponsiveWrapperDirective, typeof TableWrapperComponent, typeof TableHeaderDirective, typeof TableFooterDirective, typeof TableBodyDirective, typeof TableRowDirective, typeof TableCellDirective, typeof TableStatusIndicatorDirective, typeof TablePopoverDirective, typeof TableInnerDirective, typeof TableTextDirective, typeof TableIconDirective, typeof TableFixedDirective, typeof TableContainerDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<TableModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TableModule, never, [typeof TableComponent, typeof TableResponsiveWrapperDirective, typeof TableWrapperComponent, typeof TableHeaderDirective, typeof TableFooterDirective, typeof TableBodyDirective, typeof TableRowDirective, typeof TableCellDirective, typeof TableStatusIndicatorDirective, typeof TablePopoverDirective, typeof TableInnerDirective, typeof TableTextDirective, typeof TableIconDirective, typeof TableFixedDirective, typeof TableContainerDirective], [typeof TableComponent, typeof TableResponsiveWrapperDirective, typeof TableWrapperComponent, typeof TableHeaderDirective, typeof TableFooterDirective, typeof TableBodyDirective, typeof TableRowDirective, typeof TableCellDirective, typeof TableStatusIndicatorDirective, typeof TablePopoverDirective, typeof TableInnerDirective, typeof TableTextDirective, typeof TableIconDirective, typeof TableFixedDirective, typeof TableContainerDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TableModule>;
+}
+
+declare class TableService {
+    /** @hidden */
+    propagateKeys$: _angular_core.WritableSignal<string[]>;
+    /** @hidden */
+    changeKeys(keys: string[]): void;
 }
 
 export { FdTableContentDensityProviderParams, HIDDEN_CLASS_NAME, TableBodyDirective, TableCellDirective, TableComponent, TableContainerDirective, TableFixedDirective, TableFooterDirective, TableHeaderDirective, TableIconDirective, TableInnerDirective, TableModule, TablePopoverDirective, TableResponsiveWrapperDirective, TableRowDirective, TableService, TableStatusIndicatorDirective, TableTextDirective, TableWrapperComponent };