shared-ui-test-1 1.0.1

package/modules/ui-kit/enums/column-types.enum.d.ts

@@ -0,0 +1,8 @@
+export declare enum ColumnTypes {
+    String = "String",
+    Boolean = "Boolean",
+    Integer = "Number",
+    Reference = "Reference",
+    Nested = "Nested",
+    Date = "Date"
+}

package/modules/ui-kit/enums/component-sizes.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum ComponentSizes {
+    Large = "lg",
+    Small = "sm"
+}

package/modules/ui-kit/enums/form-item-type.d.ts

@@ -0,0 +1,5 @@
+export declare enum FormItemType {
+    Group = "group",
+    Array = "array",
+    Control = "control"
+}

package/modules/ui-kit/enums/form-types.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum FormTypes {
+    Add = "add",
+    Edit = "edit",
+    View = "view"
+}

package/modules/ui-kit/enums/form-url-params.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum FormUrlParams {
+    FormType = "formType",
+    Id = "id"
+}

package/modules/ui-kit/enums/icons.enum.d.ts

@@ -0,0 +1,22 @@
+export declare enum Icons {
+    Eye = "far fa-eye",
+    Edit = "fas fa-pencil-alt",
+    Trash = "fas fa-trash-alt",
+    Plus = "far fa-plus",
+    Save = "icon-save",
+    Cancel = "icon-cancel",
+    ChevronUp = "fas fa-chevron-up",
+    ChevronDown = "fas fa-chevron-down",
+    ChevronRight = "fa-solid fa-chevron-right",
+    Clone = "fas fa-copy",
+    ColumnSelector = "icon-column",
+    ListView = "icon-list",
+    CodeBranch = "icon-graph-view",
+    Home = "fas fa-home-lg-alt",
+    Search = "fa-solid fa-magnifying-glass",
+    Upload = "fa-solid fa-upload",
+    Sync = "fa-solid fa-rotate",
+    UPLOAD_SVG = "svg-icon-upload",
+    DOWNLOAD_SVG = "icon-download",
+    IconColumn = "icon-column"
+}

package/modules/ui-kit/enums/position.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum Position {
+    Top = "top",
+    Right = "right"
+}

package/modules/ui-kit/enums/select-option.enum.d.ts

@@ -0,0 +1,8 @@
+export declare enum SelectOptionEnum {
+    EMPTY = "",
+    DEFAULTLABEL = "Select ...",
+    SEPERATOR = ",",
+    ADDCONTROL = "addCtl",
+    LABEL = "label",
+    VALUE = "value"
+}

package/modules/ui-kit/enums/snackbar.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum SnackbarTypes {
+    Success = "Success",
+    Error = "Error",
+    Update = "Update",
+    Deleted = "Deleted"
+}

package/modules/ui-kit/enums/url-param-action.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum UrlParamActionEnum {
+    Nested = "nested",
+    Reference = "reference"
+}

package/modules/ui-kit/enums/viewType.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum ViewTypeEnum {
+    DropDown = "DropDown",
+    Link = "Link",
+    AutoComplete = "AutoComplete"
+}

package/modules/ui-kit/interfaces/api.interface.d.ts

@@ -0,0 +1,45 @@
+import { TemplateRef } from '@angular/core';
+import { IKeyValue } from 'idp-apps-shared-ui/modules/ui-kit/interfaces/generic.interface';
+import { GetSelectableFn } from 'idp-apps-shared-ui/modules/ui-kit/types/function.type';
+import { Observable } from 'rxjs';
+import { IDataTableColumn } from './data-table.interface';
+import { SortDirectionEnum } from 'idp-apps-shared-ui/enums/sort-direction.enum';
+export interface IListResApi<T> {
+    resultSet: T[];
+    page?: number;
+    itemsOnPage?: number;
+    itemsTotal?: number;
+}
+export interface IListReqParamsApi {
+    page?: number;
+    itemsOnPage?: number;
+    filterParams?: IFilterParam[];
+    activeOnly?: boolean;
+    searchText?: string;
+    sortBy?: string;
+    sortDirection?: SortDirectionEnum;
+}
+export interface IFilterParam {
+    filterColumn?: IDataTableColumn;
+    filterValue?: string | string[];
+    columnName?: string;
+    filterType?: string;
+}
+export interface IFilterOption {
+    type?: string;
+    selectableItems?: IKeyValue[];
+    selectableItems$?: Observable<IKeyValue[]>;
+    getSelectableFn$?: GetSelectableFn;
+    filterTemplate?: TemplateRef<IKeyValue>;
+    displayProp?: string;
+    minScore?: number;
+    maxScore?: number;
+    thOptions?: IKeyValue;
+    bindProp?: string;
+    initValue?: string;
+    isSearchBoxHide?: boolean;
+    dateRangeItems?: {
+        items: number[];
+        unit: 'days' | 'weeks' | 'months' | 'years';
+    };
+}

