import { ReactElement } from 'react';
import { AggregateDescriptor, CompositeFilterDescriptor, GroupDescriptor, SortDescriptor, DataResult, GroupResult, DataSource, IdType } from '@servicetitan/data-query';
import { ExcelExport, ExcelExportData, ExcelExportColumnProps } from '@progress/kendo-react-excel-export';
import { TableExpandChangeEvent, TableFilterChangeEvent, TableGroupChangeEvent, TablePageChangeEvent, TableSortChangeEvent } from '@servicetitan/design-system';
import { GridPDFExport as TablePDFExport } from '@progress/kendo-react-pdf';
import { WorkbookOptions } from '@progress/kendo-ooxml';
import { FormState, FieldState } from 'formstate';
export type Selectable<T> = {
    readonly selected: boolean | undefined;
} & T;
export type Editable<T> = {
    readonly inEdit: boolean | undefined;
} & T;
export type Expandable<T> = {
    readonly expanded: boolean | undefined;
} & T;
export type Materialized<T> = {
    readonly materializedPath: string;
} & T;
type Data<T> = DataResult<T>['data'];
export declare function isGroupItem<T>(item: T | GroupResult<T>, groups: GroupDescriptor[]): item is GroupResult<T>;
export type PossibleFormState<T> = FormState<{
    [P in keyof T]-?: FieldState<T[P]>;
}>;
export interface TableStateModel<TId extends IdType = never> {
    skip: number;
    selectedIds: TId[];
    expandedIds: TId[];
    collapsedGroups: string[];
    sort: SortDescriptor[];
    filter?: CompositeFilterDescriptor;
    aggregates: AggregateDescriptor[];
    group: GroupDescriptor[];
}
export interface TableStateConstructorParams<T, TId extends IdType = never, P = never, PId extends IdType = never> {
    dataSource?: DataSource<T, TId> | null;
    pageSize?: number;
    /** For use with tables that enable selection only. Specifies if the item is selectable in the checkbox */
    isRowUnselectable?: (row: T) => boolean;
    /**
     * Initial expand state for row details
     * collapsed - row details are collapsed by default
     * expanded - row details are expanded until it will be collapsed
     */
    rowDetailsExpandState?: 'collapsed' | 'expanded';
    selectionLimit?: number;
    getFormState?(row: T): PossibleFormState<T>;
    parent?: {
        row: P;
        tableState: TableState<P, PId>;
    };
    getDetailTableState?: (row: T) => TableState<any, any, any, any> | undefined;
    initialState?: TableStateModel<TId>;
    alwaysEditable?: boolean;
    rowIdKey?: string;
}
interface FetchDataParams {
    newSkip?: number;
    newSort?: SortDescriptor[];
    newFilter?: CompositeFilterDescriptor | null;
    newAggregates?: AggregateDescriptor[];
    newGroup?: GroupDescriptor[];
}
interface SelectionOptions {
    ignoreUnselectable?: boolean;
    recursive?: boolean;
}
interface SetDataSourceParams<TId extends IdType = never> {
    reset?: boolean;
    initialState?: TableStateModel<TId>;
}
interface EditingForm<T> {
    form: PossibleFormState<T>;
    field?: keyof T;
}
/** Interface for unit testing purposes.*/
export interface ITableState<T, TId extends IdType = never> {
    totalCount?: number;
    selectedCount?: number;
    addToDataSource?: (row: T, select?: boolean) => Promise<void>;
    removeFromDataSource?: (id: TId) => Promise<T | undefined>;
    selectAll?: () => Promise<void>;
    deselectAll?: () => void;
    setDataSource?: (dataSource: DataSource<T, TId> | null, setDataSourceParams?: boolean | SetDataSourceParams<TId>) => Promise<void>;
    isRowUnselectable?: (row: T) => boolean;
}
export declare class TableState<T, TId extends IdType = never, P = never, PId extends IdType = never> {
    private innerDataSource;
    get dataSource(): DataSource<T, TId> | null;
    private traverse;
    private get originalData();
    parent?: {
        row: P;
        tableState: TableState<P, PId>;
    };
    getDetailTableState?: (row: T) => TableState<any, any, any, any> | undefined;
    selectedIds: Set<TId>;
    inEdit: Map<TId, EditingForm<T>>;
    expandedIds: Set<TId>;
    collapsedIds: Set<TId>;
    collapsedGroups: Set<string>;
    isRowUnselectable: (row: T) => boolean;
    selectionLimit: number;
    getFormState?(row: T): PossibleFormState<T>;
    data: Data<Selectable<T>>;
    totalCount: number;
    filteredCount: number;
    selectedCount: number;
    unselectableCount: number;
    get unselectedCount(): number;
    get selectableCount(): number;
    get filteredUnselectableCount(): number;
    get filteredSelectableCount(): number;
    private get totalFilteredSelectableCountPromise();
    get totalFilteredSelectableCount(): number;
    sort: SortDescriptor[];
    filter: CompositeFilterDescriptor | undefined;
    aggregates: AggregateDescriptor[];
    innerGroup: GroupDescriptor[];
    get group(): GroupDescriptor[];
    set group(value: GroupDescriptor[]);
    skip: number;
    pageSize?: number;
    private tablePdfExport;
    private tableExcelExport;
    private readonly rowDetailsExpandState;
    rowIdKey?: string;
    alwaysEditable: boolean;
    constructor({ dataSource, rowIdKey, pageSize, isRowUnselectable, rowDetailsExpandState, selectionLimit, getFormState, parent, getDetailTableState, initialState, alwaysEditable, }?: TableStateConstructorParams<T, TId, P, PId>);
    addToDataSource(row: T, select?: boolean, index?: number): Promise<void>;
    removeFromDataSource(id: TId): Promise<T | undefined>;
    setRowsSelection(rows: T[], value: boolean, { ignoreUnselectable, recursive }?: SelectionOptions): Promise<void>;
    selectPage(options?: SelectionOptions): Promise<void>;
    deselectPage(options?: SelectionOptions): Promise<void>;
    private setAllSelection;
    selectAll(options?: SelectionOptions): Promise<void>;
    deselectAll(options?: SelectionOptions): Promise<void>;
    edit(row: T, field?: keyof T): void;
    saveEdit(row: T, beforeSave?: (changed: T, field?: keyof T) => Promise<void>): Promise<void>;
    cancelEdit(row: T): void;
    editAll(): Promise<void>;
    saveEditAll(beforeSave?: (changed: T[]) => Promise<void>): Promise<void>;
    cancelEditAll(): void;
    reset(): void;
    setDataSource(dataSource: DataSource<T, TId> | null, setDataSourceParams?: SetDataSourceParams<TId> | boolean): Promise<void>;
    private fetchInitialData;
    private addPropertiesToRows;
    handleFilterChange: (ev: TableFilterChangeEvent) => void;
    handleGroupChange: (ev: TableGroupChangeEvent) => void;
    handleExpandChange: ({ dataItem, value }: TableExpandChangeEvent) => void;
    handleSortChange: (ev: TableSortChangeEvent) => void;
    handlePageChange: (ev: TablePageChangeEvent) => void;
    /** Call without params if unchanged */
    fetchData: ({ newSkip, newSort, newFilter, newAggregates, newGroup, }?: FetchDataParams) => Promise<void>;
    isRowSelectable: (row: Selectable<T>) => boolean;
    toggleRowSelection(row: T, options?: SelectionOptions): Promise<void>;
    get isAllPageRowsSelected(): boolean;
    get isSomePageRowsSelected(): boolean;
    get isAllRowsSelected(): boolean;
    get isSomeRowsSelected(): boolean;
    setTablePdfExportRef: (el: TablePDFExport | null) => TablePDFExport | null;
    setTableExcelExportRef: (el: ExcelExport | null) => ExcelExport | null;
    exportPdf: () => Promise<void>;
    exportExcel: (data?: any[] | ExcelExportData | WorkbookOptions, columns?: ExcelExportColumnProps[] | ReactElement<ExcelExportColumnProps>[]) => Promise<void>;
    filteredSortedUnpaginatedData: () => Promise<DataResult<T>>;
    getRowsBetween: (start: Selectable<T>, end: Selectable<T>) => Selectable<T>[];
    exportState(): TableStateModel<TId>;
    importState(data: TableStateModel<TId>): void;
    private updateExpandState;
}
export {};
//# sourceMappingURL=table-state.d.ts.map