@shival99/z-ui 1.9.11 → 1.9.13

package/types/shival99-z-ui-components-z-table.d.ts

@@ -19,12 +19,33 @@ import * as _shival99_z_ui_components_z_table from '@shival99/z-ui/components/z-
 import { ZDateRange } from '@shival99/z-ui/components/z-calendar';
 import { ZDropdownMenuItem } from '@shival99/z-ui/components/z-dropdown-menu';
 
+/**
+ * Z-Table Type Definitions
+ *
+ * Central type file for the z-table component. Contains:
+ * - Default constants (row heights, sizing, debounce timers)
+ * - Column configuration types (header, body, footer)
+ * - Sort/filter/edit configuration interfaces
+ * - Event contracts for parent-component communication
+ * - Unified change event discriminated union
+ * - Virtual scrolling configuration
+ * - Settings persistence types
+ * - TanStack Table module augmentation for custom table meta
+ */
+
+/**
+ * A virtual group represents one or more consecutive rows that must be
+ * rendered together (e.g. rows sharing a rowSpan). The virtualizer operates
+ * on groups rather than individual rows to keep merged cells intact.
+ */
 interface ZVirtualGroup {
     startIndex: number;
     endIndex: number;
     rowCount: number;
+    /** null when dynamicSize is enabled — height is measured after render */
     height: number | null;
 }
