import * as _angular_core from '@angular/core';
import { Injector, OnInit, TemplateRef, ViewContainerRef, Signal, InjectionToken, OnDestroy, Predicate, PipeTransform, EnvironmentProviders, OnChanges, SimpleChanges, AfterViewInit, ElementRef, EventEmitter, QueryList, ModuleWithProviders, EnvironmentInjector } from '@angular/core';
import * as rxjs from 'rxjs';
import { Observable, Subscription, Subject, Unsubscribable, ReplaySubject, Timestamp, MonoTypeOperatorFunction, OperatorFunction } from 'rxjs';
import { HttpErrorResponse } from '@angular/common/http';
import * as _one_paragon_angular_utilities from '@one-paragon/angular-utilities';
import { QueryParamsHandling } from '@angular/router';
import * as _ngrx_entity from '@ngrx/entity';
import { Dictionary as Dictionary$1, Predicate as Predicate$1, EntityState } from '@ngrx/entity';
import { Sort, MatSort, SortDirection as SortDirection$1 } from '@angular/material/sort';
import { MatTableDataSource, MatColumnDef, MatHeaderRowDef, MatFooterRowDef, MatTable, MatRowDef } from '@angular/material/table';
import { CdkColumnDef } from '@angular/cdk/table';
import { ComponentStore } from '@ngrx/component-store';
import { NgControl } from '@angular/forms';
import * as _angular_material_paginator from '@angular/material/paginator';
import { MatPaginator, PageEvent } from '@angular/material/paginator';
import { SelectionChange, SelectionModel } from '@angular/cdk/collections';
import { CdkDropList, CdkDragDrop } from '@angular/cdk/drag-drop';
import { MatMenu } from '@angular/material/menu';
import { MatDialogConfig, MatDialogRef } from '@angular/material/dialog';
import { MatSlideToggle } from '@angular/material/slide-toggle';
import * as _ngrx_store from '@ngrx/store';
import { Action, MemoizedSelector, Store } from '@ngrx/store';
import * as i1 from '@angular/common';

declare enum RequestStatus {
    notStarted = 0,
    inProgress = 1,
    success = 2,
    fail = 3,
    cancelled = 4
}
type RequestStateCancelled = {
    status: RequestStatus.cancelled;
};
type RequestStateNotStarted = {
    status: RequestStatus.notStarted;
};
type RequestStateInProgress = {
    status: RequestStatus.inProgress;
};
type RequestStateSuccess<T> = {
    status: RequestStatus.success;
    body: T;
};
type RequestStateError = {
    status: RequestStatus.fail;
    error: any;
};
type RequestState<T = any> = RequestStateCancelled | RequestStateNotStarted | RequestStateInProgress | RequestStateSuccess<T> | RequestStateError;
declare enum RequestStrategy {
    concurrent = 1,
    singleUse = 2,
    cancelPrevious = 3,
    sequential = 4
}
interface RequestStateOptions<TParam extends any[] = any> {
    strategy?: RequestStrategy;
    autoRequest?: TParam extends never[] ? true : never;
}
interface RequestCreatorOptions<TParam extends any[] = any> extends RequestStateOptions<TParam> {
    injector?: Injector;
}
type RequestFactory<TParam extends any[], T> = (...params: [...TParam]) => Observable<T>;

declare abstract class HttpStateDirectiveBase<V, R = null> implements OnInit {
    hasView: boolean;
    private injector;
    protected templateRef: TemplateRef<any>;
    protected viewContainer: ViewContainerRef;
    ngOnInit(): void;
    private baseRender;
    abstract render: (state: RequestState) => boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HttpStateDirectiveBase<any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HttpStateDirectiveBase<any, any>, never, never, {}, {}, never, never, true, never>;
}

declare class HttpErrorStateDirective<V, R = null> extends HttpStateDirectiveBase<V, R> implements OnInit {
    render: (state: RequestState<any>) => boolean;
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HttpErrorStateDirective<any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HttpErrorStateDirective<any, any>, "[httpErrorState]", never, {}, {}, never, never, true, never>;
}

declare class HttpInProgressStateDirective<V, R = null> extends HttpStateDirectiveBase<V, R> implements OnInit {
    render: (state: RequestState<any>) => boolean;
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HttpInProgressStateDirective<any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HttpInProgressStateDirective<any, any>, "[httpInProgressState]", never, {}, {}, never, never, true, never>;
}

declare class HttpNotStartedStateDirective<V, R = null> extends HttpStateDirectiveBase<V, R> implements OnInit {
    render: (state: RequestState<any>) => boolean;
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HttpNotStartedStateDirective<any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HttpNotStartedStateDirective<any, any>, "[httpNotStartedState]", never, {}, {}, never, never, true, never>;
}

interface RequestResponse<TParam extends any[], T> {
    requestParams: [...TParam];
    response: RequestState<T>;
}
declare class RequestStateStore<TParam extends any[], V, R = null, T = R extends null ? V : R> {
    #private;
    private _state;
    private setState;
    state: Signal<RequestResponse<TParam, T>>;
    state$: Observable<RequestResponse<TParam, T>>;
    private options?;
    private project?;
    private req;
    private injector;
    private destroy$;
    private defaultErrorHandling?;
    private _useDefaultErrorHandler?;
    private defaultSuccessHandling?;
    constructor(req: RequestFactory<TParam, V>, options?: RequestStateOptions<TParam>, project?: (v: V) => R);
    reset(): void;
    private flatteningStrategy;
    private createRequestPipeline;
    private requestPipeLine;
    private flattenedRequest;
    private singleUseRequest;
    $selectRequestState: Signal<RequestState<T>>;
    selectRequestState$: Observable<RequestState<T>>;
    /**
     * @deprecated use selectRequestState$ instead
     */
    selectHttpState$: Observable<RequestState<T>>;
    $selectStatus: Signal<RequestStatus>;
    selectStatus$: Observable<RequestStatus>;
    $isSuccess: Signal<boolean>;
    $isError: Signal<boolean>;
    $isInProgress: Signal<boolean>;
    $isNotStarted: Signal<boolean>;
    selectError$: Observable<any>;
    $selectError: Signal<any>;
    selectResponse$: Observable<T>;
    $selectResponse: Signal<T | undefined>;
    private selectSuccessOrError$;
    errorHandled: boolean;
    onError(cb: (error: HttpErrorResponse) => void): this;
    /**
     * if no handler was provided will call `console.error`
     */
    useDefaultErrorHandler(): this;
    /**
     * if no handler was provided will call `console.log` with 'Success'
     */
    useDefaultSuccessHandler(): 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;
    private subscriber;
    /**
     * @deprecated use the standalone subscriber helper function
     */
    on: <V_1>(srcObservable: Observable<V_1>, func: (obj: V_1) => void) => Subscription;
    request: (...value: [...TParam]) => Subscription;
    requestWith: (params: Observable<[...TParam]> | Signal<[...TParam]>) => this;
    private assertInjectionContext;
    destroy(): void;
}
declare class CancellationToken {
}
declare function wrapInArr<T extends [Signal<any>, ...Signal<any>[]]>(...sigs: T): Signal<{
    [K in keyof T]: T[K] extends Signal<infer U> ? U : never;
}>;
declare function wrapInArr<T extends [Observable<any>, ...Observable<any>[]]>(...obs: T): Observable<{
    [K in keyof T]: T[K] extends Observable<infer U> ? U : never;
}>;
interface RequestStateStoreConfig {
    /**
     * if `useDefaultErrorHandler` is `true` this will run on each error if no other handler provided.
     * else can be used by call `.useDefaultHandler`
     */
    defaultErrorHandling?: (e?: any) => void;
    /**
     * if `useDefaultErrorHandler` is `true` `defaultErrorHandling` will run on each error if no other handler provided.
     */
    useDefaultErrorHandler?: boolean;
    /**
     * will be called if `useDefaultSuccess` is used
     */
    defaultSuccessHandling?: <T>(e?: T) => void;
}
declare const RequestStateStoreConfigToken: InjectionToken<RequestStateStoreConfig>;

interface HttpSuccessStateViewContext<T> {
    $implicit: T;
}
declare class HttpSuccessStateDirective<V, R = null> extends HttpStateDirectiveBase<V, R> implements OnInit {
    httpSuccessStateTypeSafety?: RequestStateStore<any, V, R> | Observable<RequestState<V>>;
    render: (state: RequestState<R extends null ? V : R>) => boolean;
    ngOnInit(): void;
    static ngTemplateContextGuard<V, R>(dir: HttpSuccessStateDirective<V, R>, ctx: any): ctx is HttpSuccessStateViewContext<R extends null ? V : R>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HttpSuccessStateDirective<any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HttpSuccessStateDirective<any, 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[], V, R, T = R extends null ? V : R> implements OnDestroy {
    private viewContainer;
    readonly ViewContext: HttpRequestStateViewContext<T>;
    subject: Subject<Observable<RequestState<T>>>;
    state: Observable<RequestState<T>>;
    subscription: Unsubscribable;
    hooks: ((state: RequestState<T>) => void)[];
    set stateStore(store: RequestStateStore<TParam, V, R, T> | Observable<RequestState<T>>);
    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
    ngOnDestroy(): void;
    static ngTemplateContextGuard<V, R>(dir: HttpRequestStateDirective<any, V, R>, ctx: any): ctx is HttpRequestStateViewContext<R extends null ? V : R>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HttpRequestStateDirective<any, any, any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HttpRequestStateDirective<any, any, any, any>, "[httpRequestState]", never, { "stateStore": { "alias": "httpRequestState"; "required": false; }; }, {}, never, never, true, never>;
}
type HttpRequestStateAny<T> = {
    status: RequestStatus;
    body?: T;
    error?: any;
};

declare const getRequestorBody: <T>(source: Observable<RequestState<T>>) => Observable<T>;

declare const getRequestorStatus: <T>(source: Observable<RequestState<T>>) => Observable<_one_paragon_angular_utilities.RequestStatus>;

declare function tapError(onError: (error: any) => void): (src: Observable<RequestState>) => Observable<RequestState>;

declare function tapSuccess<T>(onSuccess: (body: T) => void): (src: Observable<RequestState<T>>) => Observable<RequestState<T>>;

declare function isErrorState<T>(state: RequestState<T>): state is RequestStateError;
declare function isSuccessState<T>(state: RequestState<T>): state is RequestStateSuccess<T>;
declare function isSuccessOrErrorState<T>(state: RequestState<T>): state is (RequestStateSuccess<T> | RequestStateError);
declare function createSuccess<T>(body: T): RequestStateSuccess<T>;
declare function createFailure(error: any): RequestStateError;
declare const notStarted: RequestStateNotStarted;
declare const inProgress: RequestStateInProgress;
declare function statusIsSuccessOrInProgress(status: RequestStatus): boolean;

type HttpRequestState$<T> = Observable<RequestState<T>>;
interface HttpRequestor<Res, Req> {
    httpState$: Observable<RequestState<Res>>;
    status$: Observable<RequestStatus>;
    body$: Observable<Res>;
    request: Req;
}
declare function httpRequest<T = any>(req: Observable<T>): HttpRequestState$<T>;
declare function httpRequestor<TParam extends any[], T>(req: RequestFactory<TParam, T>): HttpRequestor<T, (...params: [...TParam]) => Observable<RequestState<T>>>;
declare function chainRequest<TParam extends any[], T, TT>(httpState$: Observable<RequestState<T>>, request: RequestFactory<TParam, TT>, requestParams: ((responseFromPrevious: T) => [...TParam]) | (() => [...TParam])): Observable<RequestState<TT>>;

declare class HttpRequestModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HttpRequestModule, never>;
    static ɵmod: _angular_core.ɵɵ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: _angular_core.ɵɵInjectorDeclaration<HttpRequestModule>;
}

