import { RowData, CellContext as CellContext$1, HeaderContext as HeaderContext$1, ColumnDef as ColumnDef$1, Row, Table as Table$1, HeaderGroup, RowModel as RowModel$1, ColumnSort as ColumnSort$1, ColumnFilter as ColumnFilter$1, PaginationState as PaginationState$1, TableOptions, TableState } from '@tanstack/react-table';
import * as React$1 from 'react';
import React__default, { ReactNode } from 'react';
import { FilterInputValueType, FilterFieldType, SelectItemInterface } from '@krainovsd/react-ui';
import { PresetColorType } from 'antd/es/theme/internal';
import * as react_jsx_runtime from 'react/jsx-runtime';

type TableTypesGetter<RowData extends DefaultRow> = {
    headerRenderProps: HeaderRenderProps<RowData>;
    cellRenderProps: CellRenderProps<RowData>;
    headerContext: HeaderContext$1<RowData, unknown>;
    cellContext: CellContext$1<RowData, unknown>;
    row: RowInterface<RowData>;
    table: TableInterface<RowData>;
    rowModel: RowModel$1<RowData>;
    filterFn: (row: RowInterface<RowData>, columnId: string, filterValue: unknown) => boolean;
    sortFn: (rowA: RowInterface<RowData>, rowB: RowInterface<RowData>, columnId: string) => number;
};
type HeaderContext<RowData extends DefaultRow> = HeaderContext$1<RowData, unknown>;
type CellContext<RowData extends DefaultRow> = CellContext$1<RowData, unknown>;
type RowModel<RowData extends DefaultRow> = RowModel$1<RowData>;
type DefaultRow = RowData;
type ColumnDef<RowData extends DefaultRow> = ColumnDef$1<RowData>;
type DefaultGanttData = Record<string, unknown>;
type ColumnSort = ColumnSort$1;
type ColumnFilter = ColumnFilter$1;
type ColumnsSortingState = ColumnSort[];
type ColumnsFilterState = ColumnFilter[];
type ColumnsVisibleState = Record<string, boolean>;
type ColumnsSizingState = Record<string, number>;
type ColumnsExpandState = Record<string, boolean>;
type ColumnsOrderState = string[];
type PaginationState = PaginationState$1;
type TableInterface<TData extends RowData> = Table$1<TData>;
type RowInterface<TData extends RowData> = Row<TData>;
type HeaderInterface<TData extends RowData> = HeaderGroup<TData>;
type FilterFn<RowData extends DefaultRow> = (row: RowInterface<RowData>, columnId: string, filterValue: unknown) => boolean;
type SortFn<RowData extends DefaultRow> = (rowA: RowInterface<RowData>, rowB: RowInterface<RowData>, columnId: string) => number;
type CellRenderProps<RowData extends DefaultRow, Settings = any> = {
    context: CellContext<RowData>;
    settings?: Settings;
};
type CellRenderComponent<RowData extends DefaultRow> = React__default.FC<CellRenderProps<RowData>>;
type HeaderRenderProps<RowData extends DefaultRow, Settings = any> = {
    context: HeaderContext<RowData>;
    settings?: Settings;
};
type HeaderRenderComponent<RowData extends DefaultRow> = React__default.FC<HeaderRenderProps<RowData>>;
type FilterRenderProps<RowData extends DefaultRow, Settings = any> = {
    context: ColumnDef<RowData>;
    settings?: Settings;
};
type FilterRenderComponent<RowData extends DefaultRow> = React__default.FC<FilterRenderProps<RowData>>;
type SortRenderProps<RowData extends DefaultRow, Settings = any> = {
    context: HeaderContext<RowData>;
    settings?: Settings;
};
type SortRenderComponent<RowData extends DefaultRow> = React__default.FC<SortRenderProps<RowData>>;
type CellClassInterface<RowData extends DefaultRow> = string | CellClassFn<RowData>;
type CellClassFn<RowData extends DefaultRow, Settings = any> = (context: CellContext<RowData>, settings?: Settings) => string | undefined;
type HeaderClassInterface<RowData extends DefaultRow> = string | HeaderClassFn<RowData>;
type HeaderClassFn<RowData extends DefaultRow, Settings = any> = (context: HeaderContext<RowData>, settings?: Settings) => string | undefined;

