import { ActivatedRoute } from '@angular/router';
import { Observable } from 'rxjs';
import { MemoizedSelector, Action } from '@ngrx/store';
import { TemplateRef } from '@angular/core';
import { IAbstractViewComponent } from '../dialog/abstract-view.component.interface';
import { KeyValue } from 'ngrx-forms';
import { IWithIdentifier, DefaultTemplateNames, ActionButtonDefinition, FunctionOrConstant, CssStyle, CssClass, DisplayValue } from '@digitaix/types';
export interface TableSortingState {
    enabled: boolean;
    direction: -1 | 0 | 1;
}
export interface DxTableTemplates<D> {
    [key: string]: TemplateRef<FirestoreTableTemplateContext<D, any>>;
}
/**
 * @deprecated
 */
export declare type FirebaseTableTemplates<D> = DxTableTemplates<D>;
export declare type DxTableActionFunction<R, D> = (row: D, definition: TableState<D>) => R;
export declare type DxTableActionType<D> = new (tableId: string, row: D, collectionPath?: string) => Action;
/**
 * @deprecated use ActionButtonDefinition
 */
export interface DxTableAction<D> {
    tooltip?: string | DxTableActionFunction<string, D>;
    action: DxTableActionType<D>;
    icon: string | DxTableActionFunction<string, D>;
    color?: string | DxTableActionFunction<string, D>;
    svg?: boolean | DxTableActionFunction<boolean, D>;
    name?: string;
    disabled?: boolean | DxTableActionFunction<boolean, D>;
    hide?: boolean | DxTableActionFunction<boolean, D>;
    show?: boolean | DxTableActionFunction<boolean, D>;
}
export declare enum DxTableColumnTypes {
    DATE = "date",
    DATETIME = "datetime",
    CURRENCY = "currency",
    CURRENCY_RANGE = "currency-range",
    JSON = "json"
}
export interface DxTableColumn<D, V, C = any> {
    name: keyof C & string;
    /**
     * column header
     */
    display?: string;
    type?: DxTableColumnTypes | string;
    format?: string;
    /**
     * @deprecated removed
     */
    templateName?: DxTableColumnTemplates | DefaultTemplateNames | string;
    /**
     * @deprecated removed
     */
    action?: new (row: D) => Action;
    color?: FunctionOrConstant<string, [V, D]>;
    class?: FunctionOrConstant<CssClass, [V, D]>;
    style?: FunctionOrConstant<CssStyle, [V, D]>;
    async?: boolean;
    allowEmpty?: boolean;
    /**
     * @deprecated removed
     */
    collectionPath?: string;
    /**
     * @deprecated removed
     */
    tableId?: string;
    toDisplay?: FunctionOrConstant<DisplayValue, [V, D]>;
    /**
     * @deprecated removed
     */
    templateRef?: TemplateRef<FirestoreTableTemplateContext<D, V>>;
    disabledFilter?: boolean;
    copyToClipboard?: boolean;
    tooltip?: FunctionOrConstant<string, [V, D]>;
    tooltipDisabled?: FunctionOrConstant<boolean, [V, D]>;
    actionButton?: ActionButtonDefinition<[C]>;
}
/**
 * @deprecated
 */
export declare type FirestoreTableColumn<D, V, C = any> = DxTableColumn<D, V, C>;
export interface DxTableTemplateContext<D, V> {
    id: string;
    row: any;
    value: V;
    display: DxTableColumn<D, V>['display'];
    column: DxTableColumn<D, V>;
    tableId: string;
    index: number;
}
/**
 * @deprecated
 */