declare class RequestStateFactory implements OnDestroy {
    constructor();
    ngOnDestroy(): void;
    private requestors;
    create<TParam extends any[], V>(req: RequestFactory<TParam, V>, options?: RequestStateOptions<TParam>): RequestStateStore<TParam, V>;
    create<TParam extends any[], V, R, T = R>(req: RequestFactory<TParam, V>, project: (v: V) => R, options?: RequestStateOptions<TParam>): RequestStateStore<TParam, V, T>;
    createHttpClient<T>(r: (o: Observable<T>) => Observable<T>, options?: RequestStateOptions<any>): RequestStateStore<[o: Observable<T>], T, null, T>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RequestStateFactory, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RequestStateFactory>;
}
declare function createRequestor<TParam extends any[], V>(req: RequestFactory<TParam, V>, options?: RequestCreatorOptions<TParam>): RequestStateStore<TParam, V>;
declare function createRequestor<TParam extends any[], V, R, T = R>(req: RequestFactory<TParam, V>, project: (v: V) => R, options?: RequestCreatorOptions<TParam>): RequestStateStore<TParam, V, T>;

interface Dictionary<T> {
    [key: string]: T;
}

declare class StylerDirective {
    #private;
    private el;
    private renderer;
    $stylesApplied: _angular_core.WritableSignal<Dictionary$1<string>>;
    $element: _angular_core.InputSignal<any>;
    $styler: _angular_core.InputSignal<StylerStyle<any>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StylerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StylerDirective, "[styler]", never, { "$element": { "alias": "element"; "required": true; "isSignal": true; }; "$styler": { "alias": "styler"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}
type StylerStyle<T = any> = Dictionary$1<string | {
    condition?: ((t: T) => boolean) | true;
    value: ((t: T) => string) | string;
}>;

declare enum FieldType {
    Unknown = 0,
    Date = 1,
    /**
     * @deprecated If `additional.link` is set the column will be treated as a link.
     */
    Link = 2,
    ImageUrl = 3,
    Currency = 4,
    Array = 5,
    Hidden = 6,
    Number = 7,
    String = 8,
    Boolean = 9,
    PhoneNumber = 10,
    /**
     * @deprecated For mapped properties use proper type (for sorting and filtering) with `map`.
     * For unmapped properties use `FieldType.NotMapped` with map.
     */
    Expression = 11,
    Enum = 12,
    DateTime = 13,
    NotMapped = 14
}
declare enum SortDirection {
    asc = "asc",
    desc = "desc"
}
declare enum Target {
    Blank = "_blank",
    Self = "_self",
    Parent = "_parent",
    Top = "_top"
}
interface BaseMeta<T = any> {
    displayName?: string;
    order?: number;
    preSort?: SortDef;
    sortLogic?: {
        /**
         * defaults to last
         */
        nulls?: 'first' | 'last';
        sortBy?: ((t: T) => any) | 'use map';
    };
    noSort?: boolean;
    width?: string;
    noExport?: boolean;
    filterLogic?: {
        filterBy?: ((t: T) => any) | 'use map';
        /**
         * defaults to the MetaData's Field type
         */
        filterType?: FieldType;
    };
    noFilter?: boolean;
    customCell?: boolean;
    /**
     * @deprecated Use `map`
     */
    transform?: ((o: T, ...args: any[]) => any) | ((o: string, ...args: any[]) => any) | PipeTransform;
    click?: (element: T, key?: string, event?: MouseEvent) => void;
    template?: TemplateRef<any>;
    classes?: Dictionary<Predicate<T> | true>;
    toolTip?: string | ((t: T) => string);
    useIcon?: boolean;
    map?: (t: T) => any;
}
type Path<T, U = never, P = never> = (T extends P ? never : T extends object ? {
    [K in keyof T]: K extends string | number ? `${K}` | (T[K] extends (Array<any> | undefined) ? `${K}.${keyof Array<any> & (string | number)}` : `${K}.${Path<T[K], T[K], P | U>}`) : never;
}[keyof T] : never);
interface BaseMappedMetaData<T = any, AdditionalFields extends string[] = []> extends BaseMeta<T> {
    key: (Path<T> | AdditionalFields[number]) & string;
    /**
   * if used with map, `mapItem` will only be used where the row is not available, ex. group header
   */
    mapItem?: (i: any) => any;
}
interface MappedMetaData<T = any, AdditionalFields extends string[] = []> extends BaseMappedMetaData<T, AdditionalFields> {
    fieldType: FieldType.String | FieldType.PhoneNumber | FieldType.ImageUrl | FieldType.Link | FieldType.Hidden | FieldType.Unknown;
    additional?: Additional<T>;
    mapItem?: (i: string) => any;
}
interface MappedNumberMetaData<T = any, AdditionalFields extends string[] = []> extends BaseMappedMetaData<T, AdditionalFields> {
    fieldType: FieldType.Number | FieldType.Currency;
    mapItem?: (i: number) => any;
    additional?: NumberAdditional<T>;
}
interface MappedEnumMetaData<T = any, AdditionalFields extends string[] = []> extends BaseMappedMetaData<T, AdditionalFields> {
    fieldType: FieldType.Enum;
    mapItem?: (i: number) => any;
    additional?: EnumAdditional<T>;
}
interface MappedDateMetaData<T = any, AdditionalFields extends string[] = []> extends BaseMappedMetaData<T, AdditionalFields> {
    fieldType: FieldType.Date | FieldType.DateTime;
    mapItem?: (i: Date) => any;
    additional?: Additional<T, Date>;
}
interface MappedBooleanMetaData<T = any, AdditionalFields extends string[] = []> extends BaseMappedMetaData<T, AdditionalFields> {
    fieldType: FieldType.Boolean;
    mapItem?: (i: boolean) => any;
    additional?: BooleanAdditional<T>;
}
interface MappedArrayMetaData<T = any, AdditionalFields extends string[] = []> extends BaseMappedMetaData<T, AdditionalFields> {
    fieldType: FieldType.Array;
    mapItem?: (i: string) => any;
    additional?: ArrayAdditional<T>;
}
type MetaData<T = any, AdditionalFields extends string[] = []> = MappedMetaData<T, AdditionalFields> | NotMappedMetaData<T> | MappedNumberMetaData<T, AdditionalFields> | MappedEnumMetaData<T, AdditionalFields> | MappedBooleanMetaData<T, AdditionalFields> | MappedDateMetaData<T, AdditionalFields> | MappedArrayMetaData<T, AdditionalFields>;
interface NotMappedMetaData<T = any> extends BaseMeta<T> {
    key: string;
    fieldType: FieldType.NotMapped | FieldType.Expression;
    additional?: Additional<T>;
}
interface ReportDef<DataType = any> {
    data: DataType[];
    metaData: MetaData[];
    totalRecords?: number;
    count: number;
}
interface SortDef {
    direction: SortDirection;
    precedence?: number;
}
interface FilterOptions<T = string> {
    filterableValues: T[] | 'all values';
}
interface DateTimeOptions {
    format?: string;
    includeSeconds?: boolean;
    includeMilliseconds: boolean;
}
type interpolatedRoute = string;
interface BaseAdditional<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 | ((t: T) => string);
        routerLinkOptions?: {
            queryParams?: [string, interpolatedRoute | ((t: T) => string)][];
            fragment?: string;
            preserveFragment?: boolean;
            queryParamsHandling?: QueryParamsHandling;
        };
    };
    export?: MetaDataExport<T>;
    dateFormat?: string;
    dateTimeOptions?: DateTimeOptions;
    styles?: StylerStyle<T>;
    columnPartStyles?: {
        header?: Dictionary<string>;
        body?: StylerStyle<T>;
        innerBody?: StylerStyle<T>;
        footer?: Dictionary<string>;
    };
    columnPartClasses?: {
        header?: Dictionary<Predicate<T> | true>;
        footer?: Dictionary<Predicate<T> | true>;
    };
    footer?: {
        type: any;
    };
}
interface Additional<T = any, V = string> extends BaseAdditional<T> {
    filterOptions?: FilterOptions<V>;
    footer?: {
        type: never;
    };
}
interface NumberAdditional<T = any> extends BaseAdditional<T> {
    filterOptions?: FilterOptions<number>;
    footer?: {
        type: 'sum';
    };
}
interface EnumAdditional<T = any> extends BaseAdditional<T> {
    filterOptions?: FilterOptions<number>;
    enumMap?: {
        [key: number]: string;
    };
    footer?: {
        type: never;
    };
}
interface BooleanAdditional<T = any> extends BaseAdditional<T> {
    filterOptions?: FilterOptions<never>;
    footer?: {
        type: never;
    };
    boolean?: {
        showForFalse?: true | {
            icon: string;
        };
        forTrue?: {
            icon: string;
        };
    };
}
declare enum ArrayStyle {
    CommaDelimited = 0,
    NewLine = 1
}
interface ArrayAdditional<T = any> extends Additional<T> {
    limit?: number;
    arrayStyle?: ArrayStyle;
}
interface MetaDataExport<T> extends TableBuilderExport {
    /**
     * This will supersede all other mappings when exporting.
     */
    mapForExport?: (t: T) => string;
    /**
     * used with `mapLink` = 'add link'
     */
    linkColumnName?: string;
}
declare function metaDataArrToDict<T = MetaData>(arr: MetaData[], transform?: (m: MetaData) => T): Dictionary<T>;
interface CustomCellMeta extends Pick<MetaData, 'key' | 'displayName' | 'preSort' | 'fieldType' | 'order' | 'width'> {
    customCell: true;
    noExport?: boolean;
}

interface DefaultSettings {
    dateFormat?: string;
    dateTimeFormat?: string;
}