type TableCellRenderKey = "default" | "select" | "tag" | "empty" | "drag";
type TableHeaderRenderKey = "default" | "select" | "empty";
type TableFilterRenderKey = "number" | "number-range" | "select" | "string" | "date" | "date-range";
type TableSortRenderKey = "single-arrow" | "double-arrow";
type TableCellClassKey = "common" | "empty" | "nowrap" | "lineClamp" | "wCenter" | "hCenter";
type TableHeaderClassKey = "common" | "empty" | "nowrap" | "lineClamp" | "wCenter" | "hCenter";
type TableCellRenders<RowData extends DefaultRow> = Record<TableCellRenderKey, CellRenderComponent<RowData>>;
type TableHeaderRenders<RowData extends DefaultRow> = Record<TableHeaderRenderKey, HeaderRenderComponent<RowData>>;
type TableFilterRenders<RowData extends DefaultRow> = Record<TableFilterRenderKey, FilterRenderComponent<RowData>>;
type TableSortRenders<RowData extends DefaultRow> = Record<TableSortRenderKey, SortRenderComponent<RowData>>;
type TableCellClasses<RowData extends DefaultRow> = Record<TableCellClassKey, string | ((props: CellContext<RowData>) => string)>;
type TableHeaderClasses<RowData extends DefaultRow> = Record<TableHeaderClassKey, string | ((props: HeaderContext<RowData>) => string)>;
type TableRenderers<RowData extends DefaultRow> = {
    expander?: (props: {
        context: CellContext<RowData>;
    }) => ReactNode;
};
type SortingKey = "number" | "string" | "boolean" | "date" | "array" | "string-with-number";
type FilterKey = "equals" | "array-some-in-array" | "array-every-in-array" | "array-equals" | "array-some-in-primitive" | "date-in-range" | "date" | "number-in-range" | "includes-string";
type TablePaginationProps<RowData extends DefaultRow> = {
    table: TableInterface<RowData>;
    pageIndex: number;
    pageSize: number;
    totalRows: number;
    pageSizes: number[];
};
type TableFilterProps<RowData extends DefaultRow> = {
    table: TableInterface<RowData>;
    filters: Record<string, FilterInputValueType>;
    filterOptions: FilterFieldType[];
};
type TableEmptyProps = {};
type TableLoaderProps = {};
type DragRowHandler = (sourceIndex: number, targetIndex: number, sourceId: number | string, targetId: number | string) => void;

type DefaultCellRenderProps<RowData extends DefaultRow> = {
    arraySeparator?: string;
    objectPath?: string;
    mappings?: Record<string, string | number | React.ReactNode>;
    Link?: (props: {
        children?: React.ReactNode;
        context: CellContext<RowData>;
    }) => React.ReactNode | null;
    floatRound?: boolean;
    floatFixed?: number;
    dateFormat?: string;
    customContent?: (context: CellContext<RowData>) => string | number | boolean;
};

type CheckProps$1 = (props: {
    checked: boolean;
    onChange: React.ChangeEventHandler<HTMLInputElement>;
}) => ReactNode;
type SelectCellRenderProps = {
    Check?: CheckProps$1;
    hover?: boolean;
};

type TagColor = keyof PresetColorType | "default";
type TagCellRenderProps = {
    color?: TagColor | ((content: unknown) => TagColor | undefined);
    mappings?: Record<string, string>;
    bordered?: boolean;
    filterable?: boolean;
};

type DragCellRenderProps<Row extends DefaultRow> = {
    dragCondition?: (row: Row, index: number) => boolean;
};

type DateFilterRenderProps = {
    format: string;
};

type DateRangeFilterRenderProps = {
    format: string;
};

type SelectFilterRenderProps = {
    options: SelectItemInterface[];
    multiple?: boolean;
};

type CheckProps = (props: {
    checked: boolean;
    onChange: React.ChangeEventHandler<HTMLInputElement>;
}) => React.ReactNode;
type SelectHeaderRenderProps = {
    Check?: CheckProps;
};

