import * as i0 from '@angular/core';
import { TemplateRef, ViewContainerRef, Injector, OnDestroy, PipeTransform, Predicate, AfterContentInit, OnInit, Renderer2, ElementRef, SimpleChanges, QueryList, EventEmitter, AfterViewInit, ComponentFactoryResolver, ChangeDetectorRef, 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 i37 from '@angular/router';
import { QueryParamsHandling } from '@angular/router';
import * as i23 from '@angular/material/sort';
import { Sort, SortDirection as SortDirection$1, MatSort } from '@angular/material/sort';
import * as i2 from '@angular/material/table';
import { MatRowDef, MatColumnDef, MatTable, MatTableDataSource } from '@angular/material/table';
import { CdkColumnDef } from '@angular/cdk/table';
import * as i1 from '@angular/material/slide-toggle';
import { MatSlideToggle } from '@angular/material/slide-toggle';
import * as i6 from '@angular/material/radio';
import { MatRadioButton } from '@angular/material/radio';
import { MatButtonToggle } from '@angular/material/button-toggle';
import * as i19 from '@angular/material/checkbox';
import { MatCheckbox } from '@angular/material/checkbox';
import * as i36 from '@angular/forms';
import { NgControl, ControlValueAccessor } from '@angular/forms';
import * as i12 from '@angular/material/core';
import { MatOption } from '@angular/material/core';
import * as i32 from '@angular/common';
import { DatePipe, CurrencyPipe } from '@angular/common';
import * as _ngrx_store from '@ngrx/store';
import { Store, Action, MemoizedSelector } from '@ngrx/store';
import { SelectionModel } from '@angular/cdk/collections';
import * as _ngrx_entity from '@ngrx/entity';
import { Dictionary as Dictionary$1, Predicate as Predicate$1, EntityState } from '@ngrx/entity';
import * as i39 from '@angular/cdk/drag-drop';
import { CdkDragDrop, CdkDropList } from '@angular/cdk/drag-drop';
import * as i25 from '@angular/material/paginator';
import { MatPaginator } from '@angular/material/paginator';
import * as i42 from 'ng-table-virtual-scroll';
import { TableVirtualScrollDataSource } from 'ng-table-virtual-scroll';
import * as i20 from '@angular/material/menu';
import { MatMenuTrigger } from '@angular/material/menu';
import * as i3 from '@angular/material/select';
import * as i4 from '@angular/material/dialog';
import { MatDialogRef, MatDialogConfig, MatDialog } from '@angular/material/dialog';
import * as i5 from '@angular/material/datepicker';
import * as i7 from '@angular/material/button';
import * as i8 from '@angular/material/expansion';
import * as i9 from '@angular/material/stepper';
import * as i10 from '@angular/material/toolbar';
import * as i11 from '@angular/material/tooltip';
import * as i13 from '@angular/material/progress-spinner';
import * as i14 from '@angular/material/grid-list';
import * as i15 from '@angular/material/card';
import * as i16 from '@angular/material/sidenav';
import * as i17 from '@angular/material/tabs';
import * as i18 from '@angular/material/input';
import * as i21 from '@angular/material/icon';
import * as i22 from '@angular/material/badge';
import * as i24 from '@angular/material/autocomplete';
import * as i26 from '@angular/material/chips';
import * as i35 from '@ngrx/effects';
import * as i38 from '@ngrx/component';
import * as i41 from '@angular/cdk/scrolling';

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 ColumnTotalPipe implements PipeTransform {
    transform(data: any[], metaData: MetaData): number | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnTotalPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ColumnTotalPipe, "columnTotal", false>;
}

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, false, never>;
}