interface TableBuilderSettings<T = any> {
    headerSettings?: Partial<TableWrapperHeaderSettings>;
    footerSettings?: Partial<TableWrapperFooterSettings>;
    columnHeaderSettings?: Partial<TableColumnHeaderSettings>;
    columnFooterSettings?: Partial<TableColumnFooterSettings>;
    tableSettings?: Partial<TableSettings<T>>;
}
declare class GeneralTableSettings implements TableBuilderSettings {
    headerSettings: TableWrapperHeaderSettings;
    footerSettings: TableWrapperFooterSettings;
    columnHeaderSettings: TableColumnHeaderSettings;
    columnFooterSettings: TableColumnFooterSettings;
    tableSettings: TableSettings<any>;
}
declare class TableWrapperHeaderSettings {
    hideExport: boolean;
    hideFilter: boolean;
    hideColumnSettings: boolean;
    hideHeader: boolean;
    hideSort: boolean;
    collapse: boolean;
    showTitleWhenCollapsed: boolean;
    headerHeight: TbSize | undefined;
}
declare class TableWrapperFooterSettings {
    collapse: boolean;
}
declare class TableColumnHeaderSettings {
    stickyHeaderRow: boolean;
    noFilters: boolean;
    noHeader: boolean;
}
declare class TableColumnFooterSettings {
    stickyFooterRow: boolean;
}
declare class TableSettings<T = any> {
    tableId?: string | undefined;
    trackBy?: string | undefined;
    includeIndexColumn: boolean;
    includeSelectionColumn: boolean;
    usePaginator: boolean | undefined;
    useVirtualScroll: boolean | undefined;
    paginatorSettings: Partial<PaginatorOptions> | undefined;
    virtualScrollSettings: Partial<VirtualScrollOptions> | undefined;
    rowHeight: TbSize | undefined;
    groupHeaderHeight?: TbSize;
    minColumnWidth: TbSize | undefined;
    rowClasses: Dictionary<Predicate<T> | true> | undefined;
    rowStyles: StylerStyle<T> | undefined;
    rowClick: ((row: T, event?: MouseEvent) => void) | undefined;
    exportSettings: TableBuilderExport | undefined;
}
declare class PersistedTableSettings {
    constructor(tableSettings?: NonFunctionProperties<PersistedTableSettings>);
    merge(tableSettings?: TableBuilderSettings): PersistedTableSettings;
    collapseHeader: boolean;
    collapseFooter: boolean;
}
declare class NotPersistedTableSettings {
    merge(tableSettings?: TableBuilderSettings): this & NotPersistedTableSettings;
    hideExport: boolean;
    hideFilter: boolean;
    hideColumnSettings: boolean;
    hideSort: boolean;
    showTitleWhenHeaderCollapsed: boolean;
    hideHeader: boolean;
    hideColumnHeaderFilters: boolean;
    hideColumnHeader: boolean;
    usePaginator: boolean;
    useVirtualScroll: boolean;
    paginatorSettings: PaginatorOptions | undefined;
    virtualSettings: VirtualScrollOptions | undefined;
    groupHeaderHeight?: TbSize;
    rowHeight?: TbSize | undefined;
    headerHeight?: TbSize;
    minColumnWidth?: TbSize | undefined;
    rowClasses?: Dictionary<Predicate<any> | true> | undefined;
    rowStyles?: StylerStyle | undefined;
    rowClick?: ((row: any, event?: MouseEvent) => void) | undefined;
    exportSettings: TableBuilderExport | undefined;
}
declare class VirtualScrollOptions {
    rowHeight: TbSize;
    enforceRowHeight: boolean;
    headerHeight: TbSize;
    enforceHeaderHeight: boolean;
    amountOfVisibleItems: number;
    /**
     * This will win over `amountOfVisibleItems`
     */
    maxViewPortHeight: TbSize | undefined;
    /**
     * Will try to bring the table to the bottom of the screen
     * If `amountOfVisibleItems` is set that will be the minimum number of rows
     * If `maxViewPortHeight` is set that will be the max table size
     */
    dynamicHeight: boolean;
    /**
     * If `dynamicHeight` is set to true, we will try to add this amount of space from the bottom of view port
     */
    dynamicalHeightBuffer: TbSize;
}
declare class PaginatorOptions {
    pageSize: number | undefined;
    defaultAll: boolean;
    includeAllInOptions: boolean;
}
declare const DefaultVirtualScrollOptions: {
    rowHeight: number;
    headerHeight: number;
};
type NonFunctionPropertyNames<T> = {
    [K in keyof T]: T[K] extends Function ? never : K;
}[keyof T];
type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;
type TbSize = number | `${number}${'px' | 'rem'}`;
declare function parseTbSizeToPixels(size?: TbSize): number | undefined;

interface TableBuilderConfig {
    defaultTableSettings: Partial<Omit<TableBuilderSettings, 'injector'>> & {
        pageSize?: number;
    };
    /**
    * @deprecated use `defaultTableSettings.tableSettings.exportSettings`.
    */
    export?: TableBuilderExport;
    dateFormats?: DefaultSettings;
    arrayDefaults?: ArrayAdditional;
    transformers?: Partial<{
        [key in keyof typeof FieldType]: (val: any) => any;
    }>;
}
interface TableBuilderExport {
    dateFormat?: string;
    dateTimeFormat?: string;
    prepend?: string;
    mapEnumToString?: boolean;
    /**
     * defaults to 'as view'
     */
    mapLink?: 'as link' | 'as view' | 'add link' | 'as excel' | 'add excel';
    /**
     * used with `mapLink` = 'as link' or 'add link' to add a domain prefix to the link
     */
    linkDomainPrefix?: string;
}
declare const TableBuilderConfigToken: InjectionToken<TableBuilderConfig>;
declare function provideTableBuilder(config?: TableBuilderConfig): EnvironmentProviders;

declare const FilterType: {
    readonly NumberEquals: "Equals";
    readonly NumberNotEqual: "Does Not Equal";
    readonly NumberGreaterThan: "Greater Than";
    readonly NumberLessThan: "Less Than";
    readonly NumberBetween: "Between";
    readonly StringEquals: "Equals";
    readonly StringContains: "Contains";
    readonly StringDoesNotContain: "Does Not Contain";
    readonly StringStartWith: "Start With";
    readonly StringEndsWith: "Ends With";
    readonly DateIsOn: "Is on";
    readonly DateIsNotOn: "Is Not On";
    readonly DateOnOrAfter: "On or After";
    readonly DateOnOrBefore: "On or Before";
    readonly DateBetween: "Between";
    readonly DateTimeIsAt: "Is At";
    readonly DateTimeIsNotAt: "Is Not At";
    readonly DateTimeAtOrAfter: "At or After";
    readonly DateTimeAtOrBefore: "At or Before";
    readonly DateTimeBetween: "Between";
    readonly BooleanEquals: "Is";
    readonly IsNull: "Is Blank";
    readonly Or: "Or";
    readonly And: "And";
    readonly In: "In";
    readonly Custom: "Custom";
};
type FilterType = typeof FilterType[keyof typeof FilterType];
type SubFilterTypes<T extends typeof FilterType[keyof typeof FilterType]> = T;
type StringFilterTypes = SubFilterTypes<'Equals' | 'Contains' | 'Does Not Contain' | 'Start With' | 'Ends With' | 'Is Blank' | 'In'>;
type NumberFilterTypes = SubFilterTypes<'Equals' | 'Does Not Equal' | 'Greater Than' | 'Less Than' | 'Between' | 'Is Blank' | 'In'>;
type DateFilterTypes = SubFilterTypes<'Is on' | 'Is Not On' | 'On or After' | 'On or Before' | 'Between' | 'Is Blank' | 'In'>;
type DateTimeFilterTypes = SubFilterTypes<'Is At' | 'Is Not At' | 'At or After' | 'At or Before' | 'Between' | DateFilterTypes>;
type BooleanFilterTypes = SubFilterTypes<'Is' | 'Is Blank'>;
type EnumFilterTypes = SubFilterTypes<'In' | 'Is Blank'>;

declare const filterTypeMap: Record<FieldType, FilterType[]>;
interface FilterState {
    filterId: string;
    filterType: FilterType;
    filterValue?: any;
    active?: boolean;
    filterBy?: (t: any) => any;
}
interface FilterInfo<T extends FieldType = any, U = any> extends FilterState {
    key: string & keyof U;
    fieldType: T;
    _isExternallyManaged?: boolean;
}
interface PartialFilter {
    filterId?: string;
    key: string;
    fieldType: FieldType;
    filterType?: FilterType;
    filterValue?: any;
    filterBy?: (t: any) => any;
}
interface CustomFilter<T = any> extends FilterState {
    predicate: Predicate<T>;
    filterType: typeof FilterType.Custom;
}
declare function isCustomFilter(filter: FilterInfo | CustomFilter): filter is CustomFilter;
declare function isFilterInfo(filter: FilterInfo | CustomFilter): filter is FilterInfo;
declare function createFilterFuncs(filters: (FilterInfo | CustomFilter)[]): Predicate<any>[];
declare function needsFilterCreation(filter: FilterInfo | CustomFilter): boolean;
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;
};
type FilterFuncs<T extends FilterType> = Partial<Record<T, FilterFunc<any, any>>>;

interface LinkInfo {
    link: (element: any) => string;
    target: string;
    useRouterLink: boolean;
    routerLinkOptions?: {
        queryParams: (element: any) => any;
        fragment?: string;
        preserveFragment?: boolean;
        queryParamsHandling?: QueryParamsHandling;
    };
}

interface TableProps {
    indexColumn: boolean;
    selectionColumn: boolean;
    isSticky: boolean;
    stickyFooter: boolean;
    groupHeaderTemplate?: TemplateRef<any>;
    groupHeaderHeight?: number;
}

type NoneGroupHeader = {
    isGroupHeader: never;
};
interface BaseGroup {
    key: string;
    groupName: string;
    groupHeaderDisplay: string;
    uniqueName: string;
    isGroupHeader: true;
    padding: number;
    length: number;
    hasTheData: boolean;
    level: number;
}
interface DataGroup<T extends NoneGroupHeader = any> extends BaseGroup {
    children: T[];
    hasTheData: true;
}
interface GroupGroup<T extends NoneGroupHeader = any> extends BaseGroup {
    groups: (DataGroup<T> | GroupGroup<T>)[];
    hasTheData: false;
}
type Group<T extends NoneGroupHeader = any> = GroupGroup<T> | DataGroup<T>;
interface GroupedData {
    key: string;
    expandedHeaders: string[];
}
interface PersistedTableState {
    hiddenKeys?: string[];
    filters: Dictionary<FilterInfo | CustomFilter>;
    sorted: Sort[];
    userDefined: {
        order: Dictionary<number>;
        widths: Dictionary<number>;
        table: {
            width?: number;
        };
        pageSize?: number;
        showAll?: boolean;
        rowHeight?: number;
        headerHeight?: number;
    };
    persistedTableSettings: PersistedTableSettings;
    groupBy: GroupedData[];
}
interface TableState extends Required<PersistedTableState> {
    initializationState: InitializationState;
    metaData: Dictionary<MetaData>;
    notPersistedTableSettings: NotPersistedTableSettings;
    pageSize: number;
    currentPage: number;
    linkMaps: Dictionary<LinkInfo>;
    allFilters: Dictionary<any[]>;
    props: TableProps;
    showAll: boolean;
}
interface DataState {
    virtualScrollOffset: number;
    virtualEnds: {
        start: number;
        end: number;
    };
    sortedFilteredDataLength: number;
    sortedFilteredGroupedDataLength: number;
}
declare enum InitializationState {
    Created = 0,
    MetaDataLoaded = 1,
    TableSettingsLoaded = 2,
    Ready = 3
}