package/modules/ui-kit/interfaces/confirm-modal-data.interface.d.ts

@@ -0,0 +1,7 @@
+export interface IConfirmModalInterface {
+    message?: string[];
+    title?: string;
+    closeButtonText?: string;
+    okButtonText?: string;
+    hideCloseButton?: boolean;
+}

package/modules/ui-kit/interfaces/constants.interface.d.ts

@@ -0,0 +1,4 @@
+import { ISelectOption } from './select.interface';
+export interface IViewConstants {
+    [key: string]: ISelectOption;
+}

package/modules/ui-kit/interfaces/data-table.interface.d.ts

@@ -0,0 +1,253 @@
+import { TemplateRef } from '@angular/core';
+import { FormGroup, ValidatorFn } from '@angular/forms';
+import { ActionTypesEnum } from 'idp-apps-shared-ui/enums/action-types.enum';
+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 { BehaviorSubject, Observable } from 'rxjs';
+import { ChangeType } from '../../../modules/ui-kit/components/data-table/constants/change-type.enum';
+import { ColumnDisableModes } from '../enums/column-disable-mode.enum';
+import { ColumnTypes } from '../enums/column-types.enum';
+import { UrlParamActionEnum } from '../enums/url-param-action.enum';
+import { ViewTypeEnum } from '../enums/viewType.enum';
+import { FormatterFn, GetOptionsFn, RowDisableFn, StorageFn } from '../types/function.type';
+import { IViewConstants } from './constants.interface';
+import { ISelectOption } from './select.interface';
+import { Icons } from 'idp-apps-shared-ui/modules/ui-kit/enums/icons.enum';
+export interface IBridgeTableInfoApi {
+    id: string;
+    bridgeId: string;
+    schema?: string;
+    object?: string;
+    isSource: boolean;
+    primaryKeys?: IBridgeTableInfoPrimaryColumns[];
+    columns?: string[];
+    stewardshipColumnConfigs?: string[];
+    isPrimaryTable: boolean;
+    dataFilter: any;
+}
+export interface IBridgeTableInfoPrimaryColumns {
+    column: string;
+    order?: number;
+    isEntityUniqueKey?: boolean;
+}
+export interface IDataTableColumn<T = any> {
+    header?: string;
+    prop?: string;
+    constants?: IViewConstants;
+    formatterFn?: FormatterFn;
+    isDisabledFn?: (row: T) => boolean;
+    isVisible?: boolean;
+    isDisplayValueAsFormControl?: boolean;
+    routeRoot?: string;
+    allowMultiple?: true;
+    editDisabledMode?: ColumnDisableModes;
+    type?: ColumnTypes;
+    isReadOnly?: boolean;
+    validators?: ValidatorFn[];
+    cellValueChanged?: (item: ITableCell) => void;
+    firstValueChanged?: (item: ITableCell) => void;
+    getDropDownData?: Observable<ISelectOption[]>;
+    getDropDownOptions?: GetOptionsFn;
+    optionsForViewMode?: boolean;
+    viewType?: ViewTypeEnum;
+    rendererTemplate?: TemplateRef<any>;
+    editTemplate?: TemplateRef<any>;
+    optionTemplate?: TemplateRef<any>;
+    fixedFirstRowTemplate?: TemplateRef<any>;
+    filterOption?: IFilterOption;
+    customCssClass?: string;
+    isDeafultDisabled?: boolean;
+    source?: string;
+    isMetaDataColumn?: boolean;
+    headerIconClass?: string;
+    options?: ISelectOption[];
+    aliasName?: string;
+    tableId?: string;
+    multipleColumnNameRank?: number;
+    doubleClicked?: boolean;
+    draggable?: boolean;
+    dragged?: boolean;
+    columnName?: string;
+}
+export interface IDataTableRow<T = IDataTableRowData> {
+    isEditing: boolean;
+    isSaving: boolean;
+    isExpanded: boolean;
+    depth: number;
+    parentId: string;
+    isLocal: boolean;
+    data: T;
+    formGroup?: FormGroup;
+    isSelected?: boolean;
+    isAccordionExpanded?: boolean;
+    accordionFormData?: IKeyValue;
+    rowIndex?: number;
+}
+export interface IRowData {
+    [key: string]: any;
+}
+export interface IDataTableRowData extends IRowData {
+    children?: IDataTableRow[];
+}
+export interface IDataTableRowEvent {
+    row: IDataTableRow;
+}
+export interface IClickedEventData {
+    rowEventData: IDataTableRowEvent;
+    column: IDataTableColumn;
+    urlActionType: UrlParamActionEnum;
+}
+export interface IDataTableExpandCollapseEvent {
+    row: IDataTableRow;
+    shouldExpand: boolean;
+}
+export interface IDataTableRowSaveEvent {
+    row: IDataTableRow;
+    saveData: IRowData;
+}
+export interface IDataTableChangeLocalDataEvent {
+    rowsData: IRowData[];
+    changeType: ChangeType;
+}
+export interface IDataTableAction<T = any> {
+    type: string;
+    payload?: T;
+}
+export interface ITableCell {
+    row: IDataTableRow;
+    rowIndex: number;
+    columnIndex: number;
+    currentValue: any;
+    prevValue: any;
+}
+export interface ITopRightAction {
+    icon?: Icons;
+    name?: string;
+    title?: string;
+    clicked?(selectedRow?: any): any;
+}
+export interface IToolBarAction {
+    name?: string;
+    iconOrClassName: Icons;
+    isClass?: boolean;
+    title?: string;
+    isDisabled?: boolean;
+    actionName?: ActionTypesEnum;
+    clicked?(): any;
+    loading$?: BehaviorSubject<boolean>;
+}
+export interface IDataTableRowDeleteOptions {
+    confirmationMessage?: string[];
+}
+export interface IDataTableRowSortOptions {
+    prop?: string;
+    order?: string;
+}
+export interface IDataTableRowCloneOptions {
+    copyOfClonableProperties?: Array<string>;
+    emptyValueProperties?: Array<string>;
+}
+export interface GridOptions {
+    editable?: boolean;
+    addIdColumn?: boolean;
+    actionAddTitle?: string;
+    isOnlyView?: boolean;
+    allowSaveColumnVisibilitySettings?: boolean;
+    showhideStoragekey?: string;
+    isRowLevelViewActionVisible?: boolean;
+    columnShowhideStoragekey?: string;
+    idProperty?: string;
+    isClientSidePagination?: boolean;
+    rowNavigationProperty?: string;
+    cloneOptions?: IDataTableRowCloneOptions;
+    searchableProperties?: string[];
+    isFilterEnabled?: boolean;
+    isRowSelectionEnable?: boolean;
+    isDefaultAllRowSelected?: boolean;
+    sortableProperties?: string[];
+    defaultSortProperty?: IDataTableRowSortOptions;
+    isSearchBoxVisible?: boolean;
+    canInlineAdd?: boolean;
+    canInlineEdit?: boolean;
+    isSaveDataLocal?: boolean;
+    isSingleSelect?: boolean;
+    filterableColumns?: Array<string>;
+    isRowActionVisible?: boolean;
+    topRightActions?: Array<ITopRightAction>;
+    topLeftAdditionalActions?: Array<IToolBarAction>;
+    isTopLeftActionsForceDisply?: boolean;
+    deleteOptions?: IDataTableRowDeleteOptions;
+    searchboxPlaceholder?: string;
+    hideTopToolbar?: boolean;
+    iconTooltips?: IKeyValue;
+    refreshOnAdd?: boolean;
+    actionsPermission?: IDataTableMainActionPermission;
+    leftActionsPermission?: IKeyValue;
+    addButtonTemplate?: TemplateRef<any>;
+    accordionDesRenderTemplate?: TemplateRef<any>;
+    leftActionBtnTemplate?: TemplateRef<any>;
+    editButtonTemplate?: TemplateRef<any>;
+    deleteButtonTemplate?: TemplateRef<any>;
+    hideColumnConfiguration?: boolean;
+    hideTableHeader?: boolean;
+    defaultFirstRowSelection?: boolean;
+    isAutoColumn?: boolean;
+    renderTemplatesProp?: IKeyValue;
+    isAccordionTable?: boolean;
+    expandEnableForSave?: boolean;
+    emptyDataMessage?: string;
+    isSortEnabled?: boolean;
+    disableIcons?: {
+        [ActionTypesEnum.ADD]?: boolean;
+        [ActionTypesEnum.EDIT]?: boolean;
+        [ActionTypesEnum.DELETE]?: boolean;
+        [ActionTypesEnum.CLONE]?: boolean;
+        [ActionTypesEnum.ADD$]?: BehaviorSubject<boolean>;
+        [ActionTypesEnum.EDIT$]?: BehaviorSubject<boolean>;
+        [ActionTypesEnum.DELETE$]?: BehaviorSubject<boolean>;
+        [ActionTypesEnum.COPY$]?: BehaviorSubject<boolean>;
+    };
+    gridMenuOptions?: IGridMenuOptions;
+    editExtraRouteParam?: string;
+    storageFn?: StorageFn;
+    metaDataColumns?: string[];
+    customTableStyle?: IKeyValue;
+    customColumnStyle?: IKeyValue;
+    isInnerScroll?: boolean;
+    isUpdatedTableDesign?: boolean;
+    newTableButtontemplate?: TemplateRef<any>;
+    isTransparentTableDesign?: boolean;
+    isSelectedRowBlock?: boolean;
+    rowDisableFn?: RowDisableFn;
+    hasFixedFirstRow?: boolean;
+    isTrackByDisabled?: boolean;
+    actionLoading$?: {
+        [ActionTypesEnum.EDIT$]?: BehaviorSubject<boolean>;
+        [ActionTypesEnum.DELETE$]?: BehaviorSubject<boolean>;
+        [ActionTypesEnum.COPY$]?: BehaviorSubject<boolean>;
+    };
+    fixedWidthData?: boolean;
+    draggable?: boolean;
+    hasDropdownStylePageSize?: boolean;
+}
+export interface IGridMenuOptions {
+    isMenuEnabled: boolean;
+    menuItems?: IGridMatMenuItem[];
+}
+export interface IGridMatMenuItem {
+    matIconName: string;
+    iconText: string;
+    clicked?(args: IDataTableRowData): void;
+}
+export interface ICheckedRowEvent {
+    pageMatchedPreviousCheckedRows: IDataTableRow[];
+    pageUnmatchedCheckedRows: IDataTableRow[];
+}
+export interface IDataTableMainActionPermission {
+    [ActionTypesEnum.ADD]?: string;
+    [ActionTypesEnum.EDIT]?: string;
+    [ActionTypesEnum.VIEW]?: string;
+    [ActionTypesEnum.DELETE]?: string;
+    [ActionTypesEnum.CLONE]?: string;
+    [ActionTypesEnum.COPY]?: string;
+}