export declare type FirestoreTableTemplateContext<D, V> = DxTableTemplateContext<D, V>;
export interface DxTableState<D, C = any> {
    sorting: {
        __updatedAt: TableSortingState;
        __createdAt: TableSortingState;
        [column: string]: TableSortingState;
    } & {
        __enabled: boolean;
    };
    pagination: {
        enabled: boolean;
        size: number;
        page: number;
        pageSizeOptions: number[];
    };
    filtering: {
        [column: string]: {
            enabled: boolean;
            value: string;
        };
    } & {
        __enabled: boolean;
    };
    limit: number;
    expandable: {
        row: (D & IWithIdentifier) | null;
        edit: boolean;
        full: boolean;
        btn: boolean;
    };
    rowStyles: FunctionOrConstant<KeyValue, [D]>;
    rowClasses: FunctionOrConstant<KeyValue | string | string[], [D]>;
    tableSettings: {
        enabled: boolean;
        archived: boolean;
        createdAt: boolean;
        updatedAt: boolean;
        dialogEdit: boolean;
        dialogView: boolean;
    };
    tabs: Array<{
        label: string;
        filter: (row: D) => boolean;
        tableState?: Partial<TableState<D, C>>;
    }>;
    sortable: boolean;
    currentTab: number | null;
    importTableData: boolean;
    exportTableData: boolean;
    downloadRow: boolean;
    editRow: boolean;
    expandRow: boolean;
    deleteRow: boolean;
    manuelDelete: boolean;
    manuelArchive: boolean;
    addRow: boolean;
    archiveRow: boolean;
    restoreRow: boolean;
    viewRow: boolean;
    dialogView: boolean;
    dialogEdit: boolean;
    dialogAdd: boolean;
    expandEdit: boolean;
    deleteMessage: string;
    expandView: boolean;
    title: string | null;
    subtitle: string | null;
    selectableRows: boolean;
    showArchived: boolean;
    showCreatedAt: boolean;
    showUpdatedAt: boolean;
    categoriesCollectionPath: string | null;
    actions: ActionButtonDefinition<[D]>[];
    columns: DxTableColumn<D, any, C>[];
    viewComponent: new (...args: any[]) => IAbstractViewComponent<any> | null;
    viewComponentId: string;
    displayedColumns: string[];
    collectionPath: string;
    getCollectionPath: ((route: ActivatedRoute) => Observable<string>) | null;
    query: any | null;
    hiddenColumns: string[];
    load: Array<string>;
    getDialogTitle: (document: D) => string;
    selectedRows: {
        [index: number]: D;
    };
    getTableData: (tableId: string, collectionPath: string) => MemoizedSelector<any, any[]>;
    formId: string | null;
    editFormId: string | null;
    createFormId: string | null;
}
/**
 * @deprecated
 */
export declare type TableState<D, C = any> = DxTableState<D, C>;
export interface DxTableStates<D> {
    [tableId: string]: TableState<D>;
}
/**
 * @deprecated
 */
export declare type FirestoreTableState<D> = DxTableStates<D>;
export declare const dxTableInitialState: FirestoreTableState<any>;
/**
 * @deprecated
 */
export declare const firestoreTableInitialState: DxTableStates<any>;
export declare enum DxTableColumnTemplates {
    ARRAY = "array",
    PLAIN = "plain",
    OBJECT = "object",
    BOOLEAN = "boolean",
    EMPTY = "empty",
    EMPTY_LOADING = "emptyLoading",
    RELATION_LINK = "relationLink",
    COLOR = "color",
    BUTTON = "button",
    RESOLVE_WITH_COLLECTION_PATH = "resolveWithCollectionPath",
    ACTION_BUTTON = "actionButton"
}
export interface ICellTemplatesComponent<D> {
    array: TemplateRef<FirestoreTableTemplateContext<D, any[]>>;
    plain: TemplateRef<FirestoreTableTemplateContext<D, any>>;
    object: TemplateRef<FirestoreTableTemplateContext<D, object>>;
    boolean: TemplateRef<FirestoreTableTemplateContext<D, boolean>>;
    empty: TemplateRef<FirestoreTableTemplateContext<D, any>>;
    emptyLoading: TemplateRef<FirestoreTableTemplateContext<D, any>>;
    relationLink: TemplateRef<FirestoreTableTemplateContext<D, any>>;
    relationLinkArray: TemplateRef<FirestoreTableTemplateContext<D, any>>;
    color: TemplateRef<FirestoreTableTemplateContext<D, any>>;
    button: TemplateRef<FirestoreTableTemplateContext<D, any>>;
    resolveWithCollectionPath: TemplateRef<FirestoreTableTemplateContext<D, any>>;
    actionButton: TemplateRef<FirestoreTableTemplateContext<D, any>>;
}