declare class TableBuilder<T = any> {
    #private;
    private data;
    private metaData?;
    private settings;
    container: _angular_core.WritableSignal<TableContainerComponent<any> | undefined>;
    $metaData: Signal<MetaData<T>[] | undefined>;
    $settings: Signal<TableBuilderSettings<any> | undefined>;
    $initialized: _angular_core.WritableSignal<boolean>;
    constructor(data: TableBuilderArgs<T[]>, metaData?: TableBuilderArgs<MetaData<T, any>[]> | undefined, settings?: TableBuilderArgs<TableBuilderSettings<T>>);
    prep(injector: Injector): void;
    $data: Signal<T[]>;
    createMetaData(obj: any): MetaData[];
}
declare const CreateTableBuilder: (reportDef$: Observable<ReportDef>) => TableBuilder;
type TableBuilderArgs<T> = T | Observable<T> | Signal<T>;

interface CustomCellContext<T> {
    $implicit: T;
    element: T;
}
declare class CustomCellDirective<T = any> implements OnInit {
    private templateRef;
    columnDef: CdkColumnDef | null;
    $customCell: _angular_core.InputSignal<string>;
    $displayName: _angular_core.InputSignal<string | undefined>;
    $preSort: _angular_core.InputSignal<SortDef | undefined>;
    $templateRef: _angular_core.InputSignal<TemplateRef<any> | undefined>;
    $customCellOrder: _angular_core.InputSignal<number | undefined>;
    $customCellWidth: _angular_core.InputSignal<string | undefined>;
    /**
       * for type safety, this is a reference to the table builder instance.
       */
    $customCellTableRef: _angular_core.InputSignal<TableBuilder<T> | undefined>;
    /**
       * true if column not mapped to a property in the data source. Default is false.
       */
    $customCellNotMapped: _angular_core.InputSignalWithTransform<boolean, any>;
    $metaData: _angular_core.Signal<CustomCellMeta | undefined>;
    $inited: _angular_core.WritableSignal<boolean>;
    ngOnInit(): void;
    static ngTemplateContextGuard<T>(dir: CustomCellDirective<T>, ctx: any): ctx is CustomCellContext<T>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CustomCellDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CustomCellDirective<any>, "[customCell]", never, { "$customCell": { "alias": "customCell"; "required": true; "isSignal": true; }; "$displayName": { "alias": "customCellDisplayName"; "required": false; "isSignal": true; }; "$preSort": { "alias": "preSort"; "required": false; "isSignal": true; }; "$templateRef": { "alias": "templateRef"; "required": false; "isSignal": true; }; "$customCellOrder": { "alias": "customCellOrder"; "required": false; "isSignal": true; }; "$customCellWidth": { "alias": "customCellWidth"; "required": false; "isSignal": true; }; "$customCellTableRef": { "alias": "customCellTableRef"; "required": false; "isSignal": true; }; "$customCellNotMapped": { "alias": "customCellNotMapped"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class MultiSortDirective extends MatSort implements OnInit, OnDestroy {
    private state;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiSortDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MultiSortDirective, "[multiSort]", ["multiSort"], { "disabled": { "alias": "matSortDisabled"; "required": false; }; }, {}, never, never, true, never>;
}
declare function sortsAreSame(a: Sort[], b: Sort[]): boolean;

type TableBuilderSort = Sort & {
    nulls?: 'first' | 'last';
    sortBy?: (t: any) => any;
};

declare class TableStore extends ComponentStore<TableState> {
    constructor();
    $initializationState: Signal<InitializationState>;
    $savableState: Signal<PersistedTableState>;
    $userDefinedOrder: Signal<Dictionary<number>>;
    metaData$: Observable<Dictionary<MetaData>>;
    $metaData: Signal<Dictionary<MetaData>>;
    $metaDataArray: Signal<MetaData[]>;
    $orderedCodeVisibleMetaDatas: Signal<MetaData[]>;
    $getMetaData: (key: string) => Signal<MetaData>;
    $hiddenKeys: Signal<string[]>;
    $orderedVisibleColumns: Signal<string[]>;
    $getUserDefinedWidths: Signal<Dictionary<number>>;
    $tableSettingsMinWidth: Signal<number | undefined>;
    $getUserDefinedWidth: (key: string) => Signal<number>;
    $filters: Signal<Dictionary<FilterInfo<any, any> | CustomFilter<any>>>;
    filters$: Observable<Dictionary<FilterInfo<any, any> | CustomFilter<any>>>;
    $getFilter: (filterId: string) => Signal<FilterInfo | CustomFilter | undefined>;
    $preSort: Signal<TableBuilderSort[]>;
    _$selectSorted: Signal<Sort[]>;
    $selectSorted: Signal<TableBuilderSort[]>;
    selectSorted$: Observable<Sort[]>;
    $getSorts: Signal<TableBuilderSort[]>;
    sort$: Observable<TableBuilderSort[]>;
    $getUserDefinedTableWidth: Signal<number | undefined>;
    getUserDefinedTableWidth$: Observable<number | undefined>;
    $userDefinedRowHeight: Signal<number | undefined>;
    $userDefinedHeaderHeight: Signal<number | undefined>;
    $userDefinedPageSize: Signal<number | undefined>;
    $footerCollapsed: Signal<boolean>;
    $headerCollapsed: Signal<boolean>;
    $groupBy: Signal<GroupedData[]>;
    $groupByKeys: Signal<string[]>;
    groupByKeys$: Observable<string[]>;
    expandedGroups$: Observable<GroupedData[]>;
    $expandGroups: Signal<GroupedData[]>;
    $getIsExpanded: (columnKey: string, groupUniqueName: string) => Signal<boolean>;
    $currentPage: Signal<number>;
    $pageSize: Signal<number>;
    $showAll: Signal<boolean>;
    $tableSettings: Signal<NonFunctionProperties<PersistedTableSettings & NotPersistedTableSettings>>;
    $notPersistedTableSettings: Signal<NotPersistedTableSettings>;
    tableSettings$: Observable<NonFunctionProperties<PersistedTableSettings & NotPersistedTableSettings>>;
    $props: Signal<TableProps>;
    $getLinkInfo: (md: MetaData) => Signal<LinkInfo>;
    $isVirtual: Signal<boolean | undefined>;
    $viewType: Signal<ViewType>;
    readonly resetState: () => void;
    readonly resetPart: (observableOrValue: "Sorting" | "Filters" | "Group By" | "Hidden Columns" | "Column Widths" | "Column Order" | "Row Height" | "Header Height" | "Page Size" | "Show All" | Observable<"Sorting" | "Filters" | "Group By" | "Hidden Columns" | "Column Widths" | "Column Order" | "Row Height" | "Header Height" | "Page Size" | "Show All">) => rxjs.Subscription;
    readonly updateStateFromPersistedState: (observableOrValue: PersistedTableState | Observable<PersistedTableState>) => rxjs.Subscription;
    private updateStateFunc;
    readonly setTableSettings: (observableOrValue: TableBuilderSettings<any> | Observable<TableBuilderSettings<any>>) => rxjs.Subscription;
    readonly setMetaData: (observableOrValue: MetaData[] | Observable<MetaData[]>) => rxjs.Subscription;
    readonly showColumn: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
    readonly hideColumn: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
    readonly setHiddenColumns: (observableOrValue: {
        key: string;
        visible: boolean;
    }[] | Observable<{
        key: string;
        visible: boolean;
    }[]>) => rxjs.Subscription;
    readonly setUserDefinedWidth: (observableOrValue: {
        key: string;
        widthInPixel: number;
    }[] | Observable<{
        key: string;
        widthInPixel: number;
    }[]>) => rxjs.Subscription;
    readonly setUserDefinedOrder: (observableOrValue: {
        newOrder: number;
        oldOrder: number;
    } | Observable<{
        newOrder: number;
        oldOrder: number;
    }>) => rxjs.Subscription;
    readonly setUserDefinedRowHeight: (observableOrValue: number | Observable<number>) => rxjs.Subscription;
    readonly setUserDefinedHeaderHeight: (observableOrValue: number | Observable<number>) => rxjs.Subscription;
    readonly addFilter: (observableOrValue: FilterInfo<any, any> | CustomFilter<any> | Observable<FilterInfo<any, any> | CustomFilter<any>>) => rxjs.Subscription;
    readonly addFilters: (observableOrValue: (FilterInfo<any, any> | CustomFilter<any>)[] | Observable<(FilterInfo<any, any> | CustomFilter<any>)[]>) => rxjs.Subscription;
    readonly removeFilter: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
    readonly removeFilters: (observableOrValue: string[] | Observable<string[]>) => rxjs.Subscription;
    readonly clearFilters: () => void;
    private addFiltersToState;
    readonly setSort: (observableOrValue: {
        key: string;
        direction?: SortDirection$1;
    } | Observable<{
        key: string;
        direction?: SortDirection$1;
    }>) => rxjs.Subscription;
    readonly setAllSort: (observableOrValue: Sort[] | Observable<Sort[]>) => rxjs.Subscription;
    readonly setCurrentPage: (observableOrValue: number | Observable<number>) => rxjs.Subscription;
    readonly setPageSize: (observableOrValue: number | Observable<number>) => rxjs.Subscription;
    readonly setUserDefinedPageSize: (observableOrValue: number | Observable<number>) => rxjs.Subscription;
    readonly setUserDefinedShowAll: (observableOrValue: boolean | Observable<boolean>) => rxjs.Subscription;
    readonly setProps: (observableOrValue: TableProps | Observable<TableProps>) => rxjs.Subscription;
    readonly setTableWidth: (observableOrValue: number | Observable<number>) => rxjs.Subscription;
    readonly setInitializationState: (observableOrValue: InitializationState | Observable<InitializationState>) => rxjs.Subscription;
    readonly toggleCollapseHeader: () => void;
    readonly toggleCollapseFooter: (() => void) | ((observableOrValue: void | {
        collapseFooter: boolean;
    } | Observable<void | {
        collapseFooter: boolean;
    } | undefined> | undefined) => rxjs.Subscription);
    readonly addGroupByKey: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
    readonly removeGroupByKey: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
    readonly updateExpandedGroups: (observableOrValue: {
        key: string;
        groupUniqueName: string;
        isExpanded: boolean;
    } | Observable<{
        key: string;
        groupUniqueName: string;
        isExpanded: boolean;
    }>) => rxjs.Subscription;
    readonly expandAllOfGroup: (observableOrValue: {
        groupHeadersByKey: Dictionary<{
            uniqueName: string;
        }[]>;
    } | Observable<{
        groupHeadersByKey: Dictionary<{
            uniqueName: string;
        }[]>;
    }>) => rxjs.Subscription;
    readonly collapseAll: () => void;
    readonly collapseAllOfKey: (observableOrValue: {
        keys: string[];
    } | Observable<{
        keys: string[];
    }>) => rxjs.Subscription;
    readonly setLinkMaps: (() => void) | ((observableOrValue: any) => rxjs.Subscription);
    updateRowProps: (observableOrValue: Pick<NotPersistedTableSettings, "rowClasses" | "rowStyles" | "rowClick"> | Observable<Pick<NotPersistedTableSettings, "rowClasses" | "rowStyles" | "rowClick">>) => rxjs.Subscription;
    on: <V>(srcObservable: Observable<V>, func: (obj: V) => void) => this;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableStore, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TableStore>;
}
type ViewType = 'virtual paginator' | 'paginator' | 'virtual all' | 'all';

declare class ResizeColumnDirective implements OnInit {
    private renderer;
    private el;
    store: TableStore;
    resizable: boolean | string;
    key: string;
    ngOnInit(): void;
    createResizerSpanInColumnHead(columnHead: HTMLElement): any;
    getTableAndColumnHeadHtmlElements(): {
        table: HTMLElement;
        columnHead: HTMLElement;
    };
    mouseDownThroughMouseUpEventMapper(resizer: HTMLElement, columnHead: HTMLElement, table: HTMLElement): 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: MouseDownData, mouseMove: MouseEvent): {
        newTableWidth: number;
        newColumnWidth: number;
    };
    getElementWidth: (elem: HTMLElement) => number;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResizeColumnDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ResizeColumnDirective, "[resizeColumn]", never, { "resizable": { "alias": "resizeColumn"; "required": false; }; "key": { "alias": "key"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_resizable: unknown;
}
interface MouseDownData {
    startPageX: number;
    startColumnWidth: number;
    startTableWidth: number;
}

declare abstract class TableCustomFilterDirective {
    abstract filter$: Observable<CustomFilter>;
    abstract $filter: Signal<CustomFilter | undefined>;
    filterId: string;
    savable: boolean;
    abstract active: boolean;
    abstract reset(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableCustomFilterDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableCustomFilterDirective, "tb-abstract", never, {}, {}, never, never, true, never>;
}
declare class TableFilterDirective implements OnChanges, OnInit {
    protected model: NgControl | null;
    private wrapper;
    constructor();
    reset(): void;
    filter$: ReplaySubject<FilterInfo<any, any>>;
    $filter: Signal<FilterInfo<any, any> | undefined>;
    filterType: FilterType;
    key: string;
    fieldType: FieldType;
    filterId: string;
    active: boolean;
    filterValue: any;
    setFilterValue(value: any): void;
    savable: boolean;
    ready: boolean;
    _userActive: boolean;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    protected setFilter(filter: FilterInfo): void;
    update(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableFilterDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableFilterDirective, "[tbFilter]", never, { "filterType": { "alias": "filterType"; "required": false; }; "key": { "alias": "key"; "required": false; }; "fieldType": { "alias": "fieldType"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; "active": { "alias": "active"; "required": false; }; "filterValue": { "alias": "filterValue"; "required": false; }; }, {}, never, never, true, never>;
}
declare class TableFilterStringContainsDirective extends TableFilterDirective implements OnChanges {
    constructor();
    reset(): void;
    setFilter(filter: FilterInfo): void;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableFilterStringContainsDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableFilterStringContainsDirective, "[tbFilterStringContains]", never, { "key": { "alias": "tbFilterStringContains"; "required": false; }; "filterValue": { "alias": "filterValue"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, never, never, true, never>;
}
declare abstract class TableCustomFilterDirectiveBase<T = any> extends TableCustomFilterDirective implements OnInit {
    filter$: ReplaySubject<CustomFilter<any>>;
    $filter: Signal<CustomFilter<any> | undefined>;
    filter: CustomFilter;
    _predicate: Predicate<T>;
    set predicate(val: Predicate<T>);
    _active: boolean;
    ready: boolean;
    update(val: Partial<CustomFilter>): void;
    set active(val: boolean);
    get active(): boolean;
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableCustomFilterDirectiveBase<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableCustomFilterDirectiveBase<any>, "[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, never, never, true, never>;
}
declare abstract class TbSelectedFilterDirective extends TableCustomFilterDirectiveBase implements OnDestroy, OnInit {
    private change;
    private isActive;
    protected wrapper: TableWrapperDirective | null;
    protected constructor(change: Observable<any>, isActive: () => boolean);
    reset(): void;
    destroySubject$: ReplaySubject<void>;
    ngOnDestroy(): void;
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TbSelectedFilterDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TbSelectedFilterDirective, never, never, {}, {}, never, never, true, never>;
}
declare class MatCheckboxTbFilterDirective extends TbSelectedFilterDirective {
    private matCheckbox;
    set active(val: boolean);
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MatCheckboxTbFilterDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MatCheckboxTbFilterDirective, "mat-checkbox[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; }, {}, never, never, true, never>;
}
declare class MatSlideToggleTbFilterDirective extends TbSelectedFilterDirective implements OnInit {
    private matSlideToggle;
    set active(val: boolean);
    constructor();
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MatSlideToggleTbFilterDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MatSlideToggleTbFilterDirective, "mat-slide-toggle[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; }, {}, never, never, true, never>;
}
declare class MatRadioButtonTbFilterDirective extends TbSelectedFilterDirective implements OnInit {
    private matRadioButton;
    set active(val: boolean);
    constructor();
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MatRadioButtonTbFilterDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MatRadioButtonTbFilterDirective, "mat-radio-button[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; }, {}, never, never, true, never>;
}
declare class MatOptionTbFilterDirective extends TbSelectedFilterDirective implements OnInit {
    private matOption;
    set active(val: boolean);
    constructor();
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MatOptionTbFilterDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MatOptionTbFilterDirective, "mat-option[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; }, {}, never, never, true, never>;
}
declare class MatButtonToggleFilterDirective extends TbSelectedFilterDirective implements OnInit {
    private matButtonToggle;
    set active(val: boolean);
    constructor();
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MatButtonToggleFilterDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MatButtonToggleFilterDirective, "mat-button-toggle[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TableWrapperDirective {
    $registrations: _angular_core.WritableSignal<(TableCustomFilterDirective | TableFilterDirective)[]>;
    register(filter: TableCustomFilterDirective | TableFilterDirective): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableWrapperDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableWrapperDirective, "[tbWrapper]", never, {}, {}, never, never, true, never>;
}

declare class TableBuilderStateStore extends ComponentStore<GlobalStorageState> {
    constructor();
    $selectLocalTableProfile: (profileKey: string) => Signal<Profile | undefined>;
    $selectLocalTableStateForView: (tableId: string) => Signal<PersistedTableState | null>;
    $selectLocalProfileCurrentKey: (key: string) => Signal<string | undefined>;
    $selectLocalProfileDefaultKey: (key: string) => Signal<string | undefined>;
    $selectLocalProfileKeys: (tableId: string) => Signal<string[]>;
    saveTableSettingsToLocalAndStorage: (tableId: string, stateName: string, tableState: PersistedTableState, asDefault?: boolean) => void;
    saveTableStateToLocal: (observableOrValue: {
        tableId: string;
        tableState: PersistedTableState;
        stateName?: string;
        asDefault?: boolean;
    } | rxjs.Observable<{
        tableId: string;
        tableState: PersistedTableState;
        stateName?: string;
        asDefault?: boolean;
    }>) => rxjs.Subscription;
    saveTableStateToStorage: (tableId: string, stateName: string, tableState: PersistedTableState, asDefault?: boolean) => void;
    addNewStateToLocalAndStorage: (tableId: string, newStateName: string, tableState: PersistedTableState, asDefault?: boolean) => void;
    setLocalCurrentState: (observableOrValue: {
        tableId: string;
        currentStateKey: string;
    } | rxjs.Observable<{
        tableId: string;
        currentStateKey: string;
    }>) => rxjs.Subscription;
    setDefaultInLocalAndStorage: (tableId: string, newDefault: string) => void;
    setDefaultInLocal: (observableOrValue: {
        key: string;
        default: string;
    } | rxjs.Observable<{
        key: string;
        default: string;
    }>) => rxjs.Subscription;
    unsetDefaultFromLocalAndStorage: (tableId: string) => void;
    unsetDefaultFromLocal: (tableId: string) => void;
    unsetDefaultFromStorage: (tableId: string) => void;
    setDefaultInStorage: (tableId: string, stateName: string) => void;
    deleteLocalProfilesState: (observableOrValue: {
        key: string;
        stateKey: string;
    } | rxjs.Observable<{
        key: string;
        stateKey: string;
    }>) => rxjs.Subscription;
    deleteProfileFromLocalAndStorage: (key: string, stateKey: string) => void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableBuilderStateStore, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TableBuilderStateStore>;
}
interface PersistedProfile {
    states: Dictionary<PersistedTableState>;
    default?: string;
}
interface Profile extends PersistedProfile {
    current?: string;
    localSavedState?: PersistedTableState;
}
interface GlobalStorageState {
    localProfiles: Dictionary<Profile>;
}

declare function setCustomGroupBy(customGroupBy: <T extends NoneGroupHeader = any>(data: T[], groupByKeys: string[], level?: number, parentGroupName?: string) => DataGroup<T>[] | GroupGroup<T>[]): void;
declare function updateGroupByState<T extends NoneGroupHeader = any>(groupedData: any[], { data, groups, expanded }: {
    data: Timestamp<T[]>;
    groups: Timestamp<string[]>;
    expanded: Timestamp<GroupedData[]>;
}, firstRun: boolean): GroupByState;
declare function mapGroupHeader(obj: DataGroup | GroupGroup, expandedHeaders: string[] | true): any[];
interface GroupByState {
    displayData: any[];
    groupedData: DataGroup[];
}
declare const initialGroupByState: {
    displayData: never[];
    groupedData: never[];
};
declare const getAllGroupHeaderNames: (data: any[]) => {};
declare const getAllGroupHeaderNamesByKeys: (data: any[], keys: string[]) => Dictionary$1<Group[]>;

declare class PaginatorComponent {
    #private;
    private state;
    private data;
    $paginator: _angular_core.Signal<MatPaginator | undefined>;
    $dataLength: _angular_core.Signal<number>;
    $viewableDataLength: _angular_core.Signal<number>;
    pageEvent$: rxjs.Observable<PageEvent>;
    $pageEvent: _angular_core.Signal<PageEvent | undefined>;
    $pageIndexChangeEvent: _angular_core.Signal<number | undefined>;
    $pageSizeChangeEvent: _angular_core.Signal<number | undefined>;
    $currentPageData: _angular_core.Signal<{
        total: number;
        currentStart: number;
        currentEnd: number;
    } | undefined>;
    onDataLengthEffect: _angular_core.EffectRef;
    $collapseFooter: _angular_core.Signal<boolean>;
    $showAllOption: _angular_core.Signal<boolean | undefined>;
    $showAll: _angular_core.Signal<boolean>;
    showAll(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaginatorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaginatorComponent, "tb-paginator", never, {}, {}, never, never, true, never>;
}

declare class DataStore extends ComponentStore<DataState> {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataStore, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DataStore>;
}

declare class TableBuilderDataSource<T> extends MatTableDataSource<T> {
    #private;
    subscription?: Subscription;
    $dataSize: Signal<{
        start: number;
        end: number;
    }>;
    _: _angular_core.EffectRef;
    setData(data: T[]): void;
    constructor(state: TableStore, data: DataStore);
    connect(): rxjs.BehaviorSubject<T[]>;
    disconnect(): void;
}

declare class ColumnBuilderComponent implements AfterViewInit {
    FieldType: typeof FieldType;
    private config;
    private table;
    private state;
    private templateService;
    private tableConfig;
    protected injector: Injector;
    $columnDef: Signal<MatColumnDef | undefined>;
    $bodyTemplate: Signal<TemplateRef<any> | undefined>;
    protected $metaData: _angular_core.WritableSignal<MetaData | undefined>;
    $additional: Signal<number | LinkInfo | undefined>;
    setMetaData(md: MetaData): void;
    $customCell: _angular_core.WritableSignal<CustomCellDirective<any> | undefined>;
    $data: Signal<any[]>;
    $transform: Signal<((value: any, ...args: any[]) => any) | undefined>;
    $innerTemplate: Signal<TemplateRef<any> | undefined>;
    $showFilters: Signal<boolean | undefined>;
    $outerTemplate: Signal<TemplateRef<any> | undefined>;
    $classes: Signal<Dictionary$1<Predicate<any> | true> | undefined>;
    $styles: Signal<{
        header: Dictionary$1<string>;
        body: _one_paragon_angular_utilities.StylerStyle;
        innerBody: _one_paragon_angular_utilities.StylerStyle;
        footer: Dictionary$1<string>;
    } | undefined>;
    private viewInited;
    ngAfterViewInit(): void;
    private onViewInit;
    whenViewInited: (callback: () => void) => void;
    cellClicked(element: any, key: string, event: MouseEvent): void;
    getTooltip: (element: any) => string | undefined;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColumnBuilderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ColumnBuilderComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

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

declare class GenericTableComponent {
    #private;
    protected state: TableStore;
    private dataStore;
    private viewContainer;
    private config;
    private _injector;
    smallFooter: number;
    $headerRow: _angular_core.Signal<MatHeaderRowDef | undefined>;
    $footerRow: _angular_core.Signal<MatFooterRowDef | undefined>;
    $table: _angular_core.Signal<MatTable<any> | undefined>;
    $dropList: _angular_core.Signal<CdkDropList<any> | undefined>;
    selection$: _angular_core.OutputEmitterRef<SelectionChange<any>>;
    $displayDataLength: _angular_core.InputSignal<number>;
    $data: _angular_core.InputSignal<any[]>;
    $rows: _angular_core.InputSignal<MatRowDef<any>[]>;
    $columnInfos: _angular_core.InputSignal<ColumnInfo[]>;
    $dataSource: _angular_core.InputSignal<MatTableDataSource<any, _angular_material_paginator.MatPaginator>>;
    $keys: _angular_core.Signal<string[]>;
    keys$: rxjs.Observable<string[]>;
    $trackBy: _angular_core.InputSignal<string | undefined>;
    $trackByFunction: _angular_core.Signal<(index: number, item: any) => any>;
    $hasFooterMeta: _angular_core.Signal<boolean>;
    $hasCustomFooter: _angular_core.Signal<boolean>;
    $footerRowStyle: _angular_core.Signal<"regular-footer" | "no-footer" | "small-footer">;
    $showFooterRow: _angular_core.Signal<boolean>;
    injector: _angular_core.DestroyableInjector;
    $hasIndexColumn: _angular_core.Signal<boolean>;
    $columns: _angular_core.WritableSignal<Dictionary<ColumnBuilderComponent>>;
    $showHeader: _angular_core.Signal<boolean>;
    $offset: _angular_core.Signal<number>;
    drop(event: CdkDragDrop<string[]>): void;
    $usePaginator: _angular_core.Signal<boolean>;
    $useVirtualScroll: _angular_core.Signal<boolean>;
    $virtualStart: _angular_core.Signal<number>;
    $offsetIndex: _angular_core.Signal<number>;
    rowClicked(t: any, event?: MouseEvent): void;
    isGroupHeader(_: number, row: {
        isGroupHeader: boolean;
    }): boolean;
    setExpanded(key: string, groupUniqueName: string, isExpanded: boolean): void;
    buildColumn(column: ColumnInfo): void;
    $hasSelectColumn: _angular_core.Signal<boolean>;
    $selection: _angular_core.Signal<SelectionModel<any>>;
    selectionChange$: rxjs.Observable<SelectionChange<any>>;
    $selectionChange: _angular_core.Signal<SelectionChange<any> | undefined>;
    onSelectionChangeEffect: _angular_core.EffectRef;
    $isAllSelected: _angular_core.Signal<boolean>;
    $masterToggleChecked: _angular_core.Signal<boolean>;
    $masterToggleIndeterminate: _angular_core.Signal<boolean>;
    $paginated: _angular_core.Signal<boolean>;
    $selectableData: _angular_core.Signal<any[]>;
    $selectAllMessage: _angular_core.Signal<string>;
    /** Selects all rows if they are not all selected; otherwise clear selection. */
    masterToggle(): void;
    $tableWidth: _angular_core.WritableSignal<{
        width: string;
    }>;
    getGroupHeaderTransform: (key: string, val: string) => _angular_core.Signal<any>;
    $rowHeight: _angular_core.Signal<string | undefined>;
    $headerHeight: _angular_core.Signal<string | undefined>;
    $groupHeaderHeight: _angular_core.Signal<string | undefined>;
    $footerHeight: _angular_core.Signal<string | undefined>;
    $stickyFooter: _angular_core.Signal<boolean | undefined>;
    $rowStyles: _angular_core.Signal<_one_paragon_angular_utilities.StylerStyle>;
    $rowClasses: _angular_core.Signal<Dictionary<true | _angular_core.Predicate<any>>>;
    allOfGroupSelected: (uniqueName: string) => _angular_core.Signal<{
        containsAll: boolean;
        containsSome: boolean;
        length: number;
    }>;
    toggleGroup: (uniqueName: string, allSelected: boolean) => void;
    toggleGroupMessage: (amountOfItems: number, allSelected: boolean) => string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GenericTableComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GenericTableComponent, "tb-generic-table", never, { "$displayDataLength": { "alias": "displayDataLength"; "required": true; "isSignal": true; }; "$data": { "alias": "data"; "required": true; "isSignal": true; }; "$rows": { "alias": "rows"; "required": false; "isSignal": true; }; "$columnInfos": { "alias": "columnInfos"; "required": true; "isSignal": true; }; "$dataSource": { "alias": "dataSource"; "required": true; "isSignal": true; }; "$trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; }, { "selection$": "selection"; }, never, never, true, never>;
}

declare class TableContainerComponent<T = any> {
    #private;
    state: TableStore;
    private dataStore;
    wrapper: TableWrapperDirective | null;
    stateService: TableBuilderStateStore;
    injector: Injector;
    elementRef: ElementRef<any>;
    private exportToCsvService;
    private config;
    protected dataSource: TableBuilderDataSource<T>;
    $filterDirectives: _angular_core.Signal<readonly TableFilterDirective[]>;
    $customFilterDirectives: _angular_core.Signal<readonly TableCustomFilterDirective[]>;
    $paginatorComponent: _angular_core.Signal<PaginatorComponent | undefined>;
    $genericTable: _angular_core.Signal<GenericTableComponent | undefined>;
    _$customRows: _angular_core.Signal<readonly MatRowDef<any>[]>;
    $customRows: _angular_core.Signal<MatRowDef<any>[]>;
    $customCells: _angular_core.Signal<readonly CustomCellDirective<any>[]>;
    $menu: _angular_core.Signal<MatMenu>;
    menuInjector: _angular_core.DestroyableInjector;
    $tableBuilder: _angular_core.InputSignal<TableBuilder<T>>;
    $tableIdInput: _angular_core.InputSignal<string | undefined>;
    $trackByInput: _angular_core.InputSignal<string | undefined>;
    $inputFilters: _angular_core.InputSignal<(FilterInfo<any, T> | Predicate<T> | CustomFilter<T>)[]>;
    $filterInfoInputs: _angular_core.Signal<(FilterInfo<any, any> | CustomFilter<any>)[]>;
    $indexColumnInput: _angular_core.InputSignal<boolean>;
    $selectionColumnInput: _angular_core.InputSignal<boolean>;
    $stickyHeaderInput: _angular_core.InputSignal<boolean>;
    $stickyFooterInput: _angular_core.InputSignal<boolean>;
    $groupHeaderTemplate: _angular_core.InputSignal<TemplateRef<any> | undefined>;
    $groupHeaderHeight: _angular_core.InputSignal<number | undefined>;
    $pageSize: _angular_core.InputSignal<number | undefined>;
    selection$: _angular_core.OutputEmitterRef<SelectionChange<T>>;
    onStateReset$: _angular_core.OutputEmitterRef<null>;
    onSaveState$: _angular_core.OutputEmitterRef<null>;
    state$: _angular_core.OutputRef<PersistedTableState>;
    $data: _angular_core.Signal<T[]>;
    data$: _angular_core.OutputRef<T[]>;
    private $displayData;
    clearSelections(): void;
    firstPage(): void;
    lastPage(): void;
    expandAllGroups: () => void;
    collapseAllGroups: () => void;
    exportToCsv: () => void;
    protected $myColumns: _angular_core.Signal<{
        metaData: MetaData;
        customCell: CustomCellDirective<any> | undefined;
    }[]>;
    protected $useVirtual: _angular_core.Signal<boolean | undefined>;
    protected $collapsedFooter: _angular_core.Signal<boolean>;
    protected $collapsedHeader: _angular_core.Signal<boolean>;
    protected $displayDataLength: _angular_core.Signal<number>;
    $tableBuilderSettings: _angular_core.Signal<_one_paragon_angular_utilities.TableBuilderSettings<any> | undefined>;
    $trackBy: _angular_core.Signal<string | undefined>;
    $tableId: _angular_core.Signal<string | undefined>;
    $includeSelectionColumn: _angular_core.Signal<boolean>;
    $includeIndexColumn: _angular_core.Signal<boolean>;
    $stickyHeader: _angular_core.Signal<boolean>;
    $stickyFooter: _angular_core.Signal<boolean>;
    $props: _angular_core.Signal<TableProps>;
    private $persistedState;
    private $allFilterDirectives;
    private $tableBuilderMetaData;
    private $allMetaDatas;
    private $allMetaDataTimeStamped;
    private $preds;
    private $predicateFiltersState;
    private $savableFiltersState;
    private $allFilterStatesTimeStamped;
    private $sortStateTimeStamped;
    private $allData;
    private $allDataTimeStamped;
    private $allTimeStamped;
    private $sortedAndFilteredData;
    $timestampedGroups: _angular_core.Signal<{
        value: string[];
        timestamp: number;
    }>;
    $timestampedExpanded: _angular_core.Signal<{
        value: GroupedData[];
        timestamp: number;
    }>;
    private $dataAndGroupsTimestamped;
    protected $filteredSortedAndGrouped: _angular_core.WritableSignal<GroupByState | undefined>;
    private $isInitializationState;
    static headerId: string;
    headerId: string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableContainerComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableContainerComponent<any>, "tb-table-container", never, { "$tableBuilder": { "alias": "tableBuilder"; "required": true; "isSignal": true; }; "$tableIdInput": { "alias": "tableId"; "required": false; "isSignal": true; }; "$trackByInput": { "alias": "trackBy"; "required": false; "isSignal": true; }; "$inputFilters": { "alias": "inputFilters"; "required": false; "isSignal": true; }; "$indexColumnInput": { "alias": "indexColumn"; "required": false; "isSignal": true; }; "$selectionColumnInput": { "alias": "selectionColumn"; "required": false; "isSignal": true; }; "$stickyHeaderInput": { "alias": "stickyHeader"; "required": false; "isSignal": true; }; "$stickyFooterInput": { "alias": "stickyFooter"; "required": false; "isSignal": true; }; "$groupHeaderTemplate": { "alias": "groupHeaderTemplate"; "required": false; "isSignal": true; }; "$groupHeaderHeight": { "alias": "groupHeaderHeight"; "required": false; "isSignal": true; }; "$pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; }, { "selection$": "selection"; "onStateReset$": "onStateReset"; "onSaveState$": "onSaveState"; "state$": "state"; "data$": "data"; }, ["$filterDirectives", "$customFilterDirectives", "_$customRows", "$customCells"], ["[before]", ".tb-header-title"], true, never>;
}

declare class SpaceCasePipe implements PipeTransform {
    transform(value: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpaceCasePipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SpaceCasePipe, "spaceCase", true>;
}
/**
 * Adds a space before uppercase letters that either
 * 1. follows a lowercase letter or digit
 * 2. or precedes a lowercase letter and follows an alpha-numeric character
 *
 * Uppercases the first digit
 *
 * Turns underscores into spaces
 */
declare function spaceCase(value: string): string;

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

type Args<S extends object, O extends keyof S> = S[O] extends (...args: infer Params) => any ? Params : never;
type Return<S extends object, O extends keyof S> = S[O] extends (...args: any[]) => infer R ? R : never;
declare class FunctionPipe implements PipeTransform {
    transform<T, TParam extends any[]>(func: (...args: TParam) => T, ...args: TParam): T;
    transform<O extends object, S extends keyof O>(s: S, obj: O, ...args: Args<O, S>): Return<O, S>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FunctionPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FunctionPipe, "func", true>;
}

declare class StopPropagationDirective {
    onClick(event: any): void;
    onMousedown(event: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StopPropagationDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StopPropagationDirective, "[stop-propagation]", never, {}, {}, never, never, true, never>;
}

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

declare class AutoFocusDirective implements AfterViewInit {
    private elementRef;
    autoFocus: boolean;
    ngAfterViewInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutoFocusDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AutoFocusDirective, "[autoFocus]", never, { "autoFocus": { "alias": "autoFocus"; "required": false; }; }, {}, never, never, true, never>;
}

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

declare class ClickSubjectDirective<T = boolean> extends Subject<T> {
    constructor();
    _val: T;
    set clickSubject(val: T);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClickSubjectDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ClickSubjectDirective<any>, "[clickSubject]", ["clickSubject"], { "clickSubject": { "alias": "clickSubject"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ClickEmitterDirective extends Subject<boolean> {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClickEmitterDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ClickEmitterDirective, "[clickEmitter]", ["clickEmitter"], {}, {}, never, never, true, never>;
}

interface DialogViewContext<T> {
    $implicit: T;
    opDialog: T;
    close: () => void;
}
declare class DialogWrapper<T = any> {
    private vcr;
    viewEmbedded: boolean;
    viewContext: DialogViewContext<T>;
    set template(tmpl: TemplateRef<DialogViewContext<T>>);
    set close(closeMethod: () => void);
    set data(value: T);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogWrapper<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DialogWrapper<any>, "dialog-wrapper", never, {}, {}, never, never, true, never>;
}
declare class DialogDirective<T> {
    private templateRef;
    private dialog;
    private dialogConfig;
    private service;
    opDialogClosed: EventEmitter<boolean>;
    _dialogConfig: MatDialogConfig<T>;
    opDialogAddDialogClass: boolean;
    set opDialogConfig(config: MatDialogConfig<T>);
    get opDialogConfig(): MatDialogConfig<T>;
    injector: Injector;
    subscriber: _one_paragon_angular_utilities.Subscriber;
    set setControl(i: Observable<T> | Signal<T>);
    nativeElement?: HTMLElement;
    dialogRef?: MatDialogRef<any, boolean>;
    componentWrapper?: DialogWrapper<T>;
    _data: Subject<Observable<T>>;
    close(): void;
    initDialog(): void;
    setDataAndState: (data: T) => void;
    setDialogState(open: boolean): void;
    static ngTemplateContextGuard<T>(dir: DialogDirective<T>, ctx: any): ctx is DialogViewContext<Exclude<T, false | 0 | '' | null | undefined>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DialogDirective<any>, "[opDialog]", never, { "opDialogAddDialogClass": { "alias": "opDialogAddDialogClass"; "required": false; }; "opDialogConfig": { "alias": "opDialogConfig"; "required": false; }; "setControl": { "alias": "opDialog"; "required": false; }; "nativeElement": { "alias": "opDialogOrigin"; "required": false; }; }, { "opDialogClosed": "opDialogClosed"; }, never, never, true, 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: _angular_core.ɵɵFactoryDeclaration<MatSlideToggleGroupDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MatSlideToggleGroupDirective, "[opMatSlideToggleGroup]", never, { "allowMultiple": { "alias": "allowMultiple"; "required": false; }; }, { "valueEmitter": "valueEmitter"; }, ["toggles"], never, true, never>;
}

declare class ConditionalClassesDirective {
    #private;
    private el;
    private renderer;
    $element: _angular_core.InputSignal<any>;
    $classes: _angular_core.InputSignal<Dictionary$1<true | Predicate$1<any>> | undefined>;
    classesApplied: string[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConditionalClassesDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ConditionalClassesDirective, "[conditionalClasses]", never, { "$element": { "alias": "element"; "required": true; "isSignal": true; }; "$classes": { "alias": "conditionalClasses"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class UtilitiesModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UtilitiesModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<UtilitiesModule, never, [typeof SpaceCasePipe, typeof PhoneNumberPipe, typeof FunctionPipe, typeof StopPropagationDirective, typeof StylerDirective, typeof PreventEnterDirective, typeof AutoFocusDirective, typeof TrimWhitespaceDirective, typeof ClickSubjectDirective, typeof ClickEmitterDirective, typeof DialogDirective, typeof MatSlideToggleGroupDirective, typeof ConditionalClassesDirective], [typeof StopPropagationDirective, typeof PreventEnterDirective, typeof SpaceCasePipe, typeof PhoneNumberPipe, typeof FunctionPipe, typeof TrimWhitespaceDirective, typeof StylerDirective, typeof AutoFocusDirective, typeof ClickSubjectDirective, typeof ClickEmitterDirective, typeof DialogDirective, typeof MatSlideToggleGroupDirective, typeof ConditionalClassesDirective]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<UtilitiesModule>;
}

declare class TableBuilderModule {
    static forRoot(config: TableBuilderConfig): ModuleWithProviders<TableBuilderModule>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableBuilderModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TableBuilderModule, never, [typeof TableContainerComponent, typeof CustomCellDirective, typeof TableFilterDirective, typeof TableFilterStringContainsDirective, typeof TableWrapperDirective], [typeof TableContainerComponent, typeof CustomCellDirective, typeof TableFilterStringContainsDirective, typeof TableWrapperDirective, typeof UtilitiesModule]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TableBuilderModule>;
}

declare class MatTableObservableDataSource<T> extends MatTableDataSource<T> {
    private dataSrc;
    subscription?: Subscription;
    constructor(dataSrc: Observable<T[]>);
    connect(): rxjs.BehaviorSubject<T[]>;
    disconnect(): void;
}

declare class DateFilterComponent {
    FilterType: {
        readonly NumberEquals: "Equals";
        readonly NumberNotEqual: "Does Not Equal";
        readonly NumberGreaterThan: "Greater Than";
        readonly NumberLessThan: "Less Than";
        readonly NumberBetween: "Between";
        readonly StringEquals: "Equals";
        readonly StringContains: "Contains";
        readonly StringDoesNotContain: "Does Not Contain";
        readonly StringStartWith: "Start With";
        readonly StringEndsWith: "Ends With";
        readonly DateIsOn: "Is on";
        readonly DateIsNotOn: "Is Not On";
        readonly DateOnOrAfter: "On or After";
        readonly DateOnOrBefore: "On or Before";
        readonly DateBetween: "Between";
        readonly DateTimeIsAt: "Is At";
        readonly DateTimeIsNotAt: "Is Not At";
        readonly DateTimeAtOrAfter: "At or After";
        readonly DateTimeAtOrBefore: "At or Before";
        readonly DateTimeBetween: "Between";
        readonly BooleanEquals: "Is";
        readonly IsNull: "Is Blank";
        readonly Or: "Or";
        readonly And: "And";
        readonly In: "In";
        readonly Custom: "Custom";
    };
    info: PartialFilter;
    CurrentFilterType: FilterType;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateFilterComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateFilterComponent, "tb-date-filter", never, { "info": { "alias": "info"; "required": false; }; "CurrentFilterType": { "alias": "CurrentFilterType"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FilterComponent {
    protected state: TableStore;
    filterTypes: Record<FieldType, FilterType[]>;
    FilterType: {
        readonly NumberEquals: "Equals";
        readonly NumberNotEqual: "Does Not Equal";
        readonly NumberGreaterThan: "Greater Than";
        readonly NumberLessThan: "Less Than";
        readonly NumberBetween: "Between";
        readonly StringEquals: "Equals";
        readonly StringContains: "Contains";
        readonly StringDoesNotContain: "Does Not Contain";
        readonly StringStartWith: "Start With";
        readonly StringEndsWith: "Ends With";
        readonly DateIsOn: "Is on";
        readonly DateIsNotOn: "Is Not On";
        readonly DateOnOrAfter: "On or After";
        readonly DateOnOrBefore: "On or Before";
        readonly DateBetween: "Between";
        readonly DateTimeIsAt: "Is At";
        readonly DateTimeIsNotAt: "Is Not At";
        readonly DateTimeAtOrAfter: "At or After";
        readonly DateTimeAtOrBefore: "At or Before";
        readonly DateTimeBetween: "Between";
        readonly BooleanEquals: "Is";
        readonly IsNull: "Is Blank";
        readonly Or: "Or";
        readonly And: "And";
        readonly In: "In";
        readonly Custom: "Custom";
    };
    FieldType: typeof FieldType;
    $filter: _angular_core.InputSignalWithTransform<PartialFilter, PartialFilter>;
    close: _angular_core.OutputEmitterRef<void>;
    $enteredFilterType: _angular_core.WritableSignal<FilterType | undefined>;
    $currentFilterType: _angular_core.Signal<FilterType | undefined>;
    $availableFilterTypes: _angular_core.Signal<FilterType[]>;
    $filterBy: _angular_core.Signal<((t: any) => any) | undefined>;
    onEnter(filter: FilterInfo, event: any): void;
    addFilter(filter: FilterInfo): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FilterComponent, "tb-filter", never, { "$filter": { "alias": "filter"; "required": true; "isSignal": true; }; }, { "close": "close"; }, never, never, true, never>;
}

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

declare class GenColDisplayerComponent {
    private tableState;
    $columns: _angular_core.Signal<{
        key: string;
        displayName: string | undefined;
        isVisible: boolean;
    }[]>;
    reset(displayCols: DisplayCol[]): void;
    drop(event: CdkDragDrop<string[]>): void;
    unset(displayCols: DisplayCol[]): void;
    emit(displayCols: DisplayCol[]): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GenColDisplayerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GenColDisplayerComponent, "tb-col-displayer", never, {}, {}, never, never, true, never>;
}

declare class WrapperFilterStore extends ComponentStore<{
    filterInfo: PartialFilter[];
}> {
    constructor();
    clearAll: () => void;
    deleteByIndex: (observableOrValue: number | rxjs.Observable<number>) => rxjs.Subscription;
    $currentFilters: _angular_core.Signal<PartialFilter[]>;
    addFilter: (observableOrValue: PartialFilter | rxjs.Observable<PartialFilter>) => rxjs.Subscription;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrapperFilterStore, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WrapperFilterStore>;
}

declare class GenFilterDisplayerComponent {
    protected tableState: TableStore;
    protected filterStore: WrapperFilterStore;
    $filterCols: _angular_core.Signal<MetaData[]>;
    addFilter(metaData: MetaData): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GenFilterDisplayerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GenFilterDisplayerComponent, "tb-filter-displayer", never, {}, {}, never, never, true, never>;
}

declare class FilterChipsComponent {
    tableState: TableStore;
    filterStore: WrapperFilterStore;
    $filters: _angular_core.Signal<FilterInfo<any, any>[]>;
    deleteByIndex(index: number): void;
    addFilter(filter: FilterInfo<any>): void;
    clearAll(): void;
    $currentFilters: _angular_core.Signal<_one_paragon_angular_utilities.PartialFilter[]>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterChipsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FilterChipsComponent, "lib-filter-list", never, {}, {}, never, never, true, never>;
}

declare class GroupByListComponent {
    tableStore: TableStore;
    $groups: _angular_core.Signal<{
        key: string;
        name: string;
    }[]>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GroupByListComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GroupByListComponent, "group-by-list", never, {}, {}, 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, index?: number) => U) => (source: Observable<T[]>) => Observable<U[]>;
declare const filterArray: <T>(filterFunc: (src: T) => boolean) => (source: Observable<T[]>) => Observable<T[]>;
declare const onWait: typeof startWithIfEmpty;
declare function startWithIfEmpty<T, V extends T>(val: V, wait?: number): 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>(): rxjs.UnaryFunction<Observable<T>, Observable<NonNullable<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 _subj;
    private merged;
    constructor(_source: Observable<T>);
    next: Subject<T>['next'];
    newSubj: (...operations: Parameters<PipeLike<T>>) => Subjectifier<unknown>;
}

declare class Subscriber implements OnDestroy {
    subscriptions: Subscription[];
    handle: (subscription: Subscription) => void;
    on: <T = any>(obs: Observable<T>, action: (t: T) => any) => void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Subscriber, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Subscriber, never, never, {}, {}, never, never, true, never>;
}
declare function subscriber(injector: Injector): Subscriber;
declare function subscriber(subscription?: Subscription, injector?: Injector): Subscriber;
declare function subscriber<T = any>(obs: Observable<T>, action: (t: T) => any, injector?: Injector): Subscriber;

declare class DialogService {
    allOpenOpDialogs: MatDialogRef<any>[];
    addDialogRef(ref: MatDialogRef<any>): void;
    removeDialogRef(ref: MatDialogRef<any>): void;
    closeAllOpDialogs(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DialogService>;
}

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: _angular_core.ɵɵFactoryDeclaration<NgrxExtModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<NgrxExtModule, never, [typeof i1.CommonModule, typeof _ngrx_store.StoreFeatureModule], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<NgrxExtModule>;
}

declare class ActionStateSpinnerComponent implements OnInit {
    status$: Observable<ActionStatus>;
    serverActionStatus$: Observable<ActionStatus>;
    serverStatusTypes: typeof serverStatusTypes;
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActionStateSpinnerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ActionStateSpinnerComponent, "lib-action-state-spinner", never, { "status$": { "alias": "status$"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ActionStateUiModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActionStateUiModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ActionStateUiModule, never, [typeof ActionStateSpinnerComponent], [typeof ActionStateSpinnerComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ActionStateUiModule>;
}

/**
 * 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 extends any[]>(selectorFactory: ((...props: Props) => MemoizedSelector<State, Result>), action: ActionReturner<Props>, dispatchIf?: (data: Result) => boolean) => (...props: Props) => MemoizedSelector<State, Result | undefined, (s1: LoadingState<Result>) => Result | undefined>;
declare const createActionSelector: <State, Result, Props extends any[] = any[]>(options: CreateActionResultsOptions<State, Result, Props>) => (...props: Props) => MemoizedSelector<State, Result | undefined, (s1: LoadingState<Result>) => Result | undefined>;
declare const createActionableResultSelector: <State, Result, Props extends any[]>(selectorFactory: ((...props: Props) => MemoizedSelector<State, Result>), action: ActionReturner<Props>, dispatchIf?: (data: Result) => boolean) => (...props: Props) => ActionableMemoizedSelector<State, LoadingState<Result>>;
declare const createActionResultSelector: <State, Result, Props extends any[] = any[]>(options: CreateActionResultsOptions<State, Result, Props>) => (...props: Props) => ActionableMemoizedSelector<State, LoadingState<Result>>;
declare const clearActionableSelectorRequestCache: () => {};
declare function defaultFilter(data: any): boolean;
declare function provideActionableSelector(): _angular_core.EnvironmentProviders;
declare const setUpStoreFactory: () => void;
declare function setUpStoreFactoryOld(store: Store, env: EnvironmentInjector): () => Promise<unknown>;
interface CreateActionResultsOptions<State, Result, Props extends any[]> {
    selectorFactory: (...props: Props) => MemoizedSelector<State, Result>;
    action: (...props: Props) => () => void;
    dispatchIf?: (data: Result) => boolean;
    injector?: Injector;
}
interface LoadingState<T> {
    loading: boolean;
    result?: T;
}
type ActionableMemoizedSelector<State, Result> = MemoizedSelector<State, Result>;
type ActionReturner<Props extends any[]> = (...props: Props) => Action;

export { ActionStateSpinnerComponent, ActionStateUiModule, ActionStatus, AppStatusState, ArrayStyle, AutoFocusDirective, CancellationToken, ClickEmitterDirective, ClickSubjectDirective, ConditionalClassesDirective, CreateTableBuilder, CustomCellDirective, DateFilterComponent, DefaultVirtualScrollOptions, DialogDirective, DialogService, DialogWrapper, FieldType, FilterChipsComponent, FilterComponent, FilterType, FunctionPipe, GenColDisplayerComponent, GenFilterDisplayerComponent, GeneralTableSettings, GenericTableComponent, GroupByListComponent, HttpErrorStateDirective, HttpInProgressStateDirective, HttpNotStartedStateDirective, HttpRequestModule, HttpRequestStateDirective, RequestStateFactory as HttpRequestStateFactory, RequestStateStore as HttpRequestStateStore, RequestStatus as HttpRequestStatus, RequestStrategy as HttpRequestStrategy, HttpSuccessStateDirective, MatButtonToggleFilterDirective, MatCheckboxTbFilterDirective, MatOptionTbFilterDirective, MatRadioButtonTbFilterDirective, MatSlideToggleGroupDirective, MatSlideToggleTbFilterDirective, MatTableObservableDataSource, MultiSortDirective, NgrxExtModule, NotPersistedTableSettings, PaginatorComponent, PaginatorOptions, PersistedTableSettings, PhoneNumberPipe, PreventEnterDirective, RequestStateFactory, RequestStateStore, RequestStateStoreConfigToken, RequestStatus, RequestStrategy, ResizeColumnDirective, SortDirection, SpaceCasePipe, StopPropagationDirective, StylerDirective, Subjectifier, Subscriber, TableBuilder, TableBuilderConfigToken, TableBuilderModule, TableColumnFooterSettings, TableColumnHeaderSettings, TableContainerComponent, TableCustomFilterDirective, TableCustomFilterDirectiveBase, TableFilterDirective, TableFilterStringContainsDirective, TableSettings, TableWrapperDirective, TableWrapperFooterSettings, TableWrapperHeaderSettings, Target, TbSelectedFilterDirective, TrimWhitespaceDirective, UtilitiesModule, VirtualScrollOptions, actionStatusReducer, chainRequest, clearActionableSelectorRequestCache, combineArrays, createActionResultSelector, createActionSelector, createActionableResultSelector, createActionableSelector, createFailure, createFilterFunc, createFilterFuncs, createRequestor, createSuccess, defaultFilter, defaultShareReplay, delayOn, filterArray, filterTypeMap, getAllGroupHeaderNames, getAllGroupHeaderNamesByKeys, getRequestorBody, getRequestorStatus, getStatusState, httpRequest, httpRequestor, inProgress, initialGroupByState, initialState, isCustomFilter, isErrorState, isFilterInfo, isSuccessOrErrorState, isSuccessState, mapArray, mapError, mapGroupHeader, metaDataArrToDict, needsFilterCreation, notNull, notStarted, onWait, onceWhen, parseTbSizeToPixels, phoneFormatter, previousAndCurrent, provideActionableSelector, provideTableBuilder, selectAll, selectEntities, selectEntity, selectIds, selectTotal, serverStatusTypes, setCustomGroupBy, setUpStoreFactory, setUpStoreFactoryOld, skipOneWhen, sortsAreSame, spaceCase, startWithIfEmpty, statusAdapter, statusIsSuccessOrInProgress, subscriber, switchOff, tapError, tapSuccess, updateGroupByState, wrapInArr };
export type { ActionReturner, Additional, ArrayAdditional, BaseMappedMetaData, BooleanFilterTypes, CreateActionResultsOptions, CustomCellMeta, CustomFilter, DateFilterTypes, DateTimeFilterTypes, DateTimeOptions, EnumFilterTypes, FilterFunc, FilterFuncs, FilterInfo, FilterOptions, FilterState, GroupByState, RequestState as HttpRequestState, HttpRequestState$, HttpRequestStateAny, HttpRequestStateViewContext, HttpRequestor, HttpSuccessStateViewContext, MappedArrayMetaData, MappedBooleanMetaData, MappedDateMetaData, MappedEnumMetaData, MappedMetaData, MappedNumberMetaData, MetaData, MetaDataExport, NonFunctionProperties, NotMappedMetaData, NumberFilterTypes, PartialFilter, Range, ReportDef, RequestCreatorOptions, RequestFactory, RequestResponse, RequestState, RequestStateCancelled, RequestStateError, RequestStateInProgress, RequestStateNotStarted, RequestStateOptions, RequestStateStoreConfig, RequestStateSuccess, SortDef, State, StatusState, StringFilterTypes, StylerStyle, SubFilterTypes, TableBuilderConfig, TableBuilderExport, TableBuilderSettings, TbSize };