@one-paragon/angular-utilities 1.1.8 → 1.2.1

package/table-builder/directives/custom-cell-directive.d.ts

@@ -0,0 +1,31 @@
+import { TemplateRef, AfterContentInit } from '@angular/core';
+import { CdkColumnDef } from '@angular/cdk/table';
+import { SortDef, MetaData } from '../interfaces/report-def';
+import { TableBuilder } from '../classes/table-builder';
+import * as i0 from "@angular/core";
+interface CustomCellContext<T> {
+    $implicit: T;
+    element: T;
+}
+export declare class CustomCellDirective<T = any> implements AfterContentInit {
+    private templateRef;
+    columnDef: CdkColumnDef;
+    customCell: string;
+    displayName?: string;
+    preSort?: SortDef;
+    TemplateRef: TemplateRef<any>;
+    customCellOrder?: number;
+    customCellWidth?: string;
+    customCellTableRef?: TableBuilder<T>;
+    /**
+     * true if column not mapped to a property in the data source. Default is false.
+     */
+    customCellNotMapped: boolean;
+    constructor(templateRef: TemplateRef<any>, columnDef: CdkColumnDef);
+    ngAfterContentInit(): void;
+    getMetaData(metaData?: MetaData): MetaData;
+    static ngTemplateContextGuard<T>(dir: CustomCellDirective<T>, ctx: any): ctx is CustomCellContext<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomCellDirective<any>, [{ optional: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CustomCellDirective<any>, "[customCell]", never, { "customCell": { "alias": "customCell"; "required": false; }; "displayName": { "alias": "displayName"; "required": false; }; "preSort": { "alias": "preSort"; "required": false; }; "TemplateRef": { "alias": "TemplateRef"; "required": false; }; "customCellOrder": { "alias": "customCellOrder"; "required": false; }; "customCellWidth": { "alias": "customCellWidth"; "required": false; }; "customCellTableRef": { "alias": "customCellTableRef"; "required": false; }; "customCellNotMapped": { "alias": "customCellNotMapped"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/{src/table-builder/directives/index.ts → table-builder/directives/index.d.ts}

@@ -1,6 +1,5 @@
-export * from './custom-cell-directive';
-export * from './multi-sort.directive';
-export * from './resize-column.directive';
-export * from './table-wrapper.directive';
-export * from './tb-filter.directive';
-
+export * from './custom-cell-directive';
+export * from './multi-sort.directive';
+export * from './resize-column.directive';
+export * from './table-wrapper.directive';
+export * from './tb-filter.directive';

package/table-builder/directives/multi-sort.directive.d.ts

@@ -0,0 +1,11 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { MatSort, Sort } from '@angular/material/sort';
+import { TableStore } from '../classes/table-store';
+import * as i0 from "@angular/core";
+export declare class MultiSortDirective extends MatSort implements OnInit, OnDestroy {
+    private state;
+    constructor(state: TableStore);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSortDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MultiSortDirective, "[multiSort]", ["multiSort"], { "disabled": { "alias": "matSortDisabled"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare function isDifferent(a: Sort[], b: Sort[]): boolean;

package/table-builder/directives/resize-column.directive.d.ts

@@ -0,0 +1,44 @@
+import { OnInit, Renderer2, ElementRef } from "@angular/core";
+import { TableStore } from "../classes/table-store";
+import * as i0 from "@angular/core";
+export declare class ResizeColumnDirective implements OnInit {
+    private renderer;
+    private el;
+    store: TableStore;
+    resizable: boolean | string;
+    key: string;
+    constructor(renderer: Renderer2, el: ElementRef, store: TableStore);
+    ngOnInit(): void;
+    createResizerSpanInColumnHead(columnHead: HTMLElement): any;
+    getTableAndColumnHeadHtmlElements(): {
+        table: HTMLElement;
+        columnHead: HTMLElement;
+    };
+    mouseDownThroughMouseUpEventMapper(resizer: HTMLElement, columnHead: HTMLElement, table: HTMLElement): import("rxjs").Observable<{
+        mouseDownData: {
+            startPageX: number;
+            startColumnWidth: number;
+            startTableWidth: number;
+        };
+        mouseMove: MouseEvent;
+    }>;
+    resizerMouseDownEventMapper(resizer: HTMLElement, columnHead: HTMLElement, table: HTMLElement): import("rxjs").Observable<{
+        startPageX: number;
+        startColumnWidth: number;
+        startTableWidth: number;
+    }>;
+    calculateNewWidths(mouseDownData: MouseDownData, mouseMove: MouseEvent): {
+        newTableWidth: number;
+        newColumnWidth: number;
+    };
+    getElementWidth: (elem: HTMLElement) => number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeColumnDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeColumnDirective, "[resizeColumn]", never, { "resizable": { "alias": "resizeColumn"; "required": false; }; "key": { "alias": "key"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_resizable: unknown;
+}
+interface MouseDownData {
+    startPageX: number;
+    startColumnWidth: number;
+    startTableWidth: number;
+}
+export {};

package/table-builder/directives/table-wrapper.directive.d.ts

@@ -0,0 +1,8 @@
+import { TableCustomFilterDirective, TableFilterDirective } from "./tb-filter.directive";
+import * as i0 from "@angular/core";
+export declare class TableWrapperDirective {
+    registrations: (TableCustomFilterDirective | TableFilterDirective)[];
+    register(filter: TableCustomFilterDirective | TableFilterDirective): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableWrapperDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableWrapperDirective, "[tbWrapper]", never, {}, {}, never, never, true, never>;
+}

package/table-builder/directives/tb-filter.directive.d.ts

@@ -0,0 +1,120 @@
+import { Predicate, SimpleChanges } from "@angular/core";
+import { Observable, ReplaySubject, Subject } from "rxjs";
+import { CustomFilter, FilterInfo } from "../classes/filter-info";
+import { FilterType } from "../enums/filterTypes";
+import { MatSlideToggle } from "@angular/material/slide-toggle";
+import { MatRadioButton } from "@angular/material/radio";
+import { MatButtonToggle } from '@angular/material/button-toggle';
+import { MatCheckbox } from "@angular/material/checkbox";
+import { FieldType } from "../interfaces/report-def";
+import { NgControl } from "@angular/forms";
+import { ComponentStore } from "@ngrx/component-store";
+import { TableWrapperDirective } from "./table-wrapper.directive";
+import { MatOption } from "@angular/material/core";
+import * as i0 from "@angular/core";
+export declare abstract class TableCustomFilterDirective<T = any> {
+    abstract filter$: Observable<CustomFilter>;
+    filterId: string;
+    savable: boolean;
+    used: boolean;
+    abstract active: boolean;
+    abstract reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCustomFilterDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableCustomFilterDirective<any>, " ", never, {}, {}, never, never, false, never>;
+}
+export declare class TableFilterDirective extends ComponentStore<FilterInfo> {
+    protected model: NgControl;
+    constructor(model: NgControl, wrapper: TableWrapperDirective);
+    reset(): void;
+    filter$: Observable<FilterInfo<any, any>>;
+    filterType: FilterType;
+    key: string;
+    fieldType: FieldType;
+    filterId: string;
+    active: boolean;
+    filterValue: any;
+    setFilterValue(value: any): void;
+    used: boolean;
+    savable: boolean;
+    ready: boolean;
+    _userActive: boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    protected setFilter(filter: FilterInfo): void;
+    update(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableFilterDirective, [{ optional: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableFilterDirective, "[tbFilter]", never, { "filterType": { "alias": "filterType"; "required": false; }; "key": { "alias": "key"; "required": false; }; "fieldType": { "alias": "fieldType"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; "active": { "alias": "active"; "required": false; }; "filterValue": { "alias": "filterValue"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class TableFilterStringContainsDirective extends TableFilterDirective {
+    constructor(model: NgControl, wrapper: TableWrapperDirective);
+    reset(): void;
+    setFilter(filter: FilterInfo): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableFilterStringContainsDirective, [{ optional: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableFilterStringContainsDirective, "[tbFilterStringContains]", never, { "key": { "alias": "tbFilterStringContains"; "required": false; }; "filterValue": { "alias": "filterValue"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare abstract class TableCustomFilterDirectiveBase<T = any> extends TableCustomFilterDirective<T> {
+    filter$: Subject<CustomFilter>;
+    filter: CustomFilter;
+    filterId: string;
+    _predicate: Predicate<T>;
+    set predicate(val: Predicate<T>);
+    _active: boolean;
+    ready: boolean;
+    update(val: Partial<CustomFilter>): void;
+    set active(val: boolean);
+    get active(): boolean;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCustomFilterDirectiveBase<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableCustomFilterDirectiveBase<any>, "[tbCustomFilter]", never, { "filterId": { "alias": "filterId"; "required": false; }; "predicate": { "alias": "tbCustomFilter"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, never, never, false, never>;
+}
+export declare abstract class TbSelectedFilterDirective<T = any> extends TableCustomFilterDirectiveBase<T> {
+    private change;
+    private isActive;
+    protected constructor(change: Observable<any>, isActive: () => boolean, wrapper: TableWrapperDirective);
+    reset(): void;
+    destroySubject$: ReplaySubject<void>;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TbSelectedFilterDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TbSelectedFilterDirective<any>, never, never, {}, {}, never, never, false, never>;
+}
+export declare class MatCheckboxTbFilterDirective extends TbSelectedFilterDirective {
+    private matCheckbox;
+    set active(val: boolean);
+    constructor(matCheckbox: MatCheckbox, wrapper: TableWrapperDirective);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatCheckboxTbFilterDirective, [null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatCheckboxTbFilterDirective, "mat-checkbox[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class MatSlideToggleTbFilterDirective<T = any> extends TbSelectedFilterDirective<T> {
+    private matSlideToggle;
+    set active(val: boolean);
+    constructor(matSlideToggle: MatSlideToggle, wrapper: TableWrapperDirective);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSlideToggleTbFilterDirective<any>, [null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatSlideToggleTbFilterDirective<any>, "mat-slide-toggle[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class MatRadioButtonTbFilterDirective extends TbSelectedFilterDirective {
+    private matRadioButton;
+    set active(val: boolean);
+    constructor(matRadioButton: MatRadioButton, wrapper: TableWrapperDirective);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatRadioButtonTbFilterDirective, [null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatRadioButtonTbFilterDirective, "mat-radio-button[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class MatOptionTbFilterDirective extends TbSelectedFilterDirective {
+    private matOption;
+    set active(val: boolean);
+    constructor(matOption: MatOption, wrapper: TableWrapperDirective);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatOptionTbFilterDirective, [null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatOptionTbFilterDirective, "mat-option[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class MatButtonToggleFilterDirective extends TbSelectedFilterDirective {
+    private matButtonToggle;
+    set active(val: boolean);
+    constructor(matButtonToggle: MatButtonToggle, wrapper: TableWrapperDirective);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatButtonToggleFilterDirective, [null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatButtonToggleFilterDirective, "mat-button-toggle[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; }, {}, never, never, true, never>;
+}

package/table-builder/enums/filterTypes.d.ts

@@ -0,0 +1,77 @@
+export declare enum FilterType {
+    NumberEquals = "Equals",
+    NumberNotEqual = "Does Not Equal",
+    NumberGreaterThan = "Greater Than",
+    NumberLessThan = "Less Than",
+    NumberBetween = "Between",
+    StringEquals = "Equals",
+    StringContains = "Contains",
+    StringDoesNotContain = "Does Not Contain",
+    StringStartWith = "Start With",
+    StringEndsWith = "Ends With",
+    DateIsOn = "Is on",
+    DateIsNotOn = "Is Not On",
+    DateOnOrAfter = "On or After",
+    DateOnOrBefore = "On or Before",
+    DateBetween = "Between",
+    DateTimeIsAt = "Is At",
+    DateTimeIsNotAt = "Is Not At",
+    DateTimeAtOrAfter = "At or After",
+    DateTimeAtOrBefore = "At or Before",
+    DateTimeBetween = "Between",
+    BooleanEquals = "Is",
+    IsNull = "Is Blank",
+    Or = "Or",
+    And = "And",
+    In = "In",
+    Custom = "Custom"
+}
+export declare const NumberFilterMap: {
+    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;
+};
+export declare const StringFilterMap: {
+    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;
+};
+export declare const DateFilterMap: {
+    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;
+};
+export declare const DateTimeFilterMap: {
+    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;
+};
+export declare const BooleanFilterMap: {
+    readonly Is: FilterType.BooleanEquals;
+    readonly "Is Blank": FilterType.IsNull;
+};
+export declare const EnumFilterMap: {
+    readonly "Is Blank": FilterType.IsNull;
+    readonly In: FilterType.In;
+};
+export type FilterToFiltersMap = Partial<{
+    [key in FilterType]: FilterType;
+}>;

package/table-builder/functions/boolean-filter-function.d.ts

@@ -0,0 +1,3 @@
+import { FilterFunc } from '../classes/filter-info';
+import { Dictionary } from '../interfaces/dictionary';
+export declare const BooleanFilterFuncs: Dictionary<FilterFunc<any, any>>;

package/table-builder/functions/date-filter-function.d.ts

@@ -0,0 +1,4 @@
+import { FilterFunc } from '../classes/filter-info';
+import { Dictionary } from '../interfaces/dictionary';
+export declare const DateFilterFuncs: Dictionary<FilterFunc<any, any>>;
+export declare const DateTimeFilterFuncs: Dictionary<FilterFunc<any, any>>;

package/table-builder/functions/download-data.d.ts

@@ -0,0 +1 @@
+export declare function downloadData(data: string, filename: string, mimeType: string): void;

package/table-builder/functions/null-filter-function.d.ts

@@ -0,0 +1,2 @@
+import { FilterFunc } from '../classes/filter-info';
+export declare const isNull: FilterFunc<boolean, any>;

package/table-builder/functions/number-filter-function.d.ts

@@ -0,0 +1,4 @@
+import { FilterFunc } from '../classes/filter-info';
+import { Dictionary } from '../interfaces/dictionary';
+export declare const multipleNumberValuesEqualsFunc: FilterFunc<number[], number>;
+export declare const NumberFilterFuncs: Dictionary<FilterFunc<any, any>>;

package/table-builder/functions/sort-data-function.d.ts

@@ -0,0 +1,6 @@
+import { Sort } from "@angular/material/sort";
+import { Predicate } from "@angular/core";
+export type direc = 'asc' | 'desc' | boolean;
+export declare function sortData<T>(data: T[], sorted: Sort[]): T[];
+export declare function filterData<T>(data: T[], filters: Predicate<T>[], resetAll?: boolean): T[];
+export declare const tbNoShowSymbol: unique symbol;

package/table-builder/functions/string-filter-function.d.ts

@@ -0,0 +1,7 @@
+import { FilterFunc } from '../classes/filter-info';
+import { Dictionary } from '../interfaces/dictionary';
+export declare const StringFilterFuncs: {
+    [k: string]: FilterFunc<any, any>;
+};
+export declare const EnumFilterFuncs: Dictionary<FilterFunc<any, any>>;
+export declare const prepareForStringCompare: (val: any) => string;

package/{src/table-builder/interfaces/ColumnInfo.ts → table-builder/interfaces/ColumnInfo.d.ts}

@@ -1,7 +1,6 @@
-import { CustomCellDirective } from "../directives/custom-cell-directive";
-import { MetaData } from "./report-def";
-
-export interface ColumnInfo {
-  metaData: MetaData;
-  customCell: CustomCellDirective;
-}
+import { CustomCellDirective } from "../directives/custom-cell-directive";
+import { MetaData } from "./report-def";
+export interface ColumnInfo {
+    metaData: MetaData;
+    customCell: CustomCellDirective;
+}

package/{src/table-builder/interfaces/dictionary.ts → table-builder/interfaces/dictionary.d.ts}

@@ -1,3 +1,3 @@
-export interface Dictionary<T> {
-  [key: string]: T;
-}
+export interface Dictionary<T> {
+    [key: string]: T;
+}

package/table-builder/interfaces/report-def.d.ts

@@ -0,0 +1,147 @@
+import { Dictionary } from './dictionary';
+import { PipeTransform, Predicate, TemplateRef } from '@angular/core';
+import { TableBuilderExport } from '../classes/TableBuilderConfig';
+import { QueryParamsHandling } from '@angular/router';
+export declare enum FieldType {
+    Unknown = 0,
+    Date = 1,
+    Link = 2,
+    ImageUrl = 3,
+    Currency = 4,
+    Array = 5,
+    Hidden = 6,
+    Number = 7,
+    String = 8,
+    Boolean = 9,
+    PhoneNumber = 10,
+    /**
+     * @deprecated For mapped properties use proper type (for sorting and filtering) with `map`.
+     * For unmapped properties use `FieldType.NotMapped` with map.
+     */
+    Expression = 11,
+    Enum = 12,
+    DateTime = 13,
+    NotMapped = 14
+}
+export declare enum SortDirection {
+    asc = "asc",
+    desc = "desc"
+}
+export declare enum Target {
+    Blank = "_blank",
+    Self = "_self",
+    Parent = "_parent",
+    Top = "_top"
+}
+interface BaseMeta<T = any> {
+    displayName?: string;
+    additional?: Additional<T>;
+    order?: number;
+    preSort?: SortDef;
+    width?: string;
+    noExport?: boolean;
+    noFilter?: boolean;
+    noSort?: boolean;
+    customCell?: boolean;
+    /**
+     * @deprecated Please use map instead
+     */
+    transform?: ((o: T, ...args: any[]) => any) | ((o: string, ...args: any[]) => any) | PipeTransform;
+    click?: (element: T, key: string) => void;
+    template?: TemplateRef<any>;
+    classes?: Dictionary<Predicate<T>>;
+    toolTip?: string | ((t: T) => string);
+    useIcon?: boolean;
+    map?: (t: T) => any;
+}
+interface MappedMetaData<T = any, AdditionalFields extends string[] = []> extends BaseMeta<T> {
+    key: (keyof T | AdditionalFields[number]) & string;
+    fieldType: Exclude<typeof FieldType[keyof typeof FieldType], FieldType.NotMapped | FieldType.Expression>;
+}
+export type MetaData<T = any, AdditionalFields extends string[] = []> = MappedMetaData<T, AdditionalFields> | NotMappedMetaData<T>;
+export interface NotMappedMetaData<T = any> extends BaseMeta<T> {
+    key: string;
+    fieldType: FieldType.NotMapped | FieldType.Expression;
+}
+export interface ReportDef<DataType = any> {
+    data: DataType[];
+    metaData: MetaData[];
+    totalRecords?: number;
+    count: number;
+}
+export interface SortDef {
+    direction: SortDirection;
+    precedence?: number;
+}
+export interface FilterOptions {
+    filterableValues: string[];
+}
+export interface DateTimeOptions {
+    format?: string;
+    includeSeconds?: boolean;
+    includeMilliseconds: boolean;
+}
+type interpolatedRoute = string;
+export interface Additional<T = any> {
+    link?: {
+        base?: string;
+        urlKey?: string;
+        target?: Target;
+        useRouterLink?: boolean;
+        /**
+         * If you want to use a route with interpolated params, you can use this. Wrap the property name in curly braces.
+         * For example, if interpolatedRoute = /users/{id}/edit, {id} will be replaced with the value of the element's id property.
+         */
+        interpolatedRoute?: interpolatedRoute;
+        routerLinkOptions?: {
+            queryParams?: [string, interpolatedRoute][];
+            fragment?: string;
+            preserveFragment?: boolean;
+            queryParamsHandling?: QueryParamsHandling;
+        };
+    };
+    footer?: {
+        type: 'sum';
+    };
+    export?: TableBuilderExport;
+    dateFormat?: string;
+    dateTimeOptions?: DateTimeOptions;
+    filterOptions?: FilterOptions;
+    styles?: Dictionary<string | {
+        condition: (t: T) => boolean | true;
+        value: (t: T) => string | string;
+    }>;
+    columnPartStyles?: {
+        header?: Dictionary<string>;
+        body?: Dictionary<string | {
+            condition: (t: T) => boolean | true;
+            value: (t: T) => string | string;
+        }>;
+        footer?: Dictionary<string>;
+    };
+    columnPartClasses?: {
+        header?: Dictionary<Predicate<T>>;
+        footer?: Dictionary<Predicate<T>>;
+    };
+    enumMap?: {
+        [key: number]: string;
+    };
+    boolean?: {
+        showForFalse?: true | {
+            icon: string;
+        };
+        forTrue?: {
+            icon: string;
+        };
+    };
+}
+export declare enum ArrayStyle {
+    CommaDelimited = 0,
+    NewLine = 1
+}
+export interface ArrayAdditional extends Additional {
+    limit?: number;
+    arrayStyle?: ArrayStyle;
+}
+export declare function metaDataArrToDict<T = MetaData>(arr: MetaData[], transform?: (m: MetaData) => T): Dictionary<T>;
+export {};

package/table-builder/ngrx/tableBuilderStateStore.d.ts

@@ -0,0 +1,70 @@
+import { ComponentStore } from "@ngrx/component-store";
+import { Signal } from "@angular/core";
+import { Observable } from "rxjs";
+import { Dictionary } from "../interfaces/dictionary";
+import { PersistedTableState } from "../classes/TableState";
+import * as i0 from "@angular/core";
+export declare class TableBuilderStateStore extends ComponentStore<GlobalStorageState> {
+    constructor();
+    $selectLocalTableProfile: (profileKey: string) => Signal<Profile | undefined>;
+    $selectLocalTableStateForView: (tableId: string) => Signal<PersistedTableState | null>;
+    $selectLocalProfileCurrentKey: (key: string) => Signal<string | undefined>;
+    $selectLocalProfileDefaultKey: (key: string) => Signal<string | undefined>;
+    $selectLocalProfileKeys: (tableId: string) => Signal<string[]>;
+    saveTableSettingsToLocalAndStorage: (tableId: string, stateName: string, tableState: PersistedTableState, asDefault?: boolean) => void;
+    saveTableStateToLocal: (observableOrValue: {
+        tableId: string;
+        tableState: PersistedTableState;
+        stateName?: string | undefined;
+        asDefault?: boolean | undefined;
+    } | Observable<{
+        tableId: string;
+        tableState: PersistedTableState;
+        stateName?: string | undefined;
+        asDefault?: boolean | undefined;
+    }>) => import("rxjs").Subscription;
+    saveTableStateToStorage: (tableId: string, stateName: string, tableState: PersistedTableState, asDefault?: boolean) => void;
+    addNewStateToLocalAndStorage: (tableId: string, newStateName: string, tableState: PersistedTableState, asDefault?: boolean) => void;
+    setLocalCurrentState: (observableOrValue: {
+        tableId: string;
+        currentStateKey: string;
+    } | Observable<{
+        tableId: string;
+        currentStateKey: string;
+    }>) => import("rxjs").Subscription;
+    setDefaultInLocalAndStorage: (tableId: string, newDefault: string) => void;
+    setDefaultInLocal: (observableOrValue: {
+        key: string;
+        default: string;
+    } | Observable<{
+        key: string;
+        default: string;
+    }>) => import("rxjs").Subscription;
+    unsetDefaultFromLocalAndStorage: (tableId: string) => void;
+    unsetDefaultFromLocal: (tableId: string) => void;
+    unsetDefaultFromStorage: (tableId: string) => void;
+    setDefaultInStorage: (tableId: string, stateName: string) => void;
+    deleteLocalProfilesState: (observableOrValue: {
+        key: string;
+        stateKey: string;
+    } | Observable<{
+        key: string;
+        stateKey: string;
+    }>) => import("rxjs").Subscription;
+    deleteProfileFromLocalAndStorage: (key: string, stateKey: string) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableBuilderStateStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableBuilderStateStore>;
+}
+interface PersistedProfile {
+    states: Dictionary<PersistedTableState>;
+    default?: string;
+}
+export interface Profile extends PersistedProfile {
+    current?: string;
+    localSavedState?: PersistedTableState;
+}
+export interface GlobalStorageState {
+    localProfiles: Dictionary<Profile>;
+}
+export declare const defaultStorageState: GlobalStorageState;
+export {};

package/table-builder/pipes/column-total.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { MetaData } from '../interfaces/report-def';
+import * as i0 from "@angular/core";
+export declare class ColumnTotalPipe implements PipeTransform {
+    transform(data: any[], metaData: MetaData): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnTotalPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ColumnTotalPipe, "columnTotal", true>;
+}

package/table-builder/pipes/format-filter-type.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { FilterType } from '../enums/filterTypes';
+import * as i0 from "@angular/core";
+export declare class FormatFilterTypePipe implements PipeTransform {
+    transform(filterType: FilterType, value: any): FilterType | "Is Not Blank";
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormatFilterTypePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormatFilterTypePipe, "formatFilterType", true>;
+}

package/table-builder/pipes/format-filter-value.pipe.d.ts

@@ -0,0 +1,14 @@
+import { PipeTransform } from '@angular/core';
+import { TableStore } from '../classes/table-store';
+import { Observable } from 'rxjs';
+import { DatePipe } from '@angular/common';
+import { FilterType } from '../enums/filterTypes';
+import * as i0 from "@angular/core";
+export declare class FormatFilterValuePipe implements PipeTransform {
+    tableState: TableStore;
+    private datePipe;
+    constructor(tableState: TableStore, datePipe: DatePipe);
+    transform(value: any, key: string, filterType: FilterType): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormatFilterValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormatFilterValuePipe, "formatFilterValue", true>;
+}

package/table-builder/pipes/key-display.d.ts

@@ -0,0 +1,11 @@
+import { PipeTransform } from '@angular/core';
+import { TableStore } from '../classes/table-store';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class KeyDisplayPipe implements PipeTransform {
+    tableState: TableStore;
+    constructor(tableState: TableStore);
+    transform(key: string): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeyDisplayPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<KeyDisplayPipe, "keyDisplay", true>;
+}