@one-paragon/angular-utilities 0.1.21 → 0.1.23

package/table-builder/components/generic-table/paginator.component.d.ts

@@ -0,0 +1,28 @@
+import { ElementRef, AfterViewInit, OnInit } from '@angular/core';
+import { MatPaginator } from '@angular/material/paginator';
+import { Observable } from 'rxjs';
+import { GenericTableDataSource } from '../../classes/GenericTableDataSource';
+import { TableStore } from '../../classes/table-store';
+import * as i0 from "@angular/core";
+export declare class PaginatorComponent implements OnInit, AfterViewInit {
+    private state;
+    dataSource: GenericTableDataSource<any>;
+    tableElRef: ElementRef;
+    paginator: MatPaginator;
+    currentPageData$: Observable<CurrentPageDetails>;
+    collapseFooter$: Observable<boolean>;
+    data$: Observable<any[]>;
+    constructor(state: TableStore);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    paginatorChange(): void;
+    ourPageEvent: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PaginatorComponent, "tb-paginator", never, { "dataSource": "dataSource"; "tableElRef": "tableElRef"; "data$": "data$"; }, {}, never, never, false, never>;
+}
+interface CurrentPageDetails {
+    currentStart: number;
+    currentEnd: number;
+    total: number;
+}
+export {};

package/table-builder/components/group-by-list/group-by-list.component.d.ts

@@ -0,0 +1,10 @@
+import { OnInit } from '@angular/core';
+import { TableStore } from '../../classes/table-store';
+import * as i0 from "@angular/core";
+export declare class GroupByListComponent implements OnInit {
+    tableStore: TableStore;
+    constructor(tableStore: TableStore);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GroupByListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GroupByListComponent, "group-by-list", never, {}, {}, never, never, false, never>;
+}

package/table-builder/components/header-menu/header-menu.component.d.ts

