@one-paragon/angular-utilities 1.2.12 → 1.2.13

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

@@ -0,0 +1,33 @@
+import { TemplateRef, OnInit } from '@angular/core';
+import { CdkColumnDef } from '@angular/cdk/table';
+import { SortDef, MetaData } from '../interfaces/report-def';
+import { TableBuilder } from '../classes/table-builder';
+import { ReplaySubject } from 'rxjs';
+import * as i0 from "@angular/core";
+interface CustomCellContext<T> {
+    $implicit: T;
+    element: T;
+}
+export declare class CustomCellDirective<T = any> implements OnInit {
+    private templateRef;
+    columnDef: CdkColumnDef | null;
+    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();
+    ngOnInit(): void;
+    $metaData: ReplaySubject<MetaData>;
+    getMetaData: () => MetaData;
+    static ngTemplateContextGuard<T>(dir: CustomCellDirective<T>, ctx: any): ctx is CustomCellContext<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomCellDirective<any>, never>;
+    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,10 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { MatSort, Sort } from '@angular/material/sort';
+import * as i0 from "@angular/core";
+export declare class MultiSortDirective extends MatSort implements OnInit, OnDestroy {
+    private state;
+    constructor();
+    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,43 @@
+import { OnInit } 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;
+    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: import("@angular/core").WritableSignal<(TableCustomFilterDirective<any> | 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,115 @@
+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 { FieldType } from "../interfaces/report-def";
+import { NgControl } from "@angular/forms";
+import { TableWrapperDirective } from "./table-wrapper.directive";
+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 {
+    protected model: NgControl | null;
+    private wrapper;
+    constructor();
+    reset(): void;
+    filter$: Subject<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, never>;
+    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();
+    reset(): void;
+    setFilter(filter: FilterInfo): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableFilterStringContainsDirective, never>;
+    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;
+    _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, { "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 wrapper: TableWrapperDirective | null;
+    protected constructor(change: Observable<any>, isActive: () => boolean);
+    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();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatCheckboxTbFilterDirective, never>;
+    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();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSlideToggleTbFilterDirective<any>, never>;
+    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();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatRadioButtonTbFilterDirective, never>;
+    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();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatOptionTbFilterDirective, never>;
+    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();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatButtonToggleFilterDirective, never>;
+    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,36 @@
+export declare const FilterTypes: {
+    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";
+};
+export type FilterType = typeof FilterTypes[keyof typeof FilterTypes];
+export type SubFilterTypes<T extends typeof FilterTypes[keyof typeof FilterTypes]> = T;
+export type StringFilterTypes = SubFilterTypes<'Equals' | 'Contains' | 'Does Not Contain' | 'Start With' | 'Ends With' | 'Is Blank' | 'In'>;
+export type NumberFilterTypes = SubFilterTypes<'Equals' | 'Does Not Equal' | 'Greater Than' | 'Less Than' | 'Between' | 'Is Blank' | 'In'>;
+export type DateFilterTypes = SubFilterTypes<'Is on' | 'Is Not On' | 'On or After' | 'On or Before' | 'Between' | 'Is Blank'>;
+export type DateTimeFilterTypes = SubFilterTypes<'Is At' | 'Is Not At' | 'At or After' | 'At or Before' | 'Between' | DateFilterTypes>;
+export type BooleanFilterTypes = SubFilterTypes<'Is' | 'Is Blank'>;
+export type EnumFilterTypes = SubFilterTypes<'In' | 'Is Blank'>;

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

@@ -0,0 +1,3 @@
+import { FilterFuncs } from '../classes/filter-info';
+import { BooleanFilterTypes } from '../enums/filterTypes';
+export declare const BooleanFilterFuncs: FilterFuncs<BooleanFilterTypes>;

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

@@ -0,0 +1,4 @@
+import { FilterFuncs } from '../classes/filter-info';
+import { DateFilterTypes, DateTimeFilterTypes } from '../enums/filterTypes';
+export declare const DateFilterFuncs: FilterFuncs<DateFilterTypes>;
+export declare const DateTimeFilterFuncs: FilterFuncs<DateTimeFilterTypes>;

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, FilterFuncs } from '../classes/filter-info';
+import { NumberFilterTypes } from '../enums/filterTypes';
+export declare const multipleNumberValuesEqualsFunc: FilterFunc<number[], number>;
+export declare const NumberFilterFuncs: FilterFuncs<NumberFilterTypes>;

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,5 @@
+import { FilterFuncs } from '../classes/filter-info';
+import { EnumFilterTypes, StringFilterTypes } from '../enums/filterTypes';
+export declare const StringFilterFuncs: FilterFuncs<StringFilterTypes>;
+export declare const EnumFilterFuncs: FilterFuncs<EnumFilterTypes>;
+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): "Equals" | "Does Not Equal" | "Greater Than" | "Less Than" | "Between" | "Contains" | "Does Not Contain" | "Start With" | "Ends With" | "Is on" | "Is Not On" | "On or After" | "On or Before" | "Is At" | "Is Not At" | "At or After" | "At or Before" | "Is" | "Is Blank" | "Or" | "And" | "In" | "Custom" | "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,12 @@
+import { PipeTransform } from '@angular/core';
+import { TableStore } from '../classes/table-store';
+import { Observable } from 'rxjs';
+import { FilterType } from '../enums/filterTypes';
+import * as i0 from "@angular/core";
+export declare class FormatFilterValuePipe implements PipeTransform {
+    tableState: TableStore;
+    private 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,10 @@
+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;
+    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,14 @@
+import { TableStore } from '../classes/table-store';
+import { MetaData } from '../interfaces/report-def';
+import * as i0 from "@angular/core";
+export declare class ExportToCsvService<T> {
+    state: TableStore;
+    private config;
+    private datePipe;
+    exportToCsv: (data: 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>>;
+}

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,14 @@
+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();
+    tableConfig: import("../classes/TableBuilderConfig").TableBuilderConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableTemplateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableTemplateService>;
+}