@one-paragon/angular-utilities 0.1.21 → 0.1.23

package/table-builder/classes/table-builder-general-settings.d.ts

@@ -0,0 +1,43 @@
+export declare class GeneralTableSettings {
+    constructor(settings?: TableBuilderSettings);
+    headerSettings: TableWrapperHeaderSettings;
+    footerSettings: TableWrapperFooterSettings;
+    columnHeaderSettings: TableColumnHeaderSettings;
+}
+export interface TableBuilderSettings {
+    headerSettings?: Partial<TableWrapperHeaderSettings>;
+    footerSettings?: Partial<TableWrapperFooterSettings>;
+    columnHeaderSettings?: Partial<TableColumnHeaderSettings>;
+}
+export declare class TableWrapperHeaderSettings {
+    hideExport: boolean;
+    hideFilter: boolean;
+    hideColumnSettings: boolean;
+    hideHeader: boolean;
+    hideSort: boolean;
+    collapse: boolean;
+    showTitleWhenCollapsed: boolean;
+}
+export declare class TableWrapperFooterSettings {
+    collapse: boolean;
+}
+export declare class TableColumnHeaderSettings {
+    noFilters: boolean;
+    noHeader: boolean;
+}
+export declare class PesrsistedTableSettings {
+    constructor(tableSettings?: GeneralTableSettings | PesrsistedTableSettings);
+    collapseHeader: boolean;
+    collapseFooter: boolean;
+}
+export declare class NotPersisitedTableSettings {
+    constructor(tableSettings?: GeneralTableSettings);
+    hideExport: boolean;
+    hideFilter: boolean;
+    hideColumnSettings: boolean;
+    hideSort: boolean;
+    showTitleWhenHeaderCollapsed: boolean;
+    hideHeader: boolean;
+    hideColumnHeaderFilters: boolean;
+    hideColumnHeader: boolean;
+}

package/table-builder/classes/table-builder.d.ts

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+import { MetaData, ReportDef } from '../interfaces/report-def';
+import { GeneralTableSettings, TableBuilderSettings } from './table-builder-general-settings';
+export declare class TableBuilder<T = any> {
+    private data$;
+    metaData$: Observable<MetaData<T>[]>;
+    constructor(data$: Observable<T[]>, metaData$?: Observable<MetaData<T, any>[]>, settings?: TableBuilderSettings | Observable<TableBuilderSettings>);
+    settings: Observable<GeneralTableSettings>;
+    getData$(): Observable<any[]>;
+    createMetaData(obj: any): MetaData[];
+    cleanVal(val: any, metaData: MetaData): any;
+    cleanRecord(record: T, metadata: MetaData[]): T;
+}
+export declare const CreateTableBuilder: (reportDef$: Observable<ReportDef>) => TableBuilder;

package/table-builder/classes/table-store.d.ts