type TableColumn<RowData extends DefaultRow = DefaultRow, CellRender extends Record<string, CellRenderComponent<RowData>> = {}, HeaderRender extends Record<string, HeaderRenderComponent<RowData>> = {}, FilterRender extends Record<string, FilterRenderComponent<RowData>> = {}, SortRender extends Record<string, SortRenderComponent<RowData>> = {}, CellClass extends Record<string, CellClassInterface<RowData>> = {}, HeaderClass extends Record<string, HeaderClassInterface<RowData>> = {}, FilterType extends Record<string, FilterFn<RowData>> = {}, SortType extends Record<string, SortFn<RowData>> = {}> = {
    id?: string;
    key: KeyofDeep<RowData>;
    icon?: ReactNode;
    name: string;
    width?: number;
    minWidth?: number;
    maxWidth?: number;
    leftFrozen?: boolean;
    rightFrozen?: boolean;
    resizable?: boolean;
    sortable?: boolean;
    filterable?: boolean;
    draggable?: boolean;
    grouping?: boolean;
    expandable?: boolean;
    expandedShift?: number;
    tooltip?: ColumnTooltipSettings<RowData> | boolean;
    className?: ((context: CellContext<RowData>) => string | undefined) | string;
    sortDirectionFirst?: "asc" | "desc";
    props?: unknown;
    sortType?: keyof SortType | SortingKey;
    filterType?: keyof FilterType | FilterKey;
    cellRender?: TableCellRendersProps<RowData, CellRender>;
    headerRender?: TableHeaderRendersProps<RowData, HeaderRender>;
    filterRender?: TableFilterRendersProps<RowData, FilterRender>;
    sortRender?: TableSortRendersProps<RowData, SortRender>;
    headerClass?: (keyof HeaderClass | TableHeaderClassKey)[];
    additionalHeaderClass?: (keyof HeaderClass | TableHeaderClassKey)[];
    cellClass?: (keyof CellClass | TableCellClassKey)[];
    additionalCellClass?: (keyof CellClass | TableCellClassKey)[];
    headerClassProps?: {
        [K in keyof HeaderClass]: FnSettings<HeaderClass[K]>;
    }[keyof HeaderClass];
    cellClassProps?: {
        [K in keyof CellClass]: FnSettings<CellClass[K]>;
    }[keyof CellClass];
};
type ColumnTooltipSettings<RowData extends DefaultRow> = {
    auto?: boolean;
    zIndex?: number;
    pathToContent?: KeyofDeep<RowData>;
    customContent?: string;
    arraySeparator?: string;
};
type DefaultTableCellRenderProps<RowData extends DefaultRow> = {
    component?: "default";
    props?: DefaultCellRenderProps<RowData>;
} | {
    component?: "tag";
    props?: TagCellRenderProps;
} | {
    component?: "select";
    props?: SelectCellRenderProps;
} | {
    component?: "drag";
    props?: DragCellRenderProps<RowData>;
} | {
    component?: Exclude<TableCellRenderKey, "text" | "tag" | "select" | "drag">;
    props?: never;
};
type DefaultHeaderRenderProps = {
    component?: "select";
    props?: SelectHeaderRenderProps;
} | {
    component?: "default";
    props?: unknown;
} | {
    component?: Exclude<TableHeaderRenderKey, "select" | "common">;
    props?: never;
};
type DefaultFilterRenderProps = {
    component?: "select";
    props?: SelectFilterRenderProps;
} | {
    component?: "date";
    props?: DateFilterRenderProps;
} | {
    component?: "date-range";
    props?: DateRangeFilterRenderProps;
} | {
    component?: Exclude<TableFilterRenderKey, "select" | "date" | "date-range">;
    props?: never;
};
type DefaultSortRenderProps = {
    component?: TableSortRenderKey;
    props?: never;
};
type ComponentProps<T> = T extends (args: infer P extends Record<string, any>) => any ? P["settings"] : unknown;
type FnSettings<T> = T extends (context: infer P, settings: infer S) => any ? S : undefined;
type CellRenderMap<RowData extends DefaultRow, CellRender extends Record<string, CellRenderComponent<RowData>>> = {
    [K in keyof CellRender]: {
        component?: K;
        props?: ComponentProps<CellRender[K]>;
    };
}[keyof CellRender];
type TableCellRendersProps<RowData extends DefaultRow, CellRender extends Record<string, CellRenderComponent<RowData>> = {}> = CellRenderMap<RowData, CellRender> | DefaultTableCellRenderProps<RowData>;
type HeaderRenderMap<RowData extends DefaultRow, HeaderRender extends Record<string, HeaderRenderComponent<RowData>>> = {
    [K in keyof HeaderRender]: {
        component?: K;
        props?: ComponentProps<HeaderRender[K]>;
    };
}[keyof HeaderRender];
type TableHeaderRendersProps<RowData extends DefaultRow, HeaderRender extends Record<string, HeaderRenderComponent<RowData>>> = HeaderRenderMap<RowData, HeaderRender> | DefaultHeaderRenderProps;
type FilterRenderMap<RowData extends DefaultRow, FilterRender extends Record<string, FilterRenderComponent<RowData>>> = {
    [K in keyof FilterRender]: {
        component?: K;
        props?: ComponentProps<FilterRender[K]>;
    };
}[keyof FilterRender];
type TableFilterRendersProps<RowData extends DefaultRow, FilterRender extends Record<string, FilterRenderComponent<RowData>> = {}> = FilterRenderMap<RowData, FilterRender> | DefaultFilterRenderProps;
type SortRenderMap<RowData extends DefaultRow, SortRender extends Record<string, SortRenderComponent<RowData>>> = {
    [K in keyof SortRender]: {
        component?: K;
        props?: ComponentProps<SortRender[K]>;
    };
}[keyof SortRender];
type TableSortRendersProps<RowData extends DefaultRow, SortRender extends Record<string, SortRenderComponent<RowData>> = {}> = SortRenderMap<RowData, SortRender> | DefaultSortRenderProps;
type TableDefaultColumnOptions<RowData extends DefaultRow, CellRender extends Record<string, CellRenderComponent<RowData>> = {}, HeaderRender extends Record<string, HeaderRenderComponent<RowData>> = {}, FilterRender extends Record<string, FilterRenderComponent<RowData>> = {}, SortRender extends Record<string, SortRenderComponent<RowData>> = {}, CellClass extends Record<string, CellClassInterface<RowData>> = {}, HeaderClass extends Record<string, HeaderClassInterface<RowData>> = {}, FilterType extends Record<string, FilterFn<RowData>> = {}, SortType extends Record<string, SortFn<RowData>> = {}> = {
    width?: number;
    minWidth?: number;
    maxWidth?: number;
    resizable?: boolean;
    sortable?: boolean;
    filterable?: boolean;
    draggable?: boolean;
    expandedShift?: number;
    tooltip?: ColumnTooltipSettings<RowData> | boolean;
    sortDirectionFirst?: "asc" | "desc";
    sortType?: keyof SortType | SortingKey;
    filterType?: keyof FilterType | FilterKey;
    cellClass?: (keyof CellClass | TableCellClassKey)[];
    headerClass?: (keyof HeaderClass | TableHeaderClassKey)[];
    cellRender?: keyof CellRender | TableCellRenderKey;
    headerRender?: keyof HeaderRender | TableHeaderRenderKey;
    filterRender?: keyof FilterRender | TableFilterRenderKey;
    sortRender?: keyof SortRender | TableSortRenderKey;
};
type TableColumnsSettings<RowData extends DefaultRow, CellRender extends Record<string, CellRenderComponent<RowData>> = {}, HeaderRender extends Record<string, HeaderRenderComponent<RowData>> = {}, FilterRender extends Record<string, FilterRenderComponent<RowData>> = {}, SortRender extends Record<string, SortRenderComponent<RowData>> = {}, CellClass extends Record<string, CellClassInterface<RowData>> = {}, HeaderClass extends Record<string, HeaderClassInterface<RowData>> = {}, FilterType extends Record<string, FilterFn<RowData>> = {}, SortType extends Record<string, SortFn<RowData>> = {}> = {
    columns: TableColumn<RowData, CellRender, HeaderRender, FilterRender, SortRender, CellClass, HeaderClass, FilterType, SortType>[];
    cellRenders?: CellRender;
    headerRenders?: HeaderRender;
    filterRenders?: FilterRender;
    sortRenders?: SortRender;
    cellClasses?: CellClass;
    headerClasses?: HeaderClass;
    filterTypes?: FilterType;
    sortTypes?: SortType;
    defaultColumnOptions?: TableDefaultColumnOptions<RowData, CellRender, HeaderRender, FilterRender, SortRender, CellClass, HeaderClass, FilterType, SortType>;
};
type IncrementDepth<N extends number, Limit extends number[]> = Limit[N];
type KeyofDeep<T, Key extends keyof T = keyof T, MaxDepth extends number[] = [1, 2], Depth extends number = 0> = Depth extends MaxDepth["length"] ? never : Key extends string ? T[Key] extends Record<string, unknown> ? `${Key}.${KeyofDeep<T[Key], keyof T[Key], MaxDepth, IncrementDepth<Depth, MaxDepth>>}` | `${Key}` : T[Key] extends (infer U)[] ? U extends Record<string, unknown> ? `${Key}[${number}].${KeyofDeep<U, keyof U, MaxDepth, IncrementDepth<Depth, MaxDepth>>}` | `${Key}` : `${Key}[${number}]` | `${Key}` : `${Key}` : never;
type ColumnSizingSettings = Record<string, {
    minSize: number | undefined;
    maxSize: number | undefined;
}>;

