@one-paragon/angular-utilities 1.2.18 → 1.3.0

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

@@ -0,0 +1,66 @@
+import { CustomFilter, FilterInfo } from './filter-info';
+import { Dictionary } from '../interfaces/dictionary';
+import { Sort } from '@angular/material/sort';
+import { MetaData } from '../interfaces/report-def';
+import { NotPersistedTableSettings, PersistedTableSettings } from './table-builder-general-settings';
+import { LinkInfo } from '../services/link-creator.service';
+import { TableProps } from '../components/table-container/tableProps';
+export interface Group {
+    key: string;
+    groupName: string;
+    children: any[];
+    isGroupHeader: true;
+}
+export interface GroupedData {
+    key: string;
+    expandedHeaders: string[];
+}
+export interface PersistedTableState {
+    hiddenKeys?: string[];
+    filters: Dictionary<FilterInfo | CustomFilter>;
+    sorted: Sort[];
+    userDefined: {
+        order: Dictionary<number>;
+        widths: Dictionary<number>;
+        table: {
+            width?: number;
+        };
+        pageSize?: number;
+    };
+    persistedTableSettings: PersistedTableSettings;
+    groupBy: GroupedData[];
+}
+export interface TableState extends Required<PersistedTableState> {
+    initializationState: InitializationState;
+    metaData: Dictionary<MetaData>;
+    notPersistedTableSettings: NotPersistedTableSettings;
+    pageSize: number;
+    currentPage: number;
+    linkMaps: Dictionary<LinkInfo>;
+    props: TableProps;
+    showAll: boolean;
+}
+export interface DataState {
+    virtualScrollOffset: number;
+    virtualEnds: {
+        start: number;
+        end: number;
+    };
+    dataLen: number;
+}
+export declare const keysToDelete: string[];
+export declare enum InitializationState {
+    Created = 0,
+    MetaDataLoaded = 1,
+    LoadedFromStore = 2,
+    Ready = 3
+}
+export declare const defaultTableState: TableState;
+export declare const defaultDataState: {
+    virtualScrollOffset: number;
+    dataLen: number;
+    virtualEnds: {
+        start: number;
+        end: number;
+    };
+};

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

@@ -0,0 +1,8 @@
+import { ComponentStore } from "@ngrx/component-store";
+import { DataState } from "./TableState";
+import * as i0 from "@angular/core";
+export declare class DataStore extends ComponentStore<DataState> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataStore>;
+}

package/{src/table-builder/classes/display-col.ts → table-builder/classes/display-col.d.ts}

@@ -1,5 +1,5 @@
-export interface DisplayCol {
-    key: string;
-    displayName?: string;
-    isVisible: boolean;
-}
+export interface DisplayCol {
+    key: string;
+    displayName?: string;
+    isVisible: boolean;
+}

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

@@ -0,0 +1,35 @@
+import { FilterTypes, FilterType } from '../enums/filterTypes';
+import { FieldType } from '../interfaces/report-def';
+import { Predicate } from '@angular/core';
+export declare const filterTypeMap: Record<FieldType, FilterType[]>;
+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 {
+    filterId?: string;
+    key: string;
+    fieldType: FieldType;
+    filterType?: FilterType;
+    filterValue?: any;
+}
+export interface CustomFilter<T extends FieldType = any> extends FilterState {
+    predicate: Predicate<T>;
+    filterType: typeof FilterTypes.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;
+};
+export type FilterFuncs<T extends FilterType> = Partial<Record<T, FilterFunc<any, any>>>;

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