package/modules/ui-kit/interfaces/form.interface.d.ts

@@ -0,0 +1,21 @@
+import { FormGroup, ValidatorFn } from '@angular/forms';
+import { FormItemType } from '../enums/form-item-type';
+import { FormTypes } from '../enums/form-types.enum';
+export interface IBaseFormItem {
+    prop: string;
+    type?: FormItemType;
+    initValue?: any;
+    validators?: ValidatorFn[];
+}
+export interface IFormGroupItem extends IBaseFormItem {
+    group?: UnionFormItem[];
+}
+export interface IInitFormEvent {
+    formGroup: FormGroup;
+    formType: FormTypes;
+    formData: IFormData;
+}
+export interface IFormData {
+    [key: string]: any;
+}
+export type UnionFormItem = IFormGroupItem;

package/modules/ui-kit/interfaces/generic.interface.d.ts

@@ -0,0 +1,7 @@
+export interface IKeyValue<T = any> {
+    [key: string]: T;
+}
+export interface IPaginationParams {
+    currentPage: number;
+    pageSize: number;
+}

package/modules/ui-kit/interfaces/list-item.interface.d.ts

@@ -0,0 +1,5 @@
+export interface ListItem {
+    header?: string;
+    prop?: string;
+    isMetadataColumn?: boolean;
+}