type GanttTaskProps<RowData extends DefaultRow, GanttData extends DefaultGanttData> = {
    row: RowInterface<RowData>;
    ganttInfo: GanttInfo<GanttData>;
    rowInfo: GanttRowInfo;
    bodyWidth: number | null;
    rowsMap: Record<string | number, GanttRowInfo | undefined>;
    hasUpArrow: boolean;
    hasDownArrow: boolean;
};
type GanttTooltipProps<RowData extends DefaultRow> = {
    row: RowInterface<RowData>;
};
type GanttArrowStyleGetter<GanttData extends DefaultGanttData> = (info: GanttInfo<GanttData>) => GanttArrowStyle | undefined;
type GanttArrowStyle = {
    color?: string;
    size?: number;
};
type GanttProps<RowData extends DefaultRow, GanttData extends DefaultGanttData> = {
    withGantt?: boolean;
    ganttVisibleArrowInRange?: boolean;
    ganttArrowGetAround?: boolean;
    firstGanttDate?: string;
    lastGanttDate?: string;
    ganttRowMini?: boolean;
    ganttInfoGetter?: (row: RowInterface<RowData>) => GanttInfo<GanttData>;
    ganttArrowStyleGetter?: GanttArrowStyleGetter<GanttData>;
    instantGanttSplitter?: boolean;
    ganttGrid?: boolean;
    GanttTooltip?: React.FC<GanttTooltipProps<RowData>>;
    GanttTask?: React.FC<GanttTaskProps<RowData, GanttData>> | undefined;
    ganttView?: GanttViewType;
};
type GanttTypeShapes = "task" | "group" | "milestone";
type GanttViewType = "years" | "months" | "quarters" | "weeks";
type GanttInfo<GanttData extends DefaultGanttData> = {
    id: number | string;
    start: string;
    end: string;
    name: string;
    type: GanttTypeShapes;
    progress?: number;
    dependents?: (string | number)[];
    props?: GanttData;
};
type GanttDate = {
    year: number;
    month: number;
    day: number;
};
type GanttRowInfo = {
    index: number;
    left: number;
    top: number;
    width: number;
    height: number;
    textWidth: number;
};
type GanttArrowInfo = {
    linkId: string;
    startLeft: number;
    startTop: number;
    index: number;
    direction: "up" | "down";
    leftToRightFirst: number;
    leftToRightSecond: number;
    rightToLeft: number;
    topToBottom: number;
    topToBottomExtra: number;
    topArrowShift: number;
    extraCorner: boolean;
    arrowSize: number;
    cornerSize: number;
    size: number;
    dependId: number | string;
    dependIndex: number;
    rowId: number | string;
    color: string | undefined;
};

