@one-paragon/angular-utilities 0.0.1 → 0.0.6

package/table-builder/components/filter/filter.component.d.ts

@@ -0,0 +1,281 @@
+import { EventEmitter } from '@angular/core';
+import { FilterInfo, UnmappedTypes, mappedFieldTypes, PartialFilter } from '../../classes/filter-info';
+import { TableStore } from '../../classes/table-store';
+import { FilterType } from '../../enums/filterTypes';
+import { FieldType } from '../../interfaces/report-def';
+import * as i0 from "@angular/core";
+export declare class FilterComponent<T extends mappedFieldTypes = any> {
+    state: TableStore;
+    filterTypes: Omit<{
+        0: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+        }>;
+        1: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+        }>;
+        2: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+        }>;
+        3: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+        }>;
+        4: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+        }>;
+        5: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+        }>;
+        6: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+        }>;
+        7: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+        }>;
+        8: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+        }>;
+        9: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+        }>;
+        10: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+        }>;
+        11: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+        }>;
+        12: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+        }>;
+    }, UnmappedTypes>;
+    FilterType: typeof FilterType;
+    FieldType: typeof FieldType;
+    filter: PartialFilter;
+    close: EventEmitter<any>;
+    currentFilterType?: FilterType;
+    constructor(state: TableStore);
+    ngOnInit(): void;
+    onEnter(filter: FilterInfo, event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterComponent<any>, "tb-filter", never, { "filter": "filter"; }, { "close": "close"; }, never, never>;
+}

package/table-builder/components/filter/in-list/in-list-filter.component.d.ts