+/** Parsed segment from the `[icon:name|size:16|class:text-red]` inline icon syntax */
 interface ZTableIconPart {
     type: 'text' | 'icon';
     value: string;
@@ -33,18 +54,35 @@ interface ZTableIconPart {
     strokeWidth?: number;
 }
 type ZTableAlign = 'left' | 'center' | 'right';
+/**
+ * Body cell content — supports static values, Angular templates/components,
+ * or a function that receives the cell context and returns dynamic content.
+ */
 type ZTableCellContent<T> = string | number | TemplateRef<{
     $implicit: CellContext<T, unknown>;
 }> | Type<unknown> | FlexRenderComponent<unknown> | ((info: CellContext<T, unknown>) => string | number | TemplateRef<unknown> | FlexRenderComponent<unknown>);
+/** Header/footer cell content — similar to body but uses HeaderContext */
 type ZTableHeaderContent<T> = string | TemplateRef<unknown> | Type<unknown> | (() => string) | ((info: HeaderContext<T, unknown>) => string);
+/** Alias for ZTableColumnConfig — kept for backward compatibility */
 type ZTableColumn<T = unknown> = ZTableColumnConfig<T>;
+/** Available column filter input types */
 type ZTableFilterType = 'text' | 'number' | 'select' | 'multi-select' | 'date' | 'date-range' | 'range' | 'tags';
+/** Available inline cell edit input types */
 type ZTableEditType = 'text' | 'number' | 'select' | 'date' | 'checkbox' | 'textarea' | 'toggle' | 'autocomplete';
+/**
+ * Table operation mode:
+ * - 'local': data is fully client-side (sort/filter/paginate handled by TanStack)
+ * - 'server': parent handles data fetching; table emits change events for server calls
+ */
 type ZTableMode = 'local' | 'server';
+/** Per-column sort configuration; mode controls local vs server-side sorting */
 interface ZTableSortConfig<T> {
     enabled?: boolean;
+    /** 'local' = TanStack sorts in-memory; 'server' = emits event for API call */
     mode?: ZTableMode;
+    /** Custom key sent with server-side sort events (defaults to column id) */
     sortKey?: string;
+    /** Custom comparator for local sorting */
     sortFn?: (rowA: Row<T>, rowB: Row<T>, columnId: string) => number;
 }
 type ZTableBuiltInFilterFn = 'equalsString' | 'includesString' | 'includesStringSensitive' | 'arrIncludes' | 'arrIncludesAll' | 'arrIncludesSome' | 'equals' | 'weakEquals' | 'inNumberRange';
@@ -110,10 +148,16 @@ interface ZTableEditConfig<T = unknown> {
     /** Allow typing custom values when no options match. Default: false */
     autocompleteAllowCustomValue?: boolean;
 }
+/** Minimal column info stored alongside saved config for cache invalidation */
 interface ZTableSavedColumnInfo {
     id: string;
     accessorKey?: string;
 }
+/**
+ * Shape of the persisted table configuration (via ZCacheService).
+ * Restored when a table with matching zKey re-mounts.
+ * columnInfo is used to detect schema changes and invalidate stale caches.
+ */
 interface ZTableSavedConfig {
     columnOrder: string[];
     columnSizing: Record<string, number>;
@@ -127,6 +171,11 @@ interface ZTableSavedConfig {
     showHorizontalBorder: boolean;
     showVerticalBorder: boolean;
 }
+/**
+ * Imperative control handle emitted via `zControl` output.
+ * Allows parent components to programmatically manipulate table state
+ * (add/update/delete items, reset filters, toggle settings, etc.).
+ */
 interface ZTableControl<T> {
     updateConfig: (config: Partial<ZTableConfig<T>>) => void;
     toggleSettings: () => void;
@@ -138,6 +187,7 @@ interface ZTableControl<T> {
     getItems: () => T[];
     setColumnVisibility: (columnIds: string | string[], visible: boolean) => void;
 }
+/** Header cell configuration — applied to the <th> in the table header row */
 interface ZTableHeaderColumnConfig<T> {
     content?: ZTableHeaderContent<T>;
     class?: string;
@@ -145,22 +195,31 @@ interface ZTableHeaderColumnConfig<T> {
     align?: ZTableAlign;
     rowSpan?: number;
     colSpan?: number;
+    /** Class applied to the inner content wrapper, not the <th> itself */
     contentClass?: string | ((info: HeaderContext<T, unknown>) => string);
     contentStyle?: Record<string, string> | ((info: HeaderContext<T, unknown>) => Record<string, string>);
     tooltip?: string | ZTooltipConfig;
 }
+/**
+ * Body cell configuration — most properties accept a static value or
+ * a function receiving CellContext for per-row dynamic behavior.
+ */
 interface ZTableBodyColumnConfig<T> {
     content?: ZTableCellContent<T>;
     class?: string | ((info: CellContext<T, unknown>) => string);
     style?: Record<string, string> | ((info: CellContext<T, unknown>) => Record<string, string>);
     align?: ZTableAlign;
+    /** Static rowSpan or function returning 0 to hide the cell (merged into neighbor) */
     rowSpan?: number | ((info: CellContext<T, unknown>) => number);
     colSpan?: number | ((info: CellContext<T, unknown>) => number);
     contentClass?: string | ((info: CellContext<T, unknown>) => string);
     contentStyle?: Record<string, string> | ((info: CellContext<T, unknown>) => Record<string, string>);
     tooltip?: string | ZTooltipConfig | ((info: CellContext<T, unknown>) => string | ZTooltipConfig);
+    /** Action buttons rendered inside this cell */
     actions?: ZTableActionColumnConfig<T>;
+    /** When true, clicking the cell emits a cellClick event */
     enabledClick?: boolean;
+    /** Enable inline editing — true uses defaults, or pass full config */
     edit?: ZTableEditConfig<T> | boolean;
     /** Control cell content visibility. When false, the cell is rendered but content is hidden. */
     visible?: boolean | ((info: CellContext<T, unknown>) => boolean);
@@ -176,10 +235,23 @@ interface ZTableFooterColumnConfig<T> {
     contentStyle?: Record<string, string> | ((info: HeaderContext<T, unknown>) => Record<string, string>);
     tooltip?: string | ZTooltipConfig;
 }
+/**
+ * Primary column definition — the consumer-facing API.
+ * Converted to TanStack ColumnDef internally via `columnConfigToColumnDef()`.
+ *
+ * Shorthand: header/body/footer accept either a full config object or
+ * just the content directly (string/template/function).
+ *
+ * Nested columns: use `columns` for multi-level header groups.
+ */
 interface ZTableColumnConfig<T> {
+    /** Unique column identifier — must be stable across re-renders */
     id: string;
+    /** Pre-filter visibility — unlike columnVisibility, this removes the column entirely */
     visible?: boolean | (() => boolean);
+    /** Object property key for simple accessor — mutually exclusive with accessorFn */
     accessorKey?: keyof T & string;
+    /** Custom accessor function for derived/computed cell values */
     accessorFn?: (row: T) => unknown;
     header?: ZTableHeaderColumnConfig<T> | ZTableHeaderContent<T>;
     body?: ZTableBodyColumnConfig<T> | ZTableCellContent<T>;
@@ -188,13 +260,17 @@ interface ZTableColumnConfig<T> {
     minSize?: number;
     maxSize?: number;
     width?: string;
+    /** true = local sort with defaults; object = full config */
     sort?: ZTableSortConfig<T> | boolean;
+    /** true = local filter with defaults; object = full config */
     filter?: ZTableFilterConfig<T> | boolean;
     enableResizing?: boolean;
     enablePinning?: boolean;
     enableHiding?: boolean;
     enableOrdering?: boolean;
+    /** Initial pin position — applied on first render */
     pinned?: 'left' | 'right' | false;
+    /** Child columns for multi-level header grouping */
     columns?: ZTableColumnConfig<T>[];
 }
 interface ZTablePaginationConfig {
@@ -208,6 +284,7 @@ interface ZTablePaginationConfig {
     totalLabel?: string;
     disabled?: boolean;
 }
+/** Distinguishes user-triggered vs programmatic pagination changes */
 type ZTableEmitType = 'user' | 'auto';
 interface ZTablePageChangeEvent {
     pageIndex: number;
@@ -290,6 +367,7 @@ interface ZTableActionColumnConfig<T = unknown> {
     actions: ZTableActionItem<T>[] | ((row: T) => ZTableActionItem<T>[]);
     maxVisible?: number;
 }
+/** All possible change event types — used as discriminant in ZTableChangeEvent */
 type ZTableChangeType = 'page' | 'sort' | 'filter' | 'search' | 'select' | 'expand' | 'rowSelect' | 'rowSelectAll' | 'rowExpand' | 'cellClick' | 'cellEdit' | 'action';
 interface ZTableChangeEventBase {
     type: ZTableChangeType;
@@ -346,7 +424,21 @@ interface ZTableCellEditChange<T> extends ZTableChangeEventBase {
     type: 'cellEdit';
     data: ZTableCellEditEvent<T>;
 }
+/**
+ * Unified change event emitted via `zChange` output.
+ * Parent components can use `event.type` to narrow the discriminated union.
+ *
+ * Example:
+ * ```ts
+ * onTableChange(event: ZTableChangeEvent<MyRow>) {
+ *   if (event.type === 'page') {
+ *     // event.data is ZTablePageChangeEvent
+ *   }
+ * }
+ * ```
+ */
 type ZTableChangeEvent<T> = ZTablePageChange | ZTableSortChange | ZTableFilterChange | ZTableSearchChange | ZTableSelectChange | ZTableExpandChange | ZTableRowSelectChange<T> | ZTableRowSelectAllChange<T> | ZTableRowExpandChange<T> | ZTableCellClickChange<T> | ZTableCellEditChange<T> | ZTableActionChange<T>;
+/** Initial table state — applied on first render, before any cached config is loaded */
 interface ZTableInitialState {
     columnPinning?: ColumnPinningState;
     rowPinning?: RowPinningState;
@@ -425,22 +517,37 @@ interface ZTableSearchConfig {
     width?: string;
     size?: ZInputSize;
 }
+/**
+ * Top-level configuration passed via `[zConfig]` input.
+ * This is the primary API surface for consumers of z-table.
+ */
 interface ZTableConfig<T> {
+    /** 'local' = client-side operations; 'server' = parent handles data fetching */
     mode?: ZTableMode;
+    /** Row data array — for server mode, this is the current page's data */
     data: T[];
+    /** Total row count for server-side pagination (aliased as totalRows) */
     totalCount?: number;
+    /** Column definitions */
     columns: ZTableColumnConfig<T>[];
+    /** Custom row ID generator — critical for selection/expansion state stability */
     getRowId?: (row: T, index: number, parent: T | undefined, data: T[]) => string;
+    /** Sub-row accessor for tree/hierarchical data */
     getSubRows?: (row: T, index: number, parent: T | undefined, data: T[]) => T[] | undefined;
+    /** @deprecated Use totalCount instead */
     totalRows?: number;
+    /** true = enable with defaults; object = full virtual scroll config */
     virtual?: ZTableVirtualConfig | boolean;
     showHorizontalBorder?: boolean;
     showVerticalBorder?: boolean;
     showHeaderShadow?: boolean;
     showFooterShadow?: boolean;
+    /** Show the settings drawer toggle button */
     enableSettings?: boolean;
     enableColumnResizing?: boolean;
+    /** When true, shift-click sorting is simulated automatically */
     enableMultiSort?: boolean;
+    /** true = enable with defaults; object = full search bar config */
     search?: ZTableSearchConfig | boolean;
     enableRowPinning?: boolean;
     enableColumnPinning?: boolean;
@@ -449,15 +556,20 @@ interface ZTableConfig<T> {
     pagination?: ZTablePaginationConfig;
     initialState?: ZTableInitialState;
     loading?: boolean;
+    /** Template rendered when a row is expanded */
     expandedRowTemplate?: TemplateRef<{
         $implicit: Row<T>;
     }>;
+    /** Template rendered when no data matches */
     emptyTemplate?: TemplateRef<void>;
+    /** Template rendered during loading state */
     loadingTemplate?: TemplateRef<void>;
     getRowCanExpand?: (row: Row<T>) => boolean;
     maxHeight?: string;
     minHeight?: string;
+    /** Debounce time (ms) for async state updates; defaults to Z_DEFAULT_DEBOUNCE_TIME */
     debounceTime?: number;
+    /** Use skeleton rows instead of loading spinner */
     useSkeleton?: boolean;
 }
 interface ZTableEditCellChangeEvent<T = unknown> {
@@ -478,6 +590,10 @@ interface ZResolvedEditConfig {
     disabled: boolean;
     readonly: boolean;
 }
+/**
+ * Extends TanStack's TableMeta to add a custom `updateData` callback.
+ * This is used by inline edit cells to notify the table of value changes.
+ */
 declare module '@tanstack/angular-table' {
     interface TableMeta<TData extends RowData> {
         updateData?: (rowIndex: number, columnId: string, value: unknown) => void;
@@ -485,21 +601,35 @@ declare module '@tanstack/angular-table' {
 }
 
 declare class ZTableComponent<T> implements AfterViewInit {
+    /** Unified change event — parent listens to this for all table interactions */
     readonly zChange: _angular_core.OutputEmitterRef<ZTableChangeEvent<T>>;
+    /** Emits an imperative control handle for programmatic table manipulation */
     readonly zControl: _angular_core.OutputEmitterRef<ZTableControl<T>>;
+    /** Extra CSS classes merged onto the table container */
     readonly zClass: _angular_core.InputSignal<ClassValue>;
+    /** Main configuration — data, columns, mode, features */
     readonly zConfig: _angular_core.InputSignal<ZTableConfig<T>>;
+    /** External loading state (complementary to config.loading) */
     readonly zLoading: _angular_core.InputSignal<boolean>;
+    /** Cache key for persisting column settings; no persistence when empty */
     readonly zKey: _angular_core.InputSignal<string>;
+    /** Visual variant: 'default' has card shadow, 'borderless' has no container border */
     readonly zVariant: _angular_core.InputSignal<"default" | "borderless">;
     private readonly _destroy$;
     private readonly _zTranslate;
+    /** Prevents recursive scroll sync between thead/tbody/tfoot */
     private readonly _isSyncingScroll;
+    /** Preserves horizontal scroll position across loading states */
     private readonly _savedScrollLeft;
+    /** Observes tbody container height changes for skeleton row count calculation */
     private _resizeObserver;
+    /** Debounces rapid settings changes (visibility/pin toggles) */
     private _settingsDebounceTimeout;
+    /** Debounces filter change emissions to server */
     private _filterEmitDebounceTimeout;
+    /** Merged loading state from both zLoading input and config.loading */
     protected readonly isLoading: _angular_core.Signal<boolean>;
+    /** True during debounced async state transitions (sort/filter processing) */
     protected readonly isProcessing: _angular_core.WritableSignal<boolean>;
     protected readonly theadWrapper: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
     protected readonly tbodyContainer: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
@@ -516,35 +646,54 @@ declare class ZTableComponent<T> implements AfterViewInit {
     protected readonly rowPinning: _angular_core.WritableSignal<RowPinningState>;
     protected readonly columnFilters: _angular_core.WritableSignal<ColumnFiltersState>;
     protected readonly globalFilter: _angular_core.WritableSignal<string>;
+    /** Note: pageIndex is 1-based here; converted to 0-based for TanStack via _tanstackPagination */
     protected readonly pagination: _angular_core.WritableSignal<PaginationState>;
     protected readonly sorting: _angular_core.WritableSignal<SortingState>;
+    /**
+     * Caches the last server-provided total to avoid flickering to 0
+     * during loading transitions in server-side pagination mode.
+     */
     private readonly _serverPaginationTotal;
+    /** Container CSS classes combining variant + user-provided classes */
     protected readonly classTable: _angular_core.Signal<string>;
+    /** Convert 1-based pagination to TanStack's 0-based pageIndex */
     private readonly _tanstackPagination;
     private readonly _configPagination;
     protected readonly paginationTotal: _angular_core.Signal<number>;
     protected readonly hasVerticalScroll: _angular_core.WritableSignal<boolean>;
     protected readonly hasHorizontalScroll: _angular_core.WritableSignal<boolean>;
+    /** True when the last row touches or extends past the container bottom (no gap) */
     protected readonly lastRowTouchesBottom: _angular_core.WritableSignal<boolean>;
     protected readonly showSettingsDrawer: _angular_core.WritableSignal<boolean>;
     protected readonly showHorizontalBorder: _angular_core.WritableSignal<boolean>;
     protected readonly showVerticalBorder: _angular_core.WritableSignal<boolean>;
     protected readonly showHeaderFooterShadow: _angular_core.WritableSignal<boolean>;
+    /** True when table body is scrolled away from left edge (shows left pin shadow) */
     protected readonly hasScrollLeft: _angular_core.WritableSignal<boolean>;
+    /** True when table has right-pinned columns and body isn't scrolled to the end */
     protected readonly hasScrollRight: _angular_core.WritableSignal<boolean>;
+    /** Maps row IDs to measured DOM heights for pinned row offset calculations */
     protected readonly pinnedRowHeights: _angular_core.WritableSignal<Record<string, number>>;
+    /** Bumped to force recomputation of pinned column IDs after programmatic pin changes */
     private readonly _columnPinVersion;
+    /** Bumped to trigger data refresh (e.g., after addItem/deleteItem via control API) */
     private readonly _dataForceUpdate;
+    /** Set when a single row is updated via control API (for targeted re-render) */
     protected readonly _rowUpdate: _angular_core.WritableSignal<{
         rowId: string;
         updates: Record<string, unknown>;
     } | null>;
+    /**
+     * Column config lookup cache — cleared when column reference changes.
+     * Avoids repeated recursive searches during render cycles.
+     */
     private _columnConfigCache;
     private _lastColumnsRef;
     protected readonly pinnedColumnIds: _angular_core.Signal<string[]>;
     protected readonly pendingVisibleColumns: _angular_core.WritableSignal<string[]>;
     protected readonly pendingColumnOrder: _angular_core.WritableSignal<string[]>;
     protected readonly pendingShowHeaderFooterShadow: _angular_core.WritableSignal<boolean>;
+    /** True if ANY body column uses rowSpan — affects virtual grouping and expand column behavior */
     protected readonly hasBodyRowSpan: _angular_core.Signal<boolean>;
     protected readonly hasSelectColumn: _angular_core.Signal<boolean>;
     protected readonly hasExpandColumn: _angular_core.Signal<boolean>;
@@ -568,15 +717,27 @@ declare class ZTableComponent<T> implements AfterViewInit {
         size: _shival99_z_ui_components_z_input.ZInputSize;
     } | null>;
     protected readonly isSearchEnabled: _angular_core.Signal<boolean>;
+    /** Data signal with force-update support for control API mutations */
     private readonly _data;
+    /**
+     * Converts ZTableColumnConfig[] into TanStack ColumnDef[].
+     * Handles special columns (select, expand, actionRowPin), action column sizing,
+     * and rowSpan/expand compatibility (expand column is removed when rowSpan is used).
+     */
     private readonly _columns;
     protected readonly isVirtual: _angular_core.Signal<boolean>;
+    /** Normalized virtual config with defaults applied */
     private readonly _virtualConfig;
     protected readonly virtualRowHeight: _angular_core.Signal<number>;
     protected readonly dynamicSize: _angular_core.Signal<boolean>;
     protected readonly groupSize: _angular_core.Signal<number>;
     protected readonly groupHeight: _angular_core.Signal<number>;
     private readonly _dynamicGroupsVersion;
+    /**
+     * Groups rows for virtual scrolling. When rowSpan is used, rows that share
+     * a merged cell are grouped together so the virtualizer treats them as
+     * a single unit, preserving the visual merge across scroll boundaries.
+     */
     protected readonly dynamicGroups: _angular_core.Signal<ZVirtualGroup[]>;
     protected readonly hasFooter: _angular_core.Signal<boolean>;
     protected readonly isEmpty: _angular_core.Signal<boolean>;
@@ -608,11 +769,22 @@ declare class ZTableComponent<T> implements AfterViewInit {
     protected readonly columnSizeVars: _angular_core.Signal<Record<string, number>>;
     protected readonly table: ReturnType<typeof createAngularTable<T>>;
     private readonly _virtualGroupCount;
+    /** Virtualizer instance — operates on groups rather than individual rows */
     protected readonly virtualizer: _shival99_angular_virtual.AngularVirtualizer<HTMLDivElement, Element>;
     private readonly _measureVirtualItems;
     constructor();
     ngAfterViewInit(): void;
+    /**
+     * Syncs parent row selection state based on children.
+     * If all children are selected, the parent is auto-selected;
+     * if no children are selected, the parent is deselected.
+     */
     private _handleRowSelectionWithParents;
+    /**
+     * Wraps state mutations with a debounced processing indicator.
+     * Shows a brief loading state to prevent UI flicker during
+     * filter/sort recomputation on large datasets.
+     */
     private _runAsyncStateUpdate;
     private _emitFilterChangeDebounced;
     private _checkScrollState;
@@ -624,6 +796,7 @@ declare class ZTableComponent<T> implements AfterViewInit {
     hasRightPinnedColumns(): boolean;
     onTbodyScroll(event: Event): void;
     private _syncScrollLeft;
+    /** Handles sort click; auto-adds shiftKey for multi-sort when enabled */
     handleSort(event: Event, handler?: (event: unknown) => void): void;
     onColumnDrop(event: CdkDragDrop<string[]>): void;
     onToggleAllColumns(): void;
@@ -646,9 +819,16 @@ declare class ZTableComponent<T> implements AfterViewInit {
     moveColumnRight(columnId: string): void;
     isFirstMovableColumn(columnId: string): boolean;
     isLastMovableColumn(columnId: string): boolean;
+    /** Saves current column layout, sizing, pinning, and visibility to ZCacheService */
     private _saveConfig;
     private _collectColumnInfo;
+    /** Loads cached config from ZCacheService; validates schema compatibility first */
     private _loadConfigCache;
+    /**
+     * Validates cached column info against current config.
+     * Returns false if columns have been added/removed/renamed since cache was saved,
+     * which triggers cache invalidation.
+     */
     private _isColumnConfigValid;
     private _getChangedFilterColumnIds;
     private _getChangedSortColumnIds;
@@ -656,6 +836,10 @@ declare class ZTableComponent<T> implements AfterViewInit {
     private _isColumnSortModeLocal;
     private _filterServerModeColumnFilters;
     private _filterServerModeSorting;
+    /**
+     * Recursively finds a column config by ID with caching.
+     * Cache is invalidated when the column array reference changes.
+     */
     private _findColumnConfig;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZTableComponent<any>, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZTableComponent<any>, "z-table", ["zTable"], { "zClass": { "alias": "zClass"; "required": false; "isSignal": true; }; "zConfig": { "alias": "zConfig"; "required": false; "isSignal": true; }; "zLoading": { "alias": "zLoading"; "required": false; "isSignal": true; }; "zKey": { "alias": "zKey"; "required": false; "isSignal": true; }; "zVariant": { "alias": "zVariant"; "required": false; "isSignal": true; }; }, { "zChange": "zChange"; "zControl": "zControl"; }, never, never, true, never>;
@@ -711,7 +895,7 @@ declare class ZTableActionsComponent<T = unknown> {
     readonly zConfig: _angular_core.InputSignal<ZTableActionColumnConfig<T>>;
     readonly zRow: _angular_core.InputSignal<T>;
     readonly zRowId: _angular_core.InputSignal<string>;
-    readonly zDropdownButtonSize: _angular_core.InputSignal<"sm" | "default" | "lg" | "xs" | "xl" | null | undefined>;
+    readonly zDropdownButtonSize: _angular_core.InputSignal<"default" | "sm" | "lg" | "xs" | "xl" | null | undefined>;
     readonly zActionClick: _angular_core.OutputEmitterRef<ZTableActionClickEvent<T>>;
     protected readonly allActions: _angular_core.Signal<ZTableActionItem<T>[]>;
     protected readonly shouldShowAsButtons: _angular_core.Signal<boolean>;
@@ -771,9 +955,13 @@ declare class ZTableEditCellComponent<T = unknown> implements OnInit {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZTableEditCellComponent<any>, "z-table-edit-cell", never, { "zRow": { "alias": "zRow"; "required": true; "isSignal": true; }; "zRowId": { "alias": "zRowId"; "required": true; "isSignal": true; }; "zRowIndex": { "alias": "zRowIndex"; "required": true; "isSignal": true; }; "zColumnId": { "alias": "zColumnId"; "required": true; "isSignal": true; }; "zValue": { "alias": "zValue"; "required": false; "isSignal": true; }; "zEditConfig": { "alias": "zEditConfig"; "required": false; "isSignal": true; }; "zRowUpdate": { "alias": "zRowUpdate"; "required": false; "isSignal": true; }; }, { "zChange": "zChange"; }, never, never, true, never>;
 }
 
+/** Type guard: is this a full header config object (not just content shorthand)? */
 declare const isHeaderConfig: <T>(config: ZTableHeaderColumnConfig<T> | ZTableHeaderContent<T> | undefined) => config is ZTableHeaderColumnConfig<T>;
+/** Type guard: is this a full body config object (not just content shorthand)? */
 declare const isBodyConfig: <T>(config: ZTableBodyColumnConfig<T> | ZTableCellContent<T> | undefined) => config is ZTableBodyColumnConfig<T>;
+/** Type guard: is this a full footer config object (not just content shorthand)? */
 declare const isFooterConfig: <T>(config: ZTableFooterColumnConfig<T> | ZTableHeaderContent<T> | undefined) => config is ZTableFooterColumnConfig<T>;
+/** Extract and normalize header config from a column definition */
 declare const getHeaderConfig: <T>(col: ZTableColumnConfig<T> | undefined) => {
     content: ZTableHeaderContent<T> | undefined;
     class: string | undefined;
@@ -795,6 +983,10 @@ declare const getHeaderConfig: <T>(col: ZTableColumnConfig<T> | undefined) => {
     contentClass: string | ((info: _tanstack_angular_table.HeaderContext<T, unknown>) => string) | ((info: _tanstack_angular_table.HeaderContext<T, unknown>) => string) | undefined;
     contentStyle: Record<string, string> | ((info: _tanstack_angular_table.HeaderContext<T, unknown>) => Record<string, string>) | ((info: _tanstack_angular_table.HeaderContext<T, unknown>) => Record<string, string>) | undefined;
 };
+/**
+ * Extract and normalize body config from a column definition.
+ * Resolves dynamic properties (class, style, rowSpan, etc.) when CellContext is provided.
+ */
 declare const getBodyConfig: <T>(col: ZTableColumnConfig<T> | undefined, ctx?: CellContext<T, unknown>) => {
     content: ZTableCellContent<T> | undefined;
     class: string | undefined;
@@ -837,7 +1029,19 @@ declare const getFooterConfig: <T>(col: ZTableColumnConfig<T> | undefined) => {
     contentClass: string | ((info: _tanstack_angular_table.HeaderContext<T, unknown>) => string) | ((info: _tanstack_angular_table.HeaderContext<T, unknown>) => string) | undefined;
     contentStyle: Record<string, string> | ((info: _tanstack_angular_table.HeaderContext<T, unknown>) => Record<string, string>) | ((info: _tanstack_angular_table.HeaderContext<T, unknown>) => Record<string, string>) | undefined;
 };
+/** Recursively search for a column config by ID within a (possibly nested) column array */
 declare const findColumnConfig: <T>(columnId: string, columns: ZTableColumnConfig<T>[]) => ZTableColumnConfig<T> | undefined;
+/**
+ * Converts the consumer-facing ZTableColumnConfig into a TanStack ColumnDef.
+ * This is the bridge between the z-table API and TanStack Table internals.
+ *
+ * Handles:
+ * - Accessor mapping (accessorKey / accessorFn)
+ * - Header/body/footer content resolution
+ * - Sort and filter function wiring (local vs server mode)
+ * - Built-in filter functions for each filter type
+ * - Recursive nested column conversion
+ */
 declare function columnConfigToColumnDef<T>(config: ZTableColumnConfig<T>): ColumnDef<T>;
 
 export { ZTableActionsComponent, ZTableComponent, ZTableEditCellComponent, ZTableFilterComponent, ZTableIconTextComponent, columnConfigToColumnDef, findColumnConfig, getBodyConfig, getFooterConfig, getHeaderConfig, isBodyConfig, isFooterConfig, isHeaderConfig };

package/types/shival99-z-ui-components-z-timeline.d.ts

@@ -1,7 +1,6 @@
 import * as _angular_core from '@angular/core';
-import { PipeTransform } from '@angular/core';
+import { TemplateRef } from '@angular/core';
 import { ClassValue } from 'clsx';
-import { ZIcon } from '@shival99/z-ui/components/z-icon';
 import * as class_variance_authority_types from 'class-variance-authority/types';
 import { VariantProps } from 'class-variance-authority';
 
@@ -10,89 +9,48 @@ interface ZTimelineItem {
     title: string;
     description?: string;
     time?: string;
-    icon?: ZIcon;
-    color?: 'default' | 'primary' | 'success' | 'warning' | 'error' | 'info';
+    subtitle?: string;
+    active?: boolean;
+    contentTemplate?: TemplateRef<unknown>;
 }
 type ZTimelineSize = 'sm' | 'default' | 'lg';
-type ZTimelineLayout = 'default' | 'reversed' | 'alternate';
-type ZTimelineLineStyle = 'solid' | 'dashed';
-type ZTimelineIconStyle = 'filled' | 'outline';
-type ZTimelineContentStyle = 'simple' | 'card';
-type ZTimelineClassType = 'item' | 'header' | 'icon' | 'iconCenter' | 'dot' | 'line' | 'dotCircle' | 'time' | 'side';
-interface ZTimelineClassOptions {
-    item?: ZTimelineItem;
-    layout?: ZTimelineLayout;
-    lineStyle?: ZTimelineLineStyle;
-    iconStyle?: ZTimelineIconStyle;
-    timeVariant?: 'default' | 'secondary' | 'outline' | 'muted';
-    side?: 'left' | 'right';
-}
+type ZTimelineLayout = 'default' | 'alternate';
 
 declare class ZTimelineComponent {
     readonly class: _angular_core.InputSignal<ClassValue>;
     readonly zItems: _angular_core.InputSignal<ZTimelineItem[]>;
     readonly zSize: _angular_core.InputSignal<ZTimelineSize>;
-    readonly zTimeVariant: _angular_core.InputSignal<"default" | "outline" | "secondary" | "muted">;
-    readonly zLineStyle: _angular_core.InputSignal<ZTimelineLineStyle>;
-    readonly zIconStyle: _angular_core.InputSignal<ZTimelineIconStyle>;
     readonly zLayout: _angular_core.InputSignal<ZTimelineLayout>;
-    readonly zContentStyle: _angular_core.InputSignal<ZTimelineContentStyle>;
     protected readonly hostClasses: _angular_core.Signal<string>;
-    protected readonly isAlternate: _angular_core.Signal<boolean>;
-    protected readonly itemClasses: _angular_core.Signal<string>;
     protected readonly dotClasses: _angular_core.Signal<string>;
-    protected readonly lineClasses: _angular_core.Signal<string>;
+    protected readonly innerDotClasses: _angular_core.Signal<string>;
+    protected readonly badgeClasses: _angular_core.Signal<string>;
     protected readonly titleClasses: _angular_core.Signal<string>;
     protected readonly descriptionClasses: _angular_core.Signal<string>;
-    protected readonly contentClasses: _angular_core.Signal<string>;
-    protected readonly iconSize: _angular_core.Signal<"18" | "14">;
+    protected readonly isAlternate: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZTimelineComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZTimelineComponent, "z-timeline", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "zItems": { "alias": "zItems"; "required": false; "isSignal": true; }; "zSize": { "alias": "zSize"; "required": false; "isSignal": true; }; "zTimeVariant": { "alias": "zTimeVariant"; "required": false; "isSignal": true; }; "zLineStyle": { "alias": "zLineStyle"; "required": false; "isSignal": true; }; "zIconStyle": { "alias": "zIconStyle"; "required": false; "isSignal": true; }; "zLayout": { "alias": "zLayout"; "required": false; "isSignal": true; }; "zContentStyle": { "alias": "zContentStyle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-declare class ZTimelineClassPipe implements PipeTransform {
-    transform(type: ZTimelineClassType, options?: ZTimelineClassOptions): string;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZTimelineClassPipe, never>;
-    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ZTimelineClassPipe, "zTimelineClass", true>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZTimelineComponent, "z-timeline", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "zItems": { "alias": "zItems"; "required": false; "isSignal": true; }; "zSize": { "alias": "zSize"; "required": false; "isSignal": true; }; "zLayout": { "alias": "zLayout"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare const zTimelineVariants: (props?: ({
-    zSize?: "default" | "sm" | "lg" | null | undefined;
-    zLayout?: "default" | "reversed" | "alternate" | null | undefined;
+    zSize?: "sm" | "default" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare const zTimelineItemVariants: (props?: ({
-    zLayout?: "default" | "reversed" | "alternate" | null | undefined;
+declare const zTimelineDotVariants: (props?: ({
+    zSize?: "sm" | "default" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare const zTimelineHeaderVariants: (props?: ({
-    hasIcon?: boolean | null | undefined;
-    zColor?: "default" | "primary" | "success" | "warning" | "error" | "info" | null | undefined;
-    zLineStyle?: "solid" | "dashed" | null | undefined;
-    zLayout?: "default" | "reversed" | "alternate" | null | undefined;
+declare const zTimelineInnerDotVariants: (props?: ({
+    zSize?: "sm" | "default" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare const zTimelineIconVariants: (props?: ({
-    zColor?: "default" | "primary" | "success" | "warning" | "error" | "info" | null | undefined;
-    zIconStyle?: "filled" | "outline" | null | undefined;
-    zLayout?: "default" | "reversed" | "alternate" | null | undefined;
+declare const zTimelineTimeBadgeVariants: (props?: ({
+    zSize?: "sm" | "default" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 declare const zTimelineTitleVariants: (props?: ({
-    zSize?: "default" | "sm" | "lg" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-declare const zTimelineTimeVariants: (props?: ({
-    zVariant?: "default" | "outline" | "secondary" | "muted" | null | undefined;
-    zLayout?: "default" | "reversed" | "alternate" | null | undefined;
+    zSize?: "sm" | "default" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 declare const zTimelineDescriptionVariants: (props?: ({
-    zSize?: "default" | "sm" | "lg" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-declare const zTimelineContentVariants: (props?: ({
-    zContentStyle?: "simple" | "card" | null | undefined;
+    zSize?: "sm" | "default" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 type ZTimelineVariants = VariantProps<typeof zTimelineVariants>;
-type ZTimelineItemVariants = VariantProps<typeof zTimelineItemVariants>;
-type ZTimelineHeaderVariants = VariantProps<typeof zTimelineHeaderVariants>;
-type ZTimelineIconVariants = VariantProps<typeof zTimelineIconVariants>;
-type ZTimelineTimeVariants = VariantProps<typeof zTimelineTimeVariants>;
-type ZTimelineContentVariants = VariantProps<typeof zTimelineContentVariants>;
 
-export { ZTimelineClassPipe, ZTimelineComponent, zTimelineContentVariants, zTimelineDescriptionVariants, zTimelineHeaderVariants, zTimelineIconVariants, zTimelineItemVariants, zTimelineTimeVariants, zTimelineTitleVariants, zTimelineVariants };
-export type { ZTimelineClassOptions, ZTimelineClassType, ZTimelineContentStyle, ZTimelineContentVariants, ZTimelineHeaderVariants, ZTimelineIconStyle, ZTimelineIconVariants, ZTimelineItem, ZTimelineItemVariants, ZTimelineLayout, ZTimelineLineStyle, ZTimelineSize, ZTimelineTimeVariants, ZTimelineVariants };
+export { ZTimelineComponent, zTimelineDescriptionVariants, zTimelineDotVariants, zTimelineInnerDotVariants, zTimelineTimeBadgeVariants, zTimelineTitleVariants, zTimelineVariants };
+export type { ZTimelineItem, ZTimelineLayout, ZTimelineSize, ZTimelineVariants };