type TableProps<RowData extends DefaultRow, GanttData extends DefaultGanttData, CellRender extends Record<string, CellRenderComponent<RowData>> = {}, HeaderRender extends Record<string, HeaderRenderComponent<RowData>> = {}, FilterRender extends Record<string, FilterRenderComponent<RowData>> = {}, SortRender extends Record<string, SortRenderComponent<RowData>> = {}, CellClass extends Record<string, CellClassInterface<RowData>> = {}, HeaderClass extends Record<string, HeaderClassInterface<RowData>> = {}, FilterType extends Record<string, FilterFn<RowData>> = {}, SortType extends Record<string, SortFn<RowData>> = {}> = TableColumnsSettings<RowData, CellRender, HeaderRender, FilterRender, SortRender, CellClass, HeaderClass, FilterType, SortType> & Pick<TableOptions<RowData>, "getSubRows" | "onExpandedChange" | "columnResizeMode" | "onGroupingChange" | "onColumnOrderChange" | "manualFiltering" | "manualExpanding" | "manualGrouping" | "manualPagination" | "manualSorting" | "onColumnFiltersChange" | "onColumnPinningChange" | "onColumnSizingChange" | "onColumnSizingInfoChange" | "onColumnVisibilityChange" | "onPaginationChange" | "onSortingChange" | "onRowSelectionChange" | "getRowId"> & Pick<Partial<TableState>, "sorting" | "columnFilters" | "columnOrder" | "columnPinning" | "columnSizing" | "columnVisibility" | "expanded" | "grouping" | "pagination" | "rowSelection"> & {
    rows: RowData[];
    frozenHeader?: boolean;
    showPerf?: boolean;
    className?: string;
    renderers?: TableRenderers<RowData>;
    withPagination?: boolean;
    withFilters?: boolean;
    withTotal?: boolean;
    totalRows?: number;
    initialPageSize?: number;
    pageSizes?: number[];
    fullSize?: boolean;
    virtualColumn?: boolean;
    rubberColumn?: boolean;
    virtualColumnOverScan?: number;
    virtualRows?: boolean;
    virtualRowSize?: number;
    virtualRowOverScan?: number;
    locale?: string;
    onClickRow?: (row: RowInterface<RowData>, event: React__default.MouseEvent<HTMLElement>) => void;
    onDoubleClickRow?: (row: RowInterface<RowData>, event: React__default.MouseEvent<HTMLElement>) => void;
    Filter?: React__default.FC<TableFilterProps<RowData>>;
    Pagination?: React__default.FC<TablePaginationProps<RowData>>;
    Empty?: React__default.FC<TableEmptyProps>;
    Loader?: React__default.FC<TableLoaderProps>;
    loading?: boolean;
    setTable?: (table: TableInterface<RowData>) => void;
    rootRef?: React__default.MutableRefObject<HTMLDivElement | null>;
    headerRowClassName?: ((header: HeaderInterface<RowData>) => string | undefined) | string;
    rowClassName?: ((row: RowInterface<RowData>) => string | undefined) | string;
    rowRender?: (row: RowInterface<RowData>) => React__default.JSX.Element | null | undefined;
    getExpandedRowModel?: () => (table: TableInterface<RowData>) => () => RowModel<RowData>;
    draggableRow?: boolean;
    onDraggableRow?: DragRowHandler;
} & GanttProps<RowData, GanttData>;
declare function Table<RowData extends DefaultRow, GanttData extends DefaultGanttData, CellRender extends Record<string, CellRenderComponent<RowData>> = {}, HeaderRender extends Record<string, HeaderRenderComponent<RowData>> = {}, FilterRender extends Record<string, FilterRenderComponent<RowData>> = {}, SortRender extends Record<string, SortRenderComponent<RowData>> = {}, CellClass extends Record<string, CellClassInterface<RowData>> = {}, HeaderClass extends Record<string, HeaderClassInterface<RowData>> = {}, FilterType extends Record<string, FilterFn<RowData>> = {}, SortType extends Record<string, SortFn<RowData>> = {}>(props: TableProps<RowData, GanttData, CellRender, HeaderRender, FilterRender, SortRender, CellClass, HeaderClass, FilterType, SortType>): react_jsx_runtime.JSX.Element | null;

