/// <reference types="react" />
import type { Column, ColumnDef, Table, VisibilityState } from '@tanstack/table-core';
import type { DataTableFilterOperatorTypes, FilterOperatorTypes, FilterSelectOption, FilterTypes, FilterValueType } from '~/types/filters';
import type { FilterChipCalendarProps } from '../filter-chip';
import type { BaseSelectProps } from '../select/select-root';
export type DataTableMode = 'client' | 'server';
export declare const SortOrders: {
    readonly ASC: "asc";
    readonly DESC: "desc";
};
export interface DataTableFilterValues {
    value: unknown;
    boolValue?: boolean;
    stringValue?: string;
    numberValue?: number;
}
export interface InternalFilter extends DataTableFilterValues {
    _type?: FilterTypes;
    _dataType?: FilterValueType;
    name: string;
    operator: FilterOperatorTypes;
}
export interface DataTableFilter extends DataTableFilterValues {
    name: string;
    operator: DataTableFilterOperatorTypes;
}
type SortOrdersKeys = keyof typeof SortOrders;
export type SortOrdersValues = (typeof SortOrders)[SortOrdersKeys];
export interface DataTableSort {
    name: string;
    order: SortOrdersValues;
}
export interface InternalQuery {
    filters?: InternalFilter[];
    sort?: DataTableSort[];
    group_by?: string[];
    offset?: number;
    limit?: number;
    search?: string;
}
export interface DataTableQuery extends Omit<InternalQuery, 'filters'> {
    filters?: DataTableFilter[];
}
export type DataTableColumn<TData, TValue> = Omit<Column<TData, TValue>, 'columnDef'> & {
    columnDef: DataTableColumnDef<TData, TValue>;
};
export type DataTableColumnDef<TData, TValue> = ColumnDef<TData, TValue> & {
    accessorKey: string;
    header: string;
    filterType?: FilterTypes;
    dataType?: FilterValueType;
    enableColumnFilter?: boolean;
    enableSorting?: boolean;
    enableHiding?: boolean;
    defaultHidden?: boolean;
    filterOptions?: FilterSelectOption[];
    defaultFilterValue?: unknown;
    filterProps?: {
        select?: BaseSelectProps;
        calendar?: FilterChipCalendarProps;
    };
    classNames?: {
        cell?: string;
        header?: string;
    };
    styles?: {
        cell?: React.CSSProperties;
        header?: React.CSSProperties;
    };
    enableGrouping?: boolean;
    showGroupCount?: boolean;
    groupCountMap?: Record<string, number>;
    groupLabelsMap?: Record<string, string>;
    icon?: React.ReactNode;
};
export interface DataTableProps<TData, TValue> {
    columns: DataTableColumnDef<TData, TValue>[];
    data: TData[];
    query?: DataTableQuery;
    mode?: DataTableMode;
    isLoading?: boolean;
    totalRowCount?: number;
    loadingRowCount?: number;
    onTableQueryChange?: (query: DataTableQuery) => void;
    defaultSort?: DataTableSort;
    onLoadMore?: () => Promise<void>;
    onRowClick?: (row: TData) => void;
    onColumnVisibilityChange?: (columnVisibility: VisibilityState) => void;
    /** When true, group headers stick under the table header while scrolling. Default is false. */
    stickyGroupHeader?: boolean;
    /** Return a stable unique id for each row (used as React key). Use for sortable/filterable tables. */
    getRowId?: (row: TData, index: number) => string;
}
export type DataTableContentClassNames = {
    root?: string;
    table?: string;
    header?: string;
    body?: string;
    row?: string;
};
export type DataTableContentBaseProps = {
    emptyState?: React.ReactNode;
    zeroState?: React.ReactNode;
    classNames?: DataTableContentClassNames;
};
export type DataTableContentProps = DataTableContentBaseProps;
export type VirtualizedContentProps = DataTableContentBaseProps & {
    /** Height of each row in pixels. */
    rowHeight?: number;
    /** Height of group header rows in pixels. Defaults to 40 (matches the non-virtualized section header height). */
    groupHeaderHeight?: number;
    /** Number of rows to render outside visible area. */
    overscan?: number;
    /** Distance in pixels from bottom to trigger load more. */
    loadMoreOffset?: number;
};
export type TableQueryUpdateFn = (query: InternalQuery) => InternalQuery;
export type TableContextType<TData, TValue> = {
    table: Table<TData>;
    columns: DataTableColumnDef<TData, TValue>[];
    isLoading?: boolean;
    loadMoreData: () => void;
    mode: DataTableMode;
    defaultSort?: DataTableSort;
    tableQuery?: InternalQuery;
    totalRowCount?: number;
    loadingRowCount?: number;
    onDisplaySettingsReset: () => void;
    updateTableQuery: (fn: TableQueryUpdateFn) => void;
    onRowClick?: (row: TData) => void;
    shouldShowFilters?: boolean;
    stickyGroupHeader?: boolean;
};
export interface ColumnData {
    label: string;
    id: string;
    isVisible?: boolean;
}
interface SubRows<_T> {
}
export interface GroupedData<T> extends SubRows<T> {
    label: string;
    group_key: string;
    subRows: T[];
    count?: number;
    showGroupCount?: boolean;
}
export declare const defaultGroupOption: {
    id: string;
    label: string;
};
export {};
//# sourceMappingURL=data-table.types.d.ts.map