shared-ui-test-2 1.0.0

package/modules/ui-kit/components/data-table/data-col-filter/filter-value-helpers/col-filter-in-value.d.ts

@@ -0,0 +1,13 @@
+import { IFilterOption } from 'idp-apps-shared-ui/modules/ui-kit/interfaces/api.interface';
+import { IKeyValue } from 'idp-apps-shared-ui/modules/ui-kit/interfaces/generic.interface';
+import { IDataTableColumnFilterValue } from '../../../data-table/interfaces/filter-value-executor.interface';
+export declare class DataTableColumnFilterInValue implements IDataTableColumnFilterValue {
+    setFilterValue(filterOption: IFilterOption, filterValue: IKeyValue, data: IKeyValue): IKeyValue;
+    isCheckedFilterValue(filterOption: IFilterOption, filterValue: IKeyValue, data: IKeyValue): boolean;
+    getFilterValue(filterValue: string[], isUpdatedTableDesign?: boolean): string;
+    matchWithFilterValue(rowValue: IKeyValue, filterValue: IKeyValue): boolean;
+    setInitValues(context: any): void;
+    isFormInvalid(context: any): boolean;
+    resetValue(context: any): void;
+    private removeSingleQuotesFromValue;
+}

package/modules/ui-kit/components/data-table/data-col-filter/filter-value-helpers/col-filter-slider-value.d.ts

@@ -0,0 +1,10 @@
+import { IDataTableColumnFilterValue } from 'idp-apps-shared-ui/modules/ui-kit/components/data-table/interfaces/filter-value-executor.interface';
+import { IKeyValue } from 'idp-apps-shared-ui/modules/ui-kit/interfaces/generic.interface';
+export declare class DataTableColumnFilterSliderValue implements IDataTableColumnFilterValue {
+    getFilterValue(filterValue: IKeyValue, isUpdatedFilterDesign?: boolean): string;
+    matchWithFilterValue(rowValue: IKeyValue, filterValue: IKeyValue): boolean;
+    setInitValues(context: any): void;
+    isFormInvalid(context: any): boolean;
+    resetValue(context: any): void;
+    private removeSingleQuotesFromValue;
+}

package/modules/ui-kit/components/data-table/data-col-filter/filter-value-helpers/filter-value-executor-provider.d.ts

@@ -0,0 +1,11 @@
+import { IDataTableColumnFilterValue } from '../../../../../../modules/ui-kit/components/data-table/interfaces/filter-value-executor.interface';
+import * as i0 from "@angular/core";
+export declare class FilterValueExecutorProvider {
+    private inValue;
+    private betweenValue;
+    private containsValue;
+    private sliderBetweenValue;
+    getFilterValueExecutorProvider(type: string): IDataTableColumnFilterValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterValueExecutorProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FilterValueExecutorProvider>;
+}

package/modules/ui-kit/components/data-table/data-column-filter/data-column-filter.component.d.ts

@@ -0,0 +1,29 @@
+import { ChangeDetectorRef, OnInit, EventEmitter } from '@angular/core';
+import { FormBuilder, FormGroup, AbstractControl } from '@angular/forms';
+import { IDataTableColumn, IDataTableRow } from '../../../interfaces/data-table.interface';
+import * as i0 from "@angular/core";
+export declare class DataColumnFilterComponent implements OnInit {
+    private formBuilder;
+    private chagedetector;
+    column: IDataTableColumn;
+    filterFired: EventEmitter<IFilterParameters>;
+    uniqueValueSet: Set<string>;
+    valueForm: FormGroup;
+    isLoading: false;
+    private rows;
+    private uniqueData;
+    constructor(formBuilder: FormBuilder, chagedetector: ChangeDetectorRef);
+    set tableRows(values: IDataTableRow[]);
+    ngOnInit(): void;
+    getControl(value: string): AbstractControl | null;
+    isValidValue(value: any): boolean;
+    applyFilter(): void;
+    private createForm;
+    private calculateUniqueValues;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataColumnFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataColumnFilterComponent, "app-data-column-filter", never, { "column": { "alias": "column"; "required": false; }; "tableRows": { "alias": "tableRows"; "required": false; }; }, { "filterFired": "filterFired"; }, never, never, false, never>;
+}
+export interface IFilterParameters {
+    values: Array<string>;
+    property: string;
+}

package/modules/ui-kit/components/data-table/data-row/data-row.component.d.ts