@@ -0,0 +1,114 @@
+import { MetaData } from '../interfaces/report-def';
+import { Observable } from 'rxjs';
+import { Group, InitializationState, PersistedTableState, TableState } from './TableState';
+import { Predicate } from '@angular/core';
+import { TableBuilderConfig } from './TableBuilderConfig';
+import { CustomFilter, FilterInfo } from './filter-info';
+import { Sort, SortDirection } from '@angular/material/sort';
+import { ComponentStore } from '@ngrx/component-store';
+import { Dictionary } from '../interfaces/dictionary';
+import { GeneralTableSettings, NotPersisitedTableSettings, PesrsistedTableSettings } from './table-builder-general-settings';
+import * as i0 from "@angular/core";
+export declare function stateIs(initializationState: InitializationState): (state: TableState) => boolean;
+export declare class TableStore extends ComponentStore<TableState> {
+    constructor(config: TableBuilderConfig);
+    getSavableState(): Observable<PersistedTableState>;
+    on: <V>(srcObservable: Observable<V>, func: (obj: V) => void) => void;
+    onLast(callback: (state: TableState) => void): void;
+    readonly metaData$: Observable<Dictionary<MetaData<any, []>>>;
+    readonly metaDataArray$: Observable<MetaData<any, []>[]>;
+    getMetaData$: (key: string) => Observable<MetaData>;
+    getUserDefinedWidth$: (key: string) => Observable<number>;
+    getUserDefinedWidths$: Observable<Dictionary<number>>;
+    private displayedColumns;
+    readonly displayedColumns$: Observable<string[]>;
+    readonly hideColumn: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    readonly resetState: () => void;
+    readonly showColumn: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    readonly setHiddenColumns: (observableOrValue: {
+        key: string;
+        visible: boolean;
+    }[] | Observable<{
+        key: string;
+        visible: boolean;
+    }[]>) => import("rxjs").Subscription;
+    setUserDefinedWidth: (observableOrValue: {
+        key: string;
+        widthInPixel: number;
+    }[] | Observable<{
+        key: string;
+        widthInPixel: number;
+    }[]>) => import("rxjs").Subscription;
+    setUserDefinedOrder: (observableOrValue: {
+        newOrder: number;
+        oldOrder: number;
+    } | Observable<{
+        newOrder: number;
+        oldOrder: number;
+    }>) => import("rxjs").Subscription;
+    readonly filters$: Observable<Dictionary<FilterInfo<any> | CustomFilter<any>>>;
+    readonly getFilter$: (filterId: string) => Observable<FilterInfo | CustomFilter | undefined>;
+    readonly addFilter: (observableOrValue: FilterInfo<any> | CustomFilter<any> | Observable<FilterInfo<any> | CustomFilter<any>>) => import("rxjs").Subscription;
+    readonly addFilters: (observableOrValue: (FilterInfo<any> | CustomFilter<any>)[] | Observable<(FilterInfo<any> | CustomFilter<any>)[]>) => import("rxjs").Subscription;
+    private addFiltersToState;
+    readonly removeFilter: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    readonly removeFilters: (observableOrValue: string[] | Observable<string[]>) => import("rxjs").Subscription;
+    readonly clearFilters: () => void;
+    readonly sorted$: Observable<Sort[]>;
+    createPreSort: (metaDatas: Dictionary<MetaData>) => Sort[];
+    readonly setSort: (observableOrValue: {
+        key: string;
+        direction?: SortDirection | undefined;
+    } | Observable<{
+        key: string;
+        direction?: SortDirection | undefined;
+    }>) => import("rxjs").Subscription;
+    readonly setAllSort: (observableOrValue: Sort[] | Observable<Sort[]>) => import("rxjs").Subscription;
+    updateStateFunc: (state: TableState, incomingTableState: Partial<TableState>) => TableState;
+    readonly setPageSize: (observableOrValue: number | Observable<number>) => import("rxjs").Subscription;
+    readonly updateState: (observableOrValue: Partial<TableState> | Observable<Partial<TableState>>) => import("rxjs").Subscription;
+    cleanPersistedState(state: TableState, pState: PersistedTableState): {
+        filters: any;
+        sorted: Sort[];
+        hiddenKeys?: string[] | undefined;
+        pageSize?: number | undefined;
+        userDefined: {
+            order: Dictionary<number>;
+            widths: Dictionary<number>;
+            table: {
+                width?: number | undefined;
+            };
+        };
+        persistedTableSettings: PesrsistedTableSettings;
+        groupByKeys: string[];
+        groups: Group[];
+    };
+    readonly updateStateFromPersistedState: (observableOrValue: PersistedTableState | Observable<PersistedTableState>) => import("rxjs").Subscription;
+    getUserDefinedTableSize$: Observable<number | undefined>;
+    setTableWidth: (observableOrValue: number | Observable<number>) => import("rxjs").Subscription;
+    mergeMeta: (orig: MetaData, merge: MetaData) => MetaData;
+    readonly setIntializationState: (observableOrValue: InitializationState | Observable<InitializationState>) => import("rxjs").Subscription;
+    runOnceWhen(predicate: Predicate<TableState>, func: (state: TableState) => void): void;
+    onReady(func: (state: TableState) => void): void;
+    readonly setMetaData: (observableOrValue: MetaData<any, []> | MetaData<any, []>[] | Observable<MetaData<any, []> | MetaData<any, []>[]>) => import("rxjs").Subscription;
+    private initializeOrder;
+    toggleCollapseHeader: () => void;
+    toggleCollapseFooter: () => void;
+    addGroupByKey: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    removeGroupByKey: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    updateGroup: (observableOrValue: Group | Observable<Group>) => import("rxjs").Subscription;
+    groupByKeys$: Observable<string[]>;
+    groups$: Observable<Group[]>;
+    setTableSettings: (observableOrValue: GeneralTableSettings | Observable<GeneralTableSettings>) => import("rxjs").Subscription;
+    tableSettings$: Observable<PesrsistedTableSettings & NotPersisitedTableSettings>;
+    setLinkMaps: (() => void) | ((observableOrValue: any) => import("rxjs").Subscription);
+    getLinkMap: (md: MetaData) => Observable<{
+        link: (t: any) => string;
+        useRouterLink: boolean;
+        target: import("../interfaces/report-def").Target;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableStore>;
+}
+export declare const orderViewableMetaData: (state: TableState) => MetaData<any, []>[];
+export declare const orderMetaData: (state: TableState) => MetaData<any, []>[];

package/table-builder/components/array-column.component.d.ts

@@ -0,0 +1,14 @@
+import { ArrayStyle, ArrayAdditional, MetaData } from '../interfaces/report-def';
+import { TableBuilderConfig } from '../classes/TableBuilderConfig';
+import * as i0 from "@angular/core";
+export declare class ArrayColumnComponent {
+    private config;
+    ArrayStyle: typeof ArrayStyle;
+    additional: ArrayAdditional;
+    array: any[];
+    metaData: MetaData;
+    constructor(config: TableBuilderConfig);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArrayColumnComponent, "tb-array-column", never, { "array": "array"; "metaData": "metaData"; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,50 @@
+import { TemplateRef, OnInit, Predicate, Injector } from '@angular/core';
+import { FieldType, MetaData } from '../../interfaces/report-def';
+import { MatColumnDef, MatTable } from '@angular/material/table';
+import { Observable } from 'rxjs';
+import { CustomCellDirective } from '../../directives';
+import { FilterInfo } from '../../classes/filter-info';
+import { TransformCreator } from '../../services/transform-creator';
+import { TableStore } from '../../classes/table-store';
+import { TableTemplateService } from '../../services/table-template-service';
+import { Dictionary } from '@ngrx/entity';
+import * as i0 from "@angular/core";
+interface widthStyle {
+    flex?: string;
+    maxWidth?: string;
+}
+interface allStyles {
+    body: widthStyle;
+    header: widthStyle;
+    footer: widthStyle;
+}
+export declare class ColumnBuilderComponent implements OnInit {
+    private transformCreator;
+    private table;
+    state: TableStore;
+    private templateService;
+    protected injector: Injector;
+    FieldType: typeof FieldType;
+    filter: Partial<FilterInfo>;
+    metaData: MetaData;
+    customCell: CustomCellDirective;
+    data$: Observable<any[]>;
+    columnDef: MatColumnDef;
+    outerTemplate: TemplateRef<any>;
+    innerTemplate: TemplateRef<any>;
+    transform: (o: any, ...args: any[]) => any;
+    bodyTemplate: TemplateRef<any>;
+    constructor(transformCreator: TransformCreator, table: MatTable<any>, state: TableStore, templateService: TableTemplateService, injector: Injector);
+    getInnerTemplate(): TemplateRef<any>;
+    showfilters$: Observable<boolean>;
+    getOuterTemplate(): TemplateRef<any>;
+    classes?: Dictionary<Predicate<any>>;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    cellClicked(element: any, key: string): void;
+    mapWidth: ([previousUserDefinedWidth, currentUserDefinedWidth]: [number, number]) => widthStyle;
+    styles$: Observable<allStyles>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnBuilderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnBuilderComponent, "tb-column-builder", never, { "metaData": "metaData"; "customCell": "customCell"; "data$": "data$"; }, {}, never, never, false, never>;
+}
+export {};

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

@@ -0,0 +1,10 @@
+import { PartialFilter } from '../../classes/filter-info';
+import { FilterType } from '../../enums/filterTypes';
+import * as i0 from "@angular/core";
+export declare class DateFilterComponent {
+    FilterType: typeof FilterType;
+    info: PartialFilter;
+    CurrentFilterType: FilterType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateFilterComponent, "tb-date-filter", never, { "info": "info"; "CurrentFilterType": "CurrentFilterType"; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,294 @@
+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[];
+            Custom: 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[];
+            Custom: 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[];
+            Custom: 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[];
+            Custom: 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[];
+            Custom: 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[];
+            Custom: 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[];
+            Custom: 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[];
+            Custom: 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[];
+            Custom: 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[];
+            Custom: 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[];
+            Custom: 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[];
+            Custom: 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[];
+            Custom: 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, false, 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 , [tb-in-list-filter]", never, { "key": "key"; }, {}, never, never, false, 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, false, never>;
+}

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

@@ -0,0 +1,71 @@
+import { SimpleChanges, OnInit, QueryList, ViewContainerRef, ElementRef, Injector, TemplateRef } 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 { CdkDragDrop, CdkDropList } from '@angular/cdk/drag-drop';
+import { Group } from '../../classes/TableState';
+import * as i0 from "@angular/core";
+export declare class GenericTableComponent implements OnInit {
+    private sort;
+    state: TableStore;
+    private viewContainer;
+    drop(event: CdkDragDrop<string[]>): void;
+    data$: Observable<any[]>;
+    IndexColumn: boolean;
+    SelectionColumn: boolean;
+    trackBy: string;
+    rows: QueryList<MatRowDef<any>>;
+    isSticky: boolean;
+    columnBuilders: ColumnBuilderComponent[];
+    columnInfos: Observable<ColumnInfo[]>;
+    groupHeaderTemplate: TemplateRef<any>;
+    private _disableSort;
+    set disableSort(val: boolean);
+    get disableSort(): boolean;
+    table: MatTable<any>;
+    dropList: CdkDropList;
+    tableElRef: ElementRef;
+    currentColumns: string[];
+    dataSource: GenericTableDataSource<any>;
+    keys: string[];
+    injector: Injector;
+    rowDefArr: MatRowDef<any>[];
+    columns: string[];
+    myColumns: Dictionary<ColumnBuilderComponent>;
+    showHeader$: Observable<boolean>;
+    constructor(sort: MatSort, state: TableStore, viewContainer: ViewContainerRef, injector: Injector);
+    trackByFunction: (index: number, item: any) => any;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    createDataSource(): void;
+    isGroupHeader(_: number, row: {
+        isGroupHeader: boolean;
+    }): boolean;
+    isGroupFooter(_: number, row: {
+        isGroupFooter: boolean;
+    }): boolean;
+    updateGroup(group: Group): void;
+    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;
+    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"; "groupHeaderTemplate": "groupHeaderTemplate"; "disableSort": "disableSort"; }, { "selection$": "selection$"; }, never, never, false, never>;
+}