@one-paragon/angular-utilities 0.3.11-beta.1 → 0.4.0

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

@@ -0,0 +1,127 @@
+import { FilterType } from '../enums/filterTypes';
+import { FieldType } from '../interfaces/report-def';
+import { Predicate } from '@angular/core';
+export type mappedFieldTypes = FieldType.Unknown | FieldType.Date | FieldType.DateTime | FieldType.Currency | FieldType.Array | FieldType.Number | FieldType.String | FieldType.Boolean | FieldType.PhoneNumber | FieldType.Link | FieldType.Enum;
+export declare const filterTypeMap: {
+    readonly 0: {
+        readonly Equals: FilterType.NumberEquals;
+        readonly Contains: FilterType.StringContains;
+        readonly "Does Not Contain": FilterType.StringDoesNotContain;
+        readonly "Start With": FilterType.StringStartWith;
+        readonly "Ends With": FilterType.StringEndsWith;
+        readonly "Is Blank": FilterType.IsNull;
+        readonly In: FilterType.In;
+    };
+    readonly 1: {
+        readonly "Is on": FilterType.DateIsOn;
+        readonly "Is Not On": FilterType.DateIsNotOn;
+        readonly "On or After": FilterType.DateOnOrAfter;
+        readonly "On or Before": FilterType.DateOnOrBefore;
+        readonly Between: FilterType.NumberBetween;
+        readonly "Is Blank": FilterType.IsNull;
+    };
+    readonly 13: {
+        readonly "Is At": FilterType.DateTimeIsAt;
+        readonly "Is Not At": FilterType.DateTimeIsNotAt;
+        readonly "At or After": FilterType.DateTimeAtOrAfter;
+        readonly "At or Before": FilterType.DateTimeAtOrBefore;
+        readonly Between: FilterType.NumberBetween;
+        readonly "Is on": FilterType.DateIsOn;
+        readonly "Is Not On": FilterType.DateIsNotOn;
+        readonly "On or After": FilterType.DateOnOrAfter;
+        readonly "On or Before": FilterType.DateOnOrBefore;
+        readonly "Is Blank": FilterType.IsNull;
+    };
+    readonly 4: {
+        readonly Equals: FilterType.NumberEquals;
+        readonly "Does Not Equal": FilterType.NumberNotEqual;
+        readonly "Greater Than": FilterType.NumberGreaterThan;
+        readonly "Less Than": FilterType.NumberLessThan;
+        readonly Between: FilterType.NumberBetween;
+        readonly "Is Blank": FilterType.IsNull;
+        readonly In: FilterType.In;
+    };
+    readonly 5: {
+        readonly Equals: FilterType.NumberEquals;
+        readonly Contains: FilterType.StringContains;
+        readonly "Does Not Contain": FilterType.StringDoesNotContain;
+        readonly "Start With": FilterType.StringStartWith;
+        readonly "Ends With": FilterType.StringEndsWith;
+        readonly "Is Blank": FilterType.IsNull;
+        readonly In: FilterType.In;
+    };
+    readonly 7: {
+        readonly Equals: FilterType.NumberEquals;
+        readonly "Does Not Equal": FilterType.NumberNotEqual;
+        readonly "Greater Than": FilterType.NumberGreaterThan;
+        readonly "Less Than": FilterType.NumberLessThan;
+        readonly Between: FilterType.NumberBetween;
+        readonly "Is Blank": FilterType.IsNull;
+        readonly In: FilterType.In;
+    };
+    readonly 8: {
+        readonly Equals: FilterType.NumberEquals;
+        readonly Contains: FilterType.StringContains;
+        readonly "Does Not Contain": FilterType.StringDoesNotContain;
+        readonly "Start With": FilterType.StringStartWith;
+        readonly "Ends With": FilterType.StringEndsWith;
+        readonly "Is Blank": FilterType.IsNull;
+        readonly In: FilterType.In;
+    };
+    readonly 9: {
+        readonly Is: FilterType.BooleanEquals;
+        readonly "Is Blank": FilterType.IsNull;
+    };
+    readonly 10: {
+        readonly Equals: FilterType.NumberEquals;
+        readonly Contains: FilterType.StringContains;
+        readonly "Does Not Contain": FilterType.StringDoesNotContain;
+        readonly "Start With": FilterType.StringStartWith;
+        readonly "Ends With": FilterType.StringEndsWith;
+        readonly "Is Blank": FilterType.IsNull;
+        readonly In: FilterType.In;
+    };
+    readonly 2: {
+        readonly Equals: FilterType.NumberEquals;
+        readonly Contains: FilterType.StringContains;
+        readonly "Does Not Contain": FilterType.StringDoesNotContain;
+        readonly "Start With": FilterType.StringStartWith;
+        readonly "Ends With": FilterType.StringEndsWith;
+        readonly "Is Blank": FilterType.IsNull;
+        readonly In: FilterType.In;
+    };
+    readonly 12: {
+        readonly "Is Blank": FilterType.IsNull;
+        readonly In: FilterType.In;
+    };
+};
+export interface FilterState {
+    filterId: string;
+    filterType: FilterType;
+    filterValue?: any;
+    active?: boolean;
+}
+export interface FilterInfo<T extends FieldType = any, U = any> extends FilterState {
+    key: string & keyof U;
+    fieldType: T;
+    _isExternallyManaged?: boolean;
+}
+export interface PartialFilter<T extends FieldType = any> {
+    filterId?: string;
+    key: string;
+    fieldType: T;
+    filterType?: FilterType;
+    filterValue?: any;
+}
+export interface CustomFilter<T extends FieldType = any> extends FilterState {
+    predicate: Predicate<T>;
+    filterType: FilterType.Custom;
+}
+export declare function isCustomFilter(filter: FilterInfo | CustomFilter): filter is CustomFilter;
+export declare function isFilterInfo(filter: FilterInfo | CustomFilter): filter is FilterInfo;
+export declare function createFilterFunc(filter: FilterInfo | CustomFilter): Predicate<any>;
+export type FilterFunc<T, V = T> = (filterInfo: FilterInfo) => (val: V) => boolean;
+export type Range<T> = {
+    Start: T;
+    End: T;
+};

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