declare function useVisibleCell<Row extends DefaultRow>(props: CellContext$1<Row, unknown>): {
    isVisible: boolean;
    level: number;
};

type CellRenderLinkProps<RowData extends DefaultRow> = {
    Link?: (props: {
        children?: React.ReactNode;
        context: CellContext<RowData>;
    }) => React.ReactNode | null;
    context: CellContext<RowData>;
};
declare function CellRenderLink<RowData extends DefaultRow>(props: React.PropsWithChildren<CellRenderLinkProps<RowData>>): string | number | boolean | Iterable<React$1.ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;

type CellRenderTooltipProps<RowData extends DefaultRow> = {
    tooltip?: ColumnTooltipSettings<RowData> | boolean;
    row: RowData;
    content: string | number | boolean;
};
declare function CellRenderTooltip<RowData extends DefaultRow>(props: React.PropsWithChildren<CellRenderTooltipProps<RowData>>): string | number | boolean | Iterable<React$1.ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;

type CellRenderWrapperProps<RowData extends DefaultRow> = {
    className?: string;
    level: number;
    context: CellContext<RowData>;
    column: ColumnDef<RowData>;
} & React.HTMLAttributes<HTMLDivElement>;
declare function CellRenderWrapper<RowData extends DefaultRow>(props: React.PropsWithChildren<CellRenderWrapperProps<RowData>>): react_jsx_runtime.JSX.Element;