package/modules/ui-kit/interfaces/mat-action-buttons.interface.d.ts

@@ -0,0 +1,14 @@
+import { TemplateRef } from '@angular/core';
+import { Observable } from 'rxjs';
+export interface IActionsButton {
+    name: string;
+    clickHandler?: (data?: any) => void;
+    customTemplate?: TemplateRef<any>;
+    iconClassName?: string;
+    className?: string;
+    isDisabled$?: Observable<boolean>;
+    tooltipText?: string;
+    isIconShow$?: Observable<boolean>;
+    actionPermission?: string;
+    childActions?: IActionsButton[];
+}

package/modules/ui-kit/interfaces/row-selection-info.interface.d.ts

@@ -0,0 +1,7 @@
+import { GridApi } from "idp-apps-shared-ui/modules/ui-kit/components/data-table/api-classes/grid-api";
+import { IDataTableRow } from "idp-apps-shared-ui/modules/ui-kit/interfaces/data-table.interface";
+export interface IRowSelectionInfo {
+    rows: IDataTableRow[];
+    gridApi: GridApi;
+    checked?: boolean;
+}

package/modules/ui-kit/interfaces/select.interface.d.ts

@@ -0,0 +1,8 @@
+import { SelectOptionValue } from '../types/select.type';
+import { IListResApi } from './api.interface';
+export interface ISelectOption {
+    label: string;
+    value: SelectOptionValue;
+}
+export interface ISelectApi extends IListResApi<ISelectOption> {
+}