@@ -0,0 +1,55 @@
+export declare class GeneralTableSettings {
+    constructor(settings?: TableBuilderSettings);
+    headerSettings: TableWrapperHeaderSettings;
+    footerSettings: TableWrapperFooterSettings;
+    columnHeaderSettings: TableColumnHeaderSettings;
+    tableSettings: TableSettings;
+}
+export interface TableBuilderSettings {
+    headerSettings?: Partial<TableWrapperHeaderSettings>;
+    footerSettings?: Partial<TableWrapperFooterSettings>;
+    columnHeaderSettings?: Partial<TableColumnHeaderSettings>;
+    tableSettings?: Partial<TableSettings>;
+}
+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 TableSettings {
+    usePaginator: boolean;
+    useVirtualScroll: true | VirtualScrollOptions | null;
+}
+export declare class PersistedTableSettings {
+    constructor(tableSettings?: GeneralTableSettings | PersistedTableSettings);
+    collapseHeader: boolean;
+    collapseFooter: boolean;
+}
+export declare class NotPersistedTableSettings {
+    constructor(tableSettings?: GeneralTableSettings);
+    hideExport: boolean;
+    hideFilter: boolean;
+    hideColumnSettings: boolean;
+    hideSort: boolean;
+    showTitleWhenHeaderCollapsed: boolean;
+    hideHeader: boolean;
+    hideColumnHeaderFilters: boolean;
+    hideColumnHeader: boolean;
+    usePaginator: boolean;
+    useVirtualScroll: true | VirtualScrollOptions | null;
+}
+export declare class VirtualScrollOptions {
+    itemHeight: number;
+    headerOffset: number;
+}

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

@@ -0,0 +1,12 @@
+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>[]> | MetaData<T, any>[], settings?: TableBuilderSettings | Observable<TableBuilderSettings>);
+    settings: Observable<GeneralTableSettings>;
+    getData$(): Observable<any[]>;
+    createMetaData(obj: any): MetaData[];
+}
+export declare const CreateTableBuilder: (reportDef$: Observable<ReportDef>) => TableBuilder;

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

