@dcs-tech/ui 0.2.0 → 0.3.0

package/dist/types/shared-web-ui/src/DataTable/types.d.ts

@@ -0,0 +1,1145 @@
+import { type ComponentType, type ReactNode } from 'react';
+import type { ChartProgressColor, ChartSlot, TrendGood } from '../Charts';
+import type { DataTableLabels } from './labels';
+export type DataTableFlashColor = 'green' | 'red' | 'amber' | 'blue' | 'purple' | 'teal' | 'orange' | 'pink';
+export interface DataTableFlashColors {
+    up?: DataTableFlashColor;
+    down?: DataTableFlashColor;
+    changed?: DataTableFlashColor;
+}
+export type DataTableCellFlashStyle = 'cell' | 'text' | 'border';
+export type DataTableLayout = 'table' | 'cards' | 'split';
+export interface DataTableCardFields {
+    title: string[];
+    subtitle: string[];
+    badge: string[];
+    details: string[];
+    more: string[];
+}
+export type DataTableCardField = keyof DataTableCardFields;
+export declare const CARD_FIELD_LIMITS: Readonly<Record<DataTableCardField, number>>;
+export interface DataTableListFields {
+    title: string[];
+    subtitle: string[];
+    badge: string[];
+}
+export type DataTableListField = keyof DataTableListFields;
+export declare const LIST_FIELD_LIMITS: Readonly<Record<DataTableListField, number>>;
+export type DataTableColumnType = 'string' | 'number' | 'date' | 'boolean' | 'select' | 'array';
+export interface DataTableCellStyle {
+    color?: string;
+    backgroundColor?: string;
+    fontWeight?: 'normal' | 'bold';
+    fontSize?: number;
+    align?: 'left' | 'center' | 'right';
+}
+export interface DataTableColumn<TData = any> {
+    key: string;
+    header: string;
+    type?: DataTableColumnType;
+    cell?: (value: any, row: TData, index: number) => ReactNode;
+    sortable?: boolean;
+    filterable?: boolean;
+    hideable?: boolean;
+    defaultHidden?: boolean;
+    summable?: boolean;
+    sticky?: 'left' | 'right';
+    align?: 'left' | 'center' | 'right';
+    width?: number;
+    minWidth?: number;
+    filterOptions?: Array<{
+        label: string;
+        value: any;
+    }>;
+    filterAccessor?: (value: any) => any;
+    field?: string;
+    groupable?: boolean;
+    authorized?: boolean;
+    license?: DataTableLicense;
+    flashStyle?: DataTableCellFlashStyle;
+    flashBadge?: boolean;
+    flashColors?: DataTableFlashColors;
+    statusColors?: Record<string, DataTableFlashColor>;
+    cellStyle?: (value: any, row: TData) => DataTableCellStyle | undefined;
+    exportValue?: (value: any, row: TData) => string | number;
+    exportHeader?: string;
+    exportable?: boolean;
+}
+export interface DataTableFilterCondition {
+    id: string;
+    column: string;
+    operator: string;
+    value: any;
+    enabled: boolean;
+}
+export interface DataTableFilterGroup {
+    id: string;
+    logic: 'AND' | 'OR';
+    negated?: boolean;
+    conditions: (DataTableFilterCondition | DataTableFilterGroup)[];
+}
+export interface DataTableActiveFilter {
+    id: string;
+    column: string;
+    columnLabel: string;
+    operator: string;
+    operatorLabel: string;
+    value: any;
+    displayValue: string;
+}
+export interface DataTableQuickFilter {
+    id: string;
+    label: string;
+    conditions: DataTableFilterCondition[];
+    logic?: 'AND' | 'OR';
+}
+export type DataTableQuickFilterMode = 'single' | 'multi';
+export interface DataTableSavedFilter {
+    id: string;
+    label: string;
+    filterGroup: DataTableFilterGroup;
+    isDefault?: boolean;
+    createdAt?: number;
+    disabled?: DataTableSavedFilterIssue;
+}
+export interface DataTableSavedFilterIssue {
+    reason: 'column' | 'operator' | 'value';
+    column: string;
+}
+export type DataTableLicense = Record<string, unknown>;
+export type DataTableSummaryStrip = 'top' | 'bottom';
+export declare const SUMMARY_STRIPS: readonly DataTableSummaryStrip[];
+export interface DataTableSummaryFigure<TData = any> {
+    id: string;
+    compute?: (rows: TData[]) => number;
+}
+export interface DataTableSummarySubline<TData = any> {
+    label: string;
+    value: DataTableSummaryFigure<TData>;
+    text?: (formatted: string) => string;
+}
+export type DataTableSummaryChart = 'donut' | 'pie' | 'bars' | 'stacked' | 'treemap';
+export type DataTableSummaryTrendChart = 'columns' | 'line' | 'area' | 'grouped' | 'stacked' | 'calendar';
+export type DataTableSummaryValueChart = 'number' | 'numberTrend';
+export type DataTableSummaryRatioChart = 'bar' | 'gauge' | 'ring' | 'donut' | 'pie';
+export type DataTableSummaryAnyChart = DataTableSummaryChart | DataTableSummaryTrendChart | DataTableSummaryValueChart | DataTableSummaryRatioChart | 'funnel';
+export declare const SUMMARY_KIND_CHARTS: {
+    readonly value: readonly ["number", "numberTrend"];
+    readonly ratio: readonly ["bar", "gauge", "ring", "donut", "pie"];
+    readonly breakdown: readonly ["donut", "pie", "bars", "stacked", "treemap"];
+    readonly trend: readonly ["columns", "line", "area", "grouped", "stacked", "calendar"];
+    readonly funnel: readonly ["funnel"];
+};
+export type DataTableSummaryWidth = 'auto' | 'quarter' | 'half' | 'full';
+export declare const SUMMARY_WIDTHS: readonly DataTableSummaryWidth[];
+export type DataTableSummaryShow = 'top5' | 'top10' | 'least5' | 'least10' | 'all';
+export declare const SUMMARY_SHOWS: readonly DataTableSummaryShow[];
+export type DataTableSummaryPart = {
+    from: 'top' | 'least';
+    count: number;
+} | {
+    from: 'all';
+};
+export interface DataTableSummaryCardContext<TData = any> {
+    query: DataTableQuery;
+    serverMode: boolean;
+    rows: TData[];
+}
+interface DataTableSummaryCardBase {
+    id: string;
+    title: string;
+    showWhen?: (ctx: DataTableSummaryCardContext<any>) => boolean;
+    unavailable?: string;
+    default?: boolean;
+    strip?: DataTableSummaryStrip;
+    width?: DataTableSummaryWidth;
+    license?: DataTableLicense;
+    authorize?: () => boolean;
+}
+export type DataTableSummaryPeriod = 'month' | 'day';
+export interface DataTableSummaryValueTrend {
+    column: string;
+    period: DataTableSummaryPeriod;
+    count: number;
+    good?: TrendGood;
+}
+export interface DataTableSummaryValueCard<TData = any> extends DataTableSummaryCardBase {
+    kind: 'value';
+    value: DataTableSummaryFigure<TData>;
+    sub?: DataTableSummarySubline<TData>;
+    chart?: DataTableSummaryValueChart;
+    trend?: DataTableSummaryValueTrend;
+}
+export interface DataTableSummaryRatioCard<TData = any> extends DataTableSummaryCardBase {
+    kind: 'ratio';
+    value: DataTableSummaryFigure<TData>;
+    total: DataTableSummaryFigure<TData>;
+    color?: ChartProgressColor;
+    sub?: DataTableSummarySubline<TData>;
+    chart?: DataTableSummaryRatioChart;
+}
+export interface DataTableSummaryBreakdownCard extends DataTableSummaryCardBase {
+    kind: 'breakdown';
+    column: string;
+    chart?: DataTableSummaryChart;
+    show?: DataTableSummaryShow;
+    slots?: Record<string, ChartSlot>;
+    within?: string;
+}
+export interface DataTableSummaryTrendCard extends DataTableSummaryCardBase {
+    kind: 'trend';
+    column: string;
+    period: DataTableSummaryPeriod;
+    count: number;
+    counts?: readonly number[];
+    chart?: DataTableSummaryTrendChart;
+    split?: string;
+    slots?: Record<string, ChartSlot>;
+}
+export interface DataTableSummaryFunnelStep<TData = any> {
+    id: string;
+    label: string;
+    value: DataTableSummaryFigure<TData>;
+    condition?: Pick<DataTableFilterCondition, 'column' | 'operator' | 'value'>;
+    slot?: ChartSlot;
+}
+export interface DataTableSummaryFunnelCard<TData = any> extends DataTableSummaryCardBase {
+    kind: 'funnel';
+    steps: DataTableSummaryFunnelStep<TData>[];
+}
+export type DataTableSummaryCard<TData = any> = DataTableSummaryValueCard<TData> | DataTableSummaryRatioCard<TData> | DataTableSummaryBreakdownCard | DataTableSummaryTrendCard | DataTableSummaryFunnelCard<TData>;
+export interface DataTableSummaryConfig<TData = any> {
+    cards: DataTableSummaryCard<TData>[];
+}
+export declare const SUMMARY_TREND_COUNTS: {
+    readonly month: readonly [3, 6, 12, 24, 36];
+    readonly day: readonly [30, 91, 182, 365];
+};
+export declare const SUMMARY_TREND_COUNT_BOUNDS: {
+    readonly month: {
+        readonly min: 1;
+        readonly max: 60;
+    };
+    readonly day: {
+        readonly min: 7;
+        readonly max: 400;
+    };
+};
+export declare const SUMMARY_USER_CARDS_MAX = 6;
+export declare const SUMMARY_PLACEMENTS_MAX = 24;
+export interface DataTableSummaryPlacement {
+    key: string;
+    card: string;
+    on: boolean;
+    title?: string;
+    chart?: DataTableSummaryAnyChart;
+    show?: DataTableSummaryShow;
+    count?: number;
+    width?: DataTableSummaryWidth;
+}
+export interface DataTableSummaryUserCard {
+    id: string;
+    column: string;
+    chart: DataTableSummaryChart;
+}
+export interface DataTableSummaryPrefs {
+    top?: DataTableSummaryPlacement[];
+    bottom?: DataTableSummaryPlacement[];
+    own?: DataTableSummaryUserCard[];
+}
+export type DataTableExportSummaryMode = 'shown' | 'chosen' | 'none';
+export interface DataTableSummaryRequest {
+    values: string[];
+    cards: DataTableSummaryCardRequest[];
+}
+export type DataTableSummaryCardRequest = {
+    key: string;
+    id: string;
+    kind: 'breakdown';
+    field: string;
+    part: DataTableSummaryPart;
+    within?: string;
+} | {
+    key: string;
+    id: string;
+    kind: 'trend';
+    field: string;
+    period: DataTableSummaryPeriod;
+    count: number;
+    split?: string;
+} | {
+    key: string;
+    id: string;
+    kind: 'series';
+    value: string;
+    field: string;
+    period: DataTableSummaryPeriod;
+    count: number;
+} | {
+    key: string;
+    id: string;
+    kind: 'funnel';
+    steps: string[];
+};
+export interface DataTableSummaryBucket {
+    value: string | number | boolean | null;
+    label?: string | null;
+    count: number;
+    children?: DataTableSummaryBucket[];
+}
+export interface DataTableSummaryPeriodCount {
+    period: string;
+    count: number;
+    split?: DataTableSummaryBucket[];
+}
+export interface DataTableSummaryBreakdown {
+    buckets: DataTableSummaryBucket[];
+    others: number;
+    values: number;
+}
+export interface DataTableSummaryFigures {
+    values?: Record<string, number>;
+    breakdowns?: Record<string, DataTableSummaryBreakdown>;
+    trends?: Record<string, DataTableSummaryPeriodCount[]>;
+    series?: Record<string, {
+        points: Array<{
+            period: string;
+            count: number;
+        }>;
+        previous: number;
+    }>;
+    funnels?: Record<string, Record<string, number>>;
+}
+type ActionVariant = 'primary' | 'secondary' | 'danger' | 'success' | 'warning';
+export interface DataTableRowAction<TData = any> {
+    id: string;
+    label?: string | ((row: TData) => string);
+    icon?: ReactNode | ((row: TData) => ReactNode);
+    onClick: (row: TData, index: number) => void;
+    variant?: ActionVariant | ((row: TData) => ActionVariant);
+    showWhen?: (row: TData) => boolean;
+    disabledWhen?: (row: TData) => boolean;
+    tooltip?: string | ((row: TData) => string);
+    primary?: boolean | ((row: TData) => boolean);
+    shortcut?: string;
+}
+export type DataTableKeyboardConfig = boolean | {
+    shortcuts?: boolean;
+};
+export interface DataTableShortcut<TData = any> {
+    key: string;
+    label: string;
+    run: (ctx: {
+        row: TData | null;
+        selectedRows: TData[];
+        query: DataTableQuery;
+    }) => void;
+    needsRow?: boolean;
+    showWhen?: (row: TData | null) => boolean;
+    disabledWhen?: (row: TData | null) => boolean;
+}
+export type DataTableVirtualizeConfig = boolean | {
+    overscan?: number;
+    estimateRowHeight?: number;
+    maxHeight?: number | string;
+};
+export interface DataTableGroupingConfig {
+    maxDepth?: number;
+    defaultGroupBy?: string[];
+}
+export interface DataTableGroupPathItem {
+    key: string;
+    field: string;
+    value: string | number | boolean | null;
+}
+export interface DataTableGroupResult {
+    value: string | number | boolean | null;
+    label?: string | null;
+    count: number;
+    aggregates?: Record<string, number | string>;
+}
+export interface DataTableGroupSummaryContext<TData = any> {
+    count: number;
+    rows?: TData[];
+    aggregates?: Record<string, number | string>;
+}
+export interface DataTableViewState {
+    search?: string;
+    filterGroup?: DataTableFilterGroup;
+    quickFilterIds?: string[];
+    sorting?: Array<{
+        key: string;
+        desc: boolean;
+    }>;
+    grouping?: string[];
+    layout?: DataTableLayout;
+    columns?: {
+        visibility?: Record<string, boolean>;
+        order?: string[];
+    };
+}
+export interface DataTableSharedView {
+    id: string;
+    viewKey: string;
+    label: string;
+    state: DataTableViewState;
+    ownerName: string;
+    mine?: boolean;
+    audienceIds?: string[];
+}
+export interface DataTableShareAudience {
+    id: string;
+    label: string;
+    group?: string;
+}
+export interface DataTableSharing {
+    listShared: (tableId: string) => Promise<DataTableSharedView[]>;
+    audiences: () => Promise<DataTableShareAudience[]>;
+    publish: (view: {
+        tableId: string;
+        viewKey: string;
+        label: string;
+        state: DataTableViewState;
+    }, audienceIds: string[]) => Promise<DataTableSharedView>;
+    unpublish: (viewId: string) => Promise<void>;
+}
+export type DataTableSelection<TData = any> = {
+    kind: 'none';
+    query: DataTableQuery;
+    count: number;
+} | {
+    kind: 'rows';
+    query: DataTableQuery;
+    count: number;
+    ids: string[];
+    rows: TData[];
+} | {
+    kind: 'query';
+    query: DataTableQuery;
+    count: number;
+} | {
+    kind: 'group';
+    query: DataTableQuery;
+    count: number;
+    path: DataTableGroupPathItem[];
+    label: string;
+};
+export interface DataTableBulkConfirm {
+    title?: string;
+    message?: ReactNode;
+    confirmLabel?: string;
+    danger?: boolean;
+    input?: {
+        label: string;
+        placeholder?: string;
+        required?: boolean;
+        maxLength?: number;
+    };
+}
+export interface DataTableBulkActionContext<TData = any> {
+    selection: DataTableSelection<TData>;
+    rows: TData[];
+    skipped: Array<{
+        row: TData;
+        reason: string;
+    }>;
+    input?: string;
+}
+export interface DataTableBulkActionResult {
+    done?: number;
+    skipped?: number;
+    reason?: string;
+    message?: string;
+    status?: 'success' | 'warning' | 'error';
+    undo?: () => Promise<void> | void;
+    keepSelection?: boolean;
+}
+export interface DataTableBulkAction<TData = any> {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    variant?: ActionVariant;
+    display?: 'icon' | 'label' | 'icon-label';
+    tooltip?: string;
+    views?: string[];
+    authorize?: () => boolean;
+    eligible?: (row: TData) => boolean | string;
+    minSelected?: number;
+    maxSelected?: number;
+    allowAllMatching?: boolean;
+    confirm?: boolean | DataTableBulkConfirm | ((ctx: {
+        count: number;
+        skipped: number;
+        selection: DataTableSelection<TData>;
+    }) => DataTableBulkConfirm | false);
+    undoTimeoutMs?: number;
+    onRun: (ctx: DataTableBulkActionContext<TData>) => Promise<DataTableBulkActionResult | void> | DataTableBulkActionResult | void;
+}
+export interface DataTableColumnPinning {
+    left: string[];
+    right: string[];
+}
+export interface DataTablePinningConfig {
+    selection?: boolean;
+    actions?: boolean;
+    enabled?: boolean;
+    firstColumn?: boolean;
+}
+export interface DataTableRowMenuItem<TData = any> {
+    id: string;
+    label: string | ((row: TData) => string);
+    icon?: ReactNode | ((row: TData) => ReactNode);
+    onClick: (row: TData) => void;
+    showWhen?: (row: TData) => boolean;
+    variant?: 'default' | 'danger';
+    shortcut?: string;
+}
+export type DataTableRowMenuBuiltIn = 'open' | 'copyCell' | 'copyRow' | 'select' | 'only' | 'hide' | 'openInNewTab';
+export interface DataTableRowMenuIconAction<TData = any> {
+    id: string;
+    label: string | ((row: TData) => string);
+    shortLabel?: string;
+    icon: ReactNode;
+    onClick: (row: TData) => void;
+    showWhen?: (row: TData) => boolean;
+    disabledWhen?: (row: TData) => boolean;
+    shortcut?: string;
+}
+export interface DataTableRowMenuConfig<TData = any> {
+    enabled?: boolean;
+    items?: DataTableRowMenuItem<TData>[];
+    onOpen?: (row: TData) => void;
+    openView?: (row: TData) => ComponentType<{
+        row: TData;
+        closeModal: () => void;
+    }> | null | undefined;
+    openHeader?: ReactNode | ((row: TData) => ReactNode);
+    openSubheader?: ReactNode | ((row: TData) => ReactNode);
+    openFooter?: ReactNode | ((row: TData) => ReactNode);
+    openOn?: 'click' | 'doubleClick';
+    longPress?: 'menu' | 'open';
+    builtIns?: DataTableRowMenuBuiltIn[];
+    iconActions?: DataTableRowMenuIconAction<TData>[];
+    getRowHref?: (row: TData) => string | undefined;
+}
+export type DataTableDetailMode = 'pane' | 'drawer' | 'fullscreen';
+export interface DataTableDetailContext {
+    id: string;
+    mode: DataTableDetailMode;
+    close: () => void;
+    position?: {
+        index: number;
+        count: number;
+    };
+    prev?: () => void;
+    next?: () => void;
+}
+export type DataTableDetailRenderer<TData = any> = (row: TData | null, ctx: DataTableDetailContext) => ReactNode;
+export interface RowMenuState {
+    visible: boolean;
+    x: number;
+    y: number;
+    row: any | null;
+}
+export interface DataTableSingleRowField {
+    key: string;
+    label: string;
+    formatter?: (val: any, row: any) => ReactNode;
+    span?: number;
+}
+export interface DataTableSingleRowAction {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    onClick: (row: any) => void;
+    variant?: string;
+}
+export interface DataTableSingleRowView {
+    enabled?: boolean;
+    fields?: DataTableSingleRowField[];
+    actions?: DataTableSingleRowAction[];
+}
+export interface DataTableComponentProps<TData = any> {
+    data: TData[];
+    rows: TData[];
+    selectedRows: TData[];
+    resultData: TData[];
+    tabletitleaddon: string;
+    visibleColumns: string[];
+    allColumns: string[];
+    filters: DataTableActiveFilter[];
+    context?: Record<string, any>;
+}
+export interface DataTableSelectionConfig<TData = any> {
+    mode: 'single' | 'multiple';
+    onSelectionChange?: (rows: TData[]) => void;
+    isSelectable?: (row: TData) => boolean;
+    show?: DataTableSelectionShow;
+}
+export type DataTableSelectionShow = 'onDemand' | 'always';
+export interface DataTablePaginationConfig {
+    pageSize?: number;
+    pageSizeOptions?: number[];
+}
+export interface DataTableSortingConfig {
+    multiSort?: boolean;
+    defaultSort?: Array<{
+        key: string;
+        desc: boolean;
+    }>;
+}
+export interface DataTableFilteringConfig {
+    advanced?: boolean;
+    quickFilters?: DataTableQuickFilter[];
+    quickFilterMode?: DataTableQuickFilterMode;
+    quickFilterLabel?: string;
+    filterRow?: boolean | {
+        defaultVisible?: boolean;
+        debounceMs?: number;
+    };
+    defaultFilter?: string;
+}
+export type DataTablePdfPageSize = 'auto' | 'A4' | 'A3' | 'A5' | 'LETTER' | 'LEGAL' | 'TABLOID';
+export type DataTablePdfOrientation = 'auto' | 'portrait' | 'landscape';
+export type DataTablePdfFontSize = 'auto' | number;
+export type DataTablePdfMargins = 'default' | 'compact' | 'tight';
+export interface DataTableExportMetadata {
+    businessName?: string;
+    businessAddress?: string;
+    businessPhone?: string;
+    taxNumber?: string;
+    taxNumberLabel?: string;
+    searchTerm?: string;
+    filters?: Array<{
+        column: string;
+        operator: string;
+        value: string;
+    }>;
+    totalRows: number;
+    filteredRows: number;
+    resultRows: number;
+    selectedRows: number;
+    labels?: Partial<DataTableLabels>;
+    locale?: string;
+}
+export type DataTableExportFormat = 'csv' | 'xlsx' | 'json' | 'pdf' | 'html' | 'xml';
+export type DataTableExportAction = 'download' | 'share' | 'preview' | 'print';
+export interface DataTableXlsxStyle {
+    columnStyles?: Record<string, {
+        numFmt?: string;
+        width?: number;
+        bold?: boolean;
+        align?: 'left' | 'center' | 'right';
+        wrapText?: boolean;
+    }>;
+    headerStyle?: {
+        fill?: string;
+        fontColor?: string;
+        bold?: boolean;
+        fontSize?: number;
+    };
+    totalsStyle?: {
+        fill?: string;
+        bold?: boolean;
+        border?: 'thin' | 'medium' | 'thick';
+    };
+    sheetName?: string;
+    freezeRows?: number;
+    freezeCols?: number;
+    autoFilter?: boolean;
+}
+export interface DataTablePdfConfig {
+    type?: 'table';
+    orientation?: 'portrait' | 'landscape';
+    pageSize?: 'A4' | 'A3' | 'A5' | 'letter' | 'legal' | 'tabloid';
+    title?: string;
+    subtitle?: string;
+    showLogo?: boolean;
+    showDate?: boolean;
+    showPageNumbers?: boolean;
+    showTotals?: boolean;
+    showSummary?: boolean;
+    columnStyles?: Record<string, {
+        width?: number | 'auto';
+        align?: 'left' | 'center' | 'right';
+        bold?: boolean;
+    }>;
+    headerStyle?: {
+        fontSize?: number;
+        color?: string;
+        background?: string;
+    };
+    fontSize?: number;
+    margin?: number | {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    autoFit?: boolean;
+}
+export type DataTableExportResultStatus = 'success' | 'warning' | 'error';
+export interface DataTableExportResult {
+    status: DataTableExportResultStatus;
+    message: string | ReactNode;
+}
+export interface DataTableExportGeneratorResult {
+    data: any;
+    result?: DataTableExportResult;
+}
+export type DataTableExportGenerator<TData = any> = (data: TData[], meta: DataTableExportMeta) => any | DataTableExportGeneratorResult | Promise<any | DataTableExportGeneratorResult>;
+interface DataTableExportOptionBase {
+    id: string;
+    label: string;
+    hint?: string;
+}
+export interface DataTableExportToggleOption extends DataTableExportOptionBase {
+    type: 'toggle';
+    default?: boolean;
+}
+export interface DataTableExportChoiceOption extends DataTableExportOptionBase {
+    type: 'choice';
+    choices: Array<{
+        label: string;
+        value: string;
+    }>;
+    default?: string;
+}
+export type DataTableExportOption = DataTableExportToggleOption | DataTableExportChoiceOption;
+export type DataTableExportOptionValues = Record<string, string | boolean>;
+export interface DataTableExportOptionContext {
+    options: DataTableExportOptionValues;
+}
+export interface DataTableFilenameContext {
+    templateId: string;
+    format: DataTableExportFormat;
+    rowCount: number;
+    globalFilter: string;
+    activeFilters: DataTableActiveFilter[];
+    selectedRows: any[];
+    meta: Record<string, any>;
+    today: string;
+    options: DataTableExportOptionValues;
+}
+export interface DataTableExportMeta {
+    filename: string;
+    format: DataTableExportFormat;
+    action: DataTableExportAction;
+    filters: DataTableActiveFilter[];
+    globalFilter: string;
+    selectedCount: number;
+    totalCount: number;
+    meta: Record<string, any>;
+}
+export interface DataTableExportContext<TData = any> {
+    data: TData[];
+    selectedRows: TData[];
+    resultData: TData[];
+    meta: Record<string, any>;
+}
+export interface DataTableExportTemplate<TData = any> {
+    id: string;
+    label: string;
+    description: string;
+    icon?: ReactNode;
+    options?: DataTableExportOption[];
+    transform: (resultData: TData[], ctx: DataTableExportOptionContext) => any[];
+    columns: DataTableColumn[] | ((ctx: DataTableExportOptionContext) => DataTableColumn[]);
+    formats: DataTableExportFormat[];
+    params?: (ctx: DataTableExportOptionContext) => Record<string, unknown>;
+    totals?: string[];
+    summary?: (rows: any[]) => Record<string, string | number>;
+    filename?: string;
+    getFilename?: (ctx: DataTableFilenameContext) => string;
+    showWhen?: (ctx: DataTableExportContext<TData>) => boolean;
+    unavailable?: string;
+    validate?: (data: any[]) => {
+        valid: boolean;
+        warnings?: string[];
+    };
+    formatAvailability?: (format: DataTableExportFormat, ctx: DataTableExportContext<TData>) => true | string;
+    defaultVisible?: boolean;
+    customizable?: boolean;
+    generate?: Partial<Record<DataTableExportFormat, DataTableExportGenerator<TData>>>;
+    previewRows?: (data: TData[]) => {
+        headers: string[];
+        rows: Record<string, any>[];
+    };
+    onResult?: (data: TData[], meta: DataTableExportMeta) => DataTableExportResult | undefined;
+    license?: DataTableLicense;
+}
+export type DataTableFileNameAs = 'title' | 'title-date' | 'title-generated' | 'title-date-generated';
+export interface DataTableQuickExport<TData = any> {
+    enabled?: boolean;
+    formats?: DataTableExportFormat[];
+    filename?: string;
+    fileNameAs?: DataTableFileNameAs;
+    getFilename?: (ctx: DataTableFilenameContext) => string;
+    totals?: boolean;
+    summary?: (rows: TData[]) => Record<string, string | number>;
+    xlsx?: DataTableXlsxStyle;
+    pdf?: DataTablePdfConfig;
+    generate?: Partial<Record<DataTableExportFormat, DataTableExportGenerator<TData>>>;
+}
+export interface DataTableExportConfig<TData = any> {
+    quick?: DataTableQuickExport<TData>;
+    templates?: DataTableExportTemplate<TData>[];
+    maxVisibleTemplates?: number;
+    meta?: Record<string, any>;
+}
+export interface DataTableExportSummaryTable {
+    id: string;
+    title: string;
+    header: [string, string];
+    rows: Array<{
+        label: string;
+        count: number;
+    }>;
+}
+export interface DataTableExportSummary {
+    items: Record<string, string | number>;
+    tables?: DataTableExportSummaryTable[];
+}
+export interface DataTableExportSettings {
+    includeTotals: boolean;
+    summary: DataTableExportSummaryMode;
+    summaryCards: string[];
+    includeBusinessData: boolean;
+    includeContext: boolean;
+    contextFilters: boolean;
+    contextSearch: boolean;
+    contextSelection: boolean;
+    contextRows: boolean;
+    columnMode: 'visible' | 'custom';
+    customExportColumns: string[];
+    pdfPageSize: DataTablePdfPageSize;
+    pdfOrientation: DataTablePdfOrientation;
+    pdfFontSize: DataTablePdfFontSize;
+    pdfMargins: DataTablePdfMargins;
+}
+export interface DataTableExportPrefs {
+    quick?: {
+        lastFormat?: DataTableExportFormat;
+        totals?: boolean;
+        summary?: DataTableExportSummaryMode;
+        summaryCards?: string[];
+        businessData?: boolean;
+        context?: boolean;
+        contextFilters?: boolean;
+        contextSearch?: boolean;
+        contextSelection?: boolean;
+        contextRows?: boolean;
+        columnMode?: 'visible' | 'custom';
+        customExportColumns?: string[];
+        pdfPageSize?: DataTablePdfPageSize;
+        pdfOrientation?: DataTablePdfOrientation;
+        pdfFontSize?: DataTablePdfFontSize;
+        pdfMargins?: DataTablePdfMargins;
+    };
+    templates?: Record<string, {
+        lastFormat?: DataTableExportFormat;
+        totals?: boolean;
+        summary?: DataTableExportSummaryMode;
+        summaryCards?: string[];
+        customColumns?: string[];
+        pdfPageSize?: DataTablePdfPageSize;
+        pdfOrientation?: DataTablePdfOrientation;
+        pdfFontSize?: DataTablePdfFontSize;
+        pdfMargins?: DataTablePdfMargins;
+    }>;
+}
+export interface DataTableManageList {
+    order?: string[];
+    hidden?: string[];
+}
+export type DataTableViewsPrefs = DataTableManageList;
+export type DataTableExportTemplatePrefs = DataTableManageList;
+export interface DataTableManagePrefs {
+    version?: number;
+    views?: DataTableViewsPrefs;
+    exportTemplates?: DataTableExportTemplatePrefs;
+}
+export interface DataTableView<TData = any> {
+    columns: DataTableColumn<TData>[];
+    resolveColumns?: (data: TData[]) => DataTableColumn<TData>[];
+    id: string;
+    renamed?: Record<string, string>;
+    label?: string;
+    defaultVisible?: boolean;
+    authorized?: boolean;
+    params?: Record<string, unknown>;
+    hint?: string;
+    rowKey?: string;
+    transform?: (data: any[]) => any[];
+    animateRows?: boolean;
+    flashColors?: DataTableFlashColors;
+    HeaderComponent?: ComponentType<DataTableComponentProps<TData> & Record<string, any>>;
+    FooterComponent?: ComponentType<DataTableComponentProps<TData> & Record<string, any>>;
+    headerProps?: Record<string, any>;
+    footerProps?: Record<string, any>;
+    selection?: boolean | DataTableSelectionShow | DataTableSelectionConfig<TData>;
+    pagination?: boolean | DataTablePaginationConfig;
+    sorting?: boolean | DataTableSortingConfig;
+    filtering?: boolean | DataTableFilteringConfig;
+    search?: boolean;
+    export?: DataTableExportConfig<TData>;
+    summary?: DataTableSummaryConfig<TData>;
+    grouping?: boolean | DataTableGroupingConfig;
+    groupSummary?: (path: DataTableGroupPathItem[], ctx: DataTableGroupSummaryContext<TData>) => ReactNode;
+    keyboard?: DataTableKeyboardConfig;
+    virtualize?: DataTableVirtualizeConfig;
+    expandRow?: (row: TData) => ReactNode;
+    actions?: DataTableRowAction<TData>[] | ((row: TData) => DataTableRowAction<TData>[]);
+    bulkActions?: DataTableBulkAction<TData>[];
+    hideBulkActions?: string[];
+    pinning?: DataTablePinningConfig;
+    devTools?: boolean;
+    singleRowView?: DataTableSingleRowView;
+    cardFields?: Partial<DataTableCardFields>;
+    listFields?: Partial<DataTableListFields>;
+    cardMinWidth?: number;
+    cardsExpanded?: boolean;
+    avatar?: false | ((row: TData) => ReactNode);
+    layouts?: DataTableLayout[];
+    defaultLayout?: DataTableLayout;
+    renderDetail?: DataTableDetailRenderer<TData>;
+    rowMenu?: DataTableRowMenuConfig<TData>;
+    context?: Record<string, any>;
+    compact?: boolean;
+    displayDefaults?: Partial<DataTableDisplayPrefs>;
+    striped?: boolean;
+    bordered?: boolean;
+    stickyHeader?: boolean;
+    emptyMessage?: string;
+    loadingMessage?: string;
+    loading?: boolean;
+}
+export interface DataTableProps<TData = any> {
+    data?: TData[];
+    views: DataTableView<TData>[];
+    tableId?: string;
+    title?: string;
+    className?: string;
+    dataSource?: DataTableDataSource<TData>;
+    persistence?: DataTablePersistence | null;
+    authorize?: DataTableAuthorize;
+    exportOptions?: DataTableExportOptions;
+    initialState?: DataTableInitialState;
+    onStateChange?: (state: DataTableQuery) => void;
+    onRowsChange?: (rows: TData[]) => void;
+    apiRef?: {
+        current: DataTableApi<TData> | null;
+    };
+    bulkActions?: DataTableBulkAction<TData>[];
+    labels?: Partial<DataTableLabels>;
+    locale?: string;
+    renderDetail?: DataTableDetailRenderer<TData>;
+    detailBar?: boolean;
+    openRowId?: string | null;
+    onOpenRowChange?: (id: string | null, row: TData | null) => void;
+    shortcuts?: DataTableShortcut<TData>[];
+    sharing?: DataTableSharing;
+    renamedViews?: Record<string, string>;
+    prefsVersion?: number;
+    migratePrefs?: (doc: Record<string, any>, fromVersion: number, key: string) => Record<string, any>;
+}
+export interface DataTableQuery {
+    viewId: string;
+    viewParams?: Record<string, unknown>;
+    search: string;
+    filterGroup: DataTableFilterGroup;
+    quickFilterIds: string[];
+    sorting: Array<{
+        key: string;
+        field: string;
+        desc: boolean;
+    }>;
+    pageIndex: number;
+    pageSize: number;
+}
+export interface DataTableRowsResult<TData = any> {
+    rows: TData[];
+    total: number;
+}
+export interface DataTableAllRowsResult<TData = any> {
+    rows: TData[];
+    total?: number;
+    capped?: boolean;
+}
+export interface DataTableCounts {
+    views?: Record<string, number>;
+    quickFilters?: Record<string, number>;
+}
+export interface DataTableDataSource<TData = any> {
+    fetchRows: (query: DataTableQuery, ctx: {
+        signal: AbortSignal;
+    }) => Promise<DataTableRowsResult<TData>>;
+    loadAllRows?: (query: DataTableQuery, ctx: {
+        format: DataTableExportFormat;
+        action: DataTableExportAction;
+        selection: DataTableSelection<TData>;
+        params?: Record<string, unknown>;
+    }) => Promise<DataTableAllRowsResult<TData>>;
+    summaries?: (query: DataTableQuery, ctx: {
+        selection: DataTableSelection<TData>;
+        request: DataTableSummaryRequest;
+        signal: AbortSignal;
+    }) => Promise<DataTableSummaryFigures>;
+    counts?: (query: DataTableQuery, ctx: {
+        signal: AbortSignal;
+    }) => Promise<DataTableCounts>;
+    groups?: (query: DataTableQuery, req: {
+        level: {
+            key: string;
+            field: string;
+        };
+        path: DataTableGroupPathItem[];
+    }, ctx: {
+        signal: AbortSignal;
+    }) => Promise<DataTableGroupResult[]>;
+    operators?: readonly string[];
+    summaryBreakdownFields?: readonly string[];
+    subscribe?: (refetch: () => void) => () => void;
+    searchDebounceMs?: number;
+    pageSizeOptions?: number[];
+}
+export interface DataTableInitialState {
+    viewId?: string;
+    search?: string;
+    filterGroup?: DataTableFilterGroup;
+    quickFilterIds?: string[];
+    sorting?: Array<{
+        key: string;
+        desc: boolean;
+    }>;
+    pageIndex?: number;
+    pageSize?: number;
+}
+export interface DataTableApi<TData = any> {
+    refresh: () => void;
+    clearSelection: () => void;
+    getQuery: () => DataTableQuery;
+    getRows: () => TData[];
+    openRow: (id: string | null) => void;
+}
+export interface DataTablePersistence {
+    load: (key: string) => Promise<Record<string, any> | null>;
+    save: (key: string, doc: Record<string, any>) => Promise<void>;
+    list?: (prefix: string) => Promise<string[]>;
+    remove?: (key: string) => Promise<void>;
+}
+export type DataTableGate = 'export' | 'export.format' | 'export.template' | 'manage' | 'selection' | 'columns' | 'cardFields' | 'savedFilters' | 'devTools' | 'license' | 'bulkAction' | 'copy' | 'layout' | 'grouping' | 'shareView' | 'rows';
+export type DataTableAuthorize = (gate: DataTableGate, subject?: unknown) => boolean;
+export interface DataTablePdfFonts {
+    fonts?: Record<string, {
+        normal: string;
+        bold: string;
+        italics: string;
+        bolditalics: string;
+    }>;
+    vfs?: Record<string, string>;
+    fontFor?: (text: string) => string | undefined;
+}
+export interface DataTableExportOptions {
+    businessMeta?: () => Pick<DataTableExportMetadata, 'businessName' | 'businessAddress' | 'businessPhone' | 'taxNumber' | 'taxNumberLabel'>;
+    branding?: {
+        name: string;
+        url?: string;
+    };
+    pdf?: DataTablePdfFonts;
+}
+export type DataTableDensity = 'compact' | 'default' | 'comfortable';
+export type DataTableFontSize = 'xs' | 'sm' | 'md' | 'lg';
+export type DataTableColumnWidth = 'scroll' | 'fit' | 'compact';
+export type DataTableActionDisplay = 'icon' | 'label' | 'icon-label' | 'label-icon';
+export interface DataTableDisplayPrefs {
+    density: DataTableDensity;
+    fontSize: DataTableFontSize;
+    columnWidth: DataTableColumnWidth;
+    showActions: boolean;
+    actionDisplayMode: DataTableActionDisplay;
+    actionDisplayModeCard: DataTableActionDisplay;
+    summaryTop: boolean;
+    summaryBottom: boolean;
+}
+export interface DataTableViewPrefs {
+    version?: number;
+    visibility: Record<string, boolean>;
+    order: string[];
+    sizes: Record<string, number>;
+    export?: DataTableExportPrefs;
+    cardFields?: DataTableCardFields;
+    listFields?: DataTableListFields;
+    layout?: DataTableLayout;
+    savedFilters?: DataTableSavedFilter[];
+    display?: Partial<DataTableDisplayPrefs>;
+    pinning?: DataTableColumnPinning;
+    filterRow?: boolean;
+    grouping?: string[];
+    summary?: DataTableSummaryPrefs;
+}
+export interface ContextMenuState {
+    visible: boolean;
+    x: number;
+    y: number;
+    columnKey: string;
+}
+export interface UseTableReturn<TData = any> {
+    table: any;
+    resultData: TData[];
+    allFilteredRows: TData[];
+    selectedRows: TData[];
+    visibleColumns: string[];
+    allColumns: string[];
+    filterGroup: DataTableFilterGroup;
+    setFilterGroup: (group: DataTableFilterGroup) => void;
+    activeFilters: DataTableActiveFilter[];
+    removeFilter: (id: string) => void;
+    clearAllFilters: () => void;
+    globalFilter: string;
+    setGlobalFilter: (value: string) => void;
+    sorting: Array<{
+        id: string;
+        desc: boolean;
+    }>;
+    setSorting: (sorting: Array<{
+        id: string;
+        desc: boolean;
+    }>) => void;
+    columnOrder: string[];
+    setColumnOrder: (order: string[] | ((prev: string[]) => string[])) => void;
+    columnVisibility: Record<string, boolean>;
+    setColumnVisibility: (visibility: Record<string, boolean> | ((prev: Record<string, boolean>) => Record<string, boolean>)) => void;
+    columnSizing: Record<string, number>;
+    setColumnSizing: (sizing: Record<string, number>) => void;
+    columnPinning: DataTableColumnPinning;
+    setColumnPinning: (pinning: DataTableColumnPinning) => void;
+    defaultPinning: DataTableColumnPinning;
+    defaultVisibility: Record<string, boolean>;
+    defaultOrder: string[];
+    resetColumns: () => void;
+    toggleRowSelection: (rowId: string) => void;
+    toggleAllRowsSelection: () => void;
+    clearRowSelection: () => void;
+    isAllRowsSelected: boolean;
+    isSomeRowsSelected: boolean;
+    pagination: {
+        pageIndex: number;
+        pageSize: number;
+    };
+    setPagination: (updater: {
+        pageIndex: number;
+        pageSize: number;
+    } | ((prev: {
+        pageIndex: number;
+        pageSize: number;
+    }) => {
+        pageIndex: number;
+        pageSize: number;
+    })) => void;
+    serverMode: boolean;
+    rowSelection: Record<string, boolean>;
+    setRowSelection: (updater: Record<string, boolean> | ((prev: Record<string, boolean>) => Record<string, boolean>)) => void;
+}
+export declare function isFilterGroup(item: DataTableFilterCondition | DataTableFilterGroup): item is DataTableFilterGroup;
+export {};