@@ -0,0 +1,27 @@
+import { ChangeDetectorRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { TableStore } from '../../../classes/table-store';
+import { Dictionary } from '../../../interfaces/dictionary';
+import { FieldType, MetaData } from '../../../interfaces/report-def';
+import * as i0 from "@angular/core";
+export declare class InListFilterComponent implements ControlValueAccessor {
+    private ref;
+    private tableState;
+    constructor(ref: ChangeDetectorRef, tableState: TableStore);
+    value: string[];
+    FieldType: typeof FieldType;
+    writeValue(obj: string[]): void;
+    onChange: (_: any) => void;
+    registerOnChange(fn: any): void;
+    onTouched: () => void;
+    registerOnTouched(fn: any): void;
+    key: string;
+    keyValues$: Observable<Dictionary<string>>;
+    selectedKeys: string[];
+    metaData: MetaData;
+    ngOnInit(): void;
+    selectFilterChanged($event: any, val: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InListFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InListFilterComponent, "tb-in-list-filter", never, { "key": "key"; }, {}, never, never>;
+}

package/table-builder/components/gen-col-displayer/gen-col-displayer.component.d.ts

@@ -0,0 +1,16 @@
+import { DisplayCol } from '../../classes/display-col';
+import { Observable } from 'rxjs';
+import { TableStore } from '../../classes/table-store';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import * as i0 from "@angular/core";
+export declare class GenColDisplayerComponent {
+    private tableState;
+    columns$: Observable<DisplayCol[]>;
+    constructor(tableState: TableStore);
+    reset(displayCols: DisplayCol[]): void;
+    drop(event: CdkDragDrop<string[]>): void;
+    unset(displayCols: DisplayCol[]): void;
+    emit(displayCols: DisplayCol[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenColDisplayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GenColDisplayerComponent, "tb-col-displayer", never, {}, {}, never, never>;
+}

package/table-builder/components/generic-table/generic-table.component.d.ts

@@ -0,0 +1,57 @@
+import { SimpleChanges, OnInit, QueryList, ComponentFactoryResolver, ViewContainerRef, ElementRef, ComponentFactory, Injector } from '@angular/core';
+import { MatSort } from '@angular/material/sort';
+import { MatRowDef, MatTable } from '@angular/material/table';
+import { Observable } from 'rxjs';
+import { SelectionModel } from '@angular/cdk/collections';
+import { TableStore } from '../../classes/table-store';
+import { ColumnBuilderComponent } from '../column-builder/column-builder.component';
+import { Dictionary } from '../../interfaces/dictionary';
+import { GenericTableDataSource } from '../../classes/GenericTableDataSource';
+import { ColumnInfo } from '../../interfaces/ColumnInfo';
+import * as i0 from "@angular/core";
+export declare class GenericTableComponent implements OnInit {
+    private sort;
+    state: TableStore;
+    private viewContainer;
+    data$: Observable<any[]>;
+    IndexColumn: boolean;
+    SelectionColumn: boolean;
+    trackBy: string;
+    rows: QueryList<MatRowDef<any>>;
+    isSticky: boolean;
+    columnBuilders: ColumnBuilderComponent[];
+    columnInfos: Observable<ColumnInfo[]>;
+    table: MatTable<any>;
+    tableElRef: ElementRef;
+    currentColumns: string[];
+    dataSource: GenericTableDataSource<any>;
+    keys: string[];
+    factory: ComponentFactory<ColumnBuilderComponent>;
+    injector: Injector;
+    constructor(sort: MatSort, state: TableStore, componentFactoryResolver: ComponentFactoryResolver, viewContainer: ViewContainerRef, injector: Injector);
+    trackByFunction: (index: number, item: any) => any;
+    rowDefArr: MatRowDef<any>[];
+    columns: string[];
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    createDataSource(): void;
+    myColumns: Dictionary<ColumnBuilderComponent>;
+    addMetaData(column: ColumnInfo): void;
+    initializeRowDefs: (defs: MatRowDef<any>[]) => void;
+    selection: SelectionModel<any>;
+    selection$: Observable<any>;
+    masterToggleChecked$: Observable<boolean>;
+    masterToggleIndeterminate$: Observable<boolean>;
+    isAllSelected(): boolean;
+    /** Selects all rows if they are not all selected; otherwise clear selection. */
+    masterToggle(): void;
+    defVal: number | undefined;
+    tableWidth: Observable<{
+        width: string;
+    } | {
+        width?: undefined;
+    }>;
+    collapseFooter$: Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenericTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GenericTableComponent, "tb-generic-table", never, { "data$": "data$"; "IndexColumn": "IndexColumn"; "SelectionColumn": "SelectionColumn"; "trackBy": "trackBy"; "rows": "rows"; "isSticky": "isSticky"; "columnBuilders": "columnBuilders"; "columnInfos": "columnInfos"; }, { "selection$": "selection$"; }, never, never>;
+}

package/table-builder/components/generic-table/paginator.component.d.ts

@@ -0,0 +1,28 @@
+import { ElementRef, AfterViewInit, OnInit } from '@angular/core';
+import { MatPaginator } from '@angular/material/paginator';
+import { Observable } from 'rxjs';
+import { GenericTableDataSource } from '../../classes/GenericTableDataSource';
+import { TableStore } from '../../classes/table-store';
+import * as i0 from "@angular/core";
+export declare class PaginatorComponent implements OnInit, AfterViewInit {
+    private state;
+    dataSource: GenericTableDataSource<any>;
+    tableElRef: ElementRef;
+    paginator: MatPaginator;
+    currentPageData$: Observable<CurrentPageDetails>;
+    collapseFooter$: Observable<boolean>;
+    data$: Observable<any[]>;
+    constructor(state: TableStore);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    paginatorChange(): void;
+    ourPageEvent: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PaginatorComponent, "tb-paginator", never, { "dataSource": "dataSource"; "tableElRef": "tableElRef"; "data$": "data$"; }, {}, never, never>;
+}
+interface CurrentPageDetails {
+    currentStart: number;
+    currentEnd: number;
+    total: number;
+}
+export {};

package/table-builder/components/header-menu/header-menu.component.d.ts

@@ -0,0 +1,25 @@
+import { FieldType, MetaData } from '../../interfaces/report-def';
+import { FilterType } from '../../enums/filterTypes';
+import { FilterInfo } from '../../classes/filter-info';
+import { TableStore } from '../../classes/table-store';
+import { MatMenuTrigger } from '@angular/material/menu';
+import * as i0 from "@angular/core";
+export declare class HeaderMenuComponent {
+    tableState: TableStore;
+    FieldType: typeof FieldType;
+    FilterType: typeof FilterType;
+    myFilterType: FilterType;
+    myFilterValue: any;
+    filter: Partial<FilterInfo>;
+    metaData: MetaData;
+    trigger: MatMenuTrigger;
+    constructor(tableState: TableStore);
+    hideField(key: string): void;
+    ngOnInit(): void;
+    resetFilterType(): void;
+    setStringFilterType(): void;
+    setFilterType(filterType: FilterType): void;
+    onEnter(filter: FilterInfo): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderMenuComponent, "tb-header-menu", never, { "filter": "filter"; "metaData": "metaData"; }, {}, never, never>;
+}

package/table-builder/components/in-filter/in-filter.component.d.ts

@@ -0,0 +1,22 @@
+import { ChangeDetectorRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { FieldType } from '../../interfaces/report-def';
+import * as i0 from "@angular/core";
+export declare class InFilterComponent implements ControlValueAccessor {
+    private ref;
+    FieldType: typeof FieldType;
+    type: FieldType;
+    value: any[];
+    constructor(ref: ChangeDetectorRef);
+    writeValue(obj: any[]): void;
+    onChange: (_: any) => void;
+    registerOnChange(fn: any): void;
+    onTouched: () => void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    addInput(): void;
+    removeInput(index: number): void;
+    onValueChange(i: number, value: number | string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InFilterComponent, "lib-in-filter", never, { "type": "type"; }, {}, never, never>;
+}

package/table-builder/components/index.d.ts

@@ -0,0 +1,8 @@
+export * from './date-filter/date-filter.component';
+export * from './filter/filter.component';
+export * from './gen-col-displayer/gen-col-displayer.component';
+export * from './table-container-filter/gen-filter-displayer/gen-filter-displayer.component';
+export * from './table-container-filter/filter-list/filter-list.component';
+export * from './generic-table/generic-table.component';
+export * from './table-container/table-container';
+export * from './generic-table/paginator.component';

package/table-builder/components/initialization-component/initialization-component.d.ts

@@ -0,0 +1,14 @@
+import { TemplateRef } from "@angular/core";
+import * as i0 from "@angular/core";
+export declare class InitializationComponent {
+    booleanTemplate: TemplateRef<any>;
+    linkTemplate: TemplateRef<any>;
+    imageUrlTemplate: TemplateRef<any>;
+    currencyTemplate: TemplateRef<any>;
+    arrayTemplate: TemplateRef<any>;
+    expressionTemplate: TemplateRef<any>;
+    defaultTemplate: TemplateRef<any>;
+    enumTemplate: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InitializationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InitializationComponent, "ng-component", never, {}, {}, never, never>;
+}

package/table-builder/components/number-filter/number-filter.component.d.ts

@@ -0,0 +1,12 @@
+import { FilterType } from '../../enums/filterTypes';
+import { PartialFilter } from '../../classes/filter-info';
+import { FieldType } from '../../interfaces/report-def';
+import * as i0 from "@angular/core";
+export declare class NumberFilterComponent {
+    FilterType: typeof FilterType;
+    FieldType: typeof FieldType;
+    CurrentFilterType: FilterType;
+    info: PartialFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NumberFilterComponent, "tb-number-filter", never, { "CurrentFilterType": "CurrentFilterType"; "info": "info"; }, {}, never, never>;
+}

package/table-builder/components/sort-menu/sort-menu.component-store.d.ts

@@ -0,0 +1,24 @@
+import { Sort } from '@angular/material/sort';
+import { ComponentStore } from '@ngrx/component-store';
+import { TableStore } from '../../classes/table-store';
+import * as i0 from "@angular/core";
+export declare class SortMenuComponentStore extends ComponentStore<ComponenStoreState> {
+    private tableState;
+    constructor(tableState: TableStore);
+    private set;
+    setSorted: (observableOrValue: SortWithName[] | import("rxjs").Observable<SortWithName[]>) => import("rxjs").Subscription;
+    setNotSorted: (observableOrValue: SortWithName[] | import("rxjs").Observable<SortWithName[]>) => import("rxjs").Subscription;
+    sorted$: import("rxjs").Observable<SortWithName[]>;
+    notSorted$: import("rxjs").Observable<SortWithName[]>;
+    setDirection: (observableOrValue: SortWithName | import("rxjs").Observable<SortWithName>) => import("rxjs").Subscription;
+    reset: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortMenuComponentStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SortMenuComponentStore>;
+}
+export interface ComponenStoreState {
+    sorted: SortWithName[];
+    notSorted: SortWithName[];
+}
+export interface SortWithName extends Sort {
+    displayName: string;
+}

package/table-builder/components/sort-menu/sort-menu.component.d.ts

@@ -0,0 +1,25 @@
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { OnInit } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { Observable } from 'rxjs';
+import { TableStore } from '../../classes/table-store';
+import { SortDirection } from '../../interfaces/report-def';
+import { SortMenuComponentStore, SortWithName } from './sort-menu.component-store';
+import * as i0 from "@angular/core";
+export declare class SortMenuComponent implements OnInit {
+    private tableState;
+    store: SortMenuComponentStore;
+    sorted$: Observable<SortWithName[]>;
+    notSorted$: Observable<SortWithName[]>;
+    SortDirection: typeof SortDirection;
+    dirty$: BehaviorSubject<boolean>;
+    constructor(tableState: TableStore, store: SortMenuComponentStore);
+    reset(): void;
+    ngOnInit(): void;
+    dropIntoSorted(event: CdkDragDrop<SortWithName[]>): void;
+    dropIntoNotSorted(event: CdkDragDrop<SortWithName[]>): void;
+    apply: (observableOrValue: Observable<null> | null) => import("rxjs").Subscription;
+    setDirection(sort: SortWithName): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SortMenuComponent, "tb-sort-menu", never, {}, {}, never, never>;
+}

package/table-builder/components/table-container/table-container.d.ts

@@ -0,0 +1,65 @@
+import { EventEmitter, QueryList } from '@angular/core';
+import { Observable, ReplaySubject } from 'rxjs';
+import { MetaData } from '../../interfaces/report-def';
+import { TableBuilder } from '../../classes/table-builder';
+import { MatRowDef } from '@angular/material/table';
+import { CustomCellDirective } from '../../directives';
+import { TableStore } from '../../classes/table-store';
+import { ExportToCsvService } from '../../services/export-to-csv.service';
+import { TableBuilderConfig } from '../../classes/TableBuilderConfig';
+import { Store } from '@ngrx/store';
+import { PersistedTableState } from '../../classes/TableState';
+import { ColumnInfo } from '../../interfaces/ColumnInfo';
+import * as i0 from "@angular/core";
+export declare class TableContainerComponent<T = any> {
+    state: TableStore;
+    exportToCsvService: ExportToCsvService<T>;
+    private config;
+    private store;
+    tableId: string;
+    SaveState: boolean;
+    tableBuilder: TableBuilder;
+    IndexColumn: boolean;
+    SelectionColumn: boolean;
+    trackBy: string;
+    isSticky: boolean;
+    set pageSize(value: number);
+    inputFilters: Observable<Array<(val: T) => boolean>>;
+    selection$: EventEmitter<any>;
+    dataSubject: ReplaySubject<Observable<T[]>>;
+    data: Observable<T[]>;
+    customRows: QueryList<MatRowDef<any>>;
+    customCells: QueryList<CustomCellDirective>;
+    OnStateReset: EventEmitter<any>;
+    OnSaveState: EventEmitter<any>;
+    state$: Observable<PersistedTableState>;
+    myColumns$: Observable<ColumnInfo[]>;
+    stateKeys$?: Observable<string[] | null>;
+    currentStateKey$?: Observable<string>;
+    constructor(state: TableStore, exportToCsvService: ExportToCsvService<T>, config: TableBuilderConfig, store: Store<any>);
+    ngOnInit(): void;
+    exportToCsv(): void;
+    saveState(): void;
+    setProfileState(val: string): void;
+    deleteProfileState(stateKey: string): void;
+    ngAfterContentInit(): void;
+    InitializeColumns(): void;
+    mapMetaDatas: (meta: MetaData<T>) => MetaData<T>;
+    cleanStateOnInitialLoad: () => (obs: Observable<PersistedTableState>) => Observable<{
+        filters: any;
+        sorted: import("@angular/material/sort").Sort[];
+        hiddenKeys?: string[] | undefined;
+        pageSize?: number | undefined;
+        userDefined: {
+            order: import("../../interfaces/dictionary").Dictionary<number>;
+            widths: import("../../interfaces/dictionary").Dictionary<number>;
+            table: {
+                width?: number | undefined;
+            };
+        };
+        persistedTableSettings: import("../../classes/table-builder-general-settings").PesrsistedTableSettings;
+    }>;
+    collapseHeader$: Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableContainerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableContainerComponent<any>, "tb-table-container", never, { "tableId": "tableId"; "SaveState": "SaveState"; "tableBuilder": "tableBuilder"; "IndexColumn": "IndexColumn"; "SelectionColumn": "SelectionColumn"; "trackBy": "trackBy"; "isSticky": "isSticky"; "pageSize": "pageSize"; "inputFilters": "inputFilters"; }, { "selection$": "selection$"; "data": "data"; "OnStateReset": "OnStateReset"; "OnSaveState": "OnSaveState"; "state$": "state$"; }, ["customRows", "customCells"], [".tb-header-title"]>;
+}

package/table-builder/components/table-container-filter/filter-list/filter-list.component.d.ts

@@ -0,0 +1,17 @@
+import { TableStore } from '../../../classes/table-store';
+import { FilterInfo } from '../../../classes/filter-info';
+import { WrapperFilterStore } from '../table-wrapper-filter-store';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class FilterChipsComponent {
+    tableState: TableStore;
+    private filterStore;
+    constructor(tableState: TableStore, filterStore: WrapperFilterStore);
+    filters$: Observable<FilterInfo<any>[]>;
+    deleteByIndex(index: number): void;
+    addFilter(filter: FilterInfo<any>): void;
+    clearAll(): void;
+    currentFilters$: Observable<import("../../../classes/filter-info").PartialFilter<any>[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterChipsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterChipsComponent, "lib-filter-list", never, {}, {}, never, never>;
+}

package/table-builder/components/table-container-filter/gen-filter-displayer/gen-filter-displayer.component.d.ts

@@ -0,0 +1,14 @@
+import { MetaData } from '../../../interfaces/report-def';
+import { Observable } from 'rxjs';
+import { TableStore } from '../../../classes/table-store';
+import { WrapperFilterStore } from '../table-wrapper-filter-store';
+import * as i0 from "@angular/core";
+export declare class GenFilterDisplayerComponent {
+    tableState: TableStore;
+    filterStore: WrapperFilterStore;
+    constructor(tableState: TableStore, filterStore: WrapperFilterStore);
+    filterCols$: Observable<MetaData[]>;
+    addFilter(metaData: MetaData): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenFilterDisplayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GenFilterDisplayerComponent, "tb-filter-displayer", never, {}, {}, never, never>;
+}