package/modules/ui-kit/interfaces/snackbar.interface.d.ts

@@ -0,0 +1,4 @@
+export interface DataSnackbar {
+    message?: string;
+    title?: string;
+}

package/modules/ui-kit/interfaces/tree-view.interface.d.ts

@@ -0,0 +1,49 @@
+export interface IDataTreeViewSchema {
+    schemaName: string;
+    databaseName: string;
+    expandFlag: boolean;
+    tables: IDataTreeViewTable[];
+    isLoading?: boolean;
+    selected?: boolean;
+}
+export interface IUsedColumns {
+    sourceFields: IDataColumnsMatchGroup[];
+    referenceFields: IDataColumnsMatchGroup[];
+}
+export interface IDataColumnsMatchGroup {
+    tableName: string;
+    columnName: string;
+}
+export interface IDataTreeViewTable {
+    tableName: string;
+    schemaName: string;
+    databaseName: string;
+    expandFlag: boolean;
+    selected: boolean;
+    disabled?: boolean;
+    isLoading?: boolean;
+    attributes: IDataTreeViewAttribute[];
+    isPrimaryTable?: boolean;
+    isMenuOpen?: boolean;
+    actionVisible?: boolean;
+    hideAction?: boolean;
+}
+export interface IDataTreeViewAttribute {
+    attributeName: string;
+    displayName?: string;
+    primaryKey: boolean;
+    isEntityUniqueKey?: string;
+    selected: boolean;
+    disabled?: boolean;
+    hideAction?: boolean;
+    isHeader?: boolean;
+    isSubheader?: boolean;
+    isMenuOpen?: boolean;
+    actionVisible?: boolean;
+    expandFlag?: boolean;
+    dataType: string;
+}
+export interface ItreeConfig {
+    hidePrimaryKeyAction?: boolean;
+    showisEntityUniqueKey?: boolean;
+}

package/modules/ui-kit/pipes/column-filter.pipe.d.ts

