@saydar/table-builder 1.0.0

package/types/saydar-table-builder.d.ts

@@ -0,0 +1,1982 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, ViewContainerRef, Injector, OnDestroy, PipeTransform, Predicate, AfterViewInit, EventEmitter, QueryList, SimpleChanges, AfterContentInit, OnInit, ElementRef, ModuleWithProviders } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable, Subscription, Subject, Unsubscribable, ReplaySubject, BehaviorSubject, OperatorFunction, MonoTypeOperatorFunction } from 'rxjs';
+import { ComponentStore } from '@ngrx/component-store';
+import { HttpErrorResponse } from '@angular/common/http';
+import * as _saydar_table_builder from '@saydar/table-builder';
+import * as i5 from '@angular/router';
+import { QueryParamsHandling } from '@angular/router';
+import { Sort, MatSort, SortDirection as SortDirection$1 } from '@angular/material/sort';
+import * as i1 from '@angular/common';
+import * as _ngrx_store from '@ngrx/store';
+import { Action, MemoizedSelector, Store } from '@ngrx/store';
+import * as i3 from '@ngrx/effects';
+import * as i4 from '@angular/forms';
+import { NgControl, ControlValueAccessor } from '@angular/forms';
+import * as i6 from '@ngrx/component';
+import * as i7 from '@angular/cdk/drag-drop';
+import { CdkDragDrop, CdkDropList } from '@angular/cdk/drag-drop';
+import { MatDialogRef, MatDialogConfig, MatDialog } from '@angular/material/dialog';
+import { MatSlideToggle } from '@angular/material/slide-toggle';
+import * as _ngrx_entity from '@ngrx/entity';
+import { Dictionary as Dictionary$1, Predicate as Predicate$1, EntityState } from '@ngrx/entity';
+import * as i9 from '@angular/cdk/scrolling';
+import * as i10 from 'ng-table-virtual-scroll';
+import { TableVirtualScrollDataSource } from 'ng-table-virtual-scroll';
+import { MatColumnDef, MatTableDataSource, MatRowDef, MatTable } from '@angular/material/table';
+import { CdkColumnDef } from '@angular/cdk/table';
+import { MatRadioButton } from '@angular/material/radio';
+import { MatButtonToggle } from '@angular/material/button-toggle';
+import { MatCheckbox } from '@angular/material/checkbox';
+import { MatOption } from '@angular/material/core';
+import { SelectionModel } from '@angular/cdk/collections';
+import { MatPaginator } from '@angular/material/paginator';
+import { MatMenuTrigger } from '@angular/material/menu';
+
+declare enum HttpRequestStatus {
+    notStarted = 0,
+    inProgress = 1,
+    success = 2,
+    fail = 3,
+    cancelled = 4
+}
+type HttpRequestStateCancelled = {
+    status: HttpRequestStatus.cancelled;
+};
+type HttpRequestStateNotStarted = {
+    status: HttpRequestStatus.notStarted;
+};
+type HttpRequestStateInProgress = {
+    status: HttpRequestStatus.inProgress;
+};
+type HttpRequestStateSuccess<T> = {
+    status: HttpRequestStatus.success;
+    body: T;
+};
+type HttpRequestStateError = {
+    status: HttpRequestStatus.fail;
+    error: any;
+};
+type HttpRequestState<T = any> = HttpRequestStateCancelled | HttpRequestStateNotStarted | HttpRequestStateInProgress | HttpRequestStateSuccess<T> | HttpRequestStateError;
+declare enum HttpRequestStrategy {
+    concurrent = 1,
+    singleUse = 2,
+    cancelPrevious = 3,
+    sequential = 4
+}
+interface RequestStateOptions {
+    strategy?: HttpRequestStrategy;
+}
+type HttpRequestFactory<TParam extends any[], T> = (...params: [...TParam]) => Observable<T>;
+
+declare abstract class HttpStateDirectiveBase {
+    private injector;
+    protected templateRef: TemplateRef<any>;
+    protected viewContainer: ViewContainerRef;
+    hasView: boolean;
+    constructor(injector: Injector, templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private baseRender;
+    abstract render: (state: HttpRequestState) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpStateDirectiveBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HttpStateDirectiveBase, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class HttpErrorStateDirective<TParam extends any[], T> extends HttpStateDirectiveBase {
+    constructor(injector: Injector, templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
+    render: (state: HttpRequestState<any>) => boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpErrorStateDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HttpErrorStateDirective<any, any>, "[httpErrorState]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HttpInProgressStateDirective extends HttpStateDirectiveBase {
+    render: (state: HttpRequestState<any>) => boolean;
+    constructor(injector: Injector, templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpInProgressStateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HttpInProgressStateDirective, "[httpInProgressState]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HttpNotStartedStateDirective<TParam extends any[], T> extends HttpStateDirectiveBase {
+    render: (state: HttpRequestState<any>) => boolean;
+    constructor(injector: Injector, templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpNotStartedStateDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HttpNotStartedStateDirective<any, any>, "[httpNotStartedState]", never, {}, {}, never, never, true, never>;
+}
+
+interface RequestResponse<TParam extends any[], T> {
+    requestParams: [...TParam];
+    response: HttpRequestState<T>;
+}
+declare class HttpRequestStateStore<TParam extends any[], T> extends ComponentStore<RequestResponse<TParam, T>> {
+    private req;
+    private options?;
+    constructor(req: HttpRequestFactory<TParam, T>, options?: RequestStateOptions | undefined);
+    reset(): void;
+    private flatteningStrategy;
+    private requestEffect;
+    private flattenedRequest;
+    private singleUseRequest;
+    selectHttpState$: Observable<HttpRequestState<T>>;
+    selectStatus$: Observable<HttpRequestStatus>;
+    selectError$: Observable<any>;
+    selectResponse$: Observable<T>;
+    selectSuccessOrError$: Observable<null>;
+    errorHandled: boolean;
+    onError(cb: (error: HttpErrorResponse) => void): this;
+    onSuccess(cb: (body: T) => void): this;
+    onSuccessOrError(cb: () => void): this;
+    onSuccessWithRequest(func: (state: {
+        requestParams: [...TParam];
+        body: T;
+    }) => void): this;
+    onErrorWithRequest(func: (state: {
+        error: HttpErrorResponse;
+        requestParams: [...TParam];
+    }) => void): this;
+    private createRequest;
+    onUpdate(func: (state: {
+        requestParams: [...TParam];
+        response: HttpRequestState<T>;
+    }) => void): void;
+    on: <V>(srcObservable: Observable<V>, func: (obj: V) => void) => Subscription;
+    request: (...value: [...TParam]) => Subscription;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpRequestStateStore<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HttpRequestStateStore<any, any>, never, never, {}, {}, never, never, true, never>;
+}
+declare class CancellationToken {
+}
+
+interface HttpSuccessStateViewContext<T> {
+    $implicit: T;
+}
+declare class HttpSuccessStateDirective<T> extends HttpStateDirectiveBase {
+    httpSuccessStateTypeSafety?: HttpRequestStateStore<any, T> | Observable<HttpRequestState<T>>;
+    render: (state: HttpRequestState<T>) => boolean;
+    constructor(injector: Injector, templateRef: TemplateRef<{
+        $implicit: T;
+    }>, viewContainer: ViewContainerRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ngTemplateContextGuard<T>(dir: HttpSuccessStateDirective<T>, ctx: any): ctx is HttpSuccessStateViewContext<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpSuccessStateDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HttpSuccessStateDirective<any>, "[httpSuccessState]", never, { "httpSuccessStateTypeSafety": { "alias": "httpSuccessStateTypeSafety"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface HttpRequestStateViewContext<T> {
+    $implicit?: HttpRequestStateAny<T>;
+    state?: HttpRequestStateAny<T>;
+    status: {
+        inProgress: boolean;
+        notStarted: boolean;
+        success: boolean;
+        error: boolean;
+    };
+}
+declare class HttpRequestStateDirective<TParam extends any[], T> {
+    private templateRef;
+    private viewContainer;
+    readonly ViewContext: HttpRequestStateViewContext<T>;
+    subject: Subject<Observable<HttpRequestState<T>>>;
+    state: Observable<HttpRequestState<T>>;
+    subscription: Unsubscribable;
+    hooks: ((state: HttpRequestState<T>) => void)[];
+    set stateStore(store: HttpRequestStateStore<TParam, T> | Observable<HttpRequestState<T>>);
+    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
+    ngOnDestroy(): void;
+    static ngTemplateContextGuard<T>(dir: HttpRequestStateDirective<any, T>, ctx: any): ctx is HttpRequestStateViewContext<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpRequestStateDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HttpRequestStateDirective<any, any>, "[httpRequestState]", never, { "stateStore": { "alias": "httpRequestState"; "required": false; }; }, {}, never, never, true, never>;
+}
+type HttpRequestStateAny<T> = {
+    status: HttpRequestStatus;
+    body?: T;
+    error?: any;
+};
+
+declare const getRequestorBody: <T>(source: Observable<HttpRequestState<T>>) => Observable<T>;
+
+declare const getRequestorStatus: <T>(source: Observable<HttpRequestState<T>>) => Observable<_saydar_table_builder.HttpRequestStatus>;
+
+declare function tapError(onError: (error: any) => void): (src: Observable<HttpRequestState>) => Observable<HttpRequestState>;
+
+declare function tapSuccess<T>(onSuccess: (body: T) => void): (src: Observable<HttpRequestState<T>>) => Observable<HttpRequestState<T>>;
+
+declare function isErrorState<T>(state: HttpRequestState<T>): state is HttpRequestStateError;
+declare function isSuccessState<T>(state: HttpRequestState<T>): state is HttpRequestStateSuccess<T>;
+declare function isSuccessOrErrorState<T>(state: HttpRequestState<T>): state is (HttpRequestStateSuccess<T> | HttpRequestStateError);
+declare function createSuccess<T>(body: T): HttpRequestStateSuccess<T>;
+declare function createFailure(error: any): HttpRequestStateError;
+declare const notStarted: HttpRequestStateNotStarted;
+declare const inProgress: HttpRequestStateInProgress;
+declare function statusIsSuccessOrInProgress(status: HttpRequestStatus): boolean;
+
+type HttpRequestState$<T> = Observable<HttpRequestState<T>>;
+interface HttpRequestor<Res, Req> {
+    httpState$: Observable<HttpRequestState<Res>>;
+    status$: Observable<HttpRequestStatus>;
+    body$: Observable<Res>;
+    request: Req;
+}
+declare function httpRequest<T = any>(req: Observable<T>): HttpRequestState$<T>;
+declare function httpRequestor<TParam extends any[], T>(req: HttpRequestFactory<TParam, T>): HttpRequestor<T, (...params: [...TParam]) => Observable<HttpRequestState<T>>>;
+declare function chainRequest<TParam extends any[], T, TT>(httpState$: Observable<HttpRequestState<T>>, request: HttpRequestFactory<TParam, TT>, requestParams: ((responseFromPrevious: T) => [...TParam]) | (() => [...TParam])): Observable<HttpRequestState<TT>>;
+
+/** @deprecated Import the standalone directives directly instead. */
+declare class HttpRequestModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpRequestModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HttpRequestModule, never, [typeof HttpSuccessStateDirective, typeof HttpRequestStateDirective, typeof HttpErrorStateDirective, typeof HttpInProgressStateDirective, typeof HttpNotStartedStateDirective], [typeof HttpSuccessStateDirective, typeof HttpRequestStateDirective, typeof HttpErrorStateDirective, typeof HttpInProgressStateDirective, typeof HttpNotStartedStateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HttpRequestModule>;
+}
+
+declare class HttpRequestStateFactory implements OnDestroy {
+    constructor();
+    ngOnDestroy(): void;
+    private requestors;
+    create<TParam extends any[], T>(req: HttpRequestFactory<TParam, T>, options?: RequestStateOptions): HttpRequestStateStore<TParam, T>;
+    createHttpClient<T>(r: (o: Observable<T>) => Observable<T>, options?: RequestStateOptions): HttpRequestStateStore<[o: Observable<T>], T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpRequestStateFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpRequestStateFactory>;
+}
+
+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"
+}
+type FilterToFiltersMap = Partial<{
+    [key in FilterType]: FilterType[];
+}>;
+
+interface Dictionary<T> {
+    [key: string]: T;
+}
+
+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,
+    Expression = 11,
+    Enum = 12,
+    DateTime = 13
+}
+declare enum SortDirection {
+    asc = "asc",
+    desc = "desc"
+}
+declare enum Target {
+    Blank = "_blank",
+    Self = "_self",
+    Parent = "_parent",
+    Top = "_top"
+}
+interface MetaData<T = any, AdditionalFields extends string[] = []> {
+    key: (keyof T | AdditionalFields[number]) & string;
+    displayName?: string;
+    fieldType: FieldType;
+    additional?: Additional<T>;
+    order?: number;
+    preSort?: SortDef;
+    _internalNotUserDefined?: boolean;
+    width?: string;
+    noExport?: boolean;
+    noFilter?: boolean;
+    customCell?: boolean;
+    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;
+    useIcon?: boolean;
+}
+interface ReportDef<DataType = any> {
+    data: DataType[];
+    metaData: MetaData[];
+    totalRecords?: number;
+    count: number;
+}
+interface SortDef {
+    direction: SortDirection;
+    precedence?: number;
+}
+interface FilterOptions {
+    filterableValues: string[];
+}
+interface DateTimeOptions {
+    format?: string;
+    includeSeconds?: boolean;
+    includeMilliseconds: boolean;
+}
+type interpolatedRoute = string;
+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;
+        };
+    };
+    /**
+     * @deprecated Please use link.base
+     */
+    base?: string;
+    /**
+     * @deprecated Please use link.urlKey
+     */
+    urlKey?: string;
+    /**
+     * @deprecated Please use link.target
+     */
+    target?: Target;
+    /**
+     * @deprecated Please use link.useRouterLink
+     */
+    useRouterLink?: boolean;
+    footer?: {
+        type: 'sum';
+    };
+    grouping?: {
+        groupBy?: boolean;
+        sum?: boolean;
+        groupTitleFn?: (val: any) => string;
+    };
+    export?: TableBuilderExport;
+    dateFormat?: string;
+    dateTimeOptions?: DateTimeOptions;
+    filterOptions?: FilterOptions;
+    styles?: Dictionary<string>;
+    columnPartStyles?: {
+        header?: Dictionary<string>;
+        body?: Dictionary<string>;
+        footer?: Dictionary<string>;
+    };
+    enumMap?: {
+        [key: number]: string;
+    };
+    boolean?: {
+        showForFalse?: true | {
+            icon: string;
+        };
+        forTrue?: {
+            icon: string;
+        };
+    };
+}
+declare enum ArrayStyle {
+    CommaDelimited = 0,
+    NewLine = 1
+}
+interface ArrayAdditional extends Additional {
+    metaData?: MetaData;
+    limit?: number;
+    arrayStyle?: ArrayStyle;
+}
+
+type FilterTypeMapType = {
+    [key in FieldType]: FilterToFiltersMap;
+};
+type UnmappedTypes = FieldType.Expression | FieldType.Hidden | FieldType.ImageUrl;
+type mappedFieldTypes = FieldType.Unknown | FieldType.Date | FieldType.DateTime | FieldType.Currency | FieldType.Array | FieldType.Number | FieldType.String | FieldType.Boolean | FieldType.PhoneNumber | FieldType.Link | FieldType.Enum;
+declare const filterTypeMap: Omit<FilterTypeMapType, UnmappedTypes>;
+interface FilterState {
+    filterId: string;
+    filterType: FilterType;
+    filterValue?: any;
+    active?: boolean;
+}
+interface FilterInfo<T extends FieldType = any> extends FilterState {
+    key: string;
+    fieldType: T;
+    _isExternalyManaged?: boolean;
+}
+interface PartialFilter<T extends FieldType = any> {
+    filterId?: string;
+    key: string;
+    fieldType: T;
+    filterType?: FilterType;
+    filterValue?: any;
+}
+interface CustomFilter<T extends FieldType = any> extends FilterState {
+    predicate: Predicate<T>;
+    filterType: FilterType.Custom;
+}
+declare function isCustomFilter(filter: FilterInfo | CustomFilter): filter is CustomFilter;
+declare function isFilterInfo(filter: FilterInfo | CustomFilter): filter is FilterInfo;
+declare function createFilterFunc(filter: FilterInfo | CustomFilter): Predicate<any>;
+type FilterFunc<T, V = T> = (filterInfo: FilterInfo) => (val: V) => boolean;
+type Range<T> = {
+    Start: T;
+    End: T;
+};
+
+declare class GeneralTableSettings {
+    constructor(settings?: TableBuilderSettings);
+    headerSettings: TableWrapperHeaderSettings;
+    footerSettings: TableWrapperFooterSettings;
+    columnHeaderSettings: TableColumnHeaderSettings;
+}
+interface TableBuilderSettings {
+    headerSettings?: Partial<TableWrapperHeaderSettings>;
+    footerSettings?: Partial<TableWrapperFooterSettings>;
+    columnHeaderSettings?: Partial<TableColumnHeaderSettings>;
+}
+declare class TableWrapperHeaderSettings {
+    hideExport: boolean;
+    hideFilter: boolean;
+    hideColumnSettings: boolean;
+    hideHeader: boolean;
+    hideSort: boolean;
+    collapse: boolean;
+    showTitleWhenCollapsed: boolean;
+}
+declare class TableWrapperFooterSettings {
+    collapse: boolean;
+}
+declare class TableColumnHeaderSettings {
+    noFilters: boolean;
+    noHeader: boolean;
+}
+declare class PesrsistedTableSettings {
+    constructor(tableSettings?: GeneralTableSettings | PesrsistedTableSettings);
+    collapseHeader: boolean;
+    collapseFooter: boolean;
+}
+declare class NotPersisitedTableSettings {
+    constructor(tableSettings?: GeneralTableSettings);
+    hideExport: boolean;
+    hideFilter: boolean;
+    hideColumnSettings: boolean;
+    hideSort: boolean;
+    showTitleWhenHeaderCollapsed: boolean;
+    hideHeader: boolean;
+    hideColumnHeaderFilters: boolean;
+    hideColumnHeader: boolean;
+}
+
+interface Group {
+    groupName?: string;
+    parentGroupName?: string;
+    isExpanded?: boolean;
+}
+interface PersistedTableState {
+    hiddenKeys?: string[];
+    pageSize?: number;
+    filters: Dictionary<FilterInfo | CustomFilter>;
+    sorted: Sort[];
+    userDefined: {
+        order: Dictionary<number>;
+        widths: Dictionary<number>;
+        table: {
+            width?: number;
+        };
+    };
+    persistedTableSettings: PesrsistedTableSettings;
+    groupByKeys: string[];
+    groups: Group[];
+}
+interface TableState extends Required<PersistedTableState> {
+    initializationState: InitializationState;
+    metaData: Dictionary<MetaData>;
+    notPersisitedTableSettings: NotPersisitedTableSettings;
+    linkMaps: {
+        [key: string]: {
+            link: (t: any) => string;
+            useRouterLink: boolean;
+            target: Target;
+        };
+    };
+}
+declare const keysToDelete: string[];
+declare enum InitializationState {
+    Created = 0,
+    MetaDataLoaded = 1,
+    LoadedFromStore = 2,
+    Ready = 3
+}
+declare const defaultTableState: TableState;
+
+interface DefaultSettings {
+    dateFormat?: string;
+    dateTimeFormat?: string;
+}
+
+interface TableBuilderConfig {
+    defaultTableState: Partial<TableState>;
+    export?: TableBuilderExport;
+    defaultSettings?: DefaultSettings;
+    arrayInfo?: ArrayAdditional;
+    transformers?: Partial<{
+        [key in keyof typeof FieldType]: (val: any) => any;
+    }>;
+}
+interface TableBuilderExport {
+    dateFormat?: string;
+    dateTimeFormat?: string;
+    onSave?: (event?: any) => void;
+    prepend?: string;
+}
+
+declare class SpaceCasePipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpaceCasePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SpaceCasePipe, "spaceCase", true>;
+}
+/**
+ * Adds a space before uppercase letters that either
+ * 1. follows a lowercase letter or digit
+ * 2. or precedes a lowercase letter and follows an alpha-numeric character
+ *
+ * Uppercases the first digit
+ *
+ * Turns underscores into spaces
+ */
+declare function spaceCase(value: string): string;
+
+declare class PhoneNumberPipe implements PipeTransform {
+    transform(phoneNum: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneNumberPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PhoneNumberPipe, "phone", true>;
+}
+
+declare class FunctionPipe implements PipeTransform {
+    transform(func: ((...args: any[]) => any) | string, ...args: any[]): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FunctionPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FunctionPipe, "func", true>;
+}
+
+declare class StopPropagationDirective {
+    onClick(event: any): void;
+    onMousedown(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StopPropagationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StopPropagationDirective, "[stop-propagation]", never, {}, {}, never, never, true, never>;
+}
+
+declare class StylerDirective {
+    private el;
+    set styler(styles: any);
+    static ɵfac: i0.ɵɵFactoryDeclaration<StylerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StylerDirective, "[styler]", never, { "styler": { "alias": "styler"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PreventEnterDirective {
+    onKeyDown(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreventEnterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PreventEnterDirective, "[preventEnter]", never, {}, {}, never, never, true, never>;
+}
+
+declare class AutoFocusDirective implements AfterViewInit {
+    private elementRef;
+    readonly autoFocus: i0.InputSignal<boolean>;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoFocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoFocusDirective, "[autoFocus]", never, { "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TrimWhitespaceDirective {
+    private elem;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrimWhitespaceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TrimWhitespaceDirective, "input[trimWhitespace]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ClickSubjectDirective<T = boolean> extends Subject<T> {
+    constructor();
+    _val: T;
+    set clickSubject(val: T);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickSubjectDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickSubjectDirective<any>, "[clickSubject]", ["clickSubject"], { "clickSubject": { "alias": "clickSubject"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ClickEmitterDirective extends Subject<boolean> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickEmitterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickEmitterDirective, "[clickEmitter]", ["clickEmitter"], {}, {}, never, never, true, never>;
+}
+
+declare class DialogService {
+    allOpenOpDialogs: MatDialogRef<any>[];
+    addDialogRef(ref: MatDialogRef<any>): void;
+    removeDialogRef(ref: MatDialogRef<any>): void;
+    closeAllOpDialogs(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
+}
+
+interface DialogViewContext<T> {
+    $implicit: T;
+    opDialog: T;
+    close: () => void;
+}
+declare class DialogWrapper<T = any> {
+    private vcr;
+    viewEmbeded: boolean;
+    viewContext: DialogViewContext<T>;
+    set template(tmpl: TemplateRef<DialogViewContext<T>>);
+    set close(closeMethod: () => void);
+    set data(value: T);
+    constructor(vcr: ViewContainerRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogWrapper<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogWrapper<any>, "app-dialog-content", never, {}, {}, never, never, false, never>;
+}
+declare class DialogDirective<T> implements OnDestroy {
+    private templateRef;
+    private dialog;
+    private service;
+    opDialogClosed: EventEmitter<boolean>;
+    _dialogConfig: MatDialogConfig<T>;
+    add_opDialog_Class: boolean;
+    set opDialogConfig(config: MatDialogConfig<T>);
+    get opDialogConfig(): MatDialogConfig<T>;
+    set state(open_close: Observable<T>);
+    nativeElement?: HTMLElement;
+    dialogRef?: MatDialogRef<any, boolean>;
+    subscription: Subscription;
+    componentWrapper?: DialogWrapper<T>;
+    constructor(templateRef: TemplateRef<DialogViewContext<T>>, dialog: MatDialog, service: DialogService);
+    _data: Subject<Observable<T>>;
+    close(): void;
+    initDialog(): void;
+    setDialogState(open: boolean): void;
+    ngOnDestroy(): void;
+    static ngTemplateContextGuard<T>(dir: DialogDirective<T>, ctx: any): ctx is DialogViewContext<Exclude<T, false | 0 | '' | null | undefined>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogDirective<any>, "[opDialog]", never, { "add_opDialog_Class": { "alias": "add_opDialog_Class"; "required": false; }; "opDialogConfig": { "alias": "opDialogConfig"; "required": false; }; "state": { "alias": "opDialog"; "required": false; }; "nativeElement": { "alias": "opDialogOrigin"; "required": false; }; }, { "opDialogClosed": "opDialogClosed"; }, never, never, true, never>;
+}
+
+declare class MatSlideToggleGroupDirective {
+    readonly allowMultiple: i0.InputSignal<boolean>;
+    _toggles: QueryList<MatSlideToggle>;
+    set toggles(val: QueryList<MatSlideToggle>);
+    private _ready;
+    get valueEmitter(): Observable<{
+        [key: string]: boolean;
+    }>;
+    getInitValue(): {
+        [k: string]: boolean;
+    };
+    getObs(): Observable<{
+        [k: string]: boolean;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSlideToggleGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatSlideToggleGroupDirective, "[opMatSlideToggleGroup]", never, { "allowMultiple": { "alias": "allowMultiple"; "required": false; "isSignal": true; }; }, { "valueEmitter": "valueEmitter"; }, ["toggles"], never, true, never>;
+}
+
+declare class ConditionalClassesDirective {
+    private el;
+    private renderer;
+    readonly element: i0.InputSignal<any>;
+    readonly classes: i0.InputSignal<Dictionary$1<Predicate$1<any>> | undefined>;
+    classesApplied: string[];
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConditionalClassesDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ConditionalClassesDirective, "[conditionalClasses]", never, { "element": { "alias": "element"; "required": false; "isSignal": true; }; "classes": { "alias": "conditionalClasses"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class UtilitiesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtilitiesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<UtilitiesModule, never, [typeof SpaceCasePipe, typeof PhoneNumberPipe, typeof FunctionPipe, typeof StopPropagationDirective, typeof StylerDirective, typeof PreventEnterDirective, typeof AutoFocusDirective, typeof TrimWhitespaceDirective, typeof ClickSubjectDirective, typeof ClickEmitterDirective, typeof DialogDirective, typeof MatSlideToggleGroupDirective, typeof ConditionalClassesDirective], [typeof StopPropagationDirective, typeof PreventEnterDirective, typeof SpaceCasePipe, typeof PhoneNumberPipe, typeof FunctionPipe, typeof StopPropagationDirective, typeof TrimWhitespaceDirective, typeof StylerDirective, typeof PreventEnterDirective, typeof AutoFocusDirective, typeof ClickSubjectDirective, typeof ClickEmitterDirective, typeof DialogDirective, typeof MatSlideToggleGroupDirective, typeof ConditionalClassesDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<UtilitiesModule>;
+}
+
+declare class ColumnTotalPipe implements PipeTransform {
+    transform(data: any[], metaData: MetaData): number | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnTotalPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ColumnTotalPipe, "columnTotal", true>;
+}
+
+declare class TableBuilder<T = any> {
+    private data$;
+    metaData$: Observable<MetaData<T>[]>;
+    constructor(data$: Observable<T[]>, metaData$?: Observable<MetaData<T, any>[]>, settings?: TableBuilderSettings | Observable<TableBuilderSettings>);
+    settings: Observable<GeneralTableSettings>;
+    getData$(): Observable<any[]>;
+    createMetaData(obj: any): MetaData[];
+    cleanVal(val: any, metaData: MetaData): any;
+    cleanRecord(record: T, metadata: MetaData[]): T;
+}
+declare const CreateTableBuilder: (reportDef$: Observable<ReportDef>) => TableBuilder;
+
+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": { "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; }; }, {}, never, never, true, never>;
+}
+
+declare class MultiSortDirective extends MatSort implements OnInit, OnDestroy {
+    private state;
+    rules: Sort[];
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSortDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MultiSortDirective, "[multiSort]", ["multiSort"], { "disabled": { "alias": "matSortDisabled"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare function stateIs(initializationState: InitializationState): (state: TableState) => boolean;
+declare class TableStore extends ComponentStore<TableState> {
+    constructor();
+    getSavableState(): Observable<PersistedTableState>;
+    on: <V>(srcObservable: Observable<V>, func: (obj: V) => void) => void;
+    onLast(callback: (state: TableState) => void): void;
+    readonly metaData$: Observable<Dictionary<MetaData<any, []>>>;
+    readonly metaDataArray$: Observable<MetaData<any, []>[]>;
+    getMetaData$: (key: string) => Observable<MetaData>;
+    getUserDefinedWidth$: (key: string) => Observable<number>;
+    getUserDefinedWidths$: Observable<Dictionary<number>>;
+    private displayedColumns;
+    readonly displayedColumns$: Observable<string[]>;
+    readonly hideColumn: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
+    readonly resetState: () => void;
+    readonly showColumn: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
+    readonly setHiddenColumns: (observableOrValue: {
+        key: string;
+        visible: boolean;
+    }[] | Observable<{
+        key: string;
+        visible: boolean;
+    }[]>) => rxjs.Subscription;
+    setUserDefinedWidth: (observableOrValue: {
+        key: string;
+        widthInPixel: number;
+    }[] | Observable<{
+        key: string;
+        widthInPixel: number;
+    }[]>) => rxjs.Subscription;
+    setUserDefinedOrder: (observableOrValue: {
+        newOrder: number;
+        oldOrder: number;
+    } | Observable<{
+        newOrder: number;
+        oldOrder: number;
+    }>) => rxjs.Subscription;
+    readonly filters$: Observable<Dictionary<FilterInfo<any> | CustomFilter<any>>>;
+    readonly getFilter$: (filterId: string) => Observable<FilterInfo | CustomFilter | undefined>;
+    readonly addFilter: (observableOrValue: FilterInfo<any> | CustomFilter<any> | Observable<FilterInfo<any> | CustomFilter<any>>) => rxjs.Subscription;
+    readonly addFilters: (observableOrValue: (FilterInfo<any> | CustomFilter<any>)[] | Observable<(FilterInfo<any> | CustomFilter<any>)[]>) => rxjs.Subscription;
+    private addFiltersToState;
+    readonly removeFilter: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
+    readonly removeFilters: (observableOrValue: string[] | Observable<string[]>) => rxjs.Subscription;
+    readonly clearFilters: () => void;
+    readonly sorted$: Observable<Sort[]>;
+    createPreSort: (metaDatas: Dictionary<MetaData>) => Sort[];
+    readonly setSort: (observableOrValue: {
+        key: string;
+        direction?: SortDirection$1;
+    } | Observable<{
+        key: string;
+        direction?: SortDirection$1;
+    }>) => rxjs.Subscription;
+    readonly setAllSort: (observableOrValue: Sort[] | Observable<Sort[]>) => rxjs.Subscription;
+    updateStateFunc: (state: TableState, incomingTableState: Partial<TableState>) => TableState;
+    readonly setPageSize: (observableOrValue: number | Observable<number>) => rxjs.Subscription;
+    readonly updateState: (observableOrValue: Partial<TableState> | Observable<Partial<TableState>>) => rxjs.Subscription;
+    cleanPersistedState(state: TableState, pState: PersistedTableState): {
+        filters: any;
+        sorted: Sort[];
+        hiddenKeys?: string[];
+        pageSize?: number;
+        userDefined: {
+            order: Dictionary<number>;
+            widths: Dictionary<number>;
+            table: {
+                width?: number;
+            };
+        };
+        persistedTableSettings: PesrsistedTableSettings;
+        groupByKeys: string[];
+        groups: Group[];
+    };
+    readonly updateStateFromPersistedState: (observableOrValue: PersistedTableState | Observable<PersistedTableState>) => rxjs.Subscription;
+    getUserDefinedTableSize$: Observable<number | undefined>;
+    setTableWidth: (observableOrValue: number | Observable<number>) => rxjs.Subscription;
+    mergeMeta: (orig: MetaData, merge: MetaData) => MetaData;
+    readonly setIntializationState: (observableOrValue: InitializationState | Observable<InitializationState>) => rxjs.Subscription;
+    runOnceWhen(predicate: Predicate<TableState>, func: (state: TableState) => void): void;
+    onReady(func: (state: TableState) => void): void;
+    readonly setMetaData: (observableOrValue: MetaData<any, []> | MetaData<any, []>[] | Observable<MetaData<any, []> | MetaData<any, []>[]>) => rxjs.Subscription;
+    private initializeOrder;
+    toggleCollapseHeader: () => void;
+    toggleCollapseFooter: () => void;
+    addGroupByKey: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
+    removeGroupByKey: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
+    updateGroups: (observableOrValue: Group[] | Observable<Group[]>) => rxjs.Subscription;
+    groupByKeys$: Observable<string[]>;
+    groups$: Observable<Group[]>;
+    setTableSettings: (observableOrValue: GeneralTableSettings | Observable<GeneralTableSettings>) => rxjs.Subscription;
+    tableSettings$: Observable<PesrsistedTableSettings & NotPersisitedTableSettings>;
+    setLinkMaps: (() => void) | ((observableOrValue: any) => rxjs.Subscription);
+    getLinkMap: (md: MetaData) => Observable<{
+        link: (t: any) => string;
+        useRouterLink: boolean;
+        target: _saydar_table_builder.Target;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableStore>;
+}
+declare const orderViewableMetaData: (state: TableState) => MetaData<any, []>[];
+declare const orderMetaData: (state: TableState) => MetaData<any, []>[];
+
+declare class ResizeColumnDirective implements OnInit {
+    private renderer;
+    private el;
+    store: TableStore;
+    readonly resizable: i0.InputSignal<boolean>;
+    readonly key: i0.InputSignal<string>;
+    ngOnInit(): void;
+    createResizerSpanInColumnHead(columnHead: HTMLElement): any;
+    getTableAndColumnHeadHtmlElements(): {
+        table: HTMLElement;
+        columnHead: HTMLElement;
+    };
+    mouseDownThroghMouseUpEventMapper(resizer: HTMLElement, columnHead: HTMLElement, table: HTMLElement): rxjs.Observable<{
+        mouseDownData: {
+            startPageX: number;
+            startColumnWidth: number;
+            startTableWidth: number;
+        };
+        mouseMove: MouseEvent;
+    }>;
+    resizerMouseDownEventMapper(resizer: HTMLElement, columnHead: HTMLElement, table: HTMLElement): 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": { "alias": "resizeColumn"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+interface MouseDowmData {
+    startPageX: number;
+    startColumnWidth: number;
+    startTableWidth: number;
+}
+
+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>;
+}
+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": { "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>;
+}
+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>;
+}
+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>;
+}
+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, true, never>;
+}
+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>;
+}
+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>;
+}
+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>;
+}
+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>;
+}
+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>;
+}
+
+declare class TableWrapperDirective {
+    readonly customFilters: i0.Signal<readonly TableCustomFilterDirective<any>[]>;
+    readonly filters: i0.Signal<readonly 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, true, never>;
+}
+
+declare class VirtualScrollViewportDirective {
+    private el;
+    private tbComponent;
+    offset: number;
+    set isVs(val: boolean | string);
+    _isVs: boolean;
+    private resizeFn;
+    private resizeTimeout;
+    destroyed$: Subject<void>;
+    addListener(callback: () => void): void;
+    removeListener(): void;
+    private adjustViewportHeight;
+    resize(): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualScrollViewportDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<VirtualScrollViewportDirective, "tb-table-container[isVs]", ["vs"], { "offset": { "alias": "offset"; "required": false; }; "isVs": { "alias": "isVs"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ExportToCsvService<T> {
+    state: TableStore;
+    private config;
+    private 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>>;
+}
+
+interface ColumnInfo {
+    metaData: MetaData;
+    customCell: CustomCellDirective;
+}
+
+interface widthStyle {
+    flex?: string;
+    maxWidth?: string;
+}
+interface allStyles {
+    body: widthStyle;
+    header: widthStyle;
+    footer: widthStyle;
+}
+declare class ColumnBuilderComponent implements OnInit {
+    private transformCreator;
+    private table;
+    state: TableStore;
+    private templateService;
+    protected injector: Injector;
+    FieldType: typeof FieldType;
+    filter: Partial<FilterInfo>;
+    metaData: MetaData;
+    customCell: CustomCellDirective;
+    data$: Observable<any[]>;
+    readonly columnDef: i0.Signal<MatColumnDef>;
+    outerTemplate: TemplateRef<any>;
+    innerTemplate: TemplateRef<any>;
+    transform: (o: any, ...args: any[]) => any;
+    readonly bodyTemplate: i0.Signal<TemplateRef<any>>;
+    getInnerTemplate(): TemplateRef<any>;
+    showfilters$: Observable<boolean>;
+    getOuterTemplate(): TemplateRef<any>;
+    classes?: Dictionary$1<Predicate<any>>;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    cellClicked(element: any, key: string): void;
+    mapWidth: ([previousUserDefinedWidth, currentUserDefinedWidth]: [number, number]) => widthStyle;
+    styles$: Observable<allStyles>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnBuilderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnBuilderComponent, "tb-column-builder", never, { "metaData": { "alias": "metaData"; "required": false; }; "customCell": { "alias": "customCell"; "required": false; }; "data$": { "alias": "data$"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MatTableObservableDataSource<T> extends MatTableDataSource<T> {
+    private dataSrc;
+    subscription?: Subscription;
+    constructor(dataSrc: Observable<T[]>);
+    connect(): rxjs.BehaviorSubject<T[]>;
+    disconnect(): void;
+}
+declare class TableVirtualScrollObservableDataSource<T> extends TableVirtualScrollDataSource<T> {
+    private dataSrc;
+    subscription?: Subscription;
+    constructor(dataSrc: Observable<T[]>);
+    connect(): rxjs.BehaviorSubject<T[]>;
+    disconnect(): void;
+}
+
+declare class GenericTableDataSource<T> extends MatTableObservableDataSource<T> {
+    constructor(dataSrc: Observable<T[]>);
+}
+
+declare class PaginatorComponent implements OnInit, AfterViewInit {
+    private state;
+    readonly dataSource: i0.InputSignal<GenericTableDataSource<any>>;
+    readonly tableElRef: i0.InputSignal<ElementRef<any>>;
+    readonly paginator: i0.Signal<MatPaginator>;
+    currentPageData$: Observable<CurrentPageDetails>;
+    collapseFooter$: Observable<boolean>;
+    readonly data$: i0.InputSignal<Observable<any[]>>;
+    readonly paginatorChangeEmitter: i0.OutputEmitterRef<void>;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    paginatorChange(): void;
+    ourPageEvent: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PaginatorComponent, "tb-paginator", never, { "dataSource": { "alias": "dataSource"; "required": true; "isSignal": true; }; "tableElRef": { "alias": "tableElRef"; "required": true; "isSignal": true; }; "data$": { "alias": "data$"; "required": true; "isSignal": true; }; }, { "paginatorChangeEmitter": "paginatorChangeEmitter"; }, never, never, true, never>;
+}
+interface CurrentPageDetails {
+    currentStart: number;
+    currentEnd: number;
+    total: number;
+}
+
+declare class GenericTableComponent implements OnInit {
+    protected sort: MatSort;
+    state: TableStore;
+    private viewContainer;
+    drop(event: CdkDragDrop<string[]>): void;
+    readonly $data: i0.InputSignal<Observable<any[]>>;
+    readonly $indexColumn: i0.InputSignal<boolean>;
+    readonly $selectionColumn: i0.InputSignal<boolean>;
+    readonly $trackBy: i0.InputSignal<string>;
+    readonly $rows: i0.InputSignal<readonly MatRowDef<any>[]>;
+    readonly $isSticky: i0.InputSignal<boolean>;
+    readonly $columnBuilders: i0.InputSignal<ColumnBuilderComponent[]>;
+    readonly $columnInfos: i0.InputSignal<Observable<ColumnInfo[]>>;
+    readonly $groupHeaderTemplate: i0.InputSignal<TemplateRef<any> | null>;
+    readonly $compareWithKey: i0.InputSignal<string>;
+    readonly $hasIndexColumn: i0.Signal<boolean>;
+    readonly $hasSelectionColumn: i0.Signal<boolean>;
+    private _disableSort;
+    set disableSort(val: boolean);
+    get disableSort(): boolean;
+    readonly $table: i0.Signal<MatTable<any>>;
+    readonly $dropList: i0.Signal<CdkDropList<any>>;
+    readonly $tableElRef: i0.Signal<ElementRef<any>>;
+    readonly $paginatorComponent: i0.Signal<PaginatorComponent>;
+    readonly paginatorChange$: i0.OutputEmitterRef<void>;
+    currentColumns: string[];
+    dataSource: any;
+    keys: string[];
+    injector: Injector;
+    rowDefArr: MatRowDef<any>[];
+    columns: string[];
+    myColumns: Dictionary<ColumnBuilderComponent>;
+    showHeader$: Observable<boolean>;
+    private _injector;
+    constructor();
+    trackByFunction: (index: number, item: any) => any;
+    ngOnChanges(changes: SimpleChanges): void;
+    customCompare: (o1: any, o2: any) => boolean;
+    updateSelection: (data: any[]) => void;
+    ngOnInit(): void;
+    createDataSource(): void;
+    isGroupHeader(_: number, row: {
+        isGroupHeader: boolean;
+    }): boolean;
+    isGroupFooter(_: number, row: {
+        isGroupFooter: boolean;
+    }): boolean;
+    updateGroup(group: Group): void;
+    addMetaData(column: ColumnInfo): void;
+    initializeRowDefs: (defs: MatRowDef<any>[]) => void;
+    selection: SelectionModel<any>;
+    selection$: Observable<any>;
+    masterToggleChecked$: Observable<boolean>;
+    masterToggleIndeterminate$: Observable<boolean>;
+    isAllSelected(): boolean;
+    /** Selects all rows if they are not all selected; otherwise clear selection. */
+    masterToggle(): void;
+    tableWidth: Observable<{
+        width: string;
+    } | {
+        width?: undefined;
+    }>;
+    collapseFooter$: Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenericTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GenericTableComponent, "tb-generic-table", never, { "$data": { "alias": "data$"; "required": true; "isSignal": true; }; "$indexColumn": { "alias": "IndexColumn"; "required": false; "isSignal": true; }; "$selectionColumn": { "alias": "SelectionColumn"; "required": false; "isSignal": true; }; "$trackBy": { "alias": "trackBy"; "required": true; "isSignal": true; }; "$rows": { "alias": "rows"; "required": true; "isSignal": true; }; "$isSticky": { "alias": "isSticky"; "required": false; "isSignal": true; }; "$columnBuilders": { "alias": "columnBuilders"; "required": false; "isSignal": true; }; "$columnInfos": { "alias": "columnInfos"; "required": true; "isSignal": true; }; "$groupHeaderTemplate": { "alias": "groupHeaderTemplate"; "required": false; "isSignal": true; }; "$compareWithKey": { "alias": "compareWithKey"; "required": false; "isSignal": true; }; "disableSort": { "alias": "disableSort"; "required": false; }; }, { "paginatorChange$": "paginatorChange"; "selection$": "selection$"; }, never, never, true, never>;
+}
+declare class GenericTableVsComponent extends GenericTableComponent {
+    createDataSource(): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenericTableVsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GenericTableVsComponent, "tb-generic-table-vs", never, {}, {}, never, never, true, never>;
+}
+
+declare class TableContainerComponent<T = any> {
+    state: TableStore;
+    exportToCsvService: ExportToCsvService<T>;
+    private config;
+    private store;
+    private wrapper;
+    readonly $genericTableComponent: i0.Signal<GenericTableComponent>;
+    readonly $customFilters: i0.Signal<readonly TableCustomFilterDirective<any>[]>;
+    readonly $filters: i0.Signal<readonly TableFilterDirective[]>;
+    readonly $customRows: i0.Signal<readonly MatRowDef<unknown>[]>;
+    readonly $customCells: i0.Signal<readonly CustomCellDirective[]>;
+    tableId: string;
+    tableBuilder: TableBuilder;
+    readonly $indexColumn: i0.InputSignal<boolean>;
+    readonly $selectionColumn: i0.InputSignal<boolean>;
+    readonly $trackBy: i0.InputSignal<string>;
+    readonly $isSticky: i0.InputSignal<boolean>;
+    readonly $inputFilters: i0.InputSignal<Observable<Predicate<T>[]> | undefined>;
+    readonly $groupHeaderTemplate: i0.InputSignal<TemplateRef<any> | null>;
+    readonly $compareWithKey: i0.InputSignal<string>;
+    set isVs(val: boolean | string);
+    set pageSize(value: number);
+    readonly selection$: i0.OutputEmitterRef<any>;
+    readonly paginatorChange$: i0.OutputEmitterRef<void>;
+    readonly onStateReset$: i0.OutputEmitterRef<void>;
+    readonly onSaveState$: i0.OutputEmitterRef<void>;
+    dataSubject: ReplaySubject<Observable<T[]>>;
+    data: Observable<T[]>;
+    _isVs: boolean;
+    state$: Observable<PersistedTableState>;
+    myColumns$: Observable<ColumnInfo[]>;
+    stateKeys$?: Observable<string[] | null>;
+    currentStateKey$?: Observable<string>;
+    disableSort: boolean;
+    constructor();
+    firstPage(): void;
+    lastPage(): void;
+    resetState(): void;
+    initializeState(): void;
+    customFiltersSubject$: 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[];
+    setDisplay: (data: any[], groups: Group[]) => any[];
+    shouldDisplay: (currentGroup?: Group, groups?: Group[]) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableContainerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableContainerComponent<any>, "tb-table-container", never, { "tableId": { "alias": "tableId"; "required": false; }; "tableBuilder": { "alias": "tableBuilder"; "required": false; }; "$indexColumn": { "alias": "IndexColumn"; "required": false; "isSignal": true; }; "$selectionColumn": { "alias": "SelectionColumn"; "required": false; "isSignal": true; }; "$trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "$isSticky": { "alias": "isSticky"; "required": false; "isSignal": true; }; "$inputFilters": { "alias": "inputFilters"; "required": false; "isSignal": true; }; "$groupHeaderTemplate": { "alias": "groupHeaderTemplate"; "required": false; "isSignal": true; }; "$compareWithKey": { "alias": "compareWithKey"; "required": false; "isSignal": true; }; "isVs": { "alias": "isVs"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; }, { "selection$": "selection$"; "paginatorChange$": "paginatorChange"; "onStateReset$": "OnStateReset"; "onSaveState$": "OnSaveState"; "data": "data"; "state$": "state$"; }, ["$customFilters", "$filters", "$customRows", "$customCells"], ["[before]", ".tb-header-title"], true, never>;
+}
+
+interface DisplayCol {
+    key: string;
+    displayName?: string;
+    isVisible: boolean;
+}
+
+declare class GenColDisplayerComponent {
+    private tableState;
+    columns$: Observable<DisplayCol[]>;
+    constructor();
+    reset(displayCols: DisplayCol[]): void;
+    drop(event: CdkDragDrop<string[]>): void;
+    unset(displayCols: DisplayCol[]): void;
+    emit(displayCols: DisplayCol[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenColDisplayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GenColDisplayerComponent, "tb-col-displayer", never, {}, {}, never, never, true, never>;
+}
+
+declare class WrapperFilterStore extends ComponentStore<{
+    filterInfo: PartialFilter[];
+}> {
+    constructor();
+    clearAll: () => void;
+    deleteByIndex: (observableOrValue: number | rxjs.Observable<number>) => rxjs.Subscription;
+    currentFilters$: rxjs.Observable<PartialFilter<any>[]>;
+    addFilter: (observableOrValue: PartialFilter<any> | rxjs.Observable<PartialFilter<any>>) => rxjs.Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrapperFilterStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WrapperFilterStore>;
+}
+
+declare class GenFilterDisplayerComponent {
+    tableState: TableStore;
+    filterStore: WrapperFilterStore;
+    constructor();
+    filterCols$: Observable<MetaData[]>;
+    addFilter(metaData: MetaData): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenFilterDisplayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GenFilterDisplayerComponent, "tb-filter-displayer", never, {}, {}, never, never, true, never>;
+}
+
+declare class DateFilterComponent {
+    FilterType: typeof FilterType;
+    readonly info: i0.InputSignal<PartialFilter<any>>;
+    readonly CurrentFilterType: i0.InputSignal<FilterType>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateFilterComponent, "tb-date-filter", never, { "info": { "alias": "info"; "required": true; "isSignal": true; }; "CurrentFilterType": { "alias": "CurrentFilterType"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FilterComponent<T extends mappedFieldTypes = any> {
+    state: TableStore;
+    filterTypes: Omit<{
+        0: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            "Is At": FilterType[];
+            "Is Not At": FilterType[];
+            "At or After": FilterType[];
+            "At or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+            Custom: FilterType[];
+        }>;
+        1: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            "Is At": FilterType[];
+            "Is Not At": FilterType[];
+            "At or After": FilterType[];
+            "At or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+            Custom: FilterType[];
+        }>;
+        2: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            "Is At": FilterType[];
+            "Is Not At": FilterType[];
+            "At or After": FilterType[];
+            "At or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+            Custom: FilterType[];
+        }>;
+        3: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            "Is At": FilterType[];
+            "Is Not At": FilterType[];
+            "At or After": FilterType[];
+            "At or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+            Custom: FilterType[];
+        }>;
+        4: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            "Is At": FilterType[];
+            "Is Not At": FilterType[];
+            "At or After": FilterType[];
+            "At or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+            Custom: FilterType[];
+        }>;
+        5: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            "Is At": FilterType[];
+            "Is Not At": FilterType[];
+            "At or After": FilterType[];
+            "At or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+            Custom: FilterType[];
+        }>;
+        6: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            "Is At": FilterType[];
+            "Is Not At": FilterType[];
+            "At or After": FilterType[];
+            "At or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+            Custom: FilterType[];
+        }>;
+        7: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            "Is At": FilterType[];
+            "Is Not At": FilterType[];
+            "At or After": FilterType[];
+            "At or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+            Custom: FilterType[];
+        }>;
+        8: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            "Is At": FilterType[];
+            "Is Not At": FilterType[];
+            "At or After": FilterType[];
+            "At or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+            Custom: FilterType[];
+        }>;
+        9: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            "Is At": FilterType[];
+            "Is Not At": FilterType[];
+            "At or After": FilterType[];
+            "At or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+            Custom: FilterType[];
+        }>;
+        10: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            "Is At": FilterType[];
+            "Is Not At": FilterType[];
+            "At or After": FilterType[];
+            "At or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+            Custom: FilterType[];
+        }>;
+        11: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            "Is At": FilterType[];
+            "Is Not At": FilterType[];
+            "At or After": FilterType[];
+            "At or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+            Custom: FilterType[];
+        }>;
+        12: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            "Is At": FilterType[];
+            "Is Not At": FilterType[];
+            "At or After": FilterType[];
+            "At or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+            Custom: FilterType[];
+        }>;
+        13: Partial<{
+            Equals: FilterType[];
+            "Does Not Equal": FilterType[];
+            "Greater Than": FilterType[];
+            "Less Than": FilterType[];
+            Between: FilterType[];
+            Contains: FilterType[];
+            "Does Not Contain": FilterType[];
+            "Start With": FilterType[];
+            "Ends With": FilterType[];
+            "Is on": FilterType[];
+            "Is Not On": FilterType[];
+            "On or After": FilterType[];
+            "On or Before": FilterType[];
+            "Is At": FilterType[];
+            "Is Not At": FilterType[];
+            "At or After": FilterType[];
+            "At or Before": FilterType[];
+            Is: FilterType[];
+            "Is Blank": FilterType[];
+            Or: FilterType[];
+            And: FilterType[];
+            In: FilterType[];
+            Custom: FilterType[];
+        }>;
+    }, UnmappedTypes>;
+    FilterType: typeof FilterType;
+    FieldType: typeof FieldType;
+    filter: PartialFilter;
+    readonly close: i0.OutputEmitterRef<void>;
+    currentFilterType?: FilterType;
+    ngOnInit(): void;
+    onEnter(filter: FilterInfo, event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterComponent<any>, "tb-filter", never, { "filter": { "alias": "filter"; "required": false; }; }, { "close": "close"; }, never, never, true, never>;
+}
+
+declare class NumberFilterComponent {
+    FilterType: typeof FilterType;
+    FieldType: typeof FieldType;
+    readonly CurrentFilterType: i0.InputSignal<FilterType>;
+    info: PartialFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NumberFilterComponent, "tb-number-filter", never, { "CurrentFilterType": { "alias": "CurrentFilterType"; "required": true; "isSignal": true; }; "info": { "alias": "info"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ArrayColumnComponent {
+    private config;
+    ArrayStyle: typeof ArrayStyle;
+    additional: ArrayAdditional;
+    array: any[];
+    readonly metaData: i0.InputSignal<MetaData<any, []>>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArrayColumnComponent, "tb-array-column", never, { "array": { "alias": "array"; "required": false; }; "metaData": { "alias": "metaData"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class LinkColumnComponent {
+    protected store: TableStore;
+    readonly metaData: i0.InputSignal<MetaData<any, []>>;
+    readonly element: i0.InputSignal<any>;
+    readonly transform: i0.InputSignal<(a: any) => any>;
+    link: (metaData: MetaData) => rxjs.Observable<{
+        link: (t: any) => string;
+        useRouterLink: boolean;
+        target: _saydar_table_builder.Target;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LinkColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LinkColumnComponent, "tb-link-column", never, { "metaData": { "alias": "metaData"; "required": true; "isSignal": true; }; "element": { "alias": "element"; "required": true; "isSignal": true; }; "transform": { "alias": "transform"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HeaderMenuComponent {
+    tableState: TableStore;
+    FieldType: typeof FieldType;
+    FilterType: typeof FilterType;
+    myFilterType: FilterType;
+    myFilterValue: any;
+    readonly filter: i0.InputSignal<Partial<FilterInfo<any>>>;
+    readonly metaData: i0.InputSignal<MetaData<any, []>>;
+    readonly trigger: i0.Signal<MatMenuTrigger>;
+    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": { "alias": "filter"; "required": true; "isSignal": true; }; "metaData": { "alias": "metaData"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+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>;
+}
+
+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>;
+}
+
+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>;
+}
+
+declare class InFilterComponent implements ControlValueAccessor {
+    private ref;
+    FieldType: typeof FieldType;
+    readonly type: i0.InputSignal<FieldType>;
+    value: any[];
+    constructor();
+    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": { "alias": "type"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class InitializationComponent {
+    readonly linkTemplate: i0.Signal<TemplateRef<any>>;
+    readonly imageUrlTemplate: i0.Signal<TemplateRef<any>>;
+    readonly currencyTemplate: i0.Signal<TemplateRef<any>>;
+    readonly arrayTemplate: i0.Signal<TemplateRef<any>>;
+    readonly defaultTemplate: i0.Signal<TemplateRef<any>>;
+    readonly defaultWithIcon: i0.Signal<TemplateRef<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InitializationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InitializationComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class InListFilterComponent implements ControlValueAccessor {
+    private ref;
+    private tableState;
+    value: string[];
+    FieldType: typeof FieldType;
+    writeValue(obj: string[]): void;
+    onChange: (_: any) => void;
+    registerOnChange(fn: any): void;
+    onTouched: () => void;
+    registerOnTouched(fn: any): void;
+    readonly key: i0.InputSignal<string>;
+    keyValues$: Observable<Dictionary<string>>;
+    selectedKeys: string[];
+    metaData: MetaData;
+    ngOnInit(): void;
+    selectFilterChanged($event: any, val: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InListFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InListFilterComponent, "tb-in-list-filter , [tb-in-list-filter]", never, { "key": { "alias": "key"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SortMenuComponentStore extends ComponentStore<ComponenStoreState> {
+    private tableState;
+    constructor();
+    private set;
+    setSorted: (observableOrValue: SortWithName[] | rxjs.Observable<SortWithName[]>) => rxjs.Subscription;
+    setNotSorted: (observableOrValue: SortWithName[] | rxjs.Observable<SortWithName[]>) => rxjs.Subscription;
+    sorted$: rxjs.Observable<SortWithName[]>;
+    notSorted$: rxjs.Observable<SortWithName[]>;
+    setDirection: (observableOrValue: SortWithName | rxjs.Observable<SortWithName>) => rxjs.Subscription;
+    reset: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortMenuComponentStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SortMenuComponentStore>;
+}
+interface ComponenStoreState {
+    sorted: SortWithName[];
+    notSorted: SortWithName[];
+}
+interface SortWithName extends Sort {
+    displayName: string;
+}
+
+declare class SortMenuComponent implements OnInit {
+    private tableState;
+    store: SortMenuComponentStore;
+    sorted$: Observable<SortWithName[]>;
+    notSorted$: Observable<SortWithName[]>;
+    SortDirection: typeof SortDirection;
+    dirty$: BehaviorSubject<boolean>;
+    constructor();
+    reset(): void;
+    ngOnInit(): void;
+    dropIntoSorted(event: CdkDragDrop<SortWithName[]>): void;
+    dropIntoNotSorted(event: CdkDragDrop<SortWithName[]>): void;
+    apply: (observableOrValue: Observable<null> | null) => rxjs.Subscription;
+    setDirection(sort: SortWithName): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SortMenuComponent, "tb-sort-menu", never, {}, {}, never, never, true, never>;
+}
+
+declare class FilterChipsComponent {
+    tableState: TableStore;
+    private filterStore;
+    filters$: Observable<FilterInfo<any>[]>;
+    deleteByIndex(index: number): void;
+    addFilter(filter: FilterInfo<any>): void;
+    clearAll(): void;
+    currentFilters$: Observable<_saydar_table_builder.PartialFilter<any>[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterChipsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterChipsComponent, "lib-filter-list", never, {}, {}, never, never, true, never>;
+}
+
+declare class GroupByListComponent implements OnInit {
+    tableStore: TableStore;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GroupByListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GroupByListComponent, "group-by-list", never, {}, {}, never, never, true, never>;
+}
+
+declare class DateTimeFilterComponent {
+    FilterType: typeof FilterType;
+    readonly info: i0.InputSignal<PartialFilter<any>>;
+    readonly CurrentFilterType: i0.InputSignal<FilterType>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateTimeFilterComponent, "tb-date-time-filter", never, { "info": { "alias": "info"; "required": true; "isSignal": true; }; "CurrentFilterType": { "alias": "CurrentFilterType"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TableBuilderModule {
+    static forRoot(config: TableBuilderConfig): ModuleWithProviders<TableBuilderModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableBuilderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TableBuilderModule, never, [typeof i1.CommonModule, typeof _ngrx_store.StoreFeatureModule, typeof i3.EffectsFeatureModule, typeof i4.FormsModule, typeof i5.RouterModule, typeof i6.LetDirective, typeof i7.DragDropModule, typeof UtilitiesModule, typeof i9.ScrollingModule, typeof i10.TableVirtualScrollModule, typeof ColumnTotalPipe, typeof TableContainerComponent, typeof GenericTableComponent, typeof GenericTableVsComponent, typeof PaginatorComponent, typeof CustomCellDirective, typeof GenColDisplayerComponent, typeof GenFilterDisplayerComponent, typeof DateFilterComponent, typeof FilterComponent, typeof MultiSortDirective, typeof NumberFilterComponent, typeof ColumnBuilderComponent, typeof ArrayColumnComponent, typeof LinkColumnComponent, typeof HeaderMenuComponent, typeof KeyDisplayPipe, typeof FormatFilterValuePipe, typeof FormatFilterTypePipe, typeof ResizeColumnDirective, typeof InFilterComponent, typeof InitializationComponent, typeof InListFilterComponent, typeof SortMenuComponent, typeof FilterChipsComponent, typeof MatSlideToggleTbFilterDirective, typeof MatRadioButtonTbFilterDirective, typeof MatOptionTbFilterDirective, typeof MatCheckboxTbFilterDirective, typeof MatButtonToggleFilterDirective, typeof TableFilterDirective, typeof TableFilterStringContainsDirective, typeof TableWrapperDirective, typeof GroupByListComponent, typeof DateTimeFilterComponent], [typeof GenericTableComponent, typeof GenericTableVsComponent, typeof PaginatorComponent, typeof TableContainerComponent, typeof CustomCellDirective, typeof GenColDisplayerComponent, typeof GenFilterDisplayerComponent, typeof FilterComponent, typeof MultiSortDirective, typeof ResizeColumnDirective, typeof MatSlideToggleTbFilterDirective, typeof MatRadioButtonTbFilterDirective, typeof MatOptionTbFilterDirective, typeof MatCheckboxTbFilterDirective, typeof MatButtonToggleFilterDirective, typeof TableFilterDirective, typeof TableFilterStringContainsDirective, typeof TableWrapperDirective, typeof GroupByListComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TableBuilderModule>;
+}
+
+declare function defaultShareReplay<T>(): (src: Observable<T>) => Observable<T>;
+
+declare function mapError<T, TResult>(projection: (error: any) => TResult): (src: Observable<T>) => Observable<T | TResult>;
+
+declare const onceWhen: <T>(predicate: Predicate<T>) => (src: Observable<T>) => Observable<T>;
+declare const mapArray: <T, U>(mapFunc: (src: T) => U) => (source: Observable<T[]>) => Observable<U[]>;
+declare const filterArray: <T>(filterFunc: (src: T) => boolean) => (source: Observable<T[]>) => Observable<T[]>;
+declare function onWait<T, V extends T>(val: V): MonoTypeOperatorFunction<T>;
+declare const combineArrays: <T>(sources: Observable<T[]>[]) => Observable<T[]>;
+declare function switchOff(switchSource: Observable<boolean>, defaultState?: boolean): <T>(source: Observable<T>) => Observable<T>;
+declare function skipOneWhen(skipper: Observable<any>): <T>(source: Observable<T>) => Observable<T>;
+declare function previousAndCurrent<T>(startingValue: T): OperatorFunction<T, [T, T]>;
+declare function notNull<T>(): OperatorFunction<(T | null | undefined), T>;
+declare function delayOn<T>(predicate: (t: T) => boolean, delayTime: number): (src: Observable<T>) => Observable<T>;
+
+type PipeLike<T> = Observable<T>['pipe'];
+declare class Subjectifier<T> extends Observable<T> {
+    private _source;
+    private _subj;
+    private merged;
+    constructor(_source: Observable<T>);
+    next: Subject<T>['next'];
+    newSubj: (...operations: Parameters<PipeLike<T>>) => Subjectifier<unknown>;
+}
+
+declare class AppStatusState {
+    readonly ActionStatusBar: ActionStatus[];
+}
+interface StatusState {
+    ids: string[];
+    entities: {
+        [id: string]: ActionStatus;
+    };
+}
+declare class ActionStatus {
+    id: string;
+    displayName?: string;
+    status: serverStatusTypes;
+    responsePayload?: any;
+}
+declare enum serverStatusTypes {
+    notStarted = 0,
+    inProgress = 1,
+    success = 2,
+    error = 3
+}
+declare const statusAdapter: _ngrx_entity.EntityAdapter<ActionStatus>;
+interface State extends EntityState<ActionStatus> {
+}
+declare const initialState: StatusState;
+declare const getStatusState: _ngrx_store.MemoizedSelector<object, State, _ngrx_store.DefaultProjectorFn<State>>;
+declare const selectIds: _ngrx_store.MemoizedSelector<object, string[] | number[], (entityState: EntityState<ActionStatus>) => string[] | number[]>;
+declare const selectEntities: _ngrx_store.MemoizedSelector<object, _ngrx_entity.Dictionary<ActionStatus>, (entityState: EntityState<ActionStatus>) => _ngrx_entity.Dictionary<ActionStatus>>;
+declare const selectAll: _ngrx_store.MemoizedSelector<object, ActionStatus[], (entityState: EntityState<ActionStatus>) => ActionStatus[]>;
+declare const selectTotal: _ngrx_store.MemoizedSelector<object, number, (entityState: EntityState<ActionStatus>) => number>;
+declare const selectEntity: (id: string) => _ngrx_store.MemoizedSelector<object, any, (s1: _ngrx_entity.Dictionary<ActionStatus>) => any>;
+declare function actionStatusReducer(state: StatusState | undefined, action: Action): StatusState;
+
+declare class NgrxExtModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgrxExtModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgrxExtModule, never, [typeof i1.CommonModule, typeof _ngrx_store.StoreFeatureModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgrxExtModule>;
+}
+
+declare class ActionStateSpinnerComponent implements OnInit {
+    status$: Observable<ActionStatus>;
+    serverActionStatus$: Observable<ActionStatus>;
+    serverStatusTypes: typeof serverStatusTypes;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionStateSpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionStateSpinnerComponent, "lib-action-state-spinner", never, { "status$": { "alias": "status$"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** @deprecated Import ActionStateSpinnerComponent directly instead. */
+declare class ActionStateUiModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionStateUiModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ActionStateUiModule, never, [typeof ActionStateSpinnerComponent], [typeof ActionStateSpinnerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ActionStateUiModule>;
+}
+
+declare function setUpStoreFactory(store: Store): () => Promise<unknown>;
+/**
+ * Creates a selector that can dispatch an action if conditions are met.
+ * Note: The props of the selector factory must include the props of the action.
+ * @param selectorFactory A method that returns selector.
+ * @param action The action that will be dispatched when conditions are met.
+ * @param [dispatchIf = defaultFilter] Optional. A method that takes the result of the selector and returns a boolean. The actions gets dispatched
+ * if true is returned. If no method is passed in than the action will be dispatched if the selector returns undefined or null.
+ */
+declare const createActionableSelector: <State, Result, Props = any>(selectorFactory: (props?: Props) => MemoizedSelector<State, Result>, action: ActionReturner<Props | undefined>, dispatchIf?: (data: Result) => boolean) => (props?: Props) => ActionableMemoizedSelector<State, Result>;
+type ActionableMemoizedSelector<State, Result> = MemoizedSelector<State, Result>;
+type ActionReturner<Props> = (props: Props) => Action;
+declare function defaultFilter(data: any): boolean;
+
+export { ActionStateSpinnerComponent, ActionStateUiModule, ActionStatus, AppStatusState, ArrayStyle, AutoFocusDirective, CancellationToken, ClickEmitterDirective, ClickSubjectDirective, ConditionalClassesDirective, CreateTableBuilder, CustomCellDirective, DateFilterComponent, DialogDirective, DialogService, DialogWrapper, FieldType, FilterChipsComponent, FilterComponent, FilterType, FunctionPipe, GenColDisplayerComponent, GenFilterDisplayerComponent, GeneralTableSettings, GenericTableComponent, GenericTableVsComponent, GroupByListComponent, HttpErrorStateDirective, HttpInProgressStateDirective, HttpNotStartedStateDirective, HttpRequestModule, HttpRequestStateDirective, HttpRequestStateFactory, HttpRequestStateStore, HttpRequestStatus, HttpRequestStrategy, HttpSuccessStateDirective, InitializationState, MatButtonToggleFilterDirective, MatCheckboxTbFilterDirective, MatOptionTbFilterDirective, MatRadioButtonTbFilterDirective, MatSlideToggleGroupDirective, MatSlideToggleTbFilterDirective, MatTableObservableDataSource, MultiSortDirective, NgrxExtModule, NotPersisitedTableSettings, PaginatorComponent, PesrsistedTableSettings, PhoneNumberPipe, PreventEnterDirective, ResizeColumnDirective, SortDirection, SpaceCasePipe, StopPropagationDirective, StylerDirective, Subjectifier, TableBuilder, TableBuilderModule, TableColumnHeaderSettings, TableContainerComponent, TableCustomFilterDirective, TableCustomFilterDirectiveBase, TableFilterDirective, TableFilterStringContainsDirective, TableStore, TableVirtualScrollObservableDataSource, TableWrapperDirective, TableWrapperFooterSettings, TableWrapperHeaderSettings, Target, TbSelectedFilterDirective, TrimWhitespaceDirective, UtilitiesModule, VirtualScrollViewportDirective, actionStatusReducer, chainRequest, combineArrays, createActionableSelector, createFailure, createFilterFunc, createSuccess, defaultFilter, defaultShareReplay, defaultTableState, delayOn, filterArray, filterTypeMap, getRequestorBody, getRequestorStatus, getStatusState, httpRequest, httpRequestor, inProgress, initialState, isCustomFilter, isErrorState, isFilterInfo, isSuccessOrErrorState, isSuccessState, keysToDelete, mapArray, mapError, notNull, notStarted, onWait, onceWhen, orderMetaData, orderViewableMetaData, previousAndCurrent, selectAll, selectEntities, selectEntity, selectIds, selectTotal, serverStatusTypes, setUpStoreFactory, skipOneWhen, spaceCase, stateIs, statusAdapter, statusIsSuccessOrInProgress, switchOff, tapError, tapSuccess };
+export type { ActionReturner, Additional, ArrayAdditional, CustomFilter, DateTimeOptions, FilterFunc, FilterInfo, FilterOptions, FilterState, Group, HttpRequestFactory, HttpRequestState, HttpRequestState$, HttpRequestStateAny, HttpRequestStateCancelled, HttpRequestStateError, HttpRequestStateInProgress, HttpRequestStateNotStarted, HttpRequestStateSuccess, HttpRequestStateViewContext, HttpRequestor, HttpSuccessStateViewContext, MetaData, PartialFilter, PersistedTableState, Range, ReportDef, RequestResponse, RequestStateOptions, SortDef, State, StatusState, TableBuilderSettings, TableState, UnmappedTypes, mappedFieldTypes };