@@ -0,0 +1,85 @@
+import { Injector } from "@angular/core";
+export declare class GeneralTableSettings implements TableBuilderSettings {
+    headerSettings: TableWrapperHeaderSettings;
+    footerSettings: TableWrapperFooterSettings;
+    columnHeaderSettings: TableColumnHeaderSettings;
+    tableSettings: TableSettings;
+    injector?: Injector;
+}
+export interface TableBuilderSettings {
+    headerSettings?: Partial<TableWrapperHeaderSettings>;
+    footerSettings?: Partial<TableWrapperFooterSettings>;
+    columnHeaderSettings?: Partial<TableColumnHeaderSettings>;
+    tableSettings?: Partial<TableSettings>;
+    injector?: Injector;
+}
+export declare class TableWrapperHeaderSettings {
+    hideExport: boolean;
+    hideFilter: boolean;
+    hideColumnSettings: boolean;
+    hideHeader: boolean;
+    hideSort: boolean;
+    collapse: boolean;
+    showTitleWhenCollapsed: boolean;
+    headerHeight: string | number | undefined;
+}
+export declare class TableWrapperFooterSettings {
+    collapse: boolean;
+}
+export declare class TableColumnHeaderSettings {
+    noFilters: boolean;
+    noHeader: boolean;
+}
+export declare class TableSettings {
+    usePaginator: boolean;
+    useVirtualScroll: true | Partial<VirtualScrollOptions> | undefined;
+    includeAllInPaginatorOptions: boolean;
+    rowHeight: string | number | undefined;
+    groupHeaderHeight?: number;
+    minColumnWidth: number | undefined;
+}
+export declare class PersistedTableSettings {
+    constructor(tableSettings?: NonFunctionProperties<PersistedTableSettings>);
+    merge(tableSettings?: TableBuilderSettings): PersistedTableSettings;
+    collapseHeader: boolean;
+    collapseFooter: boolean;
+}
+export declare class NotPersistedTableSettings {
+    merge(tableSettings?: TableBuilderSettings): this & NotPersistedTableSettings;
+    hideExport: boolean;
+    hideFilter: boolean;
+    hideColumnSettings: boolean;
+    hideSort: boolean;
+    showTitleWhenHeaderCollapsed: boolean;
+    hideHeader: boolean;
+    hideColumnHeaderFilters: boolean;
+    hideColumnHeader: boolean;
+    usePaginator: boolean;
+    useVirtualScroll: true | Partial<VirtualScrollOptions> | undefined;
+    includeAllInPaginatorOptions: boolean;
+    groupHeaderHeight?: number;
+    rowHeight?: string | number | undefined;
+    headerHeight?: string | number;
+    minColumnWidth?: number | undefined;
+}
+export declare class VirtualScrollOptions {
+    virtualAsDefault: boolean;
+    rowHeight: number;
+    enforceRowHeight: boolean;
+    headerHeight: number;
+    enforceHeaderHeight: boolean;
+    amountOfVisibleItems: number;
+    /**
+     * This will win over `amountOfVisibleItems`
+     */
+    maxViewPortHeight: number | undefined;
+}
+export declare const DefaultVirtualScrollOptions: {
+    rowHeight: number;
+    headerHeight: number;
+};
+type NonFunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
+export type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;
+export {};

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

@@ -0,0 +1,18 @@
+import { Observable } from 'rxjs';
+import { MetaData, ReportDef } from '../interfaces/report-def';
+import { TableBuilderSettings } from './table-builder-general-settings';
+import { Signal } from '@angular/core';
+export declare class TableBuilder<T = any> {
+    metaData$: Observable<MetaData<T>[]>;
+    data$: Observable<T[]>;
+    settings: Observable<TableBuilderSettings>;
+    constructor(data: TableBuilderArgs<T[]>, metaData?: TableBuilderArgs<MetaData<T, any>[]>, settings?: TableBuilderArgs<TableBuilderSettings>);
+    getData$(): Observable<any[]>;
+    createMetaData(obj: any): MetaData[];
+    coerceToObservable<T>(arg: TableBuilderArgs<T>, settings: Observable<TableBuilderSettings>): Observable<T>;
+    coerceSettingsToObservable(settings: TableBuilderArgs<TableBuilderSettings>): Observable<TableBuilderSettings>;
+    assertInjector(s: TableBuilderSettings): void;
+}
+export declare const CreateTableBuilder: (reportDef$: Observable<ReportDef>) => TableBuilder;
+type TableBuilderArgs<T> = T | Observable<T> | Signal<T>;
+export {};

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

