@frame-kit/ui-ng 0.0.1

package/types/frame-kit-ui-ng-ui-data-table.d.ts

@@ -0,0 +1,482 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, OnInit, OnDestroy, computed, Signal, ElementRef } from '@angular/core';
+import * as _frame_kit_ui_ng_ui_data_table from '@frame-kit/ui-ng/ui/data-table';
+
+interface ColumnDef<T = unknown> {
+    id: string;
+    header: string;
+    accessor: keyof T | ((row: T) => unknown);
+    sortAccessor?: (row: T) => unknown;
+    width?: string;
+    minWidth?: string;
+    maxWidth?: string;
+    flex?: number;
+    sortable?: boolean;
+    align?: 'start' | 'center' | 'end';
+    truncate?: boolean;
+    visible?: boolean;
+    className?: string;
+    headerClassName?: string;
+    cellRenderer?: TemplateRef<{
+        $implicit: unknown;
+        row: T;
+    }>;
+    headerRenderer?: TemplateRef<{
+        $implicit: ColumnDef<T>;
+    }>;
+    priority?: number;
+    hideBelow?: 'sm' | 'md' | 'lg';
+    mobileLabel?: string;
+    resizable?: boolean;
+    pinnable?: boolean;
+    pinned?: 'start' | 'end' | null;
+}
+interface TableConfig<T = unknown> {
+    responsiveMode: 'auto' | 'scroll' | 'stack' | 'priority';
+    forceScroll: boolean;
+    stickyHeader: boolean;
+    showHeader: boolean;
+    rowExpansion: boolean;
+    emptyMessage: string;
+    trackBy: (index: number, row: T) => unknown;
+    rowStyleFn: ((row: T, index: number) => Record<string, string> | null) | null;
+    virtualization: boolean | 'auto';
+    virtualizationThreshold: number;
+    rowHeight: number;
+    overscan: number;
+    breakpoints: {
+        sm: string;
+        md: string;
+    };
+}
+declare const DEFAULT_TABLE_CONFIG: TableConfig;
+type SelectionDisabled<T = unknown> = boolean | ((row: T) => boolean);
+type SelectionColumnPosition = 'start' | 'end';
+type HeaderSelectionState = 'checked' | 'unchecked' | 'indeterminate';
+type ExpansionColumnPosition = 'start' | 'end';
+type SortDirection = 'asc' | 'desc' | null;
+interface SortState {
+    columnId: string;
+    direction: SortDirection;
+}
+interface FilterState {
+    query: string;
+    columnFilters: Record<string, unknown>;
+}
+interface PageState {
+    page: number;
+    pageSize: number;
+    totalRows: number;
+}
+interface ColumnResizeEvent {
+    columnId: string;
+    width: number;
+}
+interface TableRowContext<T = unknown> {
+    row: T;
+    index: number;
+    selected: boolean;
+    expanded: boolean;
+}
+
+declare class ColumnResizeDirective implements OnInit, OnDestroy {
+    readonly columnId: _angular_core.InputSignal<string>;
+    readonly enabled: _angular_core.InputSignal<boolean>;
+    readonly minWidth: _angular_core.InputSignal<number>;
+    readonly maxWidth: _angular_core.InputSignal<number | null>;
+    readonly columnResize: _angular_core.OutputEmitterRef<ColumnResizeEvent>;
+    private readonly el;
+    private readonly renderer;
+    private readonly ngZone;
+    private handle;
+    private startX;
+    private startWidth;
+    private dragging;
+    private moveListener;
+    private upListener;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private readonly onMouseDown;
+    private readonly onTouchStart;
+    private startDrag;
+    private onDrag;
+    private endDrag;
+    private cleanupListeners;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColumnResizeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ColumnResizeDirective, "[fkColumnResize]", never, { "columnId": { "alias": "fkColumnResize"; "required": true; "isSignal": true; }; "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; }, { "columnResize": "columnResize"; }, never, never, true, never>;
+}
+
+type Breakpoint = 'sm' | 'md' | 'lg';
+type ActiveMode = 'table' | 'stack';
+declare class ResponsiveStrategyService<T = unknown> {
+    private readonly breakpointObserver;
+    private readonly destroyRef;
+    readonly columns: _angular_core.WritableSignal<ColumnDef<T>[]>;
+    readonly config: _angular_core.WritableSignal<TableConfig<T> | null>;
+    readonly currentBreakpoint: _angular_core.WritableSignal<Breakpoint>;
+    readonly activeMode: ReturnType<typeof computed<ActiveMode>>;
+    readonly responsiveColumns: _angular_core.Signal<ColumnDef<T>[]>;
+    readonly hiddenColumns: _angular_core.Signal<ColumnDef<T>[]>;
+    private initialized;
+    init(breakpoints: {
+        sm: string;
+        md: string;
+    }): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResponsiveStrategyService<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ResponsiveStrategyService<any>>;
+}
+
+declare class TableEngineService<T = unknown> {
+    readonly rows: _angular_core.WritableSignal<T[]>;
+    readonly columns: _angular_core.WritableSignal<ColumnDef<T>[]>;
+    private readonly internalSortState;
+    private readonly internalFilterState;
+    private readonly internalPageState;
+    readonly controlledSortState: _angular_core.WritableSignal<SortState | null | undefined>;
+    readonly controlledFilterState: _angular_core.WritableSignal<FilterState | null | undefined>;
+    readonly controlledPageState: _angular_core.WritableSignal<PageState | null | undefined>;
+    readonly sortState: _angular_core.Signal<SortState | null>;
+    readonly filterState: _angular_core.Signal<FilterState>;
+    readonly pageState: _angular_core.Signal<PageState | null>;
+    readonly selectedKeys: _angular_core.WritableSignal<Set<unknown>>;
+    readonly expandedKeys: _angular_core.WritableSignal<Set<unknown>>;
+    readonly sortedRows: _angular_core.Signal<T[]>;
+    readonly filteredRows: _angular_core.Signal<T[]>;
+    readonly processedRows: _angular_core.Signal<T[]>;
+    readonly totalFilteredRows: _angular_core.Signal<number>;
+    toggleSort(columnId: string): SortState;
+    setFilter(query: string): FilterState;
+    setPage(page: number, pageSize?: number): PageState;
+    /**
+     * Replace the engine's internal selection state. Used by the host
+     * data-table when running in uncontrolled mode (controlled mode goes
+     * through the parent and never touches the engine here).
+     */
+    setSelectedKeys(next: Set<unknown>): void;
+    /**
+     * Replace the engine's internal expansion state. Used by the host
+     * data-table when running in uncontrolled mode.
+     */
+    setExpandedKeys(next: Set<unknown>): void;
+    /**
+     * Toggle a single key in a Set. Derives from `current` and returns a
+     * brand-new Set — never mutates the input.
+     */
+    toggleSelection(key: unknown, current?: ReadonlySet<unknown>): Set<unknown>;
+    /**
+     * Page-local select-all. Toggles every key in `visibleKeys`:
+     * - if all visible keys are already selected → deselect them
+     * - otherwise → select them all (existing selections outside the visible
+     *   range stay intact)
+     *
+     * `disabledKeys` is excluded from both the toggle target and the
+     * "all-selected" check, so a row marked `selectionDisabled` never
+     * blocks the header checkbox from going fully checked.
+     */
+    toggleVisibleRows(visibleKeys: Iterable<unknown>, disabledKeys?: ReadonlySet<unknown>, current?: ReadonlySet<unknown>): Set<unknown>;
+    clearSelection(): Set<unknown>;
+    isSelected(key: unknown): boolean;
+    private resolveAccessor;
+    private compare;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableEngineService<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TableEngineService<any>>;
+}
+
+declare class VirtualizationEngineService {
+    readonly rowHeight: _angular_core.WritableSignal<number>;
+    readonly overscan: _angular_core.WritableSignal<number>;
+    readonly totalRows: _angular_core.WritableSignal<number>;
+    readonly viewportHeight: _angular_core.WritableSignal<number>;
+    readonly scrollTop: _angular_core.WritableSignal<number>;
+    readonly visibleRange: Signal<{
+        start: number;
+        end: number;
+    }>;
+    readonly totalHeight: Signal<number>;
+    readonly offsetY: Signal<number>;
+    readonly visibleCount: Signal<number>;
+    onScroll(scrollTop: number): void;
+    onViewportResize(height: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VirtualizationEngineService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<VirtualizationEngineService>;
+}
+
+declare class DataTableComponent<T = unknown> {
+    readonly className: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /** Column definitions that describe the table schema, headers, and cell rendering. */
+    readonly columns: _angular_core.InputSignal<ColumnDef<T>[]>;
+    /** Array of row data objects rendered by the table. */
+    readonly rows: _angular_core.InputSignal<T[]>;
+    /** Partial table configuration merged with the defaults. */
+    readonly config: _angular_core.InputSignal<Partial<TableConfig<T>>>;
+    /** When true, shows the loading overlay and suppresses the empty state. */
+    readonly loading: _angular_core.InputSignal<boolean>;
+    /** Controlled sort state; pass null to let the table manage sorting internally. */
+    readonly sortState: _angular_core.InputSignal<SortState | null>;
+    /** Controlled filter state; pass null to let the table manage filtering internally. */
+    readonly filterState: _angular_core.InputSignal<FilterState | null>;
+    /** Controlled page state; pass null to let the table manage pagination internally. */
+    readonly pageState: _angular_core.InputSignal<PageState | null>;
+    /** Opt-in to row selection; requires `getRowId` for controlled mode across pagination. */
+    readonly rowSelection: _angular_core.InputSignal<boolean>;
+    /** Controlled set of selected row keys; null lets the table manage selection internally. */
+    readonly selectedKeys: _angular_core.InputSignal<Set<unknown> | null>;
+    /** Function that returns a stable unique key for each row, required when `rowSelection` is true. */
+    readonly getRowId: _angular_core.InputSignal<((row: T) => unknown) | null>;
+    /** Predicate (or static boolean) that disables selection for matching rows. */
+    readonly selectionDisabled: _angular_core.InputSignal<SelectionDisabled<T>>;
+    /** Whether the checkbox column appears at the start or end of the table. */
+    readonly selectionColumnPosition: _angular_core.InputSignal<SelectionColumnPosition>;
+    /** Accessible label for each row's selection checkbox. */
+    readonly selectionLabel: _angular_core.InputSignal<string>;
+    /** Template rendered as the expansion detail row; presence enables the feature. */
+    readonly rowDetailTemplate: _angular_core.InputSignal<TemplateRef<{
+        $implicit: T;
+        row: T;
+        index: number;
+    }> | null>;
+    /** Whether the chevron column appears at the start or end of the table. */
+    readonly expansionColumnPosition: _angular_core.InputSignal<ExpansionColumnPosition>;
+    /** Controlled set of expanded row keys; null lets the engine manage state internally. */
+    readonly expandedKeys: _angular_core.InputSignal<Set<unknown> | null>;
+    /** Predicate that disables expansion for matching rows; default: every row is expandable. */
+    readonly expandableRow: _angular_core.InputSignal<((row: T) => boolean) | null>;
+    /** Accessible label for each row's expansion chevron. */
+    readonly expansionLabel: _angular_core.InputSignal<string>;
+    /** Fires when the user clicks a sortable column header, emitting the new sort state. */
+    readonly sortChange: _angular_core.OutputEmitterRef<SortState>;
+    /** Fires when a filter changes, emitting the updated filter state. */
+    readonly filterChange: _angular_core.OutputEmitterRef<FilterState>;
+    /** Fires when the user navigates to a different page or changes page size. */
+    readonly pageChange: _angular_core.OutputEmitterRef<PageState>;
+    /** Fires when the user clicks a table row, emitting the row context. */
+    readonly rowClick: _angular_core.OutputEmitterRef<TableRowContext<T>>;
+    /** Fires when the selection set changes, emitting the full new set of selected keys. */
+    readonly selectionChange: _angular_core.OutputEmitterRef<Set<unknown>>;
+    /** Fires when the expansion set changes, emitting the full new set of expanded keys. */
+    readonly expansionChange: _angular_core.OutputEmitterRef<Set<unknown>>;
+    /** Fires when the user finishes resizing a column, emitting the column id and new width. */
+    readonly columnResize: _angular_core.OutputEmitterRef<ColumnResizeEvent>;
+    protected readonly engine: TableEngineService<T>;
+    protected readonly virtEngine: VirtualizationEngineService;
+    protected readonly responsive: ResponsiveStrategyService<T>;
+    readonly virtualViewport: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    readonly mergedConfig: _angular_core.Signal<TableConfig<T>>;
+    readonly visibleColumns: _angular_core.Signal<ColumnDef<T>[]>;
+    readonly activeMode: _angular_core.Signal<_frame_kit_ui_ng_ui_data_table.ActiveMode>;
+    readonly useVirtualization: _angular_core.Signal<boolean>;
+    readonly virtualRows: _angular_core.Signal<T[]>;
+    readonly virtualStartIndex: _angular_core.Signal<number>;
+    readonly isEmpty: _angular_core.Signal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get hostId(): string | null;
+    private readonly ngZone;
+    /**
+     * Optional group coordinator picked up via DI when this table is
+     * wrapped in `<fk-data-table-group>`. Presence flips expansion to
+     * single-open mode; absence keeps multi-expand behavior (the
+     * default).
+     */
+    private readonly groupCoordinator;
+    constructor();
+    /** Resolves the display value for a cell given its column definition and row data. */
+    getCellValue(column: ColumnDef<T>, row: T): unknown;
+    /** Returns the trackBy function from the merged config for use in `*ngFor`. */
+    getTrackBy(): (index: number, row: T) => unknown;
+    /**
+     * Source of truth for which keys are currently selected. Reads the
+     * controlled `selectedKeys` input when the parent supplied one;
+     * otherwise falls back to the engine's internal state (uncontrolled
+     * mode). Computed so changes flow through Angular's signal graph
+     * without effect-write timing surprises.
+     */
+    private readonly effectiveSelectedKeys;
+    /**
+     * Public alias of `effectiveSelectedKeys` for the stack (mobile) child
+     * binding. The private field stays private to discourage callers from
+     * reaching past the API.
+     */
+    readonly effectiveSelectedKeysForTemplate: _angular_core.Signal<Set<unknown>>;
+    /**
+     * Resolve a row's selection key. Uses the explicit `getRowId` input
+     * when provided; otherwise falls back to the row reference itself
+     * (which only works if rows are object-stable across renders — fine
+     * for uncontrolled-mode demos, broken across server-side pagination).
+     */
+    /** Resolves a stable selection key for the given row using `getRowId` or falling back to the row reference. */
+    getSelectionKey(row: T): unknown;
+    /** Returns true if the given row is currently in the selected keys set. */
+    isRowSelected(row: T): boolean;
+    /** Returns true if selection is disabled for the given row per the `selectionDisabled` input. */
+    isRowSelectionDisabled(row: T): boolean;
+    /**
+     * Selection state of the header checkbox, derived from visible rows ∩
+     * `effectiveSelectedKeys`. Disabled rows are excluded — they can't
+     * contribute to the all-selected check.
+     */
+    readonly headerSelectionState: _angular_core.Signal<HeaderSelectionState>;
+    /**
+     * Rows currently visible in the body (post-pagination) excluding any
+     * marked as selection-disabled. The header checkbox toggles only over
+     * this set.
+     */
+    private readonly visibleSelectableRows;
+    onToggleRow(row: T, event: Event): void;
+    onToggleAllVisible(event: Event): void;
+    /**
+     * Source of truth for which row keys are currently expanded. Reads
+     * the controlled `expandedKeys` input when the parent supplied one,
+     * otherwise falls back to the engine's internal set.
+     */
+    private readonly effectiveExpandedKeys;
+    /** True when `rowDetailTemplate` is set — the feature is opt-in. */
+    readonly hasExpansion: _angular_core.Signal<boolean>;
+    /**
+     * Whether the expand chevron column appears at the start. When the
+     * expansion feature is off this returns false so the column doesn't
+     * render. Selection takes priority when both are pinned to "start"
+     * (selection comes first, then expand).
+     */
+    readonly hasExpansionStart: _angular_core.Signal<boolean>;
+    readonly hasExpansionEnd: _angular_core.Signal<boolean>;
+    /** Returns true if the given row is currently expanded. */
+    isRowExpanded(row: T): boolean;
+    /** Returns true unless an `expandableRow` predicate explicitly excludes the row. */
+    isRowExpandable(row: T): boolean;
+    /**
+     * Total columns rendered per row (data columns + selection col + expand col).
+     * Used as the colspan for the detail `<td>` so it spans the full row width.
+     */
+    readonly totalColumnCount: _angular_core.Signal<number>;
+    /** Toggle a single row's expansion via chevron click or keyboard. */
+    onToggleExpand(row: T, event: Event): void;
+    /**
+     * Public hook used by the group coordinator to force-clear this
+     * table's expansion when a sibling table opens a row. Routes through
+     * the same commit path so controlled-mode parents still see the
+     * emission.
+     */
+    clearExpansion(): void;
+    private commitExpansion;
+    onHeaderClick(column: ColumnDef<T>): void;
+    /** Returns an inline style object for the row if a `rowStyleFn` is configured, otherwise null. */
+    getRowStyle(row: T, index: number): Record<string, string> | null;
+    onRowClick(row: T, index: number): void;
+    onVirtualScroll(event: Event): void;
+    onViewportInit(el: HTMLElement): void;
+    getPinOffset(column: ColumnDef<T>): string | null;
+    onColumnResize(event: ColumnResizeEvent): void;
+    /** Returns the current sort direction for the given column id, or null if not sorted. */
+    getSortDirection(columnId: string): 'asc' | 'desc' | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataTableComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataTableComponent<any>, "fk-data-table", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "sortState": { "alias": "sortState"; "required": false; "isSignal": true; }; "filterState": { "alias": "filterState"; "required": false; "isSignal": true; }; "pageState": { "alias": "pageState"; "required": false; "isSignal": true; }; "rowSelection": { "alias": "rowSelection"; "required": false; "isSignal": true; }; "selectedKeys": { "alias": "selectedKeys"; "required": false; "isSignal": true; }; "getRowId": { "alias": "getRowId"; "required": false; "isSignal": true; }; "selectionDisabled": { "alias": "selectionDisabled"; "required": false; "isSignal": true; }; "selectionColumnPosition": { "alias": "selectionColumnPosition"; "required": false; "isSignal": true; }; "selectionLabel": { "alias": "selectionLabel"; "required": false; "isSignal": true; }; "rowDetailTemplate": { "alias": "rowDetailTemplate"; "required": false; "isSignal": true; }; "expansionColumnPosition": { "alias": "expansionColumnPosition"; "required": false; "isSignal": true; }; "expandedKeys": { "alias": "expandedKeys"; "required": false; "isSignal": true; }; "expandableRow": { "alias": "expandableRow"; "required": false; "isSignal": true; }; "expansionLabel": { "alias": "expansionLabel"; "required": false; "isSignal": true; }; }, { "sortChange": "sortChange"; "filterChange": "filterChange"; "pageChange": "pageChange"; "rowClick": "rowClick"; "selectionChange": "selectionChange"; "expansionChange": "expansionChange"; "columnResize": "columnResize"; }, never, never, true, never>;
+}
+
+/**
+ * Single-expand wrapper for `<fk-data-table>`. Mirror of
+ * `<fk-accordion-group>`: provides a coordinator scoped to itself, any
+ * descendant data-table picks it up via DI and routes every expansion
+ * toggle through it. The coordinator collapses the previously-active
+ * row when a new one expands so only one detail panel is open.
+ *
+ * Wrap a data-table when you want exclusive expansion:
+ *
+ * ```html
+ * <fk-data-table-group>
+ *   <fk-data-table [rowDetailTemplate]="detail" ... />
+ * </fk-data-table-group>
+ * ```
+ *
+ * Omit the wrapper for multi-expand (the default).
+ */
+declare class DataTableGroupComponent {
+    readonly className: _angular_core.InputSignal<string>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataTableGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataTableGroupComponent, "fk-data-table-group", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Coordinator scoped to a single `<fk-data-table-group>`. Mirrors
+ * `AccordionGroupCoordinator` — when a wrapped data-table expands a
+ * row, the previously-active row is collapsed so only one detail
+ * panel is open at a time.
+ *
+ * The wrapped data-table picks this up via `inject({ optional: true })`
+ * and routes every expansion toggle through it. Absence of the
+ * coordinator means multi-expand behavior — that's the default.
+ */
+declare class DataTableGroupCoordinator {
+    private activeTable;
+    private activeKey;
+    /**
+     * Resolve an expansion request. Caller passes the new expanded
+     * state alongside the table + row key; coordinator returns the
+     * Set the caller should commit. For multi-table groups this also
+     * collapses any active row on a sibling table.
+     */
+    resolveToggle(table: DataTableComponent<unknown>, key: unknown, nextExpanded: boolean, currentKeysOnThisTable: ReadonlySet<unknown>): {
+        keysForThisTable: Set<unknown>;
+        /** Optional: a sibling table the host should clear by calling its `clearExpansion`. */
+        siblingTableToClear: DataTableComponent<unknown> | null;
+    };
+    /**
+     * Called when a data-table inside the group disconnects. Clears the
+     * active pointer if it was tracking this table.
+     */
+    unregister(table: DataTableComponent<unknown>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataTableGroupCoordinator, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DataTableGroupCoordinator>;
+}
+
+interface StackToggleRowEvent<T = unknown> {
+    row: T;
+    event: Event;
+}
+declare class DataTableStackComponent<T = unknown> {
+    /** Row data array rendered as stacked cards in mobile layout. */
+    readonly rows: _angular_core.InputSignal<T[]>;
+    /** Column definitions used to extract field labels and cell values. */
+    readonly columns: _angular_core.InputSignal<ColumnDef<T>[]>;
+    /** Merged table configuration passed down from the host data-table. */
+    readonly config: _angular_core.InputSignal<TableConfig<T> | null>;
+    /** TrackBy function used by the `@for` loop over rows. */
+    readonly trackByFn: _angular_core.InputSignal<(index: number, row: T) => unknown>;
+    /** Mirrors the host table's `rowSelection` input to show checkboxes on each card. */
+    readonly rowSelection: _angular_core.InputSignal<boolean>;
+    /** Currently selected row keys forwarded from the host table engine. */
+    readonly selectedKeys: _angular_core.InputSignal<Set<unknown>>;
+    /** Row identity resolver forwarded from the host table. */
+    readonly getRowId: _angular_core.InputSignal<((row: T) => unknown) | null>;
+    /** Predicate (or static boolean) that disables selection for matching rows. */
+    readonly selectionDisabled: _angular_core.InputSignal<SelectionDisabled<T>>;
+    /** Accessible label for each card's selection checkbox. */
+    readonly selectionLabel: _angular_core.InputSignal<string>;
+    /** Fires when the user clicks a card row, emitting the row context. */
+    readonly rowClick: _angular_core.OutputEmitterRef<TableRowContext<T>>;
+    /** Fires when the user toggles a card's selection checkbox, bubbling up to the host. */
+    readonly toggleRow: _angular_core.OutputEmitterRef<StackToggleRowEvent<T>>;
+    readonly expandedRows: _angular_core.WritableSignal<Set<number>>;
+    readonly visibleFieldCount = 3;
+    readonly primaryColumns: _angular_core.Signal<ColumnDef<T>[]>;
+    readonly secondaryColumns: _angular_core.Signal<ColumnDef<T>[]>;
+    readonly hasSecondary: _angular_core.Signal<boolean>;
+    getCellValue(column: ColumnDef<T>, row: T): unknown;
+    getLabel(column: ColumnDef<T>): string;
+    isExpanded(index: number): boolean;
+    toggleExpand(index: number): void;
+    onRowClick(row: T, index: number): void;
+    onToggleSelection(row: T, event: Event): void;
+    isRowSelected(row: T): boolean;
+    isRowSelectionDisabled(row: T): boolean;
+    private getSelectionKey;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataTableStackComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataTableStackComponent<any>, "fk-data-table-stack", never, { "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "trackByFn": { "alias": "trackByFn"; "required": false; "isSignal": true; }; "rowSelection": { "alias": "rowSelection"; "required": false; "isSignal": true; }; "selectedKeys": { "alias": "selectedKeys"; "required": false; "isSignal": true; }; "getRowId": { "alias": "getRowId"; "required": false; "isSignal": true; }; "selectionDisabled": { "alias": "selectionDisabled"; "required": false; "isSignal": true; }; "selectionLabel": { "alias": "selectionLabel"; "required": false; "isSignal": true; }; }, { "rowClick": "rowClick"; "toggleRow": "toggleRow"; }, never, never, true, never>;
+}
+
+export { ColumnResizeDirective, DEFAULT_TABLE_CONFIG, DataTableComponent, DataTableGroupComponent, DataTableGroupCoordinator, DataTableStackComponent, ResponsiveStrategyService, TableEngineService, VirtualizationEngineService };
+export type { ActiveMode, Breakpoint, ColumnDef, ColumnResizeEvent, ExpansionColumnPosition, FilterState, HeaderSelectionState, PageState, SelectionColumnPosition, SelectionDisabled, SortDirection, SortState, StackToggleRowEvent, TableConfig, TableRowContext };

package/types/frame-kit-ui-ng-ui-dialog.d.ts

@@ -0,0 +1,166 @@
+import * as _angular_core from '@angular/core';
+import { Type, ComponentRef } from '@angular/core';
+import { Observable } from 'rxjs';
+
+type DialogSize = 'sm' | 'md' | 'lg' | 'xl' | 'fullscreen';
+type DialogPosition = 'center' | 'top';
+type DialogAnimation = 'scale-fade' | 'fade' | 'slide-up' | 'slide-down' | 'none';
+type CanCloseFn = () => boolean | Promise<boolean>;
+
+declare class FkDialogHeaderDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FkDialogHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FkDialogHeaderDirective, "[fkDialogHeader]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DialogComponent {
+    /** Controls whether the dialog is open. */
+    readonly open: _angular_core.InputSignal<boolean>;
+    /** When true, renders a backdrop overlay behind the dialog. */
+    readonly modal: _angular_core.InputSignal<boolean>;
+    /** When true, shows the close button in the dialog header. */
+    readonly closable: _angular_core.InputSignal<boolean>;
+    /** When true, pressing Escape closes the dialog. */
+    readonly closeOnEscape: _angular_core.InputSignal<boolean>;
+    /** When true, clicking the backdrop overlay closes the dialog. */
+    readonly closeOnBackdrop: _angular_core.InputSignal<boolean>;
+    /** Size variant that controls the dialog's max-width. */
+    readonly size: _angular_core.InputSignal<DialogSize>;
+    /** Where the dialog is anchored on screen. */
+    readonly position: _angular_core.InputSignal<DialogPosition>;
+    /** Optional title text rendered in the dialog header and used for `aria-labelledby`. */
+    readonly header: _angular_core.InputSignal<string | null>;
+    /** When true, focus returns to the previously focused element when the dialog closes. */
+    readonly restoreFocus: _angular_core.InputSignal<boolean>;
+    /** When true, CDK auto-focus is applied when the dialog opens. */
+    readonly autoFocus: _angular_core.InputSignal<boolean>;
+    /** Entry/exit animation applied to the dialog panel. */
+    readonly animation: _angular_core.InputSignal<DialogAnimation>;
+    /** When true, all close mechanisms (Escape, backdrop, button) are blocked. */
+    readonly preventClose: _angular_core.InputSignal<boolean>;
+    /** Async guard function called before closing; return false to cancel the close. */
+    readonly canClose: _angular_core.InputSignal<CanCloseFn | null>;
+    /** When true, the dialog expands to full-screen on mobile viewports. */
+    readonly fullscreenMobile: _angular_core.InputSignal<boolean>;
+    /** When true, the dialog body uses a flex column layout. */
+    readonly flexBody: _angular_core.InputSignal<boolean>;
+    readonly customHeader: _angular_core.Signal<FkDialogHeaderDirective | undefined>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly ariaDescribedBy: _angular_core.InputSignal<string | null>;
+    /** Fires when the dialog's open state should change, emitting the new boolean. */
+    readonly openChange: _angular_core.OutputEmitterRef<boolean>;
+    /** Fires immediately before the dialog begins its open animation. */
+    readonly beforeOpen: _angular_core.OutputEmitterRef<void>;
+    /** Fires after the dialog is fully open and visible. */
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    /** Fires immediately before the dialog begins its close animation. */
+    readonly beforeClose: _angular_core.OutputEmitterRef<void>;
+    /** Fires after the dialog is fully closed. */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private readonly doc;
+    private readonly destroyRef;
+    readonly titleId: string;
+    private previouslyFocusedElement;
+    private bodyScrollLocked;
+    private closeGuardRunning;
+    /** Whether the dialog DOM is rendered (stays true during exit animation). */
+    readonly visible: _angular_core.WritableSignal<boolean>;
+    /** Whether the dialog is animating out. */
+    readonly animatingOut: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    readonly ariaLabelledBy: _angular_core.Signal<string | null>;
+    constructor();
+    get hostClass(): string;
+    get hostId(): string | null;
+    onEscapeKey(): void;
+    /** Closes the dialog, running any `canClose` guard first; no-ops when `preventClose` is true. */
+    close(): Promise<void>;
+    onOverlayClick(): void;
+    /** Called when the overlay exit animation finishes. */
+    onExitAnimationDone(): void;
+    private onDialogOpen;
+    private onDialogClose;
+    private lockBodyScroll;
+    private unlockBodyScroll;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DialogComponent, "fk-dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "restoreFocus": { "alias": "restoreFocus"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; "animation": { "alias": "animation"; "required": false; "isSignal": true; }; "preventClose": { "alias": "preventClose"; "required": false; "isSignal": true; }; "canClose": { "alias": "canClose"; "required": false; "isSignal": true; }; "fullscreenMobile": { "alias": "fullscreenMobile"; "required": false; "isSignal": true; }; "flexBody": { "alias": "flexBody"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; "beforeOpen": "beforeOpen"; "opened": "opened"; "beforeClose": "beforeClose"; "closed": "closed"; }, ["customHeader"], ["[fkDialogHeader]", "*", "[libDialogFooter]"], true, never>;
+}
+
+interface DialogConfig<TData = unknown> {
+    modal?: boolean;
+    closable?: boolean;
+    closeOnEscape?: boolean;
+    closeOnBackdrop?: boolean;
+    size?: DialogSize;
+    position?: DialogPosition;
+    animation?: DialogAnimation;
+    header?: string | null;
+    restoreFocus?: boolean;
+    autoFocus?: boolean;
+    preventClose?: boolean;
+    canClose?: CanCloseFn;
+    fullscreenMobile?: boolean;
+    flexBody?: boolean;
+    className?: string;
+    ariaLabel?: string | null;
+    ariaDescribedBy?: string | null;
+    data?: TData;
+}
+declare const DEFAULT_DIALOG_CONFIG: DialogConfig;
+
+declare class DialogRef<TResult = unknown, TData = unknown> {
+    private readonly beforeOpenSubject;
+    private readonly afterOpenedSubject;
+    private readonly beforeCloseSubject;
+    private readonly afterClosedSubject;
+    private closed;
+    private closeGuard;
+    readonly config: DialogConfig<TData>;
+    constructor(config?: DialogConfig<TData>);
+    get data(): TData | undefined;
+    setCanClose(guard: CanCloseFn | null): void;
+    close(result?: TResult): Promise<void>;
+    beforeOpen(): Observable<void>;
+    afterOpened(): Observable<void>;
+    beforeClose(): Observable<void>;
+    afterClosed(): Observable<TResult | undefined>;
+    /** @internal */
+    markBeforeOpen(): void;
+    /** @internal */
+    markOpened(): void;
+}
+
+declare const DIALOG_DATA: unique symbol;
+declare const DIALOG_REF: unique symbol;
+interface DialogEntry {
+    ref: DialogRef;
+    hostRef: ComponentRef<DialogComponent>;
+    contentRef: ComponentRef<unknown>;
+}
+declare class DialogService {
+    private readonly appRef;
+    private readonly injector;
+    private readonly doc;
+    private readonly orchestrator;
+    private activeDialogs;
+    private overlayIds;
+    get openCount(): number;
+    open<TResult = unknown, TData = unknown>(content: Type<unknown>, config?: DialogConfig<TData>): DialogRef<TResult, TData>;
+    closeAll(): void;
+    /** Returns true if the given entry is the topmost (last) active dialog. */
+    isTopmost(entry: DialogEntry): boolean;
+    private applyZIndex;
+    private applyConfig;
+    private destroyDialog;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DialogService>;
+}
+
+declare class FkDialogActionsDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FkDialogActionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FkDialogActionsDirective, "[fkDialogActions]", never, {}, {}, never, never, true, never>;
+}
+
+export { DEFAULT_DIALOG_CONFIG, DIALOG_DATA, DIALOG_REF, DialogComponent, DialogRef, DialogService, FkDialogActionsDirective, FkDialogHeaderDirective };
+export type { CanCloseFn, DialogAnimation, DialogConfig, DialogPosition, DialogSize };