type HeaderRenderWrapperProps = {
    className?: string;
} & React.HTMLAttributes<HTMLDivElement>;
declare function HeaderRenderWrapper(props: React.PropsWithChildren<HeaderRenderWrapperProps>): react_jsx_runtime.JSX.Element;

declare module "@tanstack/react-table" {
    interface ColumnDefBase<TData extends RowData, TValue = unknown> {
        cellRender: CellRenderComponent<TData> | undefined;
        headerRender: HeaderRenderComponent<TData> | undefined;
        sortRender: SortRenderComponent<TData> | undefined;
        filterRender: FilterRenderComponent<TData> | undefined;
        headerClass: HeaderClassInterface<TData>[];
        cellClass: CellClassInterface<TData>[];
        name: string;
        icon?: ReactNode;
        accessorKey: string;
        cellRenderProps?: unknown;
        headerRenderProps?: unknown;
        filterRenderProps?: unknown;
        sortRenderProps?: unknown;
        headerClassProps?: unknown;
        cellClassProps?: unknown;
        props?: unknown;
        expandable?: boolean;
        expandedShift?: number;
        enableDraggable?: boolean;
        tooltip?: ColumnTooltipSettings<TData> | boolean;
        className?: ((context: CellContext$1<TData, unknown>) => string | undefined) | string;
    }
    interface TableMeta<TData extends RowData> {
        renderers: TableRenderers<TData>;
        pageSizes?: number[];
        totalRows?: number;
    }
}

export { CellRenderLink, CellRenderTooltip, CellRenderWrapper, HeaderRenderWrapper, Table, useVisibleCell };
export type { CellClassFn, CellClassInterface, CellContext, CellRenderComponent, CellRenderLinkProps, CellRenderMap, CellRenderProps, CellRenderTooltipProps, CellRenderWrapperProps, ColumnDef, ColumnFilter, ColumnSizingSettings, ColumnSort, ColumnTooltipSettings, ColumnsExpandState, ColumnsFilterState, ColumnsOrderState, ColumnsSizingState, ColumnsSortingState, ColumnsVisibleState, DefaultFilterRenderProps, DefaultGanttData, DefaultHeaderRenderProps, DefaultRow, DefaultSortRenderProps, DefaultTableCellRenderProps, DragRowHandler, FilterFn, FilterKey, FilterRenderComponent, FilterRenderMap, FilterRenderProps, GanttArrowInfo, GanttArrowStyle, GanttArrowStyleGetter, GanttDate, GanttInfo, GanttProps, GanttRowInfo, GanttTaskProps, GanttTooltipProps, GanttTypeShapes, GanttViewType, HeaderClassFn, HeaderClassInterface, HeaderContext, HeaderInterface, HeaderRenderComponent, HeaderRenderMap, HeaderRenderProps, HeaderRenderWrapperProps, KeyofDeep, PaginationState, RowInterface, RowModel, SortFn, SortRenderComponent, SortRenderMap, SortRenderProps, SortingKey, TableCellClassKey, TableCellClasses, TableCellRenderKey, TableCellRenders, TableCellRendersProps, TableColumn, TableColumnsSettings, TableDefaultColumnOptions, TableEmptyProps, TableFilterProps, TableFilterRenderKey, TableFilterRenders, TableFilterRendersProps, TableHeaderClassKey, TableHeaderClasses, TableHeaderRenderKey, TableHeaderRenders, TableHeaderRendersProps, TableInterface, TableLoaderProps, TablePaginationProps, TableProps, TableRenderers, TableSortRenderKey, TableSortRenders, TableSortRendersProps, TableTypesGetter };