@@ -0,0 +1,138 @@
+import { MetaData } from '../interfaces/report-def';
+import { Observable } from 'rxjs';
+import { GroupedData, InitializationState, PersistedTableState, TableState } from './TableState';
+import { Predicate } from '@angular/core';
+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 { NonFunctionProperties, NotPersistedTableSettings, PersistedTableSettings, TableBuilderSettings } 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();
+    selectStateReady: Observable<InitializationState>;
+    getSavableState(): Observable<PersistedTableState>;
+    getSavableStateSignal: import("@angular/core").Signal<PersistedTableState>;
+    private mapSaveableState;
+    on: <V>(srcObservable: Observable<V>, func: (obj: V) => void) => this;
+    readonly metaData$: Observable<Dictionary<MetaData>>;
+    $metaData: import("@angular/core").Signal<Dictionary<MetaData>>;
+    $userDefinedOrder: import("@angular/core").Signal<Dictionary<number>>;
+    $hiddenKeys: import("@angular/core").Signal<string[]>;
+    $metaDataArray: import("@angular/core").Signal<MetaData[]>;
+    getMetaData$: (key: string) => Observable<MetaData>;
+    $getUserDefinedWidth: (key: string) => import("@angular/core").Signal<number>;
+    $getUserDefinedWidths: import("@angular/core").Signal<Dictionary<number>>;
+    tableSettingsMinWidth: import("@angular/core").Signal<number | undefined>;
+    readonly resetState: () => void;
+    readonly showColumn: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    readonly hideColumn: (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;
+    $filters: import("@angular/core").Signal<Dictionary<FilterInfo<any, any> | CustomFilter<any>>>;
+    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;
+    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[] | Observable<MetaData[]>) => import("rxjs").Subscription;
+    private initializeOrder;
+    toggleCollapseHeader: () => void;
+    toggleCollapseFooter: () => void;
+    $collapseFooter: import("@angular/core").Signal<boolean>;
+    $collapseHeader: import("@angular/core").Signal<boolean>;
+    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;
+    expandAllOfGroup: (observableOrValue: {
+        groupHeadersByKey: Dictionary<{
+            groupName: string;
+        }[]>;
+    } | Observable<{
+        groupHeadersByKey: Dictionary<{
+            groupName: string;
+        }[]>;
+    }>) => import("rxjs").Subscription;
+    collapseAll: () => void;
+    collapseAllOfKey: (observableOrValue: {
+        keys: string[];
+    } | Observable<{
+        keys: string[];
+    }>) => import("rxjs").Subscription;
+    groupByKeys$: Observable<string[]>;
+    expandedGroups$: Observable<GroupedData[]>;
+    setTableSettings: (observableOrValue: TableBuilderSettings | Observable<TableBuilderSettings>) => import("rxjs").Subscription;
+    tableSettings: import("@angular/core").Signal<NonFunctionProperties<PersistedTableSettings & NotPersistedTableSettings>>;
+    tableSettings$: Observable<NonFunctionProperties<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) => import("@angular/core").Signal<boolean>;
+    $isVirtual: import("@angular/core").Signal<boolean>;
+    $viewType: import("@angular/core").Signal<ViewType>;
+    $orderedCodeVisibleMetaDatas: import("@angular/core").Signal<MetaData[]>;
+    $orderedVisibleColumns: import("@angular/core").Signal<string[]>;
+    $currentPage: import("@angular/core").Signal<number>;
+    $pageSize: import("@angular/core").Signal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableStore>;
+}
+export declare const orderedStateVisibleMetaData: (state: TableState) => MetaData[];
+export declare const orderedCodeVisibleMetaData: (state: TableState) => MetaData[];
+export declare const orderStateMetaData: (state: TableState) => MetaData[];
+export declare const orderMetaData: (metaData: Dictionary<MetaData>, userDefined: Dictionary<number>) => MetaData[];
+export type ViewType = 'virtual paginator' | 'paginator' | 'virtual all' | 'all';

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)[]>;
+    additional: import("@angular/core").InputSignal<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)[]>;
+    additional: import("@angular/core").InputSignal<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,50 @@
+import { TemplateRef, OnInit, Predicate, Injector } from '@angular/core';
+import { FieldType, MetaData } from '../../interfaces/report-def';
+import { MatColumnDef } from '@angular/material/table';
+import { Observable } from 'rxjs';
+import { CustomCellDirective } from '../../directives';
+import { FilterInfo } from '../../classes/filter-info';
+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;
+    private state;
+    private templateService;
+    protected injector: Injector;
+    columnDef: MatColumnDef;
+    bodyTemplate: TemplateRef<any>;
+    tableConfig: import("../../classes/TableBuilderConfig").TableBuilderConfig;
+    FieldType: typeof FieldType;
+    filter: Partial<FilterInfo>;
+    _metaData: MetaData;
+    get metaData(): MetaData;
+    set metaData(md: MetaData);
+    customCell?: CustomCellDirective;
+    data$: Observable<any[]>;
+    outerTemplate: TemplateRef<any>;
+    innerTemplate: TemplateRef<any>;
+    transform: (o: any, ...args: any[]) => any;
+    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;
+    private viewInited;
+    ngAfterViewInit(): void;
+    private onViewInit;
+    whenViewInited: (callback: () => void) => void;
+    initialSetUp(): void;
+    furtherSetUp(): 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,36 @@
+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 function calculateUserDefinedWidth(userDefinedWidth: number | undefined): {
+    flex: string;
+    maxWidth: string;
+} | undefined;
+export declare function calculateTableDefinedWidth(metaData: MetaData, tableSettingsMinWidth: number | undefined): {
+    flex: string;
+} | {
+    flex: string;
+    maxWidth: string;
+};
+export declare const calculateFlexWidth: (metaData: MetaData, userDefinedWidth: number | undefined, tableSettingsMinWidth: number | undefined) => {
+    flex: string;
+} | {
+    flex: string;
+    maxWidth: string;
+};
+export declare const columnStyles: (metaData: MetaData, userDefinedWidth: number | undefined, tableSettingsMinWidth?: number | undefined) => {
+    header: Dictionary<string>;
+    body: StylerStyle;
+    footer: Dictionary<string>;
+};
+export declare const calculateFlexWidths: (metaDatas: MetaData[], userDefinedWidths: Dictionary<number>, tableSettingsMinWidth: number | undefined) => import("../../interfaces/dictionary").Dictionary<{
+    flex: string;
+} | {
+    flex: string;
+    maxWidth: string;
+}>;
+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,37 @@
+import { PartialFilter } from '../../classes/filter-info';
+import { FilterType } from '../../enums/filterTypes';
+import * as i0 from "@angular/core";
+export declare class DateFilterComponent {
+    FilterType: {
+        readonly NumberEquals: "Equals";
+        readonly NumberNotEqual: "Does Not Equal";
+        readonly NumberGreaterThan: "Greater Than";
+        readonly NumberLessThan: "Less Than";
+        readonly NumberBetween: "Between";
+        readonly StringEquals: "Equals";
+        readonly StringContains: "Contains";
+        readonly StringDoesNotContain: "Does Not Contain";
+        readonly StringStartWith: "Start With";
+        readonly StringEndsWith: "Ends With";
+        readonly DateIsOn: "Is on";
+        readonly DateIsNotOn: "Is Not On";
+        readonly DateOnOrAfter: "On or After";
+        readonly DateOnOrBefore: "On or Before";
+        readonly DateBetween: "Between";
+        readonly DateTimeIsAt: "Is At";
+        readonly DateTimeIsNotAt: "Is Not At";
+        readonly DateTimeAtOrAfter: "At or After";
+        readonly DateTimeAtOrBefore: "At or Before";
+        readonly DateTimeBetween: "Between";
+        readonly BooleanEquals: "Is";
+        readonly IsNull: "Is Blank";
+        readonly Or: "Or";
+        readonly And: "And";
+        readonly In: "In";
+        readonly Custom: "Custom";
+    };
+    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,37 @@
+import { PartialFilter } from '../../classes/filter-info';
+import { FilterType } from '../../enums/filterTypes';
+import * as i0 from "@angular/core";
+export declare class DateTimeFilterComponent {
+    FilterType: {
+        readonly NumberEquals: "Equals";
+        readonly NumberNotEqual: "Does Not Equal";
+        readonly NumberGreaterThan: "Greater Than";
+        readonly NumberLessThan: "Less Than";
+        readonly NumberBetween: "Between";
+        readonly StringEquals: "Equals";
+        readonly StringContains: "Contains";
+        readonly StringDoesNotContain: "Does Not Contain";
+        readonly StringStartWith: "Start With";
+        readonly StringEndsWith: "Ends With";
+        readonly DateIsOn: "Is on";
+        readonly DateIsNotOn: "Is Not On";
+        readonly DateOnOrAfter: "On or After";
+        readonly DateOnOrBefore: "On or Before";
+        readonly DateBetween: "Between";
+        readonly DateTimeIsAt: "Is At";
+        readonly DateTimeIsNotAt: "Is Not At";
+        readonly DateTimeAtOrAfter: "At or After";
+        readonly DateTimeAtOrBefore: "At or Before";
+        readonly DateTimeBetween: "Between";
+        readonly BooleanEquals: "Is";
+        readonly IsNull: "Is Blank";
+        readonly Or: "Or";
+        readonly And: "And";
+        readonly In: "In";
+        readonly Custom: "Custom";
+    };
+    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,46 @@
+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<T extends FieldType> {
+    protected state: TableStore;
+    filterTypes: Record<FieldType, FilterType[]>;
+    FilterType: {
+        readonly NumberEquals: "Equals";
+        readonly NumberNotEqual: "Does Not Equal";
+        readonly NumberGreaterThan: "Greater Than";
+        readonly NumberLessThan: "Less Than";
+        readonly NumberBetween: "Between";
+        readonly StringEquals: "Equals";
+        readonly StringContains: "Contains";
+        readonly StringDoesNotContain: "Does Not Contain";
+        readonly StringStartWith: "Start With";
+        readonly StringEndsWith: "Ends With";
+        readonly DateIsOn: "Is on";
+        readonly DateIsNotOn: "Is Not On";
+        readonly DateOnOrAfter: "On or After";
+        readonly DateOnOrBefore: "On or Before";
+        readonly DateBetween: "Between";
+        readonly DateTimeIsAt: "Is At";
+        readonly DateTimeIsNotAt: "Is Not At";
+        readonly DateTimeAtOrAfter: "At or After";
+        readonly DateTimeAtOrBefore: "At or Before";
+        readonly DateTimeBetween: "Between";
+        readonly BooleanEquals: "Is";
+        readonly IsNull: "Is Blank";
+        readonly Or: "Or";
+        readonly And: "And";
+        readonly In: "In";
+        readonly Custom: "Custom";
+    };
+    FieldType: typeof FieldType;
+    $filter: import("@angular/core").InputSignalWithTransform<PartialFilter, PartialFilter>;
+    close: import("@angular/core").OutputEmitterRef<void>;
+    $enteredFilterType: import("@angular/core").WritableSignal<FilterType | undefined>;
+    $currentFilterType: import("@angular/core").Signal<FilterType | undefined>;
+    $availableFilterTypes: import("@angular/core").Signal<FilterType[]>;
+    onEnter(filter: FilterInfo, event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterComponent<any>, "tb-filter", never, { "$filter": { "alias": "filter"; "required": true; "isSignal": true; }; }, { "close": "close"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,24 @@
+import { ControlValueAccessor } from '@angular/forms';
+import { Observable } from 'rxjs';
+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;
+    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,17 @@
+import { DisplayCol } from '../../classes/display-col';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import * as i0 from "@angular/core";
+export declare class GenColDisplayerComponent {
+    private tableState;
+    $columns: import("@angular/core").Signal<{
+        key: string;
+        displayName: string | undefined;
+        isVisible: boolean;
+    }[]>;
+    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>;
+}