@@ -0,0 +1,12 @@
+import { PipeTransform } from '@angular/core';
+import { DataTableService } from 'idp-apps-shared-ui/modules/ui-kit/services/data-table.service';
+import { IFilterParam } from '../interfaces/api.interface';
+import { IDataTableColumn, IDataTableRow } from '../interfaces/data-table.interface';
+import * as i0 from "@angular/core";
+export declare class ColumnFilterPipe implements PipeTransform {
+    private dataTableService;
+    constructor(dataTableService: DataTableService);
+    transform(items: IDataTableRow[], filterParams: IFilterParam[], columns?: IDataTableColumn[], isClientSidePagination?: boolean): IDataTableRow[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnFilterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ColumnFilterPipe, "columnFilter", false>;
+}

package/modules/ui-kit/pipes/filter-by-prop.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { IKeyValue } from 'idp-apps-shared-ui/modules/ui-kit/interfaces/generic.interface';
+import * as i0 from "@angular/core";
+export declare class FilterByPropPipe implements PipeTransform {
+    constructor();
+    transform(items: any[], prop: string, filterValue: string): IKeyValue[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterByPropPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FilterByPropPipe, "filterByProp", false>;
+}

package/modules/ui-kit/pipes/first-letter-text.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FirstLetterTextPipe implements PipeTransform {
+    transform(value: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FirstLetterTextPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FirstLetterTextPipe, "firstLetterText", false>;
+}

package/modules/ui-kit/pipes/keys.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class KeysPipe implements PipeTransform {
+    transform(value: object): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeysPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<KeysPipe, "keys", false>;
+}

package/modules/ui-kit/pipes/paginate.pipe.d.ts

@@ -0,0 +1,12 @@
+import { PipeTransform } from '@angular/core';
+import { IDataTableRow } from 'idp-apps-shared-ui/modules/ui-kit/interfaces/data-table.interface';
+import { IPaginationParams } from 'idp-apps-shared-ui/modules/ui-kit/interfaces/generic.interface';
+import * as i0 from "@angular/core";
+export declare class PaginatePipe implements PipeTransform {
+    transform(rows: IDataTableRow[], paginationParams: IPaginationParams, isClientSidePagination: boolean): any;
+    private static getStartIndex;
+    private static getEndIndex;
+    private static getRows;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PaginatePipe, "paginate", false>;
+}

package/modules/ui-kit/pipes/search.pipe.d.ts

@@ -0,0 +1,16 @@
+import { PipeTransform } from '@angular/core';
+import { Subject } from 'rxjs';
+import { DataTableService } from 'idp-apps-shared-ui/modules/ui-kit/services/data-table.service';
+import { IDataTableColumn, IDataTableRow } from '../interfaces/data-table.interface';
+import * as i0 from "@angular/core";
+export declare class SearchPipe implements PipeTransform {
+    private dataTableService;
+    constructor(dataTableService: DataTableService);
+    transform(items: any[], search: string, columns?: IDataTableColumn[], isClientSidePagination?: boolean, searchedRowCount$?: Subject<number>): IDataTableRow[];
+    private findItem;
+    private getAllProperties;
+    private isMatched;
+    private ifDefinedAndNotNull;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SearchPipe, "search", false>;
+}

package/modules/ui-kit/services/data-table.service.d.ts

@@ -0,0 +1,37 @@
+import { Subject } from 'rxjs';
+import { IDataTableColumn, IDataTableRow, IRowData, IDataTableRowData } from '../interfaces/data-table.interface';
+import { IKeyValue } from '../interfaces/generic.interface';
+import { SelectOptionValue } from '../types/select.type';
+import { IFilterParam } from '../interfaces/api.interface';
+import * as i0 from "@angular/core";
+export declare class DataTableService {
+    searchedRowCount$: Subject<number>;
+    private filterValueExecutorProvider;
+    private FILTER_TYPES;
+    getRowDataId(rowData: IRowData): string;
+    getRowId(row: IDataTableRow): string;
+    getValueByPropertyName(row: IDataTableRow, propertyName: string): string;
+    isEmptyRow(row: IDataTableRow): boolean;
+    isEmptyRowData(rowData: IRowData): boolean;
+    getRowsFromRowsData(rowsData: IRowData[]): IDataTableRow[];
+    applyFilter(filterParams: IFilterParam[], columns: IDataTableColumn[], dataRows: IDataTableRow[]): IDataTableRow[];
+    formatValue(colValue: SelectOptionValue, column: IDataTableColumn, rowData: IDataTableRowData): string;
+    getRowsDataFromRows(rows: IDataTableRow[]): IRowData[];
+    mapRowsToRowsDataRecursively(rows: IDataTableRow[]): IRowData[];
+    getRowDataFromRow(row: IDataTableRow): IRowData;
+    getRow(rowData?: IKeyValue, depth?: number, parentId?: string, isLocal?: boolean): IDataTableRow;
+    hasRowChildren(row: IDataTableRow): boolean;
+    getEmptyRowData(viewColumns: IDataTableColumn[], defaultRowValues: IKeyValue): IKeyValue;
+    getRowsWithInsertedRow(parentId: string, rows: IDataTableRow[], insertedRow: IDataTableRow): IDataTableRow[];
+    insertRowByParentIdRecursively(parentId: string, rows: IDataTableRow[], insertedRow: IDataTableRow, isFound?: boolean): void;
+    getRowsWithRemovedRow(searchRowId: string, rows: IDataTableRow[]): IDataTableRow[];
+    removeRowByIdRecursively(searchRowId: string, rows: IDataTableRow[], isFound?: boolean): void;
+    getNewRowId(): string;
+    setEmptyValuesInRowData(row: IDataTableRow, columns: IDataTableColumn[]): void;
+    matchWithFilterValue(rowValue: any, column: any, row: any, filterParam: any): boolean;
+    private mapDataRowsToRows;
+    private getEmptyColumnVal;
+    private getColStringVal;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataTableService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataTableService>;
+}