declare function stateIs(initializationState: InitializationState): (state: TableState) => boolean;
declare class TableStore extends ComponentStore<TableState> {
    constructor(config: TableBuilderConfig);
    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 showColumnAt: (observableOrValue: {
        key: string;
        newOrder: number;
    } | Observable<{
        key: string;
        newOrder: number;
    }>) => rxjs.Subscription;
    readonly cycleColumnSort: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
    readonly reorderVisibleColumn: (observableOrValue: {
        previousVisibleIndex: number;
        currentVisibleIndex: number;
    } | Observable<{
        previousVisibleIndex: number;
        currentVisibleIndex: number;
    }>) => 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 MultiSortDirective extends MatSort implements OnInit, OnDestroy {
    private state;
    rules: Sort[];
    constructor(state: TableStore);
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSortDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MultiSortDirective, "[multiSort]", ["multiSort"], { "disabled": { "alias": "matSortDisabled"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ResizeColumnDirective implements OnInit {
    private renderer;
    private el;
    store: TableStore;
    resizable: boolean;
    key: string;
    constructor(renderer: Renderer2, el: ElementRef, store: TableStore);
    ngOnInit(): void;
    createResizerSpanInColumnHead(columnHead: HTMLElement): any;
    getTableAndColumnHeadHtmlElements(): {
        table: HTMLElement;
        columnHead: HTMLElement;
    };
    mouseDownThroghMouseUpEventMapper(resizer: HTMLElement, columnHead: HTMLElement, table: HTMLElement): 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": false; }; "key": { "alias": "key"; "required": false; }; }, {}, never, never, false, 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, false, 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, false, 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, false, 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, false, 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, false, 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, false, 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, false, never>;
}

declare class TableWrapperDirective {
    customFilters: QueryList<TableCustomFilterDirective>;
    filters: QueryList<TableFilterDirective>;
    registerations: (TableCustomFilterDirective | TableFilterDirective)[];
    register(filter: TableCustomFilterDirective | TableFilterDirective): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableWrapperDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableWrapperDirective, "[tbWrapper]", never, {}, {}, ["customFilters", "filters"], never, false, never>;
}

/**
 * Apply to any single-line `<input>` to keep tab and newline characters from being
 * silently replaced with spaces on paste. The pasted text is injected via the native
 * value setter so Angular's ngModel still sees the change.
 *
 * Pair with `splitCommaValue` (or any predicate that handles `[,\t\n\r]+` delimiters)
 * for the multi-value semantics. Plain typed input with regular spaces is untouched.
 */
declare class PreservePasteDelimitersDirective {
    private host;
    constructor(host: ElementRef<HTMLInputElement>);
    onPaste(e: ClipboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PreservePasteDelimitersDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PreservePasteDelimitersDirective, "input[tbPreservePasteDelimiters]", never, {}, {}, never, never, false, never>;
}

declare class ExportToCsvService<T> {
    state: TableStore;
    private config;
    private datePipe;
    constructor(state: TableStore, config: TableBuilderConfig, datePipe: DatePipe);
    exportToCsv: (data: Observable<T[]>) => void;
    csvData: (data: Array<T>, metaData: MetaData<T>[]) => string;
    metaToField: (meta: MetaData<T>, row: T) => any;
    private transform;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExportToCsvService<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ExportToCsvService<any>>;
}

interface ColumnInfo {
    metaData: MetaData;
    customCell: CustomCellDirective;
}

declare class TableContainerComponent<T = any> {
    state: TableStore;
    exportToCsvService: ExportToCsvService<T>;
    private config;
    private store;
    private wrapper;
    private genericTableComponent;
    customFilters: QueryList<TableCustomFilterDirective>;
    filters: QueryList<TableFilterDirective>;
    tableId: string;
    tableBuilder: TableBuilder;
    IndexColumn: boolean;
    SelectionColumn: boolean;
    trackBy: string;
    isSticky: boolean;
    set isVs(val: boolean | string);
    set pageSize(value: number);
    inputFilters?: Observable<Array<Predicate<T>>>;
    groupHeaderTemplate: TemplateRef<any>;
    compareWithKey: string;
    selection$: EventEmitter<any>;
    dataSubject: ReplaySubject<Observable<T[]>>;
    data: Observable<T[]>;
    paginatorChange: EventEmitter<void>;
    _isVs: boolean;
    customRows: QueryList<MatRowDef<any>>;
    customCells: QueryList<CustomCellDirective>;
    OnStateReset: EventEmitter<any>;
    OnSaveState: EventEmitter<any>;
    state$: Observable<PersistedTableState>;
    myColumns$: Observable<ColumnInfo[]>;
    stateKeys$?: Observable<string[] | null>;
    currentStateKey$?: Observable<string>;
    disableSort: boolean;
    constructor(state: TableStore, exportToCsvService: ExportToCsvService<T>, config: TableBuilderConfig, store: Store<any>, wrapper: TableWrapperDirective);
    firstPage(): void;
    lastPage(): void;
    resetState(): void;
    initializeState(): void;
    customFilters$: BehaviorSubject<Predicate<any>[]>;
    initializeData(): void;
    ngOnInit(): void;
    exportToCsv(): void;
    saveState(): void;
    setProfileState(val: string): void;
    deleteProfileState(stateKey: string): void;
    ngAfterContentInit(): void;
    InitializeColumns(): void;
    mapMetaDatas: (meta: MetaData<T>) => MetaData<T, []>;
    collapseHeader$: Observable<boolean>;
    getData(data: any[], groupByKeys: string[]): any[];
    tbGroupBy: (data: any[], groupByKeys: string[], parentGroupName?: any) => any[];
    addIndentation: (d: any) => any;
    setDisplay: (data: any[], groups: Group[]) => any[];
    shouldDisplay: (currentGroup?: Group, groups?: Group[]) => boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableContainerComponent<any>, [null, null, null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableContainerComponent<any>, "tb-table-container", never, { "tableId": { "alias": "tableId"; "required": false; }; "tableBuilder": { "alias": "tableBuilder"; "required": false; }; "IndexColumn": { "alias": "IndexColumn"; "required": false; }; "SelectionColumn": { "alias": "SelectionColumn"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; "isSticky": { "alias": "isSticky"; "required": false; }; "isVs": { "alias": "isVs"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "inputFilters": { "alias": "inputFilters"; "required": false; }; "groupHeaderTemplate": { "alias": "groupHeaderTemplate"; "required": false; }; "compareWithKey": { "alias": "compareWithKey"; "required": false; }; }, { "selection$": "selection$"; "data": "data"; "paginatorChange": "paginatorChange"; "OnStateReset": "OnStateReset"; "OnSaveState": "OnSaveState"; "state$": "state$"; }, ["customFilters", "filters", "customRows", "customCells"], ["[before]", ".tb-header-title"], false, never>;
}

declare class PhoneNumberPipe implements PipeTransform {
    transform(phoneNum: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneNumberPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PhoneNumberPipe, "phone", false>;
}

declare class PreventEnterDirective {
    onKeyDown(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PreventEnterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PreventEnterDirective, "preventEnter", never, {}, {}, never, never, false, never>;
}

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, false, never>;
}

declare class AutoFocusDirective implements AfterViewInit {
    private elementRef;
    autoFocus: boolean;
    constructor(elementRef: ElementRef);
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AutoFocusDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoFocusDirective, "[autoFocus]", never, { "autoFocus": { "alias": "autoFocus"; "required": false; }; }, {}, never, never, false, 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, false, never>;
}

declare class ClickEmitterDirective extends Subject<boolean> {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ClickEmitterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickEmitterDirective, "[clickEmitter]", ["clickEmitter"], {}, {}, never, never, false, 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, false, never>;
}

declare class StylerDirective {
    private el;
    set styler(styles: any);
    constructor(el: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<StylerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StylerDirective, "[styler]", never, { "styler": { "alias": "styler"; "required": false; }; }, {}, never, never, false, never>;
}

declare class MatSlideToggleGroupDirective {
    allowMultiple: 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; }; }, { "valueEmitter": "valueEmitter"; }, ["toggles"], never, false, never>;
}

declare class TrimWhitespaceDirective {
    private elem;
    constructor(elem: ElementRef);
    onBlur(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TrimWhitespaceDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TrimWhitespaceDirective, "input[trimWhitespace]", never, {}, {}, never, never, false, never>;
}

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", false>;
}

declare class SpaceCasePipe implements PipeTransform {
    transform(value: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpaceCasePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SpaceCasePipe, "spaceCase", false>;
}
/**
 * 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 ConditionalClassesDirective {
    private el;
    private renderer;
    constructor(el: ElementRef, renderer: Renderer2);
    element?: any;
    classes?: Dictionary$1<Predicate$1<any>>;
    classesApplied: string[];
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConditionalClassesDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ConditionalClassesDirective, "[conditionalClasses]", never, { "element": { "alias": "element"; "required": false; }; "classes": { "alias": "conditionalClasses"; "required": false; }; }, {}, never, never, false, never>;
}

declare class UtilitiesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UtilitiesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UtilitiesModule, [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], never, [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 TransformCreator {
    private datePipe;
    private currencyPipe;
    private phonePipe;
    private casePipe;
    private config;
    constructor(datePipe: DatePipe, currencyPipe: CurrencyPipe, phonePipe: PhoneNumberPipe, casePipe: SpaceCasePipe, config: TableBuilderConfig);
    createTransformer(metaData: MetaData): ((value: any, ...args: any[]) => any);
    static ɵfac: i0.ɵɵFactoryDeclaration<TransformCreator, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TransformCreator>;
}

declare class InitializationComponent {
    linkTemplate: TemplateRef<any>;
    imageUrlTemplate: TemplateRef<any>;
    currencyTemplate: TemplateRef<any>;
    arrayTemplate: TemplateRef<any>;
    defaultTemplate: TemplateRef<any>;
    defaultWithIcon: TemplateRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<InitializationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InitializationComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class TableTemplateService {
    instance: InitializationComponent;
    templates: any;
    initTemplates(): void;
    getTemplate(metaData: MetaData): TemplateRef<any>;
    constructor(resolver: ComponentFactoryResolver, i: Injector);
    static ɵfac: i0.ɵɵFactoryDeclaration<TableTemplateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TableTemplateService>;
}

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[]>;
    columnDef: MatColumnDef;
    outerTemplate: TemplateRef<any>;
    innerTemplate: TemplateRef<any>;
    transform: (o: any, ...args: any[]) => any;
    bodyTemplate: TemplateRef<any>;
    constructor(transformCreator: TransformCreator, table: MatTable<any>, state: TableStore, templateService: TableTemplateService, injector: Injector);
    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, false, 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;
    dataSource: GenericTableDataSource<any>;
    tableElRef: ElementRef;
    paginator: MatPaginator;
    currentPageData$: Observable<CurrentPageDetails>;
    collapseFooter$: Observable<boolean>;
    data$: Observable<any[]>;
    paginatorChangeEmitter: EventEmitter<void>;
    constructor(state: TableStore);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    paginatorChange(): void;
    ourPageEvent: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PaginatorComponent, "tb-paginator", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "tableElRef": { "alias": "tableElRef"; "required": false; }; "data$": { "alias": "data$"; "required": false; }; }, { "paginatorChangeEmitter": "paginatorChangeEmitter"; }, never, never, false, 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;
    data$: Observable<any[]>;
    IndexColumn: boolean;
    SelectionColumn: boolean;
    trackBy: string;
    rows: QueryList<MatRowDef<any>>;
    isSticky: boolean;
    columnBuilders: ColumnBuilderComponent[];
    columnInfos: Observable<ColumnInfo[]>;
    groupHeaderTemplate: TemplateRef<any>;
    compareWithKey: string;
    private _disableSort;
    set disableSort(val: boolean);
    get disableSort(): boolean;
    table: MatTable<any>;
    dropList: CdkDropList;
    tableElRef: ElementRef;
    paginatorComponent: PaginatorComponent;
    paginatorChange: EventEmitter<void>;
    currentColumns: string[];
    dataSource: any;
    keys: string[];
    injector: Injector;
    rowDefArr: MatRowDef<any>[];
    columns: string[];
    myColumns: Dictionary<ColumnBuilderComponent>;
    showHeader$: Observable<boolean>;
    constructor(sort: MatSort, state: TableStore, viewContainer: ViewContainerRef, injector: Injector);
    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": false; }; "IndexColumn": { "alias": "IndexColumn"; "required": false; }; "SelectionColumn": { "alias": "SelectionColumn"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "isSticky": { "alias": "isSticky"; "required": false; }; "columnBuilders": { "alias": "columnBuilders"; "required": false; }; "columnInfos": { "alias": "columnInfos"; "required": false; }; "groupHeaderTemplate": { "alias": "groupHeaderTemplate"; "required": false; }; "compareWithKey": { "alias": "compareWithKey"; "required": false; }; "disableSort": { "alias": "disableSort"; "required": false; }; }, { "paginatorChange": "paginatorChange"; "selection$": "selection$"; }, never, never, false, never>;
}
declare class GenericTableVsComponent extends GenericTableComponent {
    createDataSource(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenericTableVsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenericTableVsComponent, "tb-generic-table-vs", never, {}, {}, never, never, false, never>;
}

interface DisplayCol {
    key: string;
    displayName?: string;
    isVisible: boolean;
}

declare class GenColDisplayerComponent {
    private tableState;
    columns$: Observable<DisplayCol[]>;
    constructor(tableState: TableStore);
    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, false, 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>;
}

interface FilterChipVm {
    filterId: string;
    columnName: string;
    columnKey: string;
    filterType: FilterType | undefined;
    fieldType: FieldType;
    operatorLabel: string;
    /** Display string of the filter value. Arrays are joined with ", " so the user can edit them as text. */
    valueDisplay: string;
    /** Raw filterValue (used for type-aware inputs in expanded form). */
    rawValue: any;
    isCustom: boolean;
    isHidden: boolean;
}
/** Editing draft state for the currently-expanded chip. Edits don't commit until Apply. */
interface ChipDraft {
    filterId: string;
    filterType: FilterType | undefined;
    value: any;
    /** True if this draft was just created from "+ Add filter" — Cancel removes the chip entirely. */
    isNew: boolean;
}
declare class GenFilterDisplayerComponent {
    tableState: TableStore;
    filterStore: WrapperFilterStore;
    chips$: Observable<FilterChipVm[]>;
    filterCols$: Observable<MetaData[]>;
    count$: Observable<number>;
    /** Which chip is currently in expanded form. Drives compact vs expanded rendering. */
    draft: i0.WritableSignal<ChipDraft | null>;
    /** Whether the inline column picker is open (replaces the nested mat-menu so the
     * parent panel stays open after a column is selected). */
    pickerOpen: i0.WritableSignal<boolean>;
    /** Expose FilterType to the template so it can compare against d.filterType. */
    protected readonly FilterType: typeof FilterType;
    constructor(tableState: TableStore, filterStore: WrapperFilterStore);
    /** Operators compatible with a chip's column fieldType, for the operator dropdown. */
    operatorsFor(fieldType: FieldType): {
        value: FilterType;
        label: string;
    }[];
    /** Maps fieldType to the input style the expanded form should render. */
    inputKindFor(fieldType: FieldType): 'date' | 'datetime' | 'number' | 'boolean' | 'text';
    /**
     * Add a new filter from the column picker.
     * Combo 4: the chip is born expanded with no value yet. The user fills in value + Apply
     * to commit. Commits to TableStore happen on Apply, not on every keystroke, so the
     * table doesn't re-filter mid-edit.
     */
    /** Toggle the inline column picker. */
    togglePicker(event?: Event): void;
    closePicker(): void;
    addFilter(metaData: MetaData): void;
    /** Open the expanded form for an existing chip. Initializes the draft from current values. */
    expand(chip: FilterChipVm): void;
    /**
     * NumberBetween, DateBetween, and DateTimeBetween all have the same string enum value
     * ('Between'). We check against any one of them and the comparison covers all three.
     */
    protected isBetween(ft: FilterType | undefined): boolean;
    /** Update the operator in the draft (without committing). */
    draftSetOperator(filterType: FilterType, fieldType: FieldType): void;
    /** Update the value in the draft (without committing). */
    draftSetValue(value: any): void;
    /** Update the Start side of a Between range draft (without committing). */
    draftSetStart(start: any): void;
    /** Update the End side of a Between range draft (without committing). */
    draftSetEnd(end: any): void;
    /** Apply: commit the draft to TableStore, collapse. */
    apply(chip: FilterChipVm): void;
    /** Cancel: collapse without committing. For new chips, also remove the placeholder. */
    cancel(chip: FilterChipVm): void;
    removeFilter(filterId: string): void;
    clearAll(): void;
    trackByFilterId(_: number, chip: FilterChipVm): string;
    trackByKey(_: number, md: MetaData): string;
    /** True when the chip is currently the one being edited (expanded). */
    isExpanded(filterId: string): boolean;
    private defaultDraftValue;
    /** Parse the draft's loosely-typed value into something filterValue-compatible. */
    private parseDraftValue;
    private formatValue;
    /** Approximate the SpaceCase pipe locally so chip labels match the rest of the UI. */
    private spaceCase;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenFilterDisplayerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenFilterDisplayerComponent, "tb-filter-displayer", never, {}, {}, never, never, false, never>;
}

interface VisibleRow {
    key: string;
    displayName: string;
    sortDirection: 'asc' | 'desc' | null;
    sortPriority: number | null;
}
interface HiddenRow {
    key: string;
    displayName: string;
}
declare class ColumnsPanelComponent {
    private store;
    visibleRows$: Observable<VisibleRow[]>;
    hiddenRows$: Observable<HiddenRow[]>;
    visibleCount$: Observable<number>;
    totalCount$: Observable<number>;
    constructor(store: TableStore);
    cycleSort(key: string, ev: Event): void;
    onVisibleDrop(event: CdkDragDrop<VisibleRow[]>): void;
    onHiddenDrop(event: CdkDragDrop<HiddenRow[]>): void;
    trackByKey(_: number, row: {
        key: string;
    }): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnsPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnsPanelComponent, "tb-columns-panel", never, {}, {}, never, never, false, never>;
}

declare class DateFilterComponent {
    FilterType: typeof FilterType;
    info: PartialFilter;
    CurrentFilterType: FilterType;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateFilterComponent, "tb-date-filter", never, { "info": { "alias": "info"; "required": false; }; "CurrentFilterType": { "alias": "CurrentFilterType"; "required": false; }; }, {}, never, never, false, 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;
    close: EventEmitter<any>;
    currentFilterType?: FilterType;
    /** Mirror of filter.filterValue for boolean / IsNull toggles. The hidden input
     * keeps it in sync with the template-driven form so `form.value.filterValue`
     * reflects the user's toggle pick on Apply. */
    currentFilterValue: any;
    constructor(state: TableStore);
    ngOnInit(): void;
    setFilterValue(v: any): 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, false, never>;
}

declare class NumberFilterComponent {
    FilterType: typeof FilterType;
    FieldType: typeof FieldType;
    CurrentFilterType: FilterType;
    info: PartialFilter;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumberFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NumberFilterComponent, "tb-number-filter", never, { "CurrentFilterType": { "alias": "CurrentFilterType"; "required": false; }; "info": { "alias": "info"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ArrayColumnComponent {
    private config;
    ArrayStyle: typeof ArrayStyle;
    additional: ArrayAdditional;
    array: any[];
    metaData: MetaData;
    constructor(config: TableBuilderConfig);
    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": false; }; }, {}, never, never, false, never>;
}

declare class LinkColumnComponent {
    protected store: TableStore;
    metaData: MetaData;
    element: any;
    transform: (a: any) => any;
    constructor(store: TableStore);
    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": false; }; "element": { "alias": "element"; "required": false; }; "transform": { "alias": "transform"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HeaderMenuComponent {
    tableState: TableStore;
    FieldType: typeof FieldType;
    FilterType: typeof FilterType;
    myFilterType: FilterType;
    myFilterValue: any;
    filter: Partial<FilterInfo>;
    metaData: MetaData;
    trigger: MatMenuTrigger;
    constructor(tableState: TableStore);
    hideField(key: string): void;
    ngOnInit(): void;
    resetFilterType(): void;
    setStringFilterType(): void;
    setFilterType(filterType: FilterType): void;
    onEnter(filter: FilterInfo): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderMenuComponent, "tb-header-menu", never, { "filter": { "alias": "filter"; "required": false; }; "metaData": { "alias": "metaData"; "required": false; }; }, {}, never, never, false, never>;
}

declare class KeyDisplayPipe implements PipeTransform {
    tableState: TableStore;
    constructor(tableState: TableStore);
    transform(key: string): Observable<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<KeyDisplayPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<KeyDisplayPipe, "keyDisplay", false>;
}

declare class FormatFilterValuePipe implements PipeTransform {
    tableState: TableStore;
    private datePipe;
    constructor(tableState: TableStore, datePipe: DatePipe);
    transform(value: any, key: string, filterType: FilterType): Observable<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormatFilterValuePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FormatFilterValuePipe, "formatFilterValue", false>;
}

declare class AsFilterPillsPipe implements PipeTransform {
    transform(value: any): string[] | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<AsFilterPillsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AsFilterPillsPipe, "asFilterPills", false>;
}

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", false>;
}

declare class InFilterComponent implements ControlValueAccessor {
    private ref;
    FieldType: typeof FieldType;
    type: FieldType;
    value: any[];
    constructor(ref: ChangeDetectorRef);
    writeValue(obj: any[]): void;
    onChange: (_: any) => void;
    registerOnChange(fn: any): void;
    onTouched: () => void;
    registerOnTouched(fn: any): void;
    addInput(): void;
    removeInput(index: number): void;
    onValueChange(i: number, value: number | string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InFilterComponent, "lib-in-filter", never, { "type": { "alias": "type"; "required": false; }; }, {}, never, never, false, never>;
}

declare class InListFilterComponent implements ControlValueAccessor {
    private ref;
    private tableState;
    constructor(ref: ChangeDetectorRef, tableState: TableStore);
    value: string[];
    FieldType: typeof FieldType;
    writeValue(obj: string[]): void;
    onChange: (_: any) => void;
    registerOnChange(fn: any): void;
    onTouched: () => void;
    registerOnTouched(fn: any): void;
    key: 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": false; }; }, {}, never, never, false, never>;
}

declare class SortMenuComponentStore extends ComponentStore<ComponenStoreState> {
    private tableState;
    constructor(tableState: TableStore);
    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(tableState: TableStore, store: SortMenuComponentStore);
    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, false, never>;
}

declare class FilterChipsComponent {
    tableState: TableStore;
    private filterStore;
    isArray: (arg: any) => arg is any[];
    constructor(tableState: TableStore, filterStore: WrapperFilterStore);
    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, false, never>;
}

declare class GroupByListComponent implements OnInit {
    tableStore: TableStore;
    constructor(tableStore: TableStore);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GroupByListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GroupByListComponent, "group-by-list", never, {}, {}, never, never, false, never>;
}

declare class DateTimeFilterComponent {
    FilterType: typeof FilterType;
    info: PartialFilter;
    CurrentFilterType: FilterType;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateTimeFilterComponent, "tb-date-time-filter", never, { "info": { "alias": "info"; "required": false; }; "CurrentFilterType": { "alias": "CurrentFilterType"; "required": false; }; }, {}, never, never, false, never>;
}

declare class MaterialModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<MaterialModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MaterialModule, never, [typeof i1.MatSlideToggleModule, typeof i2.MatTableModule, typeof i3.MatSelectModule, typeof i4.MatDialogModule, typeof i5.MatDatepickerModule, typeof i6.MatRadioModule, typeof i7.MatButtonModule, typeof i8.MatExpansionModule, typeof i9.MatStepperModule, typeof i10.MatToolbarModule, typeof i11.MatTooltipModule, typeof i12.MatNativeDateModule, typeof i13.MatProgressSpinnerModule, typeof i14.MatGridListModule, typeof i15.MatCardModule, typeof i16.MatSidenavModule, typeof i17.MatTabsModule, typeof i18.MatInputModule, typeof i17.MatTabsModule, typeof i19.MatCheckboxModule, typeof i20.MatMenuModule, typeof i21.MatIconModule, typeof i22.MatBadgeModule, typeof i23.MatSortModule, typeof i24.MatAutocompleteModule, typeof i25.MatPaginatorModule, typeof i26.MatChipsModule, typeof i4.MatDialogModule], [typeof i1.MatSlideToggleModule, typeof i2.MatTableModule, typeof i3.MatSelectModule, typeof i4.MatDialogModule, typeof i5.MatDatepickerModule, typeof i6.MatRadioModule, typeof i7.MatButtonModule, typeof i8.MatExpansionModule, typeof i9.MatStepperModule, typeof i10.MatToolbarModule, typeof i11.MatTooltipModule, typeof i12.MatNativeDateModule, typeof i13.MatProgressSpinnerModule, typeof i14.MatGridListModule, typeof i15.MatCardModule, typeof i16.MatSidenavModule, typeof i17.MatTabsModule, typeof i18.MatInputModule, typeof i17.MatTabsModule, typeof i19.MatCheckboxModule, typeof i20.MatMenuModule, typeof i21.MatIconModule, typeof i22.MatBadgeModule, typeof i23.MatSortModule, typeof i24.MatAutocompleteModule, typeof i25.MatPaginatorModule, typeof i26.MatChipsModule, typeof i4.MatDialogModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MaterialModule>;
}

declare class TableBuilderModule {
    static forRoot(config: TableBuilderConfig): ModuleWithProviders<TableBuilderModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableBuilderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TableBuilderModule, [typeof ColumnTotalPipe, typeof TableContainerComponent, typeof GenericTableComponent, typeof GenericTableVsComponent, typeof PaginatorComponent, typeof CustomCellDirective, typeof GenColDisplayerComponent, typeof GenFilterDisplayerComponent, typeof ColumnsPanelComponent, typeof DateFilterComponent, typeof FilterComponent, typeof MultiSortDirective, typeof NumberFilterComponent, typeof ColumnBuilderComponent, typeof ArrayColumnComponent, typeof LinkColumnComponent, typeof HeaderMenuComponent, typeof KeyDisplayPipe, typeof FormatFilterValuePipe, typeof AsFilterPillsPipe, 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 PreservePasteDelimitersDirective], [typeof i32.CommonModule, typeof MaterialModule, typeof _ngrx_store.StoreFeatureModule, typeof i35.EffectsFeatureModule, typeof i36.FormsModule, typeof i37.RouterModule, typeof i38.LetDirective, typeof i39.DragDropModule, typeof UtilitiesModule, typeof i41.ScrollingModule, typeof i42.TableVirtualScrollModule], [typeof GenericTableComponent, typeof GenericTableVsComponent, typeof PaginatorComponent, typeof TableContainerComponent, typeof CustomCellDirective, typeof GenColDisplayerComponent, typeof GenFilterDisplayerComponent, typeof ColumnsPanelComponent, typeof FilterComponent, typeof MultiSortDirective, typeof ResizeColumnDirective, typeof MatSlideToggleTbFilterDirective, typeof MatRadioButtonTbFilterDirective, typeof MatOptionTbFilterDirective, typeof MatCheckboxTbFilterDirective, typeof MatButtonToggleFilterDirective, typeof TableFilterDirective, typeof TableFilterStringContainsDirective, typeof TableWrapperDirective, typeof GroupByListComponent, typeof PreservePasteDelimitersDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TableBuilderModule>;
}

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 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 i32.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, ColumnsPanelComponent, 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, PreservePasteDelimitersDirective, 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 };