@@ -0,0 +1,127 @@
+import { MetaData } from '../interfaces/report-def';
+import { Observable } from 'rxjs';
+import { 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, NotPersistedTableSettings, PersistedTableSettings } 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);
+    selectStateReady: Observable<InitializationState>;
+    getSavableState(): Observable<PersistedTableState>;
+    on: <V>(srcObservable: Observable<V>, func: (obj: V) => void) => this;
+    onLast(callback: (state: TableState) => void): void;
+    readonly metaData$: Observable<Dictionary<MetaData<any, any>>>;
+    metaDataArray: import("@angular/core").Signal<MetaData<any, any>[]>;
+    readonly metaDataArray$: Observable<MetaData<any, any>[]>;
+    getMetaData$: (key: string) => Observable<MetaData>;
+    getUserDefinedWidth$: (key: string) => Observable<number>;
+    getUserDefinedWidth: (key: string) => import("@angular/core").Signal<number>;
+    getUserDefinedWidths$: Observable<Dictionary<number>>;
+    getUserDefinedWidths: import("@angular/core").Signal<Dictionary<number>>;
+    private displayedColumns;
+    readonly displayedColumns$: Observable<any[]>;
+    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, any> | CustomFilter<any>>>;
+    readonly getFilter$: (filterId: string) => Observable<FilterInfo | CustomFilter | undefined>;
+    readonly addFilter: (observableOrValue: FilterInfo<any, any> | CustomFilter<any> | Observable<FilterInfo<any, any> | CustomFilter<any>>) => import("rxjs").Subscription;
+    readonly addFilters: (observableOrValue: (FilterInfo<any, any> | CustomFilter<any>)[] | Observable<(FilterInfo<any, 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;
+    selectSorted: Observable<Sort[]>;
+    readonly sort$: 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;
+    getPageSize: Observable<number>;
+    readonly updateState: (observableOrValue: Partial<TableState> | Observable<Partial<TableState>>) => import("rxjs").Subscription;
+    cleanPersistedState(state: TableState, pState: PersistedTableState): {
+        filters: any;
+        sorted: Sort[];
+        hiddenKeys?: string[] | undefined;
+        userDefined: {
+            order: Dictionary<number>;
+            widths: Dictionary<number>;
+            table: {
+                width?: number | undefined;
+            };
+            pageSize?: number | undefined;
+        };
+        persistedTableSettings: PersistedTableSettings;
+        groupBy: import("./TableState").GroupedData[];
+    };
+    readonly updateStateFromPersistedState: (observableOrValue: PersistedTableState | Observable<PersistedTableState>) => import("rxjs").Subscription;
+    getUserDefinedTableSize: import("@angular/core").Signal<number | undefined>;
+    getUserDefinedTableSize$: Observable<number | undefined>;
+    setTableWidth: (observableOrValue: number | Observable<number>) => import("rxjs").Subscription;
+    mergeMeta: (orig: MetaData, merge: MetaData) => MetaData;
+    readonly setInitializationState: (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, any> | MetaData<any, any>[] | Observable<MetaData<any, any> | MetaData<any, 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;
+    updateExpandedGroups: (observableOrValue: {
+        key: string;
+        groupKey: string;
+        isExpanded: boolean;
+    } | Observable<{
+        key: string;
+        groupKey: string;
+        isExpanded: boolean;
+    }>) => import("rxjs").Subscription;
+    groupByKeys$: Observable<string[]>;
+    expandedGroups$: Observable<import("./TableState").GroupedData[]>;
+    setTableSettings: (observableOrValue: GeneralTableSettings | Observable<GeneralTableSettings>) => import("rxjs").Subscription;
+    tableSettings: import("@angular/core").Signal<PersistedTableSettings & NotPersistedTableSettings>;
+    tableSettings$: Observable<PersistedTableSettings & NotPersistedTableSettings>;
+    props: import("@angular/core").Signal<import("../components/table-container/tableProps").TableProps>;
+    setLinkMaps: (() => void) | ((observableOrValue: any) => import("rxjs").Subscription);
+    getLinkInfo: (md: MetaData) => import("@angular/core").Signal<import("../services/link-creator.service").LinkInfo>;
+    getIsExpanded: (columnKey: string, groupHeaderKey: string) => Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableStore>;
+}
+export declare const orderViewableMetaData: (state: TableState) => MetaData<any, any>[];
+export declare const orderMetaData: (state: TableState) => MetaData<any, any>[];

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

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+export declare class ArrayCommaColumnComponent {
+    value: import("@angular/core").InputSignal<(string | number)[], (string | number)[]>;
+    additional: import("@angular/core").InputSignal<number, number>;
+    displayArray: import("@angular/core").Signal<(string | number)[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayCommaColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArrayCommaColumnComponent, "tb-comma-array-column", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "additional": { "alias": "additional"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class ArrayNewLineColumnComponent {
+    value: import("@angular/core").InputSignal<(string | number)[], (string | number)[]>;
+    additional: import("@angular/core").InputSignal<number, number>;
+    displayArray: import("@angular/core").Signal<(string | number)[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayNewLineColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArrayNewLineColumnComponent, "tb-new-line-array-column", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "additional": { "alias": "additional"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,47 @@
+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 { LinkInfo } from '../../services/link-creator.service';
+import * as i0 from "@angular/core";
+export declare class ColumnBuilderComponent implements OnInit {
+    private transformCreator;
+    private table;
+    state: TableStore;
+    private templateService;
+    protected injector: Injector;
+    columnDef: MatColumnDef;
+    bodyTemplate: TemplateRef<any>;
+    tableConfig: import("../../classes/TableBuilderConfig").TableBuilderConfig;
+    FieldType: typeof FieldType;
+    filter: Partial<FilterInfo>;
+    metaData: MetaData;
+    customCell?: CustomCellDirective;
+    data$: Observable<any[]>;
+    outerTemplate: TemplateRef<any>;
+    innerTemplate: TemplateRef<any>;
+    transform: (o: any, ...args: any[]) => 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>>;
+    styles: import("@angular/core").Signal<{
+        header: Dictionary<string>;
+        body: import("../../../utilities").StylerStyle;
+        footer: Dictionary<string>;
+    }>;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    cellClicked(element: any, key: string): void;
+    getTooltip: (element: any) => string;
+    additional: LinkInfo | number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnBuilderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnBuilderComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,28 @@
+import { Dictionary } from "@ngrx/entity";
+import { MetaData } from "../../interfaces/report-def";
+import { StylerStyle } from "../../../utilities/directives/styler";
+export declare const calculateWidths: (metaData: MetaData, userDefinedWidth: number | undefined) => string | undefined;
+export declare const calculateFlexWidth: (metaData: MetaData, userDefinedWidth: number | undefined) => {
+    flex: string;
+    maxWidth: string;
+} | {
+    flex: string;
+    maxWidth?: undefined;
+};
+export declare const columnStyles: (metaData: MetaData, userDefinedWidth: number | undefined) => {
+    header: Dictionary<string>;
+    body: StylerStyle;
+    footer: Dictionary<string>;
+};
+export declare const calculateFlexWidths: (metaDatas: MetaData[], userDefinedWidths: Dictionary<number>) => import("../../interfaces/dictionary").Dictionary<{
+    flex: string;
+    maxWidth: string;
+} | {
+    flex: string;
+    maxWidth?: undefined;
+}>;
+export declare const columnsStyles: (metaDatas: MetaData[], userDefinedWidths: Dictionary<number>) => import("../../interfaces/dictionary").Dictionary<{
+    header: Dictionary<string>;
+    body: StylerStyle;
+    footer: Dictionary<string>;
+}>;

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": { "alias": "info"; "required": false; }; "CurrentFilterType": { "alias": "CurrentFilterType"; "required": false; }; }, {}, never, never, true, never>;
+}

package/table-builder/components/date-time-filter/date-time-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 DateTimeFilterComponent {
+    FilterType: typeof FilterType;
+    info: PartialFilter;
+    CurrentFilterType: FilterType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateTimeFilterComponent, "tb-date-time-filter", never, { "info": { "alias": "info"; "required": false; }; "CurrentFilterType": { "alias": "CurrentFilterType"; "required": false; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,112 @@
+import { EventEmitter } from '@angular/core';
+import { FilterInfo, 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 {
+    state: TableStore;
+    filterTypes: {
+        readonly 0: {
+            readonly Equals: FilterType.NumberEquals;
+            readonly Contains: FilterType.StringContains;
+            readonly "Does Not Contain": FilterType.StringDoesNotContain;
+            readonly "Start With": FilterType.StringStartWith;
+            readonly "Ends With": FilterType.StringEndsWith;
+            readonly "Is Blank": FilterType.IsNull;
+            readonly In: FilterType.In;
+        };
+        readonly 1: {
+            readonly "Is on": FilterType.DateIsOn;
+            readonly "Is Not On": FilterType.DateIsNotOn;
+            readonly "On or After": FilterType.DateOnOrAfter;
+            readonly "On or Before": FilterType.DateOnOrBefore;
+            readonly Between: FilterType.NumberBetween;
+            readonly "Is Blank": FilterType.IsNull;
+        };
+        readonly 13: {
+            readonly "Is At": FilterType.DateTimeIsAt;
+            readonly "Is Not At": FilterType.DateTimeIsNotAt;
+            readonly "At or After": FilterType.DateTimeAtOrAfter;
+            readonly "At or Before": FilterType.DateTimeAtOrBefore;
+            readonly Between: FilterType.NumberBetween;
+            readonly "Is on": FilterType.DateIsOn;
+            readonly "Is Not On": FilterType.DateIsNotOn;
+            readonly "On or After": FilterType.DateOnOrAfter;
+            readonly "On or Before": FilterType.DateOnOrBefore;
+            readonly "Is Blank": FilterType.IsNull;
+        };
+        readonly 4: {
+            readonly Equals: FilterType.NumberEquals;
+            readonly "Does Not Equal": FilterType.NumberNotEqual;
+            readonly "Greater Than": FilterType.NumberGreaterThan;
+            readonly "Less Than": FilterType.NumberLessThan;
+            readonly Between: FilterType.NumberBetween;
+            readonly "Is Blank": FilterType.IsNull;
+            readonly In: FilterType.In;
+        };
+        readonly 5: {
+            readonly Equals: FilterType.NumberEquals;
+            readonly Contains: FilterType.StringContains;
+            readonly "Does Not Contain": FilterType.StringDoesNotContain;
+            readonly "Start With": FilterType.StringStartWith;
+            readonly "Ends With": FilterType.StringEndsWith;
+            readonly "Is Blank": FilterType.IsNull;
+            readonly In: FilterType.In;
+        };
+        readonly 7: {
+            readonly Equals: FilterType.NumberEquals;
+            readonly "Does Not Equal": FilterType.NumberNotEqual;
+            readonly "Greater Than": FilterType.NumberGreaterThan;
+            readonly "Less Than": FilterType.NumberLessThan;
+            readonly Between: FilterType.NumberBetween;
+            readonly "Is Blank": FilterType.IsNull;
+            readonly In: FilterType.In;
+        };
+        readonly 8: {
+            readonly Equals: FilterType.NumberEquals;
+            readonly Contains: FilterType.StringContains;
+            readonly "Does Not Contain": FilterType.StringDoesNotContain;
+            readonly "Start With": FilterType.StringStartWith;
+            readonly "Ends With": FilterType.StringEndsWith;
+            readonly "Is Blank": FilterType.IsNull;
+            readonly In: FilterType.In;
+        };
+        readonly 9: {
+            readonly Is: FilterType.BooleanEquals;
+            readonly "Is Blank": FilterType.IsNull;
+        };
+        readonly 10: {
+            readonly Equals: FilterType.NumberEquals;
+            readonly Contains: FilterType.StringContains;
+            readonly "Does Not Contain": FilterType.StringDoesNotContain;
+            readonly "Start With": FilterType.StringStartWith;
+            readonly "Ends With": FilterType.StringEndsWith;
+            readonly "Is Blank": FilterType.IsNull;
+            readonly In: FilterType.In;
+        };
+        readonly 2: {
+            readonly Equals: FilterType.NumberEquals;
+            readonly Contains: FilterType.StringContains;
+            readonly "Does Not Contain": FilterType.StringDoesNotContain;
+            readonly "Start With": FilterType.StringStartWith;
+            readonly "Ends With": FilterType.StringEndsWith;
+            readonly "Is Blank": FilterType.IsNull;
+            readonly In: FilterType.In;
+        };
+        readonly 12: {
+            readonly "Is Blank": FilterType.IsNull;
+            readonly In: FilterType.In;
+        };
+    };
+    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, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterComponent, "tb-filter", never, { "filter": { "alias": "filter"; "required": false; }; }, { "close": "close"; }, never, never, true, 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": { "alias": "key"; "required": false; }; }, {}, never, never, true, 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, true, never>;
+}