@one-paragon/angular-utilities 1.0.4 → 1.1.2

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,62 @@
+import { ComponentStore } from "@ngrx/component-store";
+import { Observable } from "rxjs";
+import { Dictionary } from "../interfaces/dictionary";
+import * as i0 from "@angular/core";
+export declare class TableBuilderStateStore extends ComponentStore<GlobalStorageState> {
+    constructor();
+    selectLocalProfile: (key: string) => Observable<Profile<any>>;
+    selectLocalProfileState: (key: string) => Observable<any>;
+    selectLocalProfileCurrentKey: (key: string) => Observable<string>;
+    selectLocalProfileKeys: <T>(key: string) => Observable<string[] | null>;
+    setLocalProfile: (observableOrValue: {
+        key: string;
+        value: any;
+    } | Observable<{
+        key: string;
+        value: any;
+    }>) => import("rxjs").Subscription;
+    setLocalProfilesState: (observableOrValue: {
+        key: string;
+        current: string;
+    } | Observable<{
+        key: string;
+        current: string;
+    }>) => import("rxjs").Subscription;
+    deleteLocalProfilesState: (observableOrValue: {
+        key: string;
+        stateKey: string;
+    } | Observable<{
+        key: string;
+        stateKey: string;
+    }>) => import("rxjs").Subscription;
+    saveLocalProfile: (observableOrValue: {
+        key: string;
+        value: any;
+        persist?: boolean | undefined;
+    } | Observable<{
+        key: string;
+        value: any;
+        persist?: boolean | undefined;
+    }>) => import("rxjs").Subscription;
+    deleteLocalProfile: (observableOrValue: {
+        key: string;
+        stateKey: string;
+    } | Observable<{
+        key: string;
+        stateKey: string;
+    }>) => import("rxjs").Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableBuilderStateStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableBuilderStateStore>;
+}
+export interface Profile<T = any> {
+    default: string;
+    current: string;
+    states: Dictionary<T>;
+}
+export interface GlobalStorageState {
+    globalProfileKeys: string[];
+    currentGlobalProfile: string;
+    globalProfiles: Dictionary<Profile>;
+    localProfiles: Dictionary<Profile>;
+}
+export declare const defaultStorageState: GlobalStorageState;

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>;
+}

package/table-builder/services/export-to-csv.service.d.ts

@@ -0,0 +1,22 @@
+import { DatePipe } from '@angular/common';
+import { Observable } from 'rxjs';
+import { TableStore } from '../classes/table-store';
+import { TableBuilderConfig } from '../classes/TableBuilderConfig';
+import { MetaData } from '../interfaces/report-def';
+import { TableState } from '../classes/TableState';
+import * as i0 from "@angular/core";
+export declare class ExportToCsvService<T> {
+    state: TableStore;
+    private config;
+    private datePipe;
+    constructor(state: TableStore, config: TableBuilderConfig, datePipe: DatePipe);
+    exportToCsv: (data: Observable<T[]>) => void;
+    csvData: (data: Array<T>, metaData: MetaData<T>[]) => string;
+    metaToField: (meta: MetaData<T>, row: T) => any;
+    private transform;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportToCsvService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExportToCsvService<any>>;
+}
+export declare const removeFromMetaData: (state: TableState, keysToRemove: string[]) => MetaData[];
+export declare const nonExportableFields: (state: TableState) => string[];
+export declare const mapExportableFields: (state: TableState) => MetaData[];

package/table-builder/services/link-creator.service.d.ts

@@ -0,0 +1,16 @@
+import { MetaData } from "../interfaces/report-def";
+import { Dictionary } from "@ngrx/entity";
+import { QueryParamsHandling } from "@angular/router";
+export declare function createLinkCreatorDict<T>(metaDatas: MetaData<T>[]): Dictionary<LinkInfo>;
+export declare function createLinkCreator<T>(metaData: MetaData<T>): LinkInfo;
+export interface LinkInfo {
+    link: (element: any) => string;
+    target: string;
+    useRouterLink: boolean;
+    routerLinkOptions?: {
+        queryParams: (element: any) => any;
+        fragment?: string;
+        preserveFragment?: boolean;
+        queryParamsHandling?: QueryParamsHandling;
+    };
+}

package/table-builder/services/table-template-service.d.ts

@@ -0,0 +1,15 @@
+import { ComponentFactoryResolver, Injector } from "@angular/core";
+import { TemplateRef } from "@angular/core";
+import { MetaData } from "../interfaces/report-def";
+import { InitializationComponent } from "../components/initialization-component/initialization-component";
+import * as i0 from "@angular/core";
+export declare class TableTemplateService {
+    instance: InitializationComponent;
+    templates: any;
+    initTemplates(): void;
+    getTemplate(metaData: MetaData): TemplateRef<any>;
+    constructor(resolver: ComponentFactoryResolver, i: Injector);
+    tableConfig: import("../classes/TableBuilderConfig").TableBuilderConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableTemplateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableTemplateService>;
+}

package/table-builder/services/transform-creator.d.ts

@@ -0,0 +1,21 @@
+import { PipeTransform } from '@angular/core';
+import { MetaData } from '../interfaces/report-def';
+import { DatePipe, CurrencyPipe } from '@angular/common';
+import { PhoneNumberPipe } from '../../utilities/pipes/phone.pipe';
+import { TableBuilderConfig } from '../classes/TableBuilderConfig';
+import { SpaceCasePipe } from '../../utilities';
+import * as i0 from "@angular/core";
+export declare function isPipe(o: any): o is PipeTransform;
+export declare class TransformCreator {
+    private datePipe;
+    private currencyPipe;
+    private phonePipe;
+    private casePipe;
+    private config;
+    constructor(datePipe: DatePipe, currencyPipe: CurrencyPipe, phonePipe: PhoneNumberPipe, casePipe: SpaceCasePipe, config: TableBuilderConfig);
+    createTransformer(metaData: MetaData<any, any>, noIcons?: boolean): ((value: any, ...args: any[]) => any);
+    createItemTransformer: <T = any, AdditionalFields extends string[] = []>(metaData: MetaData<T, AdditionalFields>, noIcons?: boolean, mutate?: boolean) => (t: T) => void;
+    createItemTransformers: <T = any, AdditionalFields extends string[] = []>(metaDatas: MetaData<T, AdditionalFields>[], noIcons?: boolean, mutate?: boolean) => (t: T) => T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TransformCreator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TransformCreator>;
+}