@shival99/z-ui 1.0.1 → 1.0.3

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

@@ -0,0 +1,48 @@
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { ClassValue } from 'clsx';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+type ZSwitchSize = 'sm' | 'default' | 'lg';
+
+declare class ZSwitchComponent implements ControlValueAccessor {
+    readonly class: _angular_core.InputSignal<ClassValue>;
+    readonly zSize: _angular_core.InputSignal<ZSwitchSize>;
+    readonly zLabel: _angular_core.InputSignal<string>;
+    readonly zText: _angular_core.InputSignal<string>;
+    readonly zDisabled: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zTextPosition: _angular_core.InputSignal<"left" | "right">;
+    readonly zChecked: _angular_core.ModelSignal<boolean>;
+    readonly zChange: _angular_core.OutputEmitterRef<boolean>;
+    private readonly _disabled;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    protected readonly switchClasses: _angular_core.Signal<string>;
+    protected readonly thumbClasses: _angular_core.Signal<string>;
+    protected readonly labelClasses: _angular_core.Signal<string>;
+    protected readonly switchState: _angular_core.Signal<"checked" | "unchecked">;
+    private _onChange;
+    private _onTouched;
+    writeValue(value: boolean | null): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected onSwitchClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZSwitchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZSwitchComponent, "z-switch", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "zSize": { "alias": "zSize"; "required": false; "isSignal": true; }; "zLabel": { "alias": "zLabel"; "required": false; "isSignal": true; }; "zText": { "alias": "zText"; "required": false; "isSignal": true; }; "zDisabled": { "alias": "zDisabled"; "required": false; "isSignal": true; }; "zTextPosition": { "alias": "zTextPosition"; "required": false; "isSignal": true; }; "zChecked": { "alias": "zChecked"; "required": false; "isSignal": true; }; }, { "zChecked": "zCheckedChange"; "zChange": "zChange"; }, never, never, true, never>;
+}
+
+declare const zSwitchVariants: (props?: ({
+    zSize?: "sm" | "default" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const zSwitchThumbVariants: (props?: ({
+    zSize?: "sm" | "default" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const zSwitchLabelVariants: (props?: ({
+    zSize?: "sm" | "default" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ZSwitchVariants = VariantProps<typeof zSwitchVariants>;
+
+export { ZSwitchComponent, zSwitchLabelVariants, zSwitchThumbVariants, zSwitchVariants };
+export type { ZSwitchSize, ZSwitchVariants };

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

@@ -0,0 +1,482 @@
+import * as _tanstack_angular_virtual from '@tanstack/angular-virtual';
+import * as _tanstack_angular_table from '@tanstack/angular-table';
+import { RowData, HeaderContext, CellContext, Row, ColumnPinningState, RowPinningState, SortingState, ColumnFiltersState, ExpandedState, RowSelectionState, VisibilityState, PaginationState, ColumnOrderState, createAngularTable, Column, Table, ColumnDef } from '@tanstack/angular-table';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, Type, AfterViewInit, ElementRef, OnDestroy } from '@angular/core';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { NgScrollbar } from 'ngx-scrollbar';
+import { ZSelectOption } from '@shival99/z-ui/components/z-select';
+import * as _shival99_z_ui_components_z_tooltip from '@shival99/z-ui/components/z-tooltip';
+import { ZTooltipConfig } from '@shival99/z-ui/components/z-tooltip';
+import * as _shival99_z_ui_components_z_table from '@shival99/z-ui/components/z-table';
+
+interface ZVirtualGroup {
+    startIndex: number;
+    endIndex: number;
+    rowCount: number;
+    height: number;
+}
+interface ZTableIconPart {
+    type: 'text' | 'icon';
+    value: string;
+    size?: number;
+    class?: string;
+    strokeWidth?: number;
+}
+type ZTableAlign = 'left' | 'center' | 'right';
+type ZTableCellContent<T> = string | number | TemplateRef<{
+    $implicit: CellContext<T, unknown>;
+}> | Type<unknown> | ((info: CellContext<T, unknown>) => string | number | TemplateRef<unknown>);
+type ZTableHeaderContent<T> = string | TemplateRef<unknown> | Type<unknown> | (() => string) | ((info: HeaderContext<T, unknown>) => string);
+type ZTableColumn<T = unknown> = ZTableColumnConfig<T>;
+type ZTableFilterType = 'text' | 'number' | 'select' | 'multi-select' | 'date' | 'range' | 'tags';
+type ZTableMode = 'local' | 'server';
+interface ZTableSortConfig<T> {
+    enabled?: boolean;
+    mode?: ZTableMode;
+    sortKey?: string;
+    sortFn?: (rowA: Row<T>, rowB: Row<T>, columnId: string) => number;
+}
+type ZTableBuiltInFilterFn = 'equalsString' | 'includesString' | 'includesStringSensitive' | 'arrIncludes' | 'arrIncludesAll' | 'arrIncludesSome' | 'equals' | 'weakEquals' | 'inNumberRange';
+type ZTableCustomFilterFn<T> = (row: Row<T>, columnId: string, filterValue: unknown, addMeta: (meta: unknown) => void) => boolean;
+interface ZTableFilterConfig<T = unknown> {
+    enabled?: boolean;
+    mode?: ZTableMode;
+    type?: ZTableFilterType;
+    options?: ZSelectOption[];
+    allowClear?: boolean;
+    placeholder?: string;
+    filterFn?: ZTableBuiltInFilterFn | ZTableCustomFilterFn<T>;
+}
+interface ZTableSavedConfig {
+    columnOrder: string[];
+    columnSizing: Record<string, number>;
+    columnPinning: {
+        left?: string[];
+        right?: string[];
+    };
+    columnVisibility: Record<string, boolean>;
+    showHeaderFooterShadow: boolean;
+    showHorizontalBorder: boolean;
+    showVerticalBorder: boolean;
+}
+interface ZTableControl<T> {
+    updateConfig: (config: Partial<ZTableConfig<T>>) => void;
+    toggleSettings: () => void;
+    resetFilters: () => void;
+    resetSorting: () => void;
+    addItem: (item: T) => void;
+    updateItem: (id: string | number, updates: Partial<T>, fieldKey?: keyof T) => void;
+    deleteItem: (id: string | number, fieldKey?: keyof T) => void;
+    getItems: () => T[];
+}
+/** Header cell configuration */
+interface ZTableHeaderColumnConfig<T> {
+    content?: ZTableHeaderContent<T>;
+    class?: string;
+    style?: Record<string, string>;
+    align?: ZTableAlign;
+    rowSpan?: number;
+    colSpan?: number;
+    tooltip?: string | ZTooltipConfig;
+}
+/** Body/data cell configuration */
+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;
+    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);
+}
+/** Footer cell configuration */
+interface ZTableFooterColumnConfig<T> {
+    content?: ZTableHeaderContent<T>;
+    class?: string;
+    style?: Record<string, string>;
+    align?: ZTableAlign;
+    rowSpan?: number;
+    colSpan?: number;
+    tooltip?: string | ZTooltipConfig;
+}
+interface ZTableColumnConfig<T> {
+    id: string;
+    visible?: boolean | (() => boolean);
+    accessorKey?: keyof T & string;
+    accessorFn?: (row: T) => unknown;
+    header?: ZTableHeaderColumnConfig<T> | ZTableHeaderContent<T>;
+    body?: ZTableBodyColumnConfig<T> | ZTableCellContent<T>;
+    footer?: ZTableFooterColumnConfig<T> | ZTableHeaderContent<T>;
+    size?: number;
+    minSize?: number;
+    maxSize?: number;
+    sort?: ZTableSortConfig<T> | boolean;
+    filter?: ZTableFilterConfig<T> | boolean;
+    enableResizing?: boolean;
+    enablePinning?: boolean;
+    enableHiding?: boolean;
+    pinned?: 'left' | 'right' | false;
+    columns?: ZTableColumnConfig<T>[];
+}
+interface ZTablePaginationConfig {
+    enabled?: boolean;
+    pageSize?: number;
+    pageIndex?: number;
+    pageSizeOptions?: number[];
+    showSizeChanger?: boolean;
+    showQuickJumper?: boolean;
+    showTotal?: boolean;
+    totalLabel?: string;
+    disabled?: boolean;
+}
+type ZTableEmitType = 'user' | 'auto';
+interface ZTablePageChangeEvent {
+    pageIndex: number;
+    pageSize: number;
+    emitType: ZTableEmitType;
+}
+interface ZTableRowSelectEvent<T> {
+    row: T;
+    rowId: string;
+    selected: boolean;
+    selectedRows: T[];
+    selectedRowIds: string[];
+}
+interface ZTableRowSelectAllEvent<T> {
+    selected: boolean;
+    selectedRows: T[];
+    selectedRowIds: string[];
+}
+interface ZTableRowExpandEvent<T> {
+    row: T;
+    rowId: string;
+    expanded: boolean;
+}
+interface ZTableCellClickEvent<T> {
+    row: T;
+    rowId: string;
+    columnId: string;
+    value: unknown;
+}
+interface ZTableSortChangeEvent {
+    sorting: SortingState;
+}
+interface ZTableFilterChangeEvent {
+    filters: ColumnFiltersState;
+    search: string;
+}
+interface ZTableSearchChangeEvent {
+    search: string;
+    filters: ColumnFiltersState;
+    sorting: SortingState;
+    pagination: PaginationState;
+}
+type ZTableChangeType = 'page' | 'sort' | 'filter' | 'search' | 'select' | 'expand' | 'rowSelect' | 'rowSelectAll' | 'rowExpand' | 'cellClick';
+interface ZTableChangeEventBase {
+    type: ZTableChangeType;
+}
+interface ZTablePageChange extends ZTableChangeEventBase {
+    type: 'page';
+    data: ZTablePageChangeEvent;
+}
+interface ZTableSortChange extends ZTableChangeEventBase {
+    type: 'sort';
+    data: ZTableSortChangeEvent;
+}
+interface ZTableFilterChange extends ZTableChangeEventBase {
+    type: 'filter';
+    data: ZTableFilterChangeEvent;
+}
+interface ZTableRowSelectChange<T> extends ZTableChangeEventBase {
+    type: 'rowSelect';
+    data: ZTableRowSelectEvent<T>;
+}
+interface ZTableRowSelectAllChange<T> extends ZTableChangeEventBase {
+    type: 'rowSelectAll';
+    data: ZTableRowSelectAllEvent<T>;
+}
+interface ZTableRowExpandChange<T> extends ZTableChangeEventBase {
+    type: 'rowExpand';
+    data: ZTableRowExpandEvent<T>;
+}
+interface ZTableCellClickChange<T> extends ZTableChangeEventBase {
+    type: 'cellClick';
+    data: ZTableCellClickEvent<T>;
+}
+interface ZTableSearchChange extends ZTableChangeEventBase {
+    type: 'search';
+    data: ZTableSearchChangeEvent;
+}
+interface ZTableSelectChange extends ZTableChangeEventBase {
+    type: 'select';
+    data: {
+        selection: RowSelectionState;
+    };
+}
+interface ZTableExpandChange extends ZTableChangeEventBase {
+    type: 'expand';
+    data: {
+        expanded: ExpandedState;
+    };
+}
+type ZTableChangeEvent<T> = ZTablePageChange | ZTableSortChange | ZTableFilterChange | ZTableSearchChange | ZTableSelectChange | ZTableExpandChange | ZTableRowSelectChange<T> | ZTableRowSelectAllChange<T> | ZTableRowExpandChange<T> | ZTableCellClickChange<T>;
+interface ZTableInitialState {
+    columnPinning?: ColumnPinningState;
+    rowPinning?: RowPinningState;
+    sorting?: SortingState;
+    columnFilters?: ColumnFiltersState;
+    globalFilter?: string;
+    expanded?: ExpandedState;
+    rowSelection?: RowSelectionState;
+    columnVisibility?: VisibilityState;
+    pagination?: PaginationState;
+}
+interface ZTableVirtualConfig {
+    enabled: boolean;
+    rowHeight?: number;
+    overscan?: number;
+    groupSize?: number;
+}
+interface ZTableConfig<T> {
+    mode?: ZTableMode;
+    data: T[];
+    totalCount?: number;
+    columns: ZTableColumnConfig<T>[];
+    getRowId?: (row: T, index: number, parent: T | undefined, data: T[]) => string;
+    getSubRows?: (row: T, index: number, parent: T | undefined, data: T[]) => T[] | undefined;
+    totalRows?: number;
+    virtual?: ZTableVirtualConfig | boolean;
+    showHorizontalBorder?: boolean;
+    showVerticalBorder?: boolean;
+    showHeaderShadow?: boolean;
+    showFooterShadow?: boolean;
+    enableSettings?: boolean;
+    enableColumnResizing?: boolean;
+    enableRowPinning?: boolean;
+    enableMultiSort?: boolean;
+    enableSearch?: boolean;
+    enablePagination?: boolean;
+    enableColumnPinning?: boolean;
+    pagination?: ZTablePaginationConfig;
+    initialState?: ZTableInitialState;
+    loading?: boolean;
+    expandedRowTemplate?: TemplateRef<{
+        $implicit: Row<T>;
+    }>;
+    emptyTemplate?: TemplateRef<void>;
+    loadingTemplate?: TemplateRef<void>;
+    getRowCanExpand?: (row: Row<T>) => boolean;
+    maxHeight?: string;
+    minHeight?: string;
+    debounceTime?: number;
+}
+declare module '@tanstack/angular-table' {
+    interface TableMeta<TData extends RowData> {
+        updateData?: (rowIndex: number, columnId: string, value: unknown) => void;
+    }
+}
+
+declare class ZTableComponent<T> implements AfterViewInit {
+    readonly zConfig: _angular_core.InputSignal<ZTableConfig<T>>;
+    readonly zLoading: _angular_core.InputSignal<boolean>;
+    readonly zKey: _angular_core.InputSignal<string>;
+    readonly zChange: _angular_core.OutputEmitterRef<ZTableChangeEvent<T>>;
+    readonly zControl: _angular_core.OutputEmitterRef<ZTableControl<T>>;
+    private readonly _destroyRef;
+    private readonly _ngZone;
+    private readonly _isSyncingScroll;
+    private readonly _savedScrollLeft;
+    private _resizeObserver;
+    private _settingsDebounceTimeout;
+    private _filterEmitDebounceTimeout;
+    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>;
+    protected readonly tbodyWrapper: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    protected readonly tbodyScrollbar: _angular_core.Signal<NgScrollbar | undefined>;
+    protected readonly tfootWrapper: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    protected readonly expandedRowTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    protected readonly columnPinning: _angular_core.WritableSignal<ColumnPinningState>;
+    protected readonly columnVisibility: _angular_core.WritableSignal<VisibilityState>;
+    protected readonly columnOrder: _angular_core.WritableSignal<ColumnOrderState>;
+    protected readonly expanded: _angular_core.WritableSignal<ExpandedState>;
+    protected readonly rowSelection: _angular_core.WritableSignal<RowSelectionState>;
+    protected readonly rowPinning: _angular_core.WritableSignal<RowPinningState>;
+    protected readonly columnFilters: _angular_core.WritableSignal<ColumnFiltersState>;
+    protected readonly globalFilter: _angular_core.WritableSignal<string>;
+    protected readonly pagination: _angular_core.WritableSignal<PaginationState>;
+    protected readonly sorting: _angular_core.WritableSignal<SortingState>;
+    private readonly _tanstackPagination;
+    protected readonly hasVerticalScroll: _angular_core.WritableSignal<boolean>;
+    protected readonly hasHorizontalScroll: _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>;
+    protected readonly hasScrollLeft: _angular_core.WritableSignal<boolean>;
+    protected readonly hasScrollRight: _angular_core.WritableSignal<boolean>;
+    private readonly _columnPinVersion;
+    private readonly _dataForceUpdate;
+    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>;
+    protected readonly hasBodyRowSpan: _angular_core.Signal<boolean>;
+    protected readonly hasSelectColumn: _angular_core.Signal<boolean>;
+    protected readonly hasExpandColumn: _angular_core.Signal<boolean>;
+    protected readonly hasFiltering: _angular_core.Signal<boolean>;
+    protected readonly hasSorting: _angular_core.Signal<boolean>;
+    private readonly _data;
+    private readonly _columns;
+    protected readonly isVirtual: _angular_core.Signal<boolean>;
+    private readonly _virtualConfig;
+    protected readonly virtualRowHeight: _angular_core.Signal<number>;
+    protected readonly groupSize: _angular_core.Signal<number>;
+    protected readonly groupHeight: _angular_core.Signal<number>;
+    protected readonly dynamicGroups: _angular_core.Signal<ZVirtualGroup[]>;
+    protected readonly hasFooter: _angular_core.Signal<boolean>;
+    protected readonly isEmpty: _angular_core.Signal<boolean>;
+    protected readonly isEmptyData: _angular_core.Signal<boolean>;
+    protected readonly isNoSearchResults: _angular_core.Signal<boolean>;
+    protected readonly orderedLeafColumns: _angular_core.Signal<_tanstack_angular_table.Column<T, unknown>[]>;
+    protected readonly orderedHeaderGroups: _angular_core.Signal<{
+        id: string;
+        headers: _tanstack_angular_table.Header<T, unknown>[];
+    }[]>;
+    protected readonly orderedFooterGroups: _angular_core.Signal<{
+        id: string;
+        depth: number;
+        headers: _tanstack_angular_table.Header<T, unknown>[];
+    }[]>;
+    protected readonly bottomRowsReversed: _angular_core.Signal<Row<T>[]>;
+    protected readonly totalWidth: _angular_core.Signal<number>;
+    protected readonly shouldHeaderShowShadow: _angular_core.Signal<boolean>;
+    protected readonly shouldFooterShowShadow: _angular_core.Signal<boolean>;
+    protected readonly dynamicGroupRows: _angular_core.Signal<Row<T>[][]>;
+    protected readonly dynamicGroupHeights: _angular_core.Signal<any[]>;
+    protected readonly columnSizing: _angular_core.Signal<_tanstack_angular_table.ColumnSizingState>;
+    protected readonly columnSizingInfo: _angular_core.Signal<_tanstack_angular_table.ColumnSizingInfoState>;
+    protected readonly columnSizeVars: _angular_core.Signal<Record<string, number>>;
+    protected readonly table: ReturnType<typeof createAngularTable<T>>;
+    private readonly _virtualGroupCount;
+    protected readonly virtualizer: _tanstack_angular_virtual.AngularVirtualizer<HTMLDivElement, Element>;
+    constructor();
+    ngAfterViewInit(): void;
+    private _handleRowSelectionWithParents;
+    private _runAsyncStateUpdate;
+    private _emitFilterChangeDebounced;
+    private _checkVerticalScroll;
+    private _checkHorizontalScroll;
+    private _updateScrollShadowState;
+    hasRightPinnedColumns(): boolean;
+    onTbodyScroll(event: Event): void;
+    private _syncScrollLeft;
+    handleSort(event: Event, handler?: (event: unknown) => void): void;
+    onColumnDrop(event: CdkDragDrop<string[]>): void;
+    onToggleAllColumns(): void;
+    onPageChange(event: {
+        pageIndex: number;
+        pageSize: number;
+    }, emitType?: 'user' | 'auto'): void;
+    onSearchChange(value: string | number | null): void;
+    toggleHeaderFooterShadow(): void;
+    openSettingsDrawer(): void;
+    onPendingColumnDrop(event: CdkDragDrop<string[]>): void;
+    onVisibleColumnsChange(values: (string | number)[]): void;
+    onToggleColumnVisibility(columnId: string): void;
+    onToggleColumnPin(columnId: string, position: 'left' | 'right'): void;
+    handleColumnPin(columnId: string, position: 'left' | 'right' | false): void;
+    private _saveConfig;
+    private _loadConfig;
+    private _findColumnConfig;
+    private _filterVisibleColumns;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZTableComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZTableComponent<any>, "z-table", ["zTable"], { "zConfig": { "alias": "zConfig"; "required": false; "isSignal": true; }; "zLoading": { "alias": "zLoading"; "required": false; "isSignal": true; }; "zKey": { "alias": "zKey"; "required": false; "isSignal": true; }; }, { "zChange": "zChange"; "zControl": "zControl"; }, never, never, true, never>;
+}
+
+declare class ZTableFilterComponent<T> implements OnDestroy {
+    readonly zColumn: _angular_core.InputSignal<Column<unknown, unknown>>;
+    readonly zTable: _angular_core.InputSignal<Table<T>>;
+    private _debounceTimeout;
+    private readonly _debounceMs;
+    private readonly _columnDef;
+    readonly filterType: _angular_core.Signal<_shival99_z_ui_components_z_table.ZTableFilterType | undefined>;
+    readonly columnFilterValue: _angular_core.Signal<unknown>;
+    readonly minValue: _angular_core.Signal<number | "">;
+    readonly maxValue: _angular_core.Signal<number | "">;
+    readonly rangeMinValue: _angular_core.Signal<any>;
+    readonly rangeMaxValue: _angular_core.Signal<any>;
+    readonly selectOptions: _angular_core.Signal<(ZSelectOption<unknown> | {
+        label: string;
+        value: string;
+    })[]>;
+    ngOnDestroy(): void;
+    onMinChangeDebounced(value: string | number | null): void;
+    onMaxChangeDebounced(value: string | number | null): void;
+    onTextChangeDebounced(value: string | number | null): void;
+    onSelectChange(value: unknown): void;
+    private _debounce;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZTableFilterComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZTableFilterComponent<any>, "z-table-filter", never, { "zColumn": { "alias": "zColumn"; "required": true; "isSignal": true; }; "zTable": { "alias": "zTable"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ZTableIconTextComponent {
+    readonly zText: _angular_core.InputSignal<string>;
+    readonly zTooltip: _angular_core.InputSignal<string | ZTooltipConfig>;
+    protected readonly hostEl: any;
+    protected readonly parts: _angular_core.Signal<ZTableIconPart[]>;
+    protected readonly tooltipContent: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZTableIconTextComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZTableIconTextComponent, "z-table-icon-text", never, { "zText": { "alias": "zText"; "required": false; "isSignal": true; }; "zTooltip": { "alias": "zTooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const isHeaderConfig: <T>(config: ZTableHeaderColumnConfig<T> | ZTableHeaderContent<T> | undefined) => config is ZTableHeaderColumnConfig<T>;
+declare const isBodyConfig: <T>(config: ZTableBodyColumnConfig<T> | ZTableCellContent<T> | undefined) => config is ZTableBodyColumnConfig<T>;
+declare const isFooterConfig: <T>(config: ZTableFooterColumnConfig<T> | ZTableHeaderContent<T> | undefined) => config is ZTableFooterColumnConfig<T>;
+declare const getHeaderConfig: <T>(col: ZTableColumnConfig<T> | undefined) => {
+    content: ZTableHeaderContent<T> | undefined;
+    class: string | undefined;
+    style: Record<string, string> | undefined;
+    align: string | undefined;
+    tooltip: string | object | undefined;
+    rowSpan: number | undefined;
+    colSpan: number | undefined;
+};
+declare const getBodyConfig: <T>(col: ZTableColumnConfig<T> | undefined, ctx?: CellContext<T, unknown>) => {
+    content: ZTableCellContent<T> | undefined;
+    class: string | undefined;
+    style: Record<string, string> | undefined;
+    align: string | undefined;
+    rowSpan: number | undefined;
+    colSpan: number | undefined;
+    contentClass: string | undefined;
+    contentStyle: Record<string, string> | undefined;
+    tooltip: string | object | undefined;
+} | {
+    content: ZTableCellContent<T> | undefined;
+    class: string | ((info: CellContext<T, unknown>) => string) | undefined;
+    style: Record<string, string> | undefined;
+    align: ZTableAlign | undefined;
+    rowSpan: number | undefined;
+    colSpan: number | undefined;
+    contentClass: string | ((info: CellContext<T, unknown>) => string) | undefined;
+    contentStyle: Record<string, string> | undefined;
+    tooltip: string | _shival99_z_ui_components_z_tooltip.ZTooltipConfig | ((info: CellContext<T, unknown>) => string | _shival99_z_ui_components_z_tooltip.ZTooltipConfig) | undefined;
+};
+declare const getFooterConfig: <T>(col: ZTableColumnConfig<T> | undefined) => {
+    content: ZTableHeaderContent<T> | undefined;
+    class: string | undefined;
+    style: Record<string, string> | undefined;
+    align: string | undefined;
+    tooltip: string | object | undefined;
+    rowSpan: number | undefined;
+    colSpan: number | undefined;
+};
+declare const findColumnConfig: <T>(columnId: string, columns: ZTableColumnConfig<T>[]) => ZTableColumnConfig<T> | undefined;
+declare function columnConfigToColumnDef<T>(config: ZTableColumnConfig<T>): ColumnDef<T>;
+
+export { ZTableComponent, ZTableFilterComponent, ZTableIconTextComponent, columnConfigToColumnDef, findColumnConfig, getBodyConfig, getFooterConfig, getHeaderConfig, isBodyConfig, isFooterConfig, isHeaderConfig };
+export type { ZTableChangeEvent, ZTableColumn, ZTableColumnConfig, ZTableConfig, ZTableControl, ZTableFilterChangeEvent, ZTableFilterConfig, ZTableFilterType, ZTablePageChangeEvent, ZTablePaginationConfig, ZTableRowExpandEvent, ZTableRowSelectEvent, ZTableSavedConfig, ZTableSearchChangeEvent, ZTableSortChangeEvent, ZTableSortConfig };

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

@@ -0,0 +1,75 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, AfterViewInit, OnDestroy, ElementRef } 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';
+
+declare class ZTabPanelDirective {
+    readonly zTabPanel: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZTabPanelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ZTabPanelDirective, "[z-tab-panel], [zTabPanel]", ["zTabPanel"], { "zTabPanel": { "alias": "zTabPanel"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface ZTab {
+    label: string;
+    value: string;
+    icon?: ZIcon;
+    disabled?: boolean;
+    badge?: string | number;
+    template?: TemplateRef<unknown>;
+}
+type ZTabsVariant = 'line' | 'enclosed' | 'soft' | 'pill' | 'solid' | 'underline';
+type ZTabsSize = 'sm' | 'default' | 'lg';
+type ZTabsOrientation = 'horizontal' | 'vertical';
+
+declare class ZTabsComponent implements AfterViewInit, OnDestroy {
+    readonly tabPanels: _angular_core.Signal<readonly ZTabPanelDirective[]>;
+    readonly tabsListContainer: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    readonly tabButtons: _angular_core.Signal<readonly ElementRef<HTMLButtonElement>[]>;
+    readonly class: _angular_core.InputSignal<ClassValue>;
+    readonly zTabs: _angular_core.InputSignal<ZTab[]>;
+    readonly zVariant: _angular_core.InputSignal<ZTabsVariant>;
+    readonly zSize: _angular_core.InputSignal<ZTabsSize>;
+    readonly zOrientation: _angular_core.InputSignal<ZTabsOrientation>;
+    readonly zLazy: _angular_core.InputSignal<boolean>;
+    readonly activeTab: _angular_core.ModelSignal<string>;
+    readonly zTabChange: _angular_core.OutputEmitterRef<string>;
+    protected readonly loadedTabs: _angular_core.WritableSignal<Set<string>>;
+    protected readonly canScrollLeft: _angular_core.WritableSignal<boolean>;
+    protected readonly canScrollRight: _angular_core.WritableSignal<boolean>;
+    private _resizeObserver?;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected readonly tabsClasses: _angular_core.Signal<string>;
+    protected getTabItemClasses(_tab: ZTab): string;
+    protected selectTab(tab: ZTab, scrollToView?: boolean): void;
+    protected isTabActive(tab: ZTab): boolean;
+    protected shouldRenderPanel(tabValue: string): boolean;
+    protected onTabKeydown(event: KeyboardEvent, currentIndex: number): void;
+    protected checkScroll(): void;
+    protected scrollLeft(): void;
+    protected scrollRight(): void;
+    protected onTabsScroll(): void;
+    private _setupResizeObserver;
+    protected scrollToActiveDropdownItem(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZTabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZTabsComponent, "z-tabs", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "zTabs": { "alias": "zTabs"; "required": true; "isSignal": true; }; "zVariant": { "alias": "zVariant"; "required": false; "isSignal": true; }; "zSize": { "alias": "zSize"; "required": false; "isSignal": true; }; "zOrientation": { "alias": "zOrientation"; "required": false; "isSignal": true; }; "zLazy": { "alias": "zLazy"; "required": false; "isSignal": true; }; "activeTab": { "alias": "activeTab"; "required": false; "isSignal": true; }; }, { "activeTab": "activeTabChange"; "zTabChange": "zTabChange"; }, ["tabPanels"], never, true, never>;
+}
+
+declare const zTabsVariants: (props?: ({
+    zVariant?: "line" | "enclosed" | "soft" | "pill" | "solid" | "underline" | null | undefined;
+    zOrientation?: "horizontal" | "vertical" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const zTabItemVariants: (props?: ({
+    zVariant?: "line" | "enclosed" | "soft" | "pill" | "solid" | "underline" | null | undefined;
+    zSize?: "sm" | "default" | "lg" | null | undefined;
+    zOrientation?: "horizontal" | "vertical" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ZTabsVariants = VariantProps<typeof zTabsVariants>;
+type ZTabItemVariants = VariantProps<typeof zTabItemVariants>;
+
+export { ZTabPanelDirective, ZTabsComponent, zTabItemVariants, zTabsVariants };
+export type { ZTab, ZTabItemVariants, ZTabsOrientation, ZTabsSize, ZTabsVariant, ZTabsVariants };