@@ -0,0 +1,25 @@
+import { FieldType, MetaData } from '../../interfaces/report-def';
+import { FilterType } from '../../enums/filterTypes';
+import { FilterInfo } from '../../classes/filter-info';
+import { TableStore } from '../../classes/table-store';
+import { MatMenuTrigger } from '@angular/material/menu';
+import * as i0 from "@angular/core";
+export declare class HeaderMenuComponent {
+    tableState: TableStore;
+    FieldType: typeof FieldType;
+    FilterType: typeof FilterType;
+    myFilterType: FilterType;
+    myFilterValue: any;
+    filter: Partial<FilterInfo>;
+    metaData: MetaData;
+    trigger: MatMenuTrigger;
+    constructor(tableState: TableStore);
+    hideField(key: string): void;
+    ngOnInit(): void;
+    resetFilterType(): void;
+    setStringFilterType(): void;
+    setFilterType(filterType: FilterType): void;
+    onEnter(filter: FilterInfo): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderMenuComponent, "tb-header-menu", never, { "filter": "filter"; "metaData": "metaData"; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,21 @@
+import { ChangeDetectorRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { FieldType } from '../../interfaces/report-def';
+import * as i0 from "@angular/core";
+export declare class InFilterComponent implements ControlValueAccessor {
+    private ref;
+    FieldType: typeof FieldType;
+    type: FieldType;
+    value: any[];
+    constructor(ref: ChangeDetectorRef);
+    writeValue(obj: any[]): void;
+    onChange: (_: any) => void;
+    registerOnChange(fn: any): void;
+    onTouched: () => void;
+    registerOnTouched(fn: any): void;
+    addInput(): void;
+    removeInput(index: number): void;
+    onValueChange(i: number, value: number | string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InFilterComponent, "lib-in-filter", never, { "type": "type"; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,12 @@
+import { TemplateRef } from "@angular/core";
+import * as i0 from "@angular/core";
+export declare class InitializationComponent {
+    linkTemplate: TemplateRef<any>;
+    imageUrlTemplate: TemplateRef<any>;
+    currencyTemplate: TemplateRef<any>;
+    arrayTemplate: TemplateRef<any>;
+    defaultTemplate: TemplateRef<any>;
+    defaultWithIcon: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InitializationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InitializationComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,17 @@
+import { TableStore } from "../classes/table-store";
+import { MetaData } from "../interfaces/report-def";
+import * as i0 from "@angular/core";
+export declare class LinkColumnComponent {
+    protected store: TableStore;
+    metaData: MetaData;
+    element: any;
+    transform: (a: any) => any;
+    constructor(store: TableStore);
+    link: (metaData: MetaData) => import("rxjs").Observable<{
+        link: (t: any) => string;
+        useRouterLink: boolean;
+        target: import("../interfaces/report-def").Target;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LinkColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LinkColumnComponent, "tb-link-column", never, { "metaData": "metaData"; "element": "element"; "transform": "transform"; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,12 @@
+import { FilterType } from '../../enums/filterTypes';
+import { PartialFilter } from '../../classes/filter-info';
+import { FieldType } from '../../interfaces/report-def';
+import * as i0 from "@angular/core";
+export declare class NumberFilterComponent {
+    FilterType: typeof FilterType;
+    FieldType: typeof FieldType;
+    CurrentFilterType: FilterType;
+    info: PartialFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NumberFilterComponent, "tb-number-filter", never, { "CurrentFilterType": "CurrentFilterType"; "info": "info"; }, {}, never, never, false, never>;
+}

package/table-builder/components/sort-menu/sort-menu.component-store.d.ts

@@ -0,0 +1,24 @@
+import { Sort } from '@angular/material/sort';
+import { ComponentStore } from '@ngrx/component-store';
+import { TableStore } from '../../classes/table-store';
+import * as i0 from "@angular/core";
+export declare class SortMenuComponentStore extends ComponentStore<ComponenStoreState> {
+    private tableState;
+    constructor(tableState: TableStore);
+    private set;
+    setSorted: (observableOrValue: SortWithName[] | import("rxjs").Observable<SortWithName[]>) => import("rxjs").Subscription;
+    setNotSorted: (observableOrValue: SortWithName[] | import("rxjs").Observable<SortWithName[]>) => import("rxjs").Subscription;
+    sorted$: import("rxjs").Observable<SortWithName[]>;
+    notSorted$: import("rxjs").Observable<SortWithName[]>;
+    setDirection: (observableOrValue: SortWithName | import("rxjs").Observable<SortWithName>) => import("rxjs").Subscription;
+    reset: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortMenuComponentStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SortMenuComponentStore>;
+}
+export interface ComponenStoreState {
+    sorted: SortWithName[];
+    notSorted: SortWithName[];
+}
+export interface SortWithName extends Sort {
+    displayName: string;
+}

package/table-builder/components/sort-menu/sort-menu.component.d.ts

@@ -0,0 +1,25 @@
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { OnInit } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { Observable } from 'rxjs';
+import { TableStore } from '../../classes/table-store';
+import { SortDirection } from '../../interfaces/report-def';
+import { SortMenuComponentStore, SortWithName } from './sort-menu.component-store';
+import * as i0 from "@angular/core";
+export declare class SortMenuComponent implements OnInit {
+    private tableState;
+    store: SortMenuComponentStore;
+    sorted$: Observable<SortWithName[]>;
+    notSorted$: Observable<SortWithName[]>;
+    SortDirection: typeof SortDirection;
+    dirty$: BehaviorSubject<boolean>;
+    constructor(tableState: TableStore, store: SortMenuComponentStore);
+    reset(): void;
+    ngOnInit(): void;
+    dropIntoSorted(event: CdkDragDrop<SortWithName[]>): void;
+    dropIntoNotSorted(event: CdkDragDrop<SortWithName[]>): void;
+    apply: (observableOrValue: Observable<null> | null) => import("rxjs").Subscription;
+    setDirection(sort: SortWithName): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SortMenuComponent, "tb-sort-menu", never, {}, {}, never, never, false, never>;
+}

package/table-builder/components/table-container/table-container.d.ts

@@ -0,0 +1,65 @@
+import { EventEmitter, QueryList, Predicate, TemplateRef } from '@angular/core';
+import { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';
+import { MetaData } from '../../interfaces/report-def';
+import { TableBuilder } from '../../classes/table-builder';
+import { MatRowDef } from '@angular/material/table';
+import { CustomCellDirective, TableCustomFilterDirective, TableFilterDirective } from '../../directives';
+import { TableStore } from '../../classes/table-store';
+import { ExportToCsvService } from '../../services/export-to-csv.service';
+import { TableBuilderConfig } from '../../classes/TableBuilderConfig';
+import { Store } from '@ngrx/store';
+import { Group, PersistedTableState } from '../../classes/TableState';
+import { ColumnInfo } from '../../interfaces/ColumnInfo';
+import { TableWrapperDirective } from '../../directives/table-wrapper.directive';
+import * as i0 from "@angular/core";
+export declare class TableContainerComponent<T = any> {
+    state: TableStore;
+    exportToCsvService: ExportToCsvService<T>;
+    private config;
+    private store;
+    private wrapper;
+    customFilters: QueryList<TableCustomFilterDirective>;
+    filters: QueryList<TableFilterDirective>;
+    tableId: string;
+    tableBuilder: TableBuilder;
+    IndexColumn: boolean;
+    SelectionColumn: boolean;
+    trackBy: string;
+    isSticky: boolean;
+    set pageSize(value: number);
+    inputFilters?: Observable<Array<Predicate<T>>>;
+    groupHeaderTemplate: TemplateRef<any>;
+    selection$: EventEmitter<any>;
+    dataSubject: ReplaySubject<Observable<T[]>>;
+    data: Observable<T[]>;
+    customRows: QueryList<MatRowDef<any>>;
+    customCells: QueryList<CustomCellDirective>;
+    OnStateReset: EventEmitter<any>;
+    OnSaveState: EventEmitter<any>;
+    state$: Observable<PersistedTableState>;
+    myColumns$: Observable<ColumnInfo[]>;
+    stateKeys$?: Observable<string[] | null>;
+    currentStateKey$?: Observable<string>;
+    disableSort: boolean;
+    constructor(state: TableStore, exportToCsvService: ExportToCsvService<T>, config: TableBuilderConfig, store: Store<any>, wrapper: TableWrapperDirective);
+    resetState(): void;
+    initializeState(): void;
+    customFilters$: BehaviorSubject<Predicate<any>[]>;
+    initializeData(): void;
+    ngOnInit(): void;
+    exportToCsv(): void;
+    saveState(): void;
+    setProfileState(val: string): void;
+    deleteProfileState(stateKey: string): void;
+    ngAfterContentInit(): void;
+    InitializeColumns(): void;
+    mapMetaDatas: (meta: MetaData<T>) => MetaData<T, []>;
+    collapseHeader$: Observable<boolean>;
+    getData(data: any[], groupByKeys: string[]): any[];
+    tbGroupBy: (data: any[], groupByKeys: string[], parentGroupName?: any) => any[];
+    addIndentation: (d: any) => any;
+    setDisplay: (data: any[], groups: Group[]) => any[];
+    shouldDisplay: (currentGroup?: Group, groups?: Group[]) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableContainerComponent<any>, [null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableContainerComponent<any>, "tb-table-container", never, { "tableId": "tableId"; "tableBuilder": "tableBuilder"; "IndexColumn": "IndexColumn"; "SelectionColumn": "SelectionColumn"; "trackBy": "trackBy"; "isSticky": "isSticky"; "pageSize": "pageSize"; "inputFilters": "inputFilters"; "groupHeaderTemplate": "groupHeaderTemplate"; }, { "selection$": "selection$"; "data": "data"; "OnStateReset": "OnStateReset"; "OnSaveState": "OnSaveState"; "state$": "state$"; }, ["customFilters", "filters", "customRows", "customCells"], ["[before]", ".tb-header-title"], false, never>;
+}

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

@@ -0,0 +1,17 @@
+import { TableStore } from '../../../classes/table-store';
+import { FilterInfo } from '../../../classes/filter-info';
+import { WrapperFilterStore } from '../table-wrapper-filter-store';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class FilterChipsComponent {
+    tableState: TableStore;
+    private filterStore;
+    constructor(tableState: TableStore, filterStore: WrapperFilterStore);
+    filters$: Observable<FilterInfo<any>[]>;
+    deleteByIndex(index: number): void;
+    addFilter(filter: FilterInfo<any>): void;
+    clearAll(): void;
+    currentFilters$: Observable<import("../../../classes/filter-info").PartialFilter<any>[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterChipsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterChipsComponent, "lib-filter-list", never, {}, {}, never, never, false, never>;
+}

package/table-builder/components/table-container-filter/gen-filter-displayer/gen-filter-displayer.component.d.ts

@@ -0,0 +1,14 @@
+import { MetaData } from '../../../interfaces/report-def';
+import { Observable } from 'rxjs';
+import { TableStore } from '../../../classes/table-store';
+import { WrapperFilterStore } from '../table-wrapper-filter-store';
+import * as i0 from "@angular/core";
+export declare class GenFilterDisplayerComponent {
+    tableState: TableStore;
+    filterStore: WrapperFilterStore;
+    constructor(tableState: TableStore, filterStore: WrapperFilterStore);
+    filterCols$: Observable<MetaData[]>;
+    addFilter(metaData: MetaData): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenFilterDisplayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GenFilterDisplayerComponent, "tb-filter-displayer", never, {}, {}, never, never, false, never>;
+}

package/table-builder/components/table-container-filter/table-wrapper-filter-store.d.ts

@@ -0,0 +1,14 @@
+import { ComponentStore } from "@ngrx/component-store";
+import { PartialFilter } from "../../classes/filter-info";
+import * as i0 from "@angular/core";
+export declare class WrapperFilterStore extends ComponentStore<{
+    filterInfo: PartialFilter[];
+}> {
+    constructor();
+    clearAll: () => void;
+    deleteByIndex: (observableOrValue: number | import("rxjs").Observable<number>) => import("rxjs").Subscription;
+    currentFilters$: import("rxjs").Observable<PartialFilter<any>[]>;
+    addFilter: (observableOrValue: PartialFilter<any> | import("rxjs").Observable<PartialFilter<any>>) => import("rxjs").Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrapperFilterStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WrapperFilterStore>;
+}

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

@@ -0,0 +1,19 @@
+import { TemplateRef, AfterContentInit } from '@angular/core';
+import { CdkColumnDef } from '@angular/cdk/table';
+import { SortDef, MetaData } from '../interfaces/report-def';
+import * as i0 from "@angular/core";
+export declare class CustomCellDirective implements AfterContentInit {
+    private templateRef;
+    columnDef: CdkColumnDef;
+    customCell: string;
+    displayName?: string;
+    preSort?: SortDef;
+    TemplateRef: TemplateRef<any>;
+    customCellOrder?: number;
+    customCellWidth?: string;
+    constructor(templateRef: TemplateRef<any>, columnDef: CdkColumnDef);
+    ngAfterContentInit(): void;
+    getMetaData(metaData?: MetaData): MetaData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomCellDirective, [{ optional: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CustomCellDirective, "[customCell]", never, { "customCell": "customCell"; "displayName": "displayName"; "preSort": "preSort"; "TemplateRef": "TemplateRef"; "customCellOrder": "customCellOrder"; "customCellWidth": "customCellWidth"; }, {}, never, never, false, never>;
+}

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

@@ -3,4 +3,3 @@ 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;
+    rules: Sort[];
+    constructor(state: TableStore);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSortDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MultiSortDirective, "[multiSort]", ["multiSort"], { "disabled": "matSortDisabled"; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,43 @@
+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;
+    key: string;
+    constructor(renderer: Renderer2, el: ElementRef, store: TableStore);
+    ngOnInit(): void;
+    createResizerSpanInColumnHead(columnHead: HTMLElement): any;
+    getTableAndColumnHeadHtmlElements(): {
+        table: HTMLElement;
+        columnHead: HTMLElement;
+    };
+    mouseDownThroghMouseUpEventMapper(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: MouseDowmData, mouseMove: MouseEvent): {
+        newTableWidth: number;
+        newColumnWidth: number;
+    };
+    getElementWidth: (elem: HTMLElement) => number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeColumnDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeColumnDirective, "[resizeColumn]", never, { "resizable": "resizeColumn"; "key": "key"; }, {}, never, never, false, never>;
+}
+interface MouseDowmData {
+    startPageX: number;
+    startColumnWidth: number;
+    startTableWidth: number;
+}
+export {};

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

@@ -0,0 +1,11 @@
+import { QueryList } from "@angular/core";
+import { TableCustomFilterDirective, TableFilterDirective } from "./tb-filter.directive";
+import * as i0 from "@angular/core";
+export declare class TableWrapperDirective {
+    customFilters: QueryList<TableCustomFilterDirective>;
+    filters: QueryList<TableFilterDirective>;
+    registerations: (TableCustomFilterDirective | TableFilterDirective)[];
+    register(filter: TableCustomFilterDirective | TableFilterDirective): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableWrapperDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableWrapperDirective, "[tbWrapper]", never, {}, {}, ["customFilters", "filters"], never, false, 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>>;
+    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": "filterType"; "key": "key"; "fieldType": "fieldType"; "filterId": "filterId"; "active": "active"; "filterValue": "filterValue"; }, {}, never, never, false, 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": "tbFilterStringContains"; "filterValue": "filterValue"; "filterId": "filterId"; "active": "active"; }, {}, never, never, false, 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": "filterId"; "predicate": "tbCustomFilter"; "active": "active"; }, {}, 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": "tbCustomFilter"; "filterId": "filterId"; }, {}, never, never, false, 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": "tbCustomFilter"; "filterId": "filterId"; }, {}, never, never, false, 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": "tbCustomFilter"; }, {}, never, never, false, 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": "tbCustomFilter"; "filterId": "filterId"; }, {}, never, never, false, 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": "tbCustomFilter"; "filterId": "filterId"; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,31 @@
+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",
+    BooleanEquals = "Is",
+    IsNull = "Is Blank",
+    Or = "Or",
+    And = "And",
+    In = "In",
+    Custom = "Custom"
+}
+export declare const NumberFilterMap: FilterToFiltersMap;
+export declare const StringFilterMap: FilterToFiltersMap;
+export declare const DateFilterMap: FilterToFiltersMap;
+export declare const BooleanFilterMap: FilterToFiltersMap;
+export declare const EnumFilterMap: FilterToFiltersMap;
+export declare 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,3 @@
+import { FilterFunc } from '../classes/filter-info';
+import { Dictionary } from '../interfaces/dictionary';
+export declare const DateFilterFuncs: 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,3 @@
+import { Sort } from "@angular/material/sort";
+export declare type direc = 'asc' | 'desc' | boolean;
+export declare function sortData<T>(data: T[], sorted: Sort[]): T[];

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;
+    [key: string]: T;
 }