@competer/primeng-table 0.0.0-stage → 14.2.0

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@competer/primeng-table" />
+export * from './public-api';

package/lib/components/column-selector/column-selector.d.ts

@@ -0,0 +1,55 @@
+import { ChangeDetectorRef, EventEmitter, OnChanges, OnDestroy } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { Table } from 'primeng/table';
+import { CellOverflowBehaviour, DataAlignHorizontal, DataAlignVertical } from '../../enums';
+import { IColumnMetadata } from '../../interfaces';
+import * as i0 from "@angular/core";
+export declare class ColumnSelector implements OnChanges, OnDestroy {
+    private translate;
+    private readonly destroy$;
+    orderByHeader: boolean;
+    constructor(translate: TranslateService, changeDetector: ChangeDetectorRef);
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    private updateVisibleColumns;
+    dt_columnDialog: Table;
+    visible: boolean;
+    columnModalData: any[];
+    filteredColumnData: any[];
+    visibleChange: EventEmitter<boolean>;
+    applyChanges: EventEmitter<IColumnMetadata[]>;
+    cellOverflowBehaviourOptions: {
+        icon: string;
+        val: CellOverflowBehaviour;
+        name: string;
+    }[];
+    dataAlignHorizontalOptions: {
+        icon: string;
+        val: DataAlignHorizontal;
+        name: string;
+    }[];
+    dataAlignVerticalOptions: {
+        icon: string;
+        val: DataAlignVertical;
+        name: string;
+    }[];
+    translatedOptions(options: {
+        name: string;
+        icon: string;
+        val: number;
+    }[]): {
+        name: any;
+        icon: string;
+        val: number;
+    }[];
+    globalSearchText: string | null;
+    globalSearchMaxLength: number;
+    allColumnsCheckboxActive(): boolean;
+    allColumnsCheckboxClick(event: any): void;
+    filterColumnModal(event: any): void;
+    applyColumnModalChanges(): void;
+    clearGlobalFilter(dt: Table): void;
+    closeModal(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnSelector, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnSelector, "ecs-column-selector", never, { "orderByHeader": "orderByHeader"; "visible": "visible"; "columnModalData": "columnModalData"; "filteredColumnData": "filteredColumnData"; }, { "visibleChange": "visibleChange"; "applyChanges": "applyChanges"; }, never, never, true>;
+}

package/lib/components/ecs-primeng-table/ecs-primeng-table.d.ts

@@ -0,0 +1,256 @@
+import { AfterViewInit, ElementRef, EventEmitter, OnInit, OnDestroy } from '@angular/core';
+import { Table } from 'primeng/table';
+import { LazyLoadEvent } from 'primeng/api';
+import { FilterMetadata, MenuItem } from 'primeng/api';
+import { Menu } from 'primeng/menu';
+import { ECSPrimengTableService } from './ecs-primeng-table.service';
+import { DeviceType, CellOverflowBehaviour, DataAlignHorizontal, DataAlignVertical, DataType, FrozenColumnAlign, TableViewSaveMode } from '../../enums';
+import { IColumnMetadata, IPredefinedFilter, ITablePagedResponse, ITableView, ITableOptions } from '../../interfaces';
+import { ECSPrimengTableNotificationService } from '../../services';
+import { TreeRow, TreeTableState } from '../../utils/tree-table-state';
+import * as i0 from "@angular/core";
+declare type TableLazyLoadEvent = Omit<LazyLoadEvent, 'filters'> & {
+    filters?: Record<string, FilterMetadata | FilterMetadata[]>;
+};
+interface TablePageEvent {
+    first: number;
+    rows: number;
+}
+interface TableRowSelectEvent<T> {
+    data: T;
+}
+interface TableRowUnSelectEvent<T> {
+    data: T;
+}
+export declare class ECSPrimengTable implements OnInit, AfterViewInit, OnDestroy {
+    private tableService;
+    private notification;
+    private readonly i18n;
+    private readonly changeDetector;
+    private readonly stateScope;
+    private readonly destroy$;
+    private initialStateApplied;
+    private destroyed;
+    constructor(tableService: ECSPrimengTableService, notification: ECSPrimengTableNotificationService);
+    tableOptions: ITableOptions;
+    treeState?: TreeTableState;
+    private treeQuery?;
+    private treeStateRestored;
+    onRowCheckboxChange: EventEmitter<{
+        rowID: any;
+        selected: boolean;
+    }>;
+    onRowSelect: EventEmitter<{
+        rowID: any;
+        rowData: any;
+    }>;
+    onRowUnselect: EventEmitter<{
+        rowID: any;
+        rowData: any;
+    }>;
+    onDataEndUpdate: EventEmitter<void>;
+    viewsModalShow: boolean;
+    tableViewCurrentSelectedAlias: string | null;
+    tableViewsFirstFetchDone: boolean;
+    excelReportTitle: string;
+    showExportModal: boolean;
+    showColumnSelector: boolean;
+    selectedRowsCheckbox: any[];
+    selectAllLoading: boolean;
+    private selectionQuery?;
+    private selectionQueryKey;
+    private matchingSelectionKeys?;
+    dt: Table;
+    globalSearchText: string | null;
+    private appliedGlobalSearchText;
+    private globalSearchManaged;
+    private globalSearchTimer?;
+    /** The applied query stays separate from text being typed during the debounce. */
+    get effectiveGlobalSearchText(): string | null;
+    private cancelGlobalSearch;
+    private restoreGlobalSearch;
+    private globalSearchOption;
+    onGlobalSearchInput(value: string): void;
+    tableViewsList: ITableView[];
+    tableViews_menuItems: any[];
+    DataType: typeof DataType;
+    CellOverflowBehaviour: typeof CellOverflowBehaviour;
+    DataAlignHorizontal: typeof DataAlignHorizontal;
+    DataAlignVertical: typeof DataAlignVertical;
+    FrozenColumnAlign: typeof FrozenColumnAlign;
+    TableViewSaveMode: typeof TableViewSaveMode;
+    rowSelection: any;
+    currentPage: number;
+    currentRowsPerPage: number;
+    allowedRowsPerPage: number[];
+    totalRecords: number;
+    totalRecordsNotFiltered: number;
+    dateFormat: string;
+    dateTimezone: string;
+    dateCulture: string;
+    exportDateFormat: string;
+    columns: IColumnMetadata[];
+    columnsCantBeHidden: IColumnMetadata[];
+    columnsSelected: IColumnMetadata[];
+    columnModalData: any[];
+    filteredColumnData: any[];
+    private initialColumnWidths;
+    private initialTableWidth;
+    predefinedFiltersSelectedValuesCollection: {
+        [key: string]: any[];
+    };
+    private copyCellDataTimer;
+    tableLazyLoadEventInformation: TableLazyLoadEvent;
+    private initialConfigurationFetched;
+    private maxViews;
+    ngOnInit(): void;
+    tableContainer: ElementRef;
+    headerContainer: ElementRef;
+    paginatorContainer: ElementRef;
+    ngAfterViewInit(): void;
+    deviceType: DeviceType;
+    private columnSelectionCustomized;
+    headerMenuItems: MenuItem[];
+    rowMenuItems: MenuItem[];
+    rowMenuRow: any;
+    responsiveHeaderMenu?: Menu;
+    responsiveRowMenu?: Menu;
+    get compactHeader(): boolean;
+    get compactRows(): boolean;
+    get actionColumnWidth(): number;
+    getColumnHeaderGroups(columns: IColumnMetadata[]): {
+        field: string;
+        label: string;
+        colspan: number;
+        frozenColumnAlign: FrozenColumnAlign;
+    }[];
+    private isInitiallyVisible;
+    private updateResponsiveViewport;
+    private buttonVisible;
+    hasRowMenuActions(row: any): boolean;
+    private buttonMenuItems;
+    closeResponsiveMenus(): void;
+    openRowMenu(event: Event, row: any): void;
+    private translateMenuItems;
+    openHeaderMenu(event: Event): void;
+    private validateStatePersistence;
+    ngOnDestroy(): void;
+    private restoreNavigationState;
+    private restorePredefinedSelections;
+    onResize(): void;
+    private calculateScrollHeight;
+    get scrollHeightValue(): string;
+    /**
+     * Updates the table data and, if needed, retrieves the initial table configuration from an external source.
+     *
+     * Also allows resetting the table to its original state before any user manipulations.
+     *
+     * @param {boolean} [resetTableView=false] Optional.
+     * - `true`: resets the table state before loading data.
+     * - `false`: refreshes data using the current configuration (and retrieves initial configuration if necessary).
+     *
+     * **_Behavior_**
+     * - The table is automatically set to `isActive = true`.
+     * - If the initial configuration has not been fetched, it will fetch it and then update the data.
+     * - If the initial configuration is already fetched, it will just update the data.
+     * - If `resetTableView` is true and the configuration is already initialized, the table will be reset to its original state before updating the data.
+     */
+    updateData(resetTableView?: boolean): void;
+    private canFetchData;
+    private fetchTableConfiguration;
+    private handleTableConfigurationResponse;
+    refreshData(event: any): void;
+    tableViewsEnabled(): boolean;
+    private fetchTableViews;
+    private tableViewListProcess;
+    private startInitialDataLoad;
+    viewLoad(tableViewAlias: string): void;
+    viewCreate(viewAlias: string): void;
+    viewDelete(viewAlias: string): void;
+    viewEditAlias(event: {
+        viewAliasOld: string;
+        viewAliasNew: string;
+    }): void;
+    viewUpdateData(viewAlias: string): void;
+    viewUpdateActiveStartup(viewAlias: string): void;
+    viewsSave(endMessage: number): void;
+    viewsSaveEnd(endMessage: number): void;
+    fetchTableData(event: TableLazyLoadEvent): void;
+    modifyFiltersWithoutGlobalAndSelectedRows(filters: any, overrideOption?: number): any;
+    resetTableView(): void;
+    private selectorRowFilterBuilder;
+    revertDateTimeZoneFilters(inputFilter: any): any;
+    handleTableDataResponse(body: ITablePagedResponse): void;
+    private generateViewData;
+    private treeFetcher;
+    private syncTreeRows;
+    toggleTreeRow(event: Event, row: TreeRow): Promise<void>;
+    loadMoreTreeRows(event: Event, row: TreeRow): Promise<void>;
+    get treeColumn(): string | undefined;
+    treePageChange(event: {
+        first?: number;
+        rows?: number;
+    }): void;
+    clearFilters(dt: Table, force?: boolean, onlyGlobalFilter?: boolean): void;
+    clearSorts(dt: Table, force?: boolean): void;
+    hasToClearSorts(dt: Table, force?: boolean): boolean;
+    hasToClearFilters(dt: Table, globalSearchText: string | null, force?: boolean): boolean;
+    /**
+     * Determines whether there are active filters based on the provided filter rules.
+     *
+     * @param {any} filterRules An object representing filter rules for each column.
+     *   The keys are column names, and the values are arrays of filter rules.
+     *   Each filter rule has the following properties:
+     *     - `field`: The field or property name of the column.
+     *     - `value`: The filter value entered by the user.
+     *     - Other properties depending on the type of filter (e.g., `matchMode` for string filters).
+     * @returns {boolean} `true` if at least one active filter is found, otherwise `false`.
+     */
+    private hasFilters;
+    getColumnStyle(col: any, headerCols?: boolean): Record<string, string>;
+    getPredefinedFilterValues(columnKeyName: string): IPredefinedFilter[];
+    getFrozenColumnAlignAsText(frozenColumnAlign: FrozenColumnAlign): string;
+    getDataTypeAsText(dataType: DataType): string;
+    /**
+     * Updates the filters of a PrimeNG data table based on predefined filter changes.
+     *
+     * @param {string} filterName - The name of the filter to be updated.
+     * @param {IPrimengPredefinedFilter[]} selectedValues - An array of selected predefined filter values.
+     */
+    onPredefinedFilterChange(filterName: string, selectedValues: IPredefinedFilter[]): void;
+    /**
+     * Checks if the provided column metadata matches a specific style of the predefined filters
+     * that need to be applied to an item on a row.
+     *
+     * @param {IprimengColumnsMetadata} colMetadata - The metadata of the column being checked.
+     * @param {any} value - The value to be matched against the predefined filter values.
+     * @returns {any} The matching predefined filter value if found, otherwise null.
+     */
+    getPredfinedFilterMatch(colMetadata: IColumnMetadata, value: any): any;
+    copyToClipboardStart(event: MouseEvent): void;
+    copyToClipboardCancel(): void;
+    getDataAlignHorizontalAsText(dataAlignHorizontal: DataAlignHorizontal): string;
+    getDataAlignVerticalAsText(dataAlignVertical: DataAlignVertical): string;
+    isRowCheckboxSelected(rowID: any): boolean;
+    get allMatchingRowsSelected(): boolean;
+    get matchingRowsPartiallySelected(): boolean;
+    toggleAllMatchingRows(checked: boolean): Promise<void>;
+    onRowChekboxChange(event: any, rowID: any): void;
+    rowSelect(event: TableRowSelectEvent<any>): void;
+    rowUnselect(event: TableRowUnSelectEvent<any>): void;
+    pageChange(event: TablePageEvent): void;
+    columnSelectorShow(): void;
+    applyColumnModalChanges(selectedColumns: IColumnMetadata[]): void;
+    private updateColumnsSpecialProperties;
+    openExcelExport(): void;
+    generateExcelReport(event: any): void;
+    updateIconBlobsForCollections(): void;
+    ecsTrack1(index: number, button: any): any;
+    ecsTrack2(index: number, button: any): any;
+    ecsTrack3(index: number, group: any): any;
+    ecsTrack4(index: number, col: any): any;
+    ecsTrack5(index: number, col: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ECSPrimengTable, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ECSPrimengTable, "ecs-primeng-table", never, { "tableOptions": "tableOptions"; }, { "onRowCheckboxChange": "onRowCheckboxChange"; "onRowSelect": "onRowSelect"; "onRowUnselect": "onRowUnselect"; "onDataEndUpdate": "onDataEndUpdate"; }, never, never, true>;
+}
+export {};

package/lib/components/ecs-primeng-table/ecs-primeng-table.service.d.ts

@@ -0,0 +1,52 @@
+import { Observable } from 'rxjs';
+import { HttpResponse } from '@angular/common/http';
+import { ECSPrimengTableHttpService, ECSPrimengTableNotificationService } from '../../services';
+import { IColumnMetadata, IExcelExportRequest, IPredefinedFilter, ITableConfiguration, ITablePagedResponse, ITableView, ITableViewData } from '../../interfaces';
+import { TableViewSaveMode } from '../../enums';
+import { ITableQueryRequest } from '../../interfaces/table-query-request.interface';
+import { MenuItem } from 'primeng/api';
+import { Table } from 'primeng/table';
+import * as i0 from "@angular/core";
+export declare class ECSPrimengTableService {
+    private http;
+    private notification;
+    private readonly i18n;
+    constructor(http: ECSPrimengTableHttpService, notification: ECSPrimengTableNotificationService);
+    fetchTableConfiguration(url: string): Observable<HttpResponse<ITableConfiguration>>;
+    fetchTableData(url: string, postData: ITableQueryRequest): Observable<HttpResponse<ITablePagedResponse>>;
+    fetchExcelReport(url: string, postData: IExcelExportRequest): Observable<HttpResponse<Blob>>;
+    getIconBlob(url: string): Observable<HttpResponse<Blob>>;
+    downloadFile(data: Blob, fileName: string, contentType: string): void;
+    handleTableError(error: any, customTitle?: string): void;
+    orderColumnsWithFrozens(colsToOrder: IColumnMetadata[]): IColumnMetadata[];
+    /**
+     * Handles click events on action buttons in a row of data.
+     *
+     * @param {function} action - The action function to be executed when the button is clicked. It should accept one parameter, which is the row data.
+     * @param {any} [rowData=null] - The data of the row corresponding to the clicked button. Defaults to null.
+     *
+     * @returns {void}
+     *
+     * @example
+     * // Define an action for a button
+     * const deleteAction = (rowData) => {
+     *   console.log(`Delete row with id: ${rowData.rowID}`);
+     * };
+     *
+     * // Use handleButtonsClick with row data
+     * handleButtonsClick(deleteAction, { rowID: 1, name: 'John Doe' });
+     */
+    handleButtonsClick(action: (rowData: any) => void, rowData?: any): void;
+    handlePredefinedFilterClick(action: (rowData: any, option: IPredefinedFilter) => void, rowData: any, option: IPredefinedFilter): void;
+    getColumnStyle(col: any, headerCols?: boolean): Record<string, string>;
+    fetchTableViews(tableViewSaveAs: TableViewSaveMode, recoverListEndpoint: string, tableViewSaveKey: string): ITableView[] | Observable<HttpResponse<ITableView[]>>;
+    sortViews(tableSaveViewList: ITableView[]): void;
+    updateViewsMenuItems(tableSaveViewList: ITableView[]): MenuItem[];
+    viewsSaveToDatabase(tableSaveViewList: ITableView[], setListEndpoint: string, tableViewSaveKey: string): Observable<HttpResponse<any>>;
+    fetchSelectionKeys(endpoint: string, request: ITableQueryRequest): Observable<HttpResponse<any[]>>;
+    viewGenerateData(dt: Table, globalSearchText: string | null, currentPage: number, currentRowsPerPage: number, modifyFiltersFn: (filters: any) => any): ITableViewData;
+    computeColumnWidths(dt: Table): any;
+    computeTableWidth(dt: Table): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ECSPrimengTableService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ECSPrimengTableService>;
+}

package/lib/components/export-excel/export-excel.d.ts

@@ -0,0 +1,51 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { ECSPrimengTableNotificationService } from '../../services';
+import { ExportExcelService } from './export-excel.service';
+import * as i0 from "@angular/core";
+export declare class ExportExcel implements OnChanges {
+    private notificationSerivce;
+    private exportExcelService;
+    private readonly i18n;
+    private readonly translatedOptionSets;
+    visible: boolean;
+    rowCheckboxSelectorActive: boolean;
+    excelReportTitle: string;
+    includeTimeInTitle: boolean;
+    exportUseIconsInBools: boolean;
+    allowTitleUserEdit: boolean;
+    exportToExcel: EventEmitter<{
+        allColumns: boolean;
+        applyFilters: boolean;
+        applySorts: boolean;
+        selectedRows: number;
+        filename: string;
+        useIconInBools: boolean;
+    }>;
+    visibleChange: EventEmitter<boolean>;
+    constructor(notificationSerivce: ECSPrimengTableNotificationService, exportExcelService: ExportExcelService);
+    option_exportColumns_selected: boolean;
+    option_exportColumns: any[];
+    option_applyCurrentFilters_selected: boolean;
+    option_applyCurrentFilters: any[];
+    option_applyCurrentSorts_selected: boolean;
+    option_applyCurrentSorts: any[];
+    option_selectedRowsExport_selected: number;
+    option_selectedRowsExport: any[];
+    ngOnChanges(changes: SimpleChanges): void;
+    private resetValues;
+    getExcelReport(): void;
+    translatedOptions(options: {
+        label: string;
+        value: boolean | number;
+    }[]): {
+        label: string;
+        value: number | boolean;
+    }[];
+    filterSelectorDisabled(): boolean;
+    onChangeExportRows(event: {
+        value: number;
+    }): void;
+    closeModal(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportExcel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExportExcel, "ecs-export-excel", never, { "visible": "visible"; "rowCheckboxSelectorActive": "rowCheckboxSelectorActive"; "excelReportTitle": "excelReportTitle"; "allowTitleUserEdit": "allowTitleUserEdit"; }, { "exportToExcel": "exportToExcel"; "visibleChange": "visibleChange"; }, never, never, true>;
+}

package/lib/components/export-excel/export-excel.service.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class ExportExcelService {
+    getCurrentTimeString(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportExcelService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExportExcelService>;
+}

package/lib/components/table-button/table-button.d.ts

@@ -0,0 +1,16 @@
+import { ECSPrimengTableService } from '../ecs-primeng-table/ecs-primeng-table.service';
+import { ITableButton } from '../../interfaces';
+import * as i0 from "@angular/core";
+export declare class TableButton {
+    private tableService;
+    constructor(tableService: ECSPrimengTableService);
+    button: any;
+    rowData: any;
+    isActionButton: boolean;
+    isLastActionButton: boolean;
+    overrideAction?: ((event: Event) => void);
+    handleClick(event: Event): void;
+    getButtonStyle(button: ITableButton, isActionButton: boolean, isLastActionButton: boolean): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableButton, "ecs-table-button", never, { "button": "button"; "rowData": "rowData"; "isActionButton": "isActionButton"; "isLastActionButton": "isLastActionButton"; "overrideAction": "overrideAction"; }, {}, never, never, true>;
+}

package/lib/components/table-cell/table-cell.d.ts

@@ -0,0 +1,69 @@
+import { CellDisplay, DataAlignHorizontal, DataAlignVertical, DataType } from '../../enums';
+import { DatePipe } from '@angular/common';
+import { IColumnMetadata, IPredefinedFilter } from '../../interfaces';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export declare class TableCell {
+    private datePipe;
+    private sanitizer;
+    constructor(datePipe: DatePipe, sanitizer: DomSanitizer);
+    col: any;
+    rowData: any;
+    globalSearchText: string | null;
+    predefinedFiltersCollection?: {
+        [key: string]: IPredefinedFilter[];
+    };
+    dateFormat: string;
+    dateTimezone: string;
+    dateCulture: string;
+    DataType: typeof DataType;
+    CellDisplay: typeof CellDisplay;
+    /** Only finite numbers are valid; do not turn empty strings or booleans into progress. */
+    get hasProgressValue(): boolean;
+    get progressValue(): number;
+    get progressTooltip(): any;
+    get value(): any;
+    get tooltipText(): any;
+    getListValues(col: any, rowData: any): string[];
+    /** List tooltips use the same semicolon-separated positions as the displayed list. */
+    getListTooltip(item: string, index: number): string;
+    getDataAlignHorizontalAsText(dataAlignHorizontal: DataAlignHorizontal): void;
+    getDataAlignVerticalAsText(dataAlignVertical: DataAlignVertical): void;
+    /**
+     * Formats a date value using either column-level overrides or global settings.
+     * The incoming value is assumed to represent a UTC date.
+     *
+     * @param {any} value - The date value to be formatted.
+     * @param {string | null} dateFormat - Optional column-level override for the date format.
+     * @param {string | null} dateTimezone - Optional column-level override for the timezone used in formatting.
+     * @param {string | null} dateCulture - Optional column-level override for the culture used in formatting.
+     *
+     * @returns {string} - The formatted date string using the effective (column or global) settings,
+     *                     or an empty string if the value is invalid or undefined.
+     *
+     * @example
+     * // Example using only global settings:
+     * const result = formatDate(dateValue, null, null, null);
+     *
+     * @example
+     * // Example using column-level overrides:
+     * const result = formatDate(dateValue, 'dd/MM/yyyy', 'UTC', 'en-GB');
+     */
+    formatDate(value: any, dateFormat: string | null, dateTimezone: string | null, dateCulture: string | null): string;
+    getPredefinedFilterTooltip(colMetadata: IColumnMetadata, value: any): any;
+    /**
+     * Checks if the provided column metadata matches a specific style of the predefined filters
+     * that need to be applied to an item on a row.
+     *
+     * @param {IprimengColumnsMetadata} colMetadata - The metadata of the column being checked.
+     * @param {any} value - The value to be matched against the predefined filter values.
+     * @returns {any} The matching predefined filter value if found, otherwise null.
+     */
+    getPredfinedFilterMatch(colMetadata: IColumnMetadata, value: any): any;
+    getPredefinedFilterValues(columnKeyName: string): IPredefinedFilter[];
+    highlightText(cellValue: any, colMetadata: IColumnMetadata, globalSearchText: string | null): SafeHtml;
+    ecsTrack6(index: number, item: any): any;
+    ecsTrack7(index: number, item: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCell, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableCell, "ecs-table-cell", never, { "col": "col"; "rowData": "rowData"; "globalSearchText": "globalSearchText"; "predefinedFiltersCollection": "predefinedFiltersCollection"; "dateFormat": "dateFormat"; "dateTimezone": "dateTimezone"; "dateCulture": "dateCulture"; }, {}, never, never, true>;
+}

package/lib/components/table-predefined-filters/table-predefined-filters.d.ts

@@ -0,0 +1,39 @@
+import { DomSanitizer, SafeHtml, SafeUrl } from '@angular/platform-browser';
+import { ECSPrimengTableService } from '../ecs-primeng-table/ecs-primeng-table.service';
+import { IColumnMetadata } from '../../interfaces';
+import * as i0 from "@angular/core";
+export declare class TablePredefinedFilters {
+    private sanitizer;
+    private tableService;
+    constructor(sanitizer: DomSanitizer, tableService: ECSPrimengTableService);
+    option: any;
+    col: any;
+    selectable: boolean;
+    rowData: any;
+    globalSearchText?: any;
+    /**
+     * Converts a blob from the database to a safe URL that can be used to display an image.
+     *
+     * This function takes a `Blob` object, converts it to a base64 encoded string, and returns a `SafeUrl`
+     * that can be used in an HTML template to display the image securely. The `SafeUrl` ensures that
+     * Angular's security mechanisms are bypassed correctly, preventing potential security risks.
+     *
+     * @param {Blob} blob - The blob object representing the image data from the database.
+     * @returns {SafeUrl} A safe URL that can be used to display the image in an HTML template.
+     *
+     * @example
+     * // Example usage in a component
+     * const imageBlob = new Blob([binaryData], { type: 'image/jpeg' });
+     * const imageUrl = this.getBlobIconAsUrl(imageBlob);
+     *
+     * // In your HTML template
+     * <img [src]="imageUrl" alt="Image">
+     */
+    getBlobIconAsUrl(blob: Blob): SafeUrl;
+    handleClick(): void;
+    getTagStyle(option: any): any;
+    getImageSkeletonStyle(width?: number, height?: number, isSkeleton?: boolean): Record<string, string>;
+    highlightText(cellValue: any, colMetadata: IColumnMetadata, globalSearchText: string | null | undefined): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TablePredefinedFilters, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TablePredefinedFilters, "ecs-table-predefined-filters", never, { "option": "option"; "col": "col"; "selectable": "selectable"; "rowData": "rowData"; "globalSearchText": "globalSearchText"; }, {}, never, never, true>;
+}

package/lib/components/views-management/views-management.d.ts

@@ -0,0 +1,34 @@
+import { EventEmitter } from '@angular/core';
+import { ECSPrimengTableNotificationService } from '../../services';
+import * as i0 from "@angular/core";
+export declare class ViewsManagement {
+    private notification;
+    private readonly i18n;
+    constructor(notification: ECSPrimengTableNotificationService);
+    visible: boolean;
+    tableViews_menuItems: any[];
+    onViewSelect: EventEmitter<string>;
+    onViewDelete: EventEmitter<string>;
+    onViewUpdateData: EventEmitter<string>;
+    onViewUpdateActiveStartup: EventEmitter<string>;
+    onViewEditAlias: EventEmitter<{
+        viewAliasOld: string;
+        viewAliasNew: string;
+    }>;
+    onViewCreate: EventEmitter<string>;
+    visibleChange: EventEmitter<boolean>;
+    viewEditorShow: boolean;
+    editingViewAlias: string;
+    newViewAlias: string;
+    loadView(viewAlias: string): void;
+    deleteView(viewAlias: string): void;
+    updateView(viewAlias: string): void;
+    updateViewActiveStartup(viewAlias: string): void;
+    createView(viewAlias: string): void;
+    editViewAlias(viewAliasOld: string, viewAliasNew: string): void;
+    showViewEditor(editingViewAlias?: string): void;
+    closeModal(): void;
+    createOrUpdateTableView(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewsManagement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ViewsManagement, "ecs-views-management", never, { "visible": "visible"; "tableViews_menuItems": "tableViews_menuItems"; }, { "onViewSelect": "onViewSelect"; "onViewDelete": "onViewDelete"; "onViewUpdateData": "onViewUpdateData"; "onViewUpdateActiveStartup": "onViewUpdateActiveStartup"; "onViewEditAlias": "onViewEditAlias"; "onViewCreate": "onViewCreate"; "visibleChange": "visibleChange"; }, never, never, true>;
+}

package/lib/enums/cell-display.enum.d.ts

@@ -0,0 +1,5 @@
+/** Cell presentation. Filtering, sorting and export continue to use DataType. */
+export declare enum CellDisplay {
+    Default = 0,
+    ProgressBar = 1
+}

package/lib/enums/cell-overflow-behaviour.enum.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Defines how content that overflows a table cell is displayed.
+ *
+ * @remarks
+ * This enumeration specifies the visual behavior of cell content when it exceeds the cell’s width.
+ */
+export declare enum CellOverflowBehaviour {
+    /** The overflowing content is clipped and not visible. */
+    Hidden = 0,
+    /** The content wraps onto multiple lines to fit within the cell. */
+    Wrap = 1
+}

package/lib/enums/data-align-horizontal.enum.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Defines the horizontal alignment of content within a table cell.
+ *
+ * @remarks
+ * Specifies how the content inside a cell is positioned horizontally relative to the cell's width.
+ */
+export declare enum DataAlignHorizontal {
+    /** Content is aligned to the left side of the cell. */
+    Left = 0,
+    /** Content is aligned to the center of the cell. */
+    Center = 1,
+    /** Content is aligned to the right side of the cell. */
+    Right = 2
+}

package/lib/enums/data-align-vertical.enum.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Enum representing the vertical alignment of content within a table cell.
+ *
+ * @remarks
+ * Determines how the content inside a cell is positioned vertically relative to the cell's height.
+ */
+export declare enum DataAlignVertical {
+    /** Align content to the top of the cell. */
+    Top = 0,
+    /** Align content to the vertical middle of the cell. */
+    Middle = 1,
+    /** Align content to the bottom of the cell. */
+    Bottom = 2
+}

package/lib/enums/data-type.enum.enum.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Enum representing the different types of data a table column can hold.
+ *
+ * @remarks
+ * This is used to determine how values should be rendered, formatted, and
+ * filtered in the table component.
+ */
+export declare enum DataType {
+    /** Plain text string values. */
+    Text = 0,
+    /** Numeric values, e.g., integers or decimals. */
+    Numeric = 1,
+    /** Boolean values (true/false). */
+    Boolean = 2,
+    /** Date or datetime values. */
+    Date = 3,
+    /** List of values, stored as a string separated by a delimiter (";"). */
+    List = 4
+}