@@ -0,0 +1,81 @@
+import { EventEmitter, QueryList, OnChanges, ChangeDetectorRef } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { SelectionModel } from '@angular/cdk/collections';
+import { IDataTableColumn, IDataTableRow, IDataTableRowEvent, GridOptions, IDataTableAction, IClickedEventData, IGridMatMenuItem } from '../../../interfaces/data-table.interface';
+import { ColumnTypes } from '../../../enums/column-types.enum';
+import { FormService } from '../../../services/form.service';
+import { IKeyValue } from '../../../interfaces/generic.interface';
+import { BaseDataColComponent } from '../data-col/base-data-col/base-data-col.component';
+import { ColumnDisableModes } from '../../../enums/column-disable-mode.enum';
+import { IDataRowComponent } from '../interfaces/data-table-component.interface';
+import * as i0 from "@angular/core";
+export declare class DataRowComponent implements IDataRowComponent, OnChanges {
+    private formService;
+    changeDetectorRef: ChangeDetectorRef;
+    set setColumnComponents(columns: QueryList<BaseDataColComponent>);
+    get rowValue(): IKeyValue;
+    private get firstVisibleCol();
+    row: IDataTableRow;
+    rowIndex: number;
+    viewColumns: IDataTableColumn[];
+    canInlineEdit: boolean;
+    isTreeGrid: boolean;
+    hasRowChildren: boolean;
+    isOnlyView: boolean;
+    isEditable: boolean;
+    selection: SelectionModel<IDataTableRow>;
+    isDeleteDisabled: boolean;
+    isRowUnchecked?: (row: IDataTableRow) => boolean;
+    clickAction: EventEmitter<IDataTableAction>;
+    gridOptions: GridOptions;
+    hasEmptyRow: boolean;
+    isEditing: boolean;
+    isSaving: boolean;
+    isRowSelectionEnable: boolean;
+    isCloneVisible: boolean;
+    clickAdd: EventEmitter<undefined>;
+    clickEdit: EventEmitter<undefined>;
+    clickEditCancel: EventEmitter<undefined>;
+    clickEditSave: EventEmitter<IKeyValue>;
+    clickView: EventEmitter<IDataTableRowEvent>;
+    clickDelete: EventEmitter<undefined>;
+    changeExpandCollapse: EventEmitter<boolean>;
+    columnTypes: typeof ColumnTypes;
+    readonly columnDisableModes: typeof ColumnDisableModes;
+    clickClone: EventEmitter<undefined>;
+    complexDetailClicked: EventEmitter<IClickedEventData>;
+    CheckboxSelect: EventEmitter<IDataTableRow>;
+    private columnComponents;
+    private formGroup;
+    constructor(formService: FormService, changeDetectorRef: ChangeDetectorRef);
+    getColumnComponents(): BaseDataColComponent[];
+    ngOnChanges(): void;
+    isDataColView(viewColumn: IDataTableColumn): boolean;
+    isAnyFormControlVisibleSet(): boolean;
+    onClickAction(action: IDataTableAction): void;
+    onClickEdit(): void;
+    onClickClone(): void;
+    onClickEditCancel(): void;
+    onClickEditSave(): void;
+    onClickView(): void;
+    onClickDelete(): void;
+    onClickAdd(): void;
+    onChangeExpandCollapse(shouldExpand: boolean): void;
+    getColControl(viewColumn: IDataTableColumn, row?: any): FormControl | null;
+    hasColExpandCollapse(viewColumn: IDataTableColumn): boolean;
+    isFirstVisibleCol(viewColumn: IDataTableColumn): boolean;
+    getIsFormControlColVisible(viewColumn: IDataTableColumn): boolean;
+    isColumnInEditMode(viewColumn: IDataTableColumn): boolean;
+    getAccordionClasss(): string;
+    isColumnEditMode(viewColumn: IDataTableColumn): boolean;
+    isAddRow(): boolean;
+    get isViewActionVisible(): boolean;
+    get isRowDisabled(): boolean;
+    ComplexDetailClicked(eventData: IClickedEventData): void;
+    ActionClickHandler(menu: IGridMatMenuItem): void;
+    isCheckboxSelect(row: IDataTableRow): void;
+    private initRowForm;
+    private updateFormState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataRowComponent, "[app-data-row]", never, { "row": { "alias": "row"; "required": false; }; "rowIndex": { "alias": "rowIndex"; "required": false; }; "viewColumns": { "alias": "viewColumns"; "required": false; }; "canInlineEdit": { "alias": "canInlineEdit"; "required": false; }; "isTreeGrid": { "alias": "isTreeGrid"; "required": false; }; "hasRowChildren": { "alias": "hasRowChildren"; "required": false; }; "isOnlyView": { "alias": "isOnlyView"; "required": false; }; "isEditable": { "alias": "isEditable"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "isDeleteDisabled": { "alias": "isDeleteDisabled"; "required": false; }; "isRowUnchecked": { "alias": "isRowUnchecked"; "required": false; }; "gridOptions": { "alias": "gridOptions"; "required": false; }; "hasEmptyRow": { "alias": "hasEmptyRow"; "required": false; }; "isEditing": { "alias": "isEditing"; "required": false; }; "isSaving": { "alias": "isSaving"; "required": false; }; "isRowSelectionEnable": { "alias": "isRowSelectionEnable"; "required": false; }; "isCloneVisible": { "alias": "isCloneVisible"; "required": false; }; }, { "clickAction": "clickAction"; "clickAdd": "clickAdd"; "clickEdit": "clickEdit"; "clickEditCancel": "clickEditCancel"; "clickEditSave": "clickEditSave"; "clickView": "clickView"; "clickDelete": "clickDelete"; "changeExpandCollapse": "changeExpandCollapse"; "clickClone": "clickClone"; "complexDetailClicked": "complexDetailClicked"; "CheckboxSelect": "CheckboxSelect"; }, never, never, false, never>;
+}

package/modules/ui-kit/components/data-table/data-table/data-table.component.d.ts

@@ -0,0 +1,302 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter, OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { MatDialog } from '@angular/material/dialog';
+import { ActivatedRoute, Router } from '@angular/router';
+import { LocalStorageService } from 'idp-apps-shared-ui/core/services/local-storage.service';
+import { UserManagementService } from 'idp-apps-shared-ui/core/services/user-management.service';
+import { ActionTypesEnum } from 'idp-apps-shared-ui/enums/action-types.enum';
+import { SortDirectionEnum } from 'idp-apps-shared-ui/enums/sort-direction.enum';
+import { SourceTypesEnum } from 'idp-apps-shared-ui/enums/source-types.enum';
+import { ToolTipsProp } from 'idp-apps-shared-ui/enums/tooltips-prop.enum';
+import { IRowSelectionInfo } from 'idp-apps-shared-ui/modules/ui-kit/interfaces/row-selection-info.interface';
+import { ColumnFilterPipe } from 'idp-apps-shared-ui/modules/ui-kit/pipes/column-filter.pipe';
+import { SearchPipe } from 'idp-apps-shared-ui/modules/ui-kit/pipes/search.pipe';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { Icons } from '../../../enums/icons.enum';
+import { IFilterParam } from '../../../interfaces/api.interface';
+import { GridOptions, IClickedEventData, IDataTableAction, IDataTableChangeLocalDataEvent, IDataTableColumn, IDataTableExpandCollapseEvent, IDataTableRow, IDataTableRowEvent, IDataTableRowSaveEvent, IRowData, ITopRightAction } from '../../../interfaces/data-table.interface';
+import { IKeyValue, IPaginationParams } from '../../../interfaces/generic.interface';
+import { DataTableService } from '../../../services/data-table.service';
+import { FormService } from '../../../services/form.service';
+import { SnackbarService } from '../../../services/snackbar.service';
+import { DeleteItemFn, GetListFn, PostItemFn, PutItemFn } from '../../../types/function.type';
+import { DeleteModalComponent } from '../../modals/delete-modal/delete-modal.component';
+import { FilterManager } from '../api-classes/filter-manager';
+import { GridApi } from '../api-classes/grid-api';
+import { DataTableBodyComponent } from '../data-table-body/data-table-body.component';
+import { IDataTableComponent } from '../interfaces/data-table-component.interface';
+import { DataTableContextService } from '../services/data-table-context.service';
+import * as i0 from "@angular/core";
+export interface ScrollPosition {
+    x: number;
+    y: number;
+}
+export interface ScrollEvent extends Event {
+    isTrusted: boolean;
+    currentScrollPosition: ScrollPosition;
+    currentElement: ElementRef<HTMLElement>;
+}
+export declare class DataTableComponent implements OnInit, AfterViewInit, OnDestroy, IDataTableComponent {
+    dataTableService: DataTableService;
+    private router;
+    private activatedRoute;
+    private matDialog;
+    changeDetectorRef: ChangeDetectorRef;
+    private snackbarService;
+    private userManagementService;
+    private filterPipe;
+    private searchPipe;
+    private localStorageService;
+    dialog: MatDialog;
+    formService: FormService;
+    private dataTableContext;
+    get canInlineEdit(): boolean;
+    set setDataTableBody(tableBody: DataTableBodyComponent);
+    get columnShowhideStoragekey(): string | undefined;
+    get allowSaveColumnVisibilitySettings(): boolean;
+    get addActionTitle(): string;
+    get isViewActionVisible(): boolean;
+    get searchPlaceholder(): string;
+    get isTableInEditState(): boolean;
+    private get apiReqParams();
+    get getSortParams(): {
+        sortBy: string;
+        sortDirection: SortDirectionEnum;
+    };
+    readonly ICONS: typeof Icons;
+    readonly sortDirectionEnum: typeof SortDirectionEnum;
+    readonly toolTips: typeof ToolTipsProp;
+    readonly actionTypes: typeof ActionTypesEnum;
+    readonly DEFAULT_PAGE_SIZE: number;
+    readonly DEFAULT_INIT_PAGE: number;
+    readonly confirmationMsgPagination: string;
+    defaultRowValues: IKeyValue;
+    columns: IDataTableColumn[];
+    getListFn: GetListFn;
+    postItemFn: PostItemFn;
+    putItemFn: PutItemFn;
+    deleteItemFn: DeleteItemFn;
+    header: string;
+    description: string;
+    actionAddTitle: string;
+    isIdColVisible: boolean;
+    hasPagination: boolean;
+    isOnlyView: boolean;
+    isOnlyViewRow?: (row: IDataTableRow) => boolean;
+    isDeleteDisabled?: (row: IDataTableRow) => boolean;
+    isEditable: boolean;
+    isCloneVisible: boolean;
+    isLazyInitialization: boolean;
+    objectName: string;
+    gridOptions: GridOptions;
+    isRowSelectionEnable: boolean;
+    beforeSaveFn?: (rowsData: IRowData[], saveEventData: IDataTableRowSaveEvent) => boolean;
+    onBeforeEdit?: (rowsData: IRowData[], saveEventData: IDataTableRowEvent) => boolean;
+    onAddClick?: (rowsData: IRowData[], saveEventData: IDataTableRowEvent) => boolean;
+    isRowUnchecked?: (row: IDataTableRow) => boolean;
+    isSaveDataLocal: boolean;
+    scrollPosition: ScrollPosition;
+    isTreeGrid: boolean;
+    initialPage: number;
+    changeLocalData: EventEmitter<IDataTableChangeLocalDataEvent>;
+    actionClick: EventEmitter<IDataTableAction>;
+    onInitCompleted: EventEmitter<any>;
+    onComplexDetailClicked: EventEmitter<IClickedEventData>;
+    onEditClicked: EventEmitter<IDataTableRowEvent>;
+    onAddClicked: EventEmitter<any>;
+    onRowClicked: EventEmitter<any>;
+    onPageChanged: EventEmitter<any>;
+    matExpansionPanelClicked: EventEmitter<IDataTableRowEvent>;
+    onUpdateCompleted: EventEmitter<IDataTableRowEvent>;
+    onDeleteCompleted: EventEmitter<IDataTableRowEvent>;
+    onScrolled: EventEmitter<ScrollEvent>;
+    CheckboxSelect: EventEmitter<IRowSelectionInfo>;
+    isTableDataLoad: EventEmitter<boolean>;
+    searchValue: FormControl;
+    searchColumns: IDataTableColumn[];
+    isSearchDisabled: boolean;
+    selectedRow: IDataTableRow;
+    filteredRows: IDataTableRow[];
+    deleteModal: TemplateRef<DeleteModalComponent>;
+    customDataTable: ElementRef<HTMLElement>;
+    sliderTemplate: ViewContainerRef;
+    readonly sourceTypes: typeof SourceTypesEnum;
+    dataTableBody: DataTableBodyComponent;
+    gridApi: GridApi;
+    masterSelection: FormControl;
+    paginationParams: IPaginationParams;
+    searchedRowCount$: Subject<number>;
+    isClearFilter$: BehaviorSubject<boolean>;
+    isFilterView: boolean;
+    viewColumns: IDataTableColumn[];
+    rows: IDataTableRow[];
+    excludedRows: IDataTableRow[];
+    sortedColumn: {};
+    count: number;
+    filterManager: FilterManager;
+    isLoading$: BehaviorSubject<boolean>;
+    hasEmptyRow: boolean;
+    isEditing: boolean;
+    isSaving: boolean;
+    rowToDelete: IDataTableRow;
+    selection: SelectionModel<IDataTableRow>;
+    map: Map<any, any>;
+    numberOfTableRefresh: number;
+    private defaultSortedColumns;
+    private originalUnsortedRows;
+    private clearSubs$;
+    private storageKey;
+    private totalItems;
+    private startX;
+    private startWidth;
+    private resizingTh;
+    private apolloDataTable;
+    private resizingTd;
+    private clickTimeout;
+    private defaultGridOptions;
+    constructor(dataTableService: DataTableService, router: Router, activatedRoute: ActivatedRoute, matDialog: MatDialog, changeDetectorRef: ChangeDetectorRef, snackbarService: SnackbarService, userManagementService: UserManagementService, filterPipe: ColumnFilterPipe, searchPipe: SearchPipe, localStorageService: LocalStorageService, dialog: MatDialog, formService: FormService, dataTableContext: DataTableContextService);
+    get getSelectedRows(): IDataTableRow[];
+    get getAllCheckedRows(): IDataTableRow[];
+    get isActionsDisabled(): boolean;
+    get getRows(): IDataTableRow[];
+    get getCustomTableStyle(): IKeyValue;
+    onTableScrolled(e: Event): void;
+    changeScrollPosition(position: ScrollPosition): void;
+    ngOnInit(): void;
+    isDisabledMainAction(actionProp: string): boolean;
+    nonFilterClassName(columnProp: string): string;
+    isFilterEnable(columnProp: string): boolean;
+    isFilterableColumn(columnProp: string): boolean;
+    get isFilterApplied(): boolean;
+    get nonDisabledRows(): IDataTableRow[];
+    ngAfterViewInit(): void;
+    checkDeleteDisabled(): boolean;
+    isAllSelected(): boolean;
+    isSortColumn(viewColumn: IDataTableColumn): boolean;
+    openColumnShowHideDialogue(): void;
+    masterToggle(): void;
+    isCheckboxSelect(row: IDataTableRow): void;
+    refresh(): void;
+    onClickAction(action: IDataTableAction): void;
+    onClickAdd(): void;
+    addActionHandler(): void;
+    onClickRow(eventData: IDataTableRowEvent): void;
+    onClickRowAdd(eventData: IDataTableRowEvent): void;
+    onClickEdit(eventData: IDataTableRowEvent): void;
+    onClickClone(eventData: IDataTableRowEvent): void;
+    onClickView(eventData: IDataTableRowEvent): void;
+    ComplexDetailClicked(eventData: IClickedEventData): void;
+    ActionClickHandler(action: ITopRightAction): void;
+    showHideFilterView(): void;
+    clearGlobalFilter(): void;
+    onChangePage(paginationParams: IPaginationParams, selectableIndex?: number | string): void;
+    onExpansionPanelClick(eventData: IDataTableRowEvent): void;
+    onChangePageSize(pageSize: number): void;
+    getFilterParam(column: IDataTableColumn): IFilterParam;
+    isFilteredColumn(columnProp: string): boolean;
+    onFilterClicked(filterParam: IFilterParam): void;
+    onClickEditCancel(eventData: IDataTableRowEvent): void;
+    onClickEditSave(eventData: IDataTableRowSaveEvent): void;
+    onChangeExpandCollapse(eventData: IDataTableExpandCollapseEvent): void;
+    getNavigateItemValue(eventData: IDataTableRowEvent): string;
+    navigateToItem(type: string, id: string): void;
+    onClickDeleteRow(eventData: IDataTableRowEvent): void;
+    onClickDeleteModal(shouldDelete: any): void;
+    VisibleColumnListChanged(columnList: IDataTableColumn[]): void;
+    ngOnDestroy(): void;
+    init(): void;
+    sortTable(viewColumn: IDataTableColumn): void;
+    deleteRow(row: IDataTableRow): void;
+    searchModelChanged(): void;
+    getTooltipText(text: string): string;
+    getActionName(prop: ActionTypesEnum): string;
+    getLeftActionName(prop: ActionTypesEnum): string;
+    getLeftRightActionText(data: IKeyValue): string;
+    get isSingleSelect(): boolean;
+    get pageSize(): number;
+    get currentPage(): number;
+    detectChange(): void;
+    selectNextRow(): void;
+    selectPreviousRow(): void;
+    uncheckSelectedSource(): void;
+    onDoubleClickSeparator(index: number, viewColumn: IDataTableColumn): void;
+    getHeaderStyle(index: number, viewColumn: IDataTableColumn): string[];
+    onSeparatorMouseDown(event: MouseEvent, index: number, viewColumn: IDataTableColumn): void;
+    private getSelectedHtml;
+    private formatTableData;
+    private formatTableHeader;
+    private onMouseMove;
+    private onMouseUp;
+    private setWidthToElement;
+    private getActualWidth;
+    private get pagesCount();
+    private get rowsCountInCurrentPage();
+    private isLastRowInPage;
+    private isFirstRowInPage;
+    private isFirstRowInFirstPage;
+    private isLastRowInLastPage;
+    private detectRowChange;
+    private isClientSidePagination;
+    private setIdColumn;
+    private initColumns;
+    private configureDialog;
+    private initViewColumns;
+    private addIdColumn;
+    private setData;
+    private setInitApiParams;
+    private setInitFilterParams;
+    private initGetFunc;
+    private isEligibleForAllCheck;
+    private getSelectableValidIndex;
+    private setPaginationData;
+    private checkedAllExceptExcludedRows;
+    private applyDefaultSort;
+    private applyDefaultSortingParams;
+    private setPaginationDataOnSizeChanged;
+    private navigatePage;
+    private openDeleteModal;
+    private saveRow;
+    private postDataForAdd;
+    private putDataForEdit;
+    private downSort;
+    private upSort;
+    private unsort;
+    private sortData;
+    private addEmptyRow;
+    private removeEmptyRow;
+    private onSaveLocalRow;
+    private addLocalRow;
+    private editLocalRow;
+    private saveLocalRow;
+    private updateRowData;
+    private removeLocalRow;
+    private selectAutoNextRow;
+    private isDefaultFirstRowSelected;
+    private emitNextRow;
+    private toggleRowEditing;
+    private toggleRowExpandCollapse;
+    private getEmptyRow;
+    private onChangeLocalData;
+    private fireInitCompleted;
+    private addCloneRow;
+    private getGridApi;
+    private getSearchableColumns;
+    private masterToggleClientSide;
+    private clearPropertyWhenSelectionEnable;
+    private getCheckedRows;
+    private masterToggleServerSide;
+    private addUnmatchedRowToSelection;
+    private setRowChecked;
+    private getFilteredDataRow;
+    private setColumnSource;
+    private setColumnsUsingStoredData;
+    private selectedCheckboxPagingConfirmation;
+    private isSelectedRow;
+    private searchTable;
+    private populateFilterParams;
+    private getConfiguredColumns;
+    private generateColumns;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataTableComponent, "app-data-table", never, { "defaultRowValues": { "alias": "defaultRowValues"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "getListFn": { "alias": "getListFn"; "required": false; }; "postItemFn": { "alias": "postItemFn"; "required": false; }; "putItemFn": { "alias": "putItemFn"; "required": false; }; "deleteItemFn": { "alias": "deleteItemFn"; "required": false; }; "header": { "alias": "header"; "required": false; }; "description": { "alias": "description"; "required": false; }; "actionAddTitle": { "alias": "actionAddTitle"; "required": false; }; "isIdColVisible": { "alias": "isIdColVisible"; "required": false; }; "hasPagination": { "alias": "hasPagination"; "required": false; }; "isOnlyView": { "alias": "isOnlyView"; "required": false; }; "isOnlyViewRow": { "alias": "isOnlyViewRow"; "required": false; }; "isDeleteDisabled": { "alias": "isDeleteDisabled"; "required": false; }; "isEditable": { "alias": "isEditable"; "required": false; }; "isCloneVisible": { "alias": "isCloneVisible"; "required": false; }; "isLazyInitialization": { "alias": "isLazyInitialization"; "required": false; }; "objectName": { "alias": "objectName"; "required": false; }; "gridOptions": { "alias": "gridOptions"; "required": false; }; "isRowSelectionEnable": { "alias": "isRowSelectionEnable"; "required": false; }; "beforeSaveFn": { "alias": "beforeSaveFn"; "required": false; }; "onBeforeEdit": { "alias": "onBeforeEdit"; "required": false; }; "onAddClick": { "alias": "onAddClick"; "required": false; }; "isRowUnchecked": { "alias": "isRowUnchecked"; "required": false; }; "isSaveDataLocal": { "alias": "isSaveDataLocal"; "required": false; }; "scrollPosition": { "alias": "scrollPosition"; "required": false; }; "isTreeGrid": { "alias": "isTreeGrid"; "required": false; }; "initialPage": { "alias": "initialPage"; "required": false; }; }, { "changeLocalData": "changeLocalData"; "actionClick": "actionClick"; "onInitCompleted": "onInitCompleted"; "onComplexDetailClicked": "onComplexDetailClicked"; "onEditClicked": "onEditClicked"; "onAddClicked": "onAddClicked"; "onRowClicked": "onRowClicked"; "onPageChanged": "onPageChanged"; "matExpansionPanelClicked": "matExpansionPanelClicked"; "onUpdateCompleted": "onUpdateCompleted"; "onDeleteCompleted": "onDeleteCompleted"; "onScrolled": "onScrolled"; "CheckboxSelect": "CheckboxSelect"; "isTableDataLoad": "isTableDataLoad"; }, never, never, false, never>;
+}

package/modules/ui-kit/components/data-table/data-table-actions/data-table-actions.component.d.ts

@@ -0,0 +1,53 @@
+import { EventEmitter } from '@angular/core';
+import { ToolTipsProp } from 'idp-apps-shared-ui/enums/tooltips-prop.enum';
+import { DataTableActions } from '../../../../../modules/ui-kit/components/data-table/data-table-row-actions/const/data-table-actions.enum';
+import { Icons } from '../../../enums/icons.enum';
+import { IDataTableRow, GridOptions } from '../../../interfaces/data-table.interface';
+import { GridApi } from '../api-classes/grid-api';
+import { SnackbarService } from '../../../services/snackbar.service';
+import { UserManagementService } from 'idp-apps-shared-ui/core/services/user-management.service';
+import { ActionTypesEnum } from 'idp-apps-shared-ui/enums/action-types.enum';
+import * as i0 from "@angular/core";
+export declare class DataTableActionsComponent {
+    private userManagementService;
+    private snackbarService;
+    canInlineEdit: boolean;
+    isEditable: boolean;
+    isEditing: boolean;
+    isSaving: boolean;
+    isTreeGrid: boolean;
+    isOnlyView: boolean;
+    hasEmptyRow: boolean;
+    isCloneVisible: boolean;
+    isDeleteVisible: boolean;
+    selectedRow: IDataTableRow;
+    gridApi: GridApi;
+    gridOptions: GridOptions;
+    isIconsDisabled: boolean;
+    clickAdd: EventEmitter<number>;
+    readonly ICONS: typeof Icons;
+    readonly tooltipsProp: typeof ToolTipsProp;
+    readonly actionsTypes: typeof ActionTypesEnum;
+    readonly DATA_TABLE_ACTIONS: typeof DataTableActions;
+    constructor(userManagementService: UserManagementService, snackbarService: SnackbarService);
+    getActionClass(actionType: DataTableActions): string;
+    onClickAdd(): void;
+    onClickEdit(): void;
+    onClickClone(): void;
+    onClickDelete(): void;
+    onClickCancel(): void;
+    onClickSave(): void;
+    get isAddActionVisible(): boolean;
+    get isEditVisible(): boolean;
+    get shouldDeleteBeShown(): boolean;
+    get isCLoneVisible(): boolean;
+    get isActionDisabled(): boolean;
+    get hasAddTemplate(): boolean;
+    get hasEditTemplate(): boolean;
+    get hasDeleteTemplate(): boolean;
+    getTooltipText(text: string): string;
+    getActionName(prop: string): string;
+    isDisabledMainAction(actionProp: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataTableActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataTableActionsComponent, "app-data-table-actions", never, { "canInlineEdit": { "alias": "canInlineEdit"; "required": false; }; "isEditable": { "alias": "isEditable"; "required": false; }; "isEditing": { "alias": "isEditing"; "required": false; }; "isSaving": { "alias": "isSaving"; "required": false; }; "isTreeGrid": { "alias": "isTreeGrid"; "required": false; }; "isOnlyView": { "alias": "isOnlyView"; "required": false; }; "hasEmptyRow": { "alias": "hasEmptyRow"; "required": false; }; "isCloneVisible": { "alias": "isCloneVisible"; "required": false; }; "isDeleteVisible": { "alias": "isDeleteVisible"; "required": false; }; "selectedRow": { "alias": "selectedRow"; "required": false; }; "gridApi": { "alias": "gridApi"; "required": false; }; "gridOptions": { "alias": "gridOptions"; "required": false; }; "isIconsDisabled": { "alias": "isIconsDisabled"; "required": false; }; }, { "clickAdd": "clickAdd"; }, never, never, false, never>;
+}

package/modules/ui-kit/components/data-table/data-table-body/data-table-body.component.d.ts

@@ -0,0 +1,75 @@
+import { ChangeDetectorRef, EventEmitter, QueryList } from '@angular/core';
+import { SelectionModel } from '@angular/cdk/collections';
+import { Subject } from 'rxjs';
+import { IDataTableColumn, IDataTableExpandCollapseEvent, IDataTableRow, IDataTableRowEvent, IDataTableRowSaveEvent, IDataTableAction, GridOptions, IClickedEventData } from '../../../interfaces/data-table.interface';
+import { IKeyValue, IPaginationParams } from '../../../interfaces/generic.interface';
+import { DataTableService } from '../../../services/data-table.service';
+import { DataRowComponent } from '../data-row/data-row.component';
+import * as i0 from "@angular/core";
+export declare class DataTableBodyComponent {
+    dataTableService: DataTableService;
+    private cd;
+    rows: IDataTableRow[];
+    viewColumns: IDataTableColumn[];
+    canInlineEdit: boolean;
+    isTreeGrid: boolean;
+    isOnlyView: boolean;
+    isOnlyViewRow?: (row: IDataTableRow) => boolean;
+    isDeleteDisabled?: (row: IDataTableRow) => boolean;
+    isEditable: boolean;
+    searchedRowCount$: Subject<number>;
+    clickAction: EventEmitter<IDataTableAction>;
+    gridOptions: GridOptions;
+    search: string;
+    paginationParams: IPaginationParams;
+    hasEmptyRow: boolean;
+    isEditing: boolean;
+    isSaving: boolean;
+    isRowSelectionEnable: boolean;
+    isCloneVisible: boolean;
+    searchColumns: IDataTableColumn[];
+    selection: SelectionModel<IDataTableRow>;
+    selectedRow: IDataTableRow;
+    isRowUnchecked?: (row: any) => boolean;
+    clickEdit: EventEmitter<IDataTableRowEvent>;
+    clickEditCancel: EventEmitter<IDataTableRowEvent>;
+    clickEditSave: EventEmitter<IDataTableRowSaveEvent>;
+    clickView: EventEmitter<IDataTableRowEvent>;
+    clickDelete: EventEmitter<IDataTableRowEvent>;
+    clickAdd: EventEmitter<IDataTableRowEvent>;
+    clickRow: EventEmitter<IDataTableRowEvent>;
+    changeExpandCollapse: EventEmitter<IDataTableExpandCollapseEvent>;
+    complexDetailClicked: EventEmitter<IClickedEventData>;
+    clickClone: EventEmitter<IDataTableRowEvent>;
+    matExpansionPanelClicked: EventEmitter<IDataTableRowEvent>;
+    onAddClick?: (rowsData: any, saveEventData: IDataTableRowEvent) => boolean;
+    CheckboxSelect: EventEmitter<IDataTableRow>;
+    rowComponents: QueryList<DataRowComponent>;
+    set setColumnComponents(items: QueryList<DataRowComponent>);
+    constructor(dataTableService: DataTableService, cd: ChangeDetectorRef);
+    get getEmptyDataClassName(): string;
+    get isNoRecordsFound(): boolean;
+    detectChange(): void;
+    onClickEdit(row: IDataTableRow): void;
+    onClickClone(row: IDataTableRow): void;
+    onClickEditCancel(row: IDataTableRow): void;
+    onClickEditSave(row: IDataTableRow, saveData: IKeyValue): void;
+    onClickDelete(row: IDataTableRow): void;
+    isExpandable(row: IDataTableRow): boolean;
+    onExpansionPanelClicked(row: IDataTableRow): void;
+    onClickView(eventData: IDataTableRowEvent): void;
+    onClickAction(action: IDataTableAction): void;
+    onClickAdd(row: IDataTableRow): void;
+    onRowClick(row: IDataTableRow, $event: any, index: number): void;
+    isActive(row: IDataTableRow): boolean;
+    onChangeExpandCollapse(row: IDataTableRow, shouldExpand: boolean): void;
+    trackByFn(index: number, item: IDataTableRow): any;
+    areChildrenVisible(row: IDataTableRow): boolean;
+    ComplexDetailClicked(eventData: IClickedEventData): void;
+    get isClientSidePagination(): boolean;
+    checkRowIsViewOnly(row: IDataTableRow): boolean;
+    checkDeleteDisabled(row: IDataTableRow): boolean;
+    isCheckboxSelect(row: IDataTableRow): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataTableBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataTableBodyComponent, "[app-data-table-body]", never, { "rows": { "alias": "rows"; "required": false; }; "viewColumns": { "alias": "viewColumns"; "required": false; }; "canInlineEdit": { "alias": "canInlineEdit"; "required": false; }; "isTreeGrid": { "alias": "isTreeGrid"; "required": false; }; "isOnlyView": { "alias": "isOnlyView"; "required": false; }; "isOnlyViewRow": { "alias": "isOnlyViewRow"; "required": false; }; "isDeleteDisabled": { "alias": "isDeleteDisabled"; "required": false; }; "isEditable": { "alias": "isEditable"; "required": false; }; "searchedRowCount$": { "alias": "searchedRowCount$"; "required": false; }; "gridOptions": { "alias": "gridOptions"; "required": false; }; "search": { "alias": "search"; "required": false; }; "paginationParams": { "alias": "paginationParams"; "required": false; }; "hasEmptyRow": { "alias": "hasEmptyRow"; "required": false; }; "isEditing": { "alias": "isEditing"; "required": false; }; "isSaving": { "alias": "isSaving"; "required": false; }; "isRowSelectionEnable": { "alias": "isRowSelectionEnable"; "required": false; }; "isCloneVisible": { "alias": "isCloneVisible"; "required": false; }; "searchColumns": { "alias": "searchColumns"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "isRowUnchecked": { "alias": "isRowUnchecked"; "required": false; }; "onAddClick": { "alias": "onAddClick"; "required": false; }; }, { "clickAction": "clickAction"; "clickEdit": "clickEdit"; "clickEditCancel": "clickEditCancel"; "clickEditSave": "clickEditSave"; "clickView": "clickView"; "clickDelete": "clickDelete"; "clickAdd": "clickAdd"; "clickRow": "clickRow"; "changeExpandCollapse": "changeExpandCollapse"; "complexDetailClicked": "complexDetailClicked"; "clickClone": "clickClone"; "matExpansionPanelClicked": "matExpansionPanelClicked"; "CheckboxSelect": "CheckboxSelect"; }, never, never, false, never>;
+}

package/modules/ui-kit/components/data-table/data-table-check-rows/data-table-check-rows.component.d.ts

@@ -0,0 +1,25 @@
+import { EventEmitter } from '@angular/core';
+import { GridOptions, IDataTableRow } from 'idp-apps-shared-ui/modules/ui-kit/interfaces/data-table.interface';
+import { SelectionModel } from '@angular/cdk/collections';
+import { GridApi } from '../api-classes/grid-api';
+import { FormService } from '../../../services/form.service';
+import { DataTableContextService } from '../services/data-table-context.service';
+import { IDataTableComponent } from '../interfaces/data-table-component.interface';
+import * as i0 from "@angular/core";
+export declare class DataTableCheckRowsComponent {
+    private dataTable;
+    private dataTableContext;
+    formService: FormService;
+    selection: SelectionModel<IDataTableRow>;
+    row: IDataTableRow;
+    gridOptions: GridOptions;
+    isRowUnchecked?: (row: IDataTableRow) => boolean;
+    CheckboxSelect: EventEmitter<IDataTableRow>;
+    gridApi: GridApi;
+    constructor(dataTable: IDataTableComponent, dataTableContext: DataTableContextService, formService: FormService);
+    get isCheckboxDisabled(): boolean;
+    selectionToggle(): void;
+    private uncheckedRowData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataTableCheckRowsComponent, [{ optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataTableCheckRowsComponent, "app-data-table-check-rows", never, { "selection": { "alias": "selection"; "required": false; }; "row": { "alias": "row"; "required": false; }; "gridOptions": { "alias": "gridOptions"; "required": false; }; "isRowUnchecked": { "alias": "isRowUnchecked"; "required": false; }; }, { "CheckboxSelect": "CheckboxSelect"; }, never, never, false, never>;
+}

package/modules/ui-kit/components/data-table/data-table-row-actions/const/data-table-actions.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum DataTableActions {
+    EDIT = "edit",
+    CLONE = "clone",
+    VIEW = "view",
+    DELETE = "delete"
+}