import type { TooltipProps } from 'ant-design-vue/es/tooltip';
import type { CSSProperties, ExtractPropTypes, HTMLAttributes, PropType, Ref, VNode } from 'vue';
import type { AppendCellRange, FormatRangeCellTextParams, KeydownPayload, SelectedRangeItem } from '../hooks/RangeInterface';
import type { INTERNAL_SELECTION_ITEM } from '../hooks/useRowSelection';
import type { DOWN, LEFT, RIGHT, UP, WHOLE_ROW_DRAG_KEY } from './Drag/constant';
import type { TablePaginationConfig, TablePaginationPosition } from './PaginationConfig';
export declare type DefaultRecordType = Record<string, any>;
export interface TooltipAlignConfig {
    points?: [string, string];
    offset?: [number | string, number | string];
    targetOffset?: [number | string, number | string];
    overflow?: {
        adjustX: boolean;
        adjustY: boolean;
    };
    useCssRight?: boolean;
    useCssBottom?: boolean;
    useCssTransform?: boolean;
}
export declare type RowType = 'left' | 'center' | 'right';
export declare type Key = string | number;
export interface Position {
    left?: number;
    top?: number;
    columnIndex?: number;
    columnKey?: Key;
    rowKey?: Key;
}
export type { TablePaginationConfig, TablePaginationPosition };
export declare type DataIndex = string | number | readonly (string | number)[];
export declare type CellEllipsisType = {
    showTitle?: boolean;
} | boolean;
export declare type FixedType = 'left' | 'right' | boolean;
export declare type RowHeight = ((p: Record<any, any>, isExpandRow: boolean, baseHeight: number) => number | undefined) | number;
export declare type PreserveRow = (p: {
    record: any;
    index: number;
}) => boolean;
export declare type HeaderHeight = number[] | number;
export interface RowsRefsItem {
    left?: any;
    right?: any;
    conter?: any;
}
declare const SpinSizes: ["small", "default", "large"];
export declare type SpinSize = (typeof SpinSizes)[number];
declare const TableActions: ["paginate", "sort", "filter"];
export declare type TableAction = (typeof TableActions)[number];
export interface StickyOffsets {
    left: readonly number[];
    right: readonly number[];
    isSticky?: boolean;
}
export interface CellEditorArgs {
    modelValue: Ref<any>;
    save: () => void;
    onInput: (event: Event, value: any) => void;
    closeEditor: () => void;
    column: ColumnType;
    editorRef: Ref<any>;
    getPopupContainer: () => HTMLElement;
    recordIndexs: number[];
    record: any;
}
export declare const checkboxProps: () => {
    prefixCls: StringConstructor;
    disabled: BooleanConstructor;
    tabindex: (StringConstructor | NumberConstructor)[];
    name: StringConstructor;
    id: StringConstructor;
    style: {
        type: PropType<CSSProperties>;
        default: CSSProperties;
    };
    class: StringConstructor;
    checked: BooleanConstructor;
    indeterminate: BooleanConstructor;
    ariaLabel: StringConstructor;
};
export declare type CheckboxProps = Partial<ExtractPropTypes<ReturnType<typeof checkboxProps>>>;
export declare type RowSelectionType = 'checkbox' | 'radio';
export declare type GetRowKey<RecordType = DefaultRecordType> = (record: RecordType, index?: number) => Key;
export interface HeaderSticky {
    offsetHeader?: number;
    topSummary?: boolean;
}
export declare type FlatRecord<T = DefaultRecordType> = {
    record: T;
    indent: number;
    rowKey: Key;
    isExpandRow?: boolean;
    rowIndex: number;
    pos: string;
    flattenIndex: number;
    level: number;
};
export declare type GetPopupContainer = (triggerNode: HTMLElement) => HTMLElement;
export interface SorterResult<RecordType> {
    column?: ColumnType<RecordType>;
    order?: SortOrder;
    field?: Key | readonly Key[];
    columnKey?: Key;
}
export interface TableCurrentDataSource<RecordType = DefaultRecordType> {
    currentDataSource: RecordType[];
    action: TableAction;
}
declare type ChangeEvent<RecordType> = (pagination: TablePaginationConfig, filters: Record<string, FilterValue | null>, sorter: SorterResult<RecordType> | SorterResult<RecordType>[], extra: TableCurrentDataSource<RecordType>) => void;
declare type Scroll = {
    x?: number | string;
    y?: number | string;
    scrollToFirstRowOnChange?: boolean;
};
export declare type RowClassName<RecordType> = (record: RecordType, index: number, indent?: number) => string;
export declare type ExpandType = null | 'row' | 'nest';
export declare type ExpandedRowRender<ValueType> = (opt: {
    record: ValueType;
    index: number;
    indent: number;
    expanded: boolean;
}) => any;
export declare type TriggerEventHandler<RecordType> = (record: RecordType, key: Key, event: MouseEvent) => void;
export interface RenderExpandIconProps<RecordType> {
    prefixCls: string;
    expanded: boolean;
    record: RecordType;
    expandable: boolean;
    onExpand: TriggerEventHandler<RecordType>;
}
export declare type RenderExpandIcon<RecordType> = (props: RenderExpandIconProps<RecordType>) => any;
export declare type SelectionItemSelectFn = (currentRowKeys: Key[]) => void;
export interface SelectionItem {
    key: string;
    text: any;
    onSelect?: SelectionItemSelectFn;
}
export declare type SelectionSelectFn<T> = (record: T, selected: boolean, selectedRows: T[], nativeEvent: Event) => void;
export interface TableRowSelection<T = DefaultRecordType> {
    /** Keep the selection keys in list even the key not exist in `dataSource` anymore */
    preserveSelectedRowKeys?: boolean;
    type?: RowSelectionType;
    allowCancelRadio?: boolean;
    selectedRowKeys?: Key[];
    defaultSelectedRowKeys?: Key[];
    onChange?: (selectedRowKeys: Key[], selectedRows: T[]) => void;
    getCheckboxProps?: (record: T) => Partial<Omit<CheckboxProps, 'checked' | 'defaultChecked'>>;
    onSelect?: SelectionSelectFn<T>;
    onSelectMultiple?: (selected: boolean, selectedRows: T[], changeRows: T[]) => void;
    /** @deprecated This function is meaningless and should use `onChange` instead */
    onSelectAll?: (selected: boolean, selectedRows: T[], changeRows: T[]) => void;
    /** @deprecated This function is meaningless and should use `onChange` instead */
    onSelectInvert?: (selectedRowKeys: Key[]) => void;
    onSelectNone?: () => void;
    selections?: INTERNAL_SELECTION_ITEM[] | boolean;
    hideSelectAll?: boolean;
    fixed?: boolean;
    columnWidth?: string | number;
    columnTitle?: any;
    checkStrictly?: boolean;
    customRender?: ColumnType<T>['customRender'];
}
declare type GetComponentProps<DataType> = (data: DataType, index?: number) => Omit<HTMLAttributes, 'style'> & {
    style?: CSSProperties;
};
export declare type ResizeActionType = 'start' | 'move' | 'end';
export declare type SummaryFixed = boolean | 'top' | 'bottom';
export declare const surelyTableProps: <T extends DefaultRecordType>() => {
    ignoreCellKey: BooleanConstructor;
    showHeaderScrollbar: BooleanConstructor;
    deepWatchDataSource: BooleanConstructor;
    deepWatchColumns: BooleanConstructor;
    prefixCls: StringConstructor;
    columnDrag: {
        type: BooleanConstructor;
        default: boolean;
    };
    multiRowDrag: {
        type: BooleanConstructor;
        default: boolean;
    };
    animateRows: {
        type: BooleanConstructor;
        default: any;
    };
    dropdownPrefixCls: {
        type: StringConstructor;
        default: string;
    };
    columns: {
        type: PropType<ColumnsType<T>>;
        default: ColumnsType<T>;
    };
    dataSource: {
        type: PropType<T[]>;
        default: () => T[];
    };
    virtual: {
        type: BooleanConstructor;
        default: any;
    };
    xVirtual: {
        type: BooleanConstructor;
        default: any;
    };
    rowHeight: {
        type: PropType<RowHeight>;
        default: any;
    };
    preserveRow: {
        type: PropType<PreserveRow>;
        default: any;
    };
    autoHeaderHeight: {
        type: BooleanConstructor;
        default: boolean;
    };
    headerHeight: {
        type: PropType<HeaderHeight>;
    };
    height: {
        type: (StringConstructor | NumberConstructor)[];
    };
    maxHeight: {
        type: (StringConstructor | NumberConstructor)[];
    };
    size: {
        type: PropType<"small" | "default" | "middle">;
        default: string;
    };
    bordered: {
        type: BooleanConstructor;
        default: boolean;
    };
    wrapText: {
        type: BooleanConstructor;
        default: boolean;
    };
    loading: {
        type: PropType<boolean | Partial<ExtractPropTypes<{
            prefixCls: StringConstructor;
            spinning: {
                type: BooleanConstructor;
                default: any;
            };
            size: PropType<import("ant-design-vue/es/spin/Spin").SpinSize>;
            wrapperClassName: StringConstructor;
            tip: import("vue-types").VueTypeValidableDef<any>;
            delay: NumberConstructor;
            indicator: import("vue-types").VueTypeValidableDef<any>;
        }>>>;
        default: boolean | Partial<ExtractPropTypes<{
            prefixCls: StringConstructor;
            spinning: {
                type: BooleanConstructor;
                default: any;
            };
            size: PropType<import("ant-design-vue/es/spin/Spin").SpinSize>;
            wrapperClassName: StringConstructor;
            tip: import("vue-types").VueTypeValidableDef<any>;
            delay: NumberConstructor;
            indicator: import("vue-types").VueTypeValidableDef<any>;
        }>>;
    };
    pagination: {
        type: PropType<false | TablePaginationConfig>;
        default: () => {};
    };
    direction: {
        type: PropType<"rtl">;
        default: any;
    };
    stripe: {
        type: BooleanConstructor;
        default: boolean;
    };
    rowClassName: {
        type: PropType<string | RowClassName<T>>;
        default: any;
    };
    sticky: {
        type: PropType<boolean | HeaderSticky>;
        default: boolean | HeaderSticky;
    };
    selectedRowKeys: {
        type: PropType<Key[]>;
        default: any;
    };
    expandFixed: {
        type: PropType<FixedType>;
        default: any;
    };
    expandColumnWidth: {
        type: NumberConstructor;
        default: any;
    };
    expandedRowKeys: {
        type: PropType<Key[]>;
        default: Key[];
    };
    defaultExpandedRowKeys: {
        type: PropType<Key[]>;
        default: Key[];
    };
    expandedRowRender: {
        type: PropType<ExpandedRowRender<T>>;
        default: any;
    };
    expandRowByClick: {
        type: BooleanConstructor;
        default: any;
    };
    expandIcon: {
        type: PropType<RenderExpandIcon<T>>;
        default: any;
    };
    onExpand: {
        type: PropType<(expanded: boolean, record: T) => void>;
        default: any;
    };
    onExpandedRowsChange: {
        type: PropType<(expandedKeys: Key[]) => void>;
        default: any;
    };
    defaultExpandAllRows: {
        type: BooleanConstructor;
        default: any;
    };
    indentSize: NumberConstructor;
    expandIconColumnIndex: NumberConstructor;
    childrenColumnName: {
        type: StringConstructor;
        default: any;
    };
    rowExpandable: {
        type: PropType<(record: T) => boolean>;
        default: () => boolean;
    };
    rowSelection: {
        type: PropType<TableRowSelection<DefaultRecordType>>;
        default: any;
    };
    rowKey: {
        type: PropType<string | GetRowKey<T>>;
    };
    customRow: {
        type: PropType<GetComponentProps<T>>;
        default: () => {};
    };
    customCell: {
        type: PropType<(obj: CellInfoOptions<T>) => Record<string, any>>;
        default: () => Record<string, any>;
    };
    customHeaderCell: {
        type: PropType<(column: ColumnType<T>) => Record<string, any>>;
        default: () => Record<string, any>;
    };
    customSummaryCellProps: {
        type: PropType<(obj: {
            record: T;
            rowIndex: number;
            column: ColumnType<T>;
            columnIndex: number;
        }) => Record<string, any>>;
        default: () => Record<string, any>;
    };
    showHeader: {
        type: BooleanConstructor;
        default: boolean;
    };
    showSorterTooltip: {
        type: PropType<boolean | Partial<ExtractPropTypes<{
            title: import("vue-types").VueTypeValidableDef<any>;
            trigger: PropType<import("ant-design-vue/es/tooltip/abstractTooltipProps").TriggerType | import("ant-design-vue/es/tooltip/abstractTooltipProps").TriggerType[]>;
            open: {
                type: BooleanConstructor;
                default: any;
            };
            visible: {
                type: BooleanConstructor;
                default: any;
            };
            placement: PropType<import("ant-design-vue/es/tooltip").TooltipPlacement>;
            color: PropType<import("ant-design-vue/es/_util/type").LiteralUnion<import("ant-design-vue/es/_util/colors").PresetColorType>>;
            transitionName: StringConstructor;
            overlayStyle: {
                type: PropType<CSSProperties>;
                default: CSSProperties;
            };
            overlayInnerStyle: {
                type: PropType<CSSProperties>;
                default: CSSProperties;
            };
            overlayClassName: StringConstructor;
            openClassName: StringConstructor;
            prefixCls: StringConstructor;
            mouseEnterDelay: NumberConstructor;
            mouseLeaveDelay: NumberConstructor;
            getPopupContainer: PropType<(triggerNode: HTMLElement) => HTMLElement>;
            arrowPointAtCenter: {
                type: BooleanConstructor;
                default: any;
            };
            arrow: {
                type: PropType<boolean | {
                    pointAtCenter?: boolean;
                }>;
                default: boolean | {
                    pointAtCenter?: boolean;
                };
            };
            autoAdjustOverflow: {
                type: PropType<boolean | import("ant-design-vue/es/tooltip").AdjustOverflow>;
                default: boolean | import("ant-design-vue/es/tooltip").AdjustOverflow;
            };
            destroyTooltipOnHide: {
                type: BooleanConstructor;
                default: any;
            };
            align: {
                type: PropType<import("ant-design-vue/es/vc-trigger/interface").AlignType>;
                default: import("ant-design-vue/es/vc-trigger/interface").AlignType;
            };
            builtinPlacements: {
                type: PropType<import("ant-design-vue/es/vc-trigger/interface").BuildInPlacements>;
                default: import("ant-design-vue/es/vc-trigger/interface").BuildInPlacements;
            };
            children: ArrayConstructor;
            onVisibleChange: PropType<(vis: boolean) => void>;
            'onUpdate:visible': PropType<(vis: boolean) => void>;
            onOpenChange: PropType<(vis: boolean) => void>;
            'onUpdate:open': PropType<(vis: boolean) => void>;
        }>>>;
        default: boolean;
    };
    getPopupContainer: {
        type: PropType<GetPopupContainer>;
    };
    locale: {
        type: PropType<TableLocale>;
        default: TableLocale;
    };
    scrollX: {
        type: PropType<string | number>;
    };
    scroll: {
        type: PropType<Scroll>;
        default: Scroll;
    };
    rangeSelection: {
        type: PropType<boolean | "single">;
        default: string;
    };
    copyDelimiter: {
        type: StringConstructor;
        default: string;
    };
    rowDrag: {
        type: PropType<boolean | typeof WHOLE_ROW_DRAG_KEY>;
    };
    onChange: {
        type: PropType<ChangeEvent<T>>;
    };
    summaryFixed: {
        type: PropType<SummaryFixed>;
        default: boolean;
    };
    yBuff: {
        type: NumberConstructor;
        default: number;
    };
    xBuff: {
        type: NumberConstructor;
        default: number;
    };
    hasContextmenuPopup: BooleanConstructor;
    formatRangeCellText: {
        type: PropType<(params: FormatRangeCellTextParams) => string>;
    };
    tooltipDelay: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * beta
     */
    editCellsInfo: {
        type: PropType<CellInfo[]>;
        default: () => any;
    };
    'onUpdate:selectedRowKeys': {
        type: PropType<(selectedRowKeys: Key[], selectedRows: T[]) => void>;
    };
    onScroll: {
        type: PropType<(e: UIEvent) => void>;
    };
    'onUpdate:expandedRowKeys': {
        type: PropType<(info: Key[]) => void>;
    };
    onResizeColumn: {
        type: PropType<(w: number, col: ColumnType, action: ResizeActionType) => boolean | void>;
        default: any;
    };
    onRowDragEnd: {
        type: PropType<(opt: DragRowEventInfo & {
            fromIndexs: number[];
        }) => boolean | Promise<any> | void>;
        default: any;
    };
    onColumnDragEnd: {
        type: PropType<(opt: DragColumnEventInfo) => boolean | Promise<any> | void>;
        default: any;
    };
    onCellKeydown: {
        type: PropType<(e: KeyboardEvent, opt: KeydownPayload) => boolean | void>;
        default: any;
    };
    onCellClick: {
        type: PropType<(e: MouseEvent, opt: CellRenderArgs) => void>;
        default: any;
    };
    onBeforeOpenEditor: {
        type: PropType<(opt: CellRenderArgs) => boolean | Promise<boolean> | void>;
        default: any;
    };
    onOpenEditor: {
        type: PropType<(opt: CellRenderArgs) => void>;
        default: any;
    };
    onBeforeCloseEditor: {
        type: PropType<(opt: CellRenderArgs) => boolean | Promise<boolean> | void>;
        default: any;
    };
    onCloseEditor: {
        type: PropType<(opt: CellRenderArgs) => void>;
        default: any;
    };
    'onUpdate:pagination': {
        type: PropType<(info: TablePaginationConfig) => void>;
    };
    'onUpdate:dataSource': {
        type: PropType<(dataSource: T[]) => void>;
    };
};
declare class Helper<T> {
    Return: {
        ignoreCellKey: BooleanConstructor;
        showHeaderScrollbar: BooleanConstructor;
        deepWatchDataSource: BooleanConstructor;
        deepWatchColumns: BooleanConstructor;
        prefixCls: StringConstructor;
        columnDrag: {
            type: BooleanConstructor;
            default: boolean;
        };
        multiRowDrag: {
            type: BooleanConstructor;
            default: boolean;
        };
        animateRows: {
            type: BooleanConstructor;
            default: any;
        };
        dropdownPrefixCls: {
            type: StringConstructor;
            default: string;
        };
        columns: {
            type: PropType<ColumnsType<T>>;
            default: ColumnsType<T>;
        };
        dataSource: {
            type: PropType<T[]>;
            default: () => T[];
        };
        virtual: {
            type: BooleanConstructor;
            default: any;
        };
        xVirtual: {
            type: BooleanConstructor;
            default: any;
        };
        rowHeight: {
            type: PropType<RowHeight>;
            default: any;
        };
        preserveRow: {
            type: PropType<PreserveRow>;
            default: any;
        };
        autoHeaderHeight: {
            type: BooleanConstructor;
            default: boolean;
        };
        headerHeight: {
            type: PropType<HeaderHeight>;
        };
        height: {
            type: (StringConstructor | NumberConstructor)[];
        };
        maxHeight: {
            type: (StringConstructor | NumberConstructor)[];
        };
        size: {
            type: PropType<"small" | "default" | "middle">;
            default: string;
        };
        bordered: {
            type: BooleanConstructor;
            default: boolean;
        };
        wrapText: {
            type: BooleanConstructor;
            default: boolean;
        };
        loading: {
            type: PropType<boolean | Partial<ExtractPropTypes<{
                prefixCls: StringConstructor;
                spinning: {
                    type: BooleanConstructor;
                    default: any;
                };
                size: PropType<import("ant-design-vue/es/spin/Spin").SpinSize>;
                wrapperClassName: StringConstructor;
                tip: import("vue-types").VueTypeValidableDef<any>;
                delay: NumberConstructor;
                indicator: import("vue-types").VueTypeValidableDef<any>;
            }>>>;
            default: boolean | Partial<ExtractPropTypes<{
                prefixCls: StringConstructor;
                spinning: {
                    type: BooleanConstructor;
                    default: any;
                };
                size: PropType<import("ant-design-vue/es/spin/Spin").SpinSize>;
                wrapperClassName: StringConstructor;
                tip: import("vue-types").VueTypeValidableDef<any>;
                delay: NumberConstructor;
                indicator: import("vue-types").VueTypeValidableDef<any>;
            }>>;
        };
        pagination: {
            type: PropType<false | TablePaginationConfig>;
            default: () => {};
        };
        direction: {
            type: PropType<"rtl">;
            default: any;
        };
        stripe: {
            type: BooleanConstructor;
            default: boolean;
        };
        rowClassName: {
            type: PropType<string | RowClassName<T>>;
            default: any;
        };
        sticky: {
            type: PropType<boolean | HeaderSticky>;
            default: boolean | HeaderSticky;
        };
        selectedRowKeys: {
            type: PropType<Key[]>;
            default: any;
        };
        expandFixed: {
            type: PropType<FixedType>;
            default: any;
        };
        expandColumnWidth: {
            type: NumberConstructor;
            default: any;
        };
        expandedRowKeys: {
            type: PropType<Key[]>;
            default: Key[];
        };
        defaultExpandedRowKeys: {
            type: PropType<Key[]>;
            default: Key[];
        };
        expandedRowRender: {
            type: PropType<ExpandedRowRender<T>>;
            default: any;
        };
        expandRowByClick: {
            type: BooleanConstructor;
            default: any;
        };
        expandIcon: {
            type: PropType<RenderExpandIcon<T>>;
            default: any;
        };
        onExpand: {
            type: PropType<(expanded: boolean, record: T) => void>;
            default: any;
        };
        onExpandedRowsChange: {
            type: PropType<(expandedKeys: Key[]) => void>;
            default: any;
        };
        defaultExpandAllRows: {
            type: BooleanConstructor;
            default: any;
        };
        indentSize: NumberConstructor;
        expandIconColumnIndex: NumberConstructor;
        childrenColumnName: {
            type: StringConstructor;
            default: any;
        };
        rowExpandable: {
            type: PropType<(record: T) => boolean>;
            default: () => boolean;
        };
        rowSelection: {
            type: PropType<TableRowSelection<DefaultRecordType>>;
            default: any;
        };
        rowKey: {
            type: PropType<string | GetRowKey<T>>;
        };
        customRow: {
            type: PropType<GetComponentProps<T>>;
            default: () => {};
        };
        customCell: {
            type: PropType<(obj: CellInfoOptions<T>) => Record<string, any>>;
            default: () => Record<string, any>;
        };
        customHeaderCell: {
            type: PropType<(column: ColumnType<T>) => Record<string, any>>;
            default: () => Record<string, any>;
        };
        customSummaryCellProps: {
            type: PropType<(obj: {
                record: T;
                rowIndex: number;
                column: ColumnType<T>;
                columnIndex: number;
            }) => Record<string, any>>;
            default: () => Record<string, any>;
        };
        showHeader: {
            type: BooleanConstructor;
            default: boolean;
        };
        showSorterTooltip: {
            type: PropType<boolean | Partial<ExtractPropTypes<{
                title: import("vue-types").VueTypeValidableDef<any>;
                trigger: PropType<import("ant-design-vue/es/tooltip/abstractTooltipProps").TriggerType | import("ant-design-vue/es/tooltip/abstractTooltipProps").TriggerType[]>;
                open: {
                    type: BooleanConstructor;
                    default: any;
                };
                visible: {
                    type: BooleanConstructor;
                    default: any;
                };
                placement: PropType<import("ant-design-vue/es/tooltip").TooltipPlacement>;
                color: PropType<import("ant-design-vue/es/_util/type").LiteralUnion<import("ant-design-vue/es/_util/colors").PresetColorType>>;
                transitionName: StringConstructor;
                overlayStyle: {
                    type: PropType<CSSProperties>;
                    default: CSSProperties;
                };
                overlayInnerStyle: {
                    type: PropType<CSSProperties>;
                    default: CSSProperties;
                };
                overlayClassName: StringConstructor;
                openClassName: StringConstructor;
                prefixCls: StringConstructor;
                mouseEnterDelay: NumberConstructor;
                mouseLeaveDelay: NumberConstructor;
                getPopupContainer: PropType<(triggerNode: HTMLElement) => HTMLElement>;
                arrowPointAtCenter: {
                    type: BooleanConstructor;
                    default: any;
                };
                arrow: {
                    type: PropType<boolean | {
                        pointAtCenter?: boolean;
                    }>;
                    default: boolean | {
                        pointAtCenter?: boolean;
                    };
                };
                autoAdjustOverflow: {
                    type: PropType<boolean | import("ant-design-vue/es/tooltip").AdjustOverflow>;
                    default: boolean | import("ant-design-vue/es/tooltip").AdjustOverflow;
                };
                destroyTooltipOnHide: {
                    type: BooleanConstructor;
                    default: any;
                };
                align: {
                    type: PropType<import("ant-design-vue/es/vc-trigger/interface").AlignType>;
                    default: import("ant-design-vue/es/vc-trigger/interface").AlignType;
                };
                builtinPlacements: {
                    type: PropType<import("ant-design-vue/es/vc-trigger/interface").BuildInPlacements>;
                    default: import("ant-design-vue/es/vc-trigger/interface").BuildInPlacements;
                };
                children: ArrayConstructor;
                onVisibleChange: PropType<(vis: boolean) => void>;
                'onUpdate:visible': PropType<(vis: boolean) => void>;
                onOpenChange: PropType<(vis: boolean) => void>;
                'onUpdate:open': PropType<(vis: boolean) => void>;
            }>>>;
            default: boolean;
        };
        getPopupContainer: {
            type: PropType<GetPopupContainer>;
        };
        locale: {
            type: PropType<TableLocale>;
            default: TableLocale;
        };
        scrollX: {
            type: PropType<string | number>;
        };
        scroll: {
            type: PropType<Scroll>;
            default: Scroll;
        };
        rangeSelection: {
            type: PropType<boolean | "single">;
            default: string;
        };
        copyDelimiter: {
            type: StringConstructor;
            default: string;
        };
        rowDrag: {
            type: PropType<boolean | typeof WHOLE_ROW_DRAG_KEY>;
        };
        onChange: {
            type: PropType<ChangeEvent<T>>;
        };
        summaryFixed: {
            type: PropType<SummaryFixed>;
            default: boolean;
        };
        yBuff: {
            type: NumberConstructor;
            default: number;
        };
        xBuff: {
            type: NumberConstructor;
            default: number;
        };
        hasContextmenuPopup: BooleanConstructor;
        formatRangeCellText: {
            type: PropType<(params: FormatRangeCellTextParams) => string>;
        };
        tooltipDelay: {
            type: NumberConstructor;
            default: number;
        };
        /**
         * beta
         */
        editCellsInfo: {
            type: PropType<CellInfo[]>;
            default: () => any;
        };
        'onUpdate:selectedRowKeys': {
            type: PropType<(selectedRowKeys: Key[], selectedRows: T[]) => void>;
        };
        onScroll: {
            type: PropType<(e: UIEvent) => void>;
        };
        'onUpdate:expandedRowKeys': {
            type: PropType<(info: Key[]) => void>;
        };
        onResizeColumn: {
            type: PropType<(w: number, col: ColumnType<DefaultRecordType>, action: ResizeActionType) => boolean | void>;
            default: any;
        };
        onRowDragEnd: {
            type: PropType<(opt: DragRowEventInfo & {
                fromIndexs: number[];
            }) => boolean | void | Promise<any>>;
            default: any;
        };
        onColumnDragEnd: {
            type: PropType<(opt: DragColumnEventInfo) => boolean | void | Promise<any>>;
            default: any;
        };
        onCellKeydown: {
            type: PropType<(e: KeyboardEvent, opt: KeydownPayload) => boolean | void>;
            default: any;
        };
        onCellClick: {
            type: PropType<(e: MouseEvent, opt: CellRenderArgs) => void>;
            default: any;
        };
        onBeforeOpenEditor: {
            type: PropType<(opt: CellRenderArgs) => boolean | void | Promise<boolean>>;
            default: any;
        };
        onOpenEditor: {
            type: PropType<(opt: CellRenderArgs) => void>;
            default: any;
        };
        onBeforeCloseEditor: {
            type: PropType<(opt: CellRenderArgs) => boolean | void | Promise<boolean>>;
            default: any;
        };
        onCloseEditor: {
            type: PropType<(opt: CellRenderArgs) => void>;
            default: any;
        };
        'onUpdate:pagination': {
            type: PropType<(info: TablePaginationConfig) => void>;
        };
        'onUpdate:dataSource': {
            type: PropType<(dataSource: T[]) => void>;
        };
    };
}
export declare type SurelyTableProps<T = DefaultRecordType> = Partial<ExtractPropTypes<Helper<T>['Return']>>;
export interface TableLocale {
    filterTitle?: string;
    filterConfirm?: any;
    filterReset?: any;
    filterEmptyText?: any;
    emptyText?: any | (() => any);
    selectAll?: any;
    selectNone?: any;
    selectInvert?: any;
    selectionAll?: any;
    sortTitle?: string;
    expand?: string;
    collapse?: string;
    triggerDesc?: string;
    triggerAsc?: string;
    cancelSort?: string;
}
export interface ColumnTitleProps<RecordType> {
    /** @deprecated Please use `sorterColumns` instead. */
    sortOrder?: SortOrder;
    /** @deprecated Please use `sorterColumns` instead. */
    sortColumn?: ColumnType<RecordType>;
    sortColumns?: {
        column: ColumnType<RecordType>;
        order: SortOrder;
    }[];
    filters?: Record<string, string[]>;
}
export declare type ColumnTitle<RecordType = DefaultRecordType> = String | number | object | ((props: ColumnTitleProps<RecordType>) => any);
interface ColumnSharedType {
    title?: ColumnTitle;
    key?: Key;
    className?: string;
    class?: string;
    fixed?: FixedType;
    ellipsis?: CellEllipsisType;
    align?: AlignType;
    wrapText?: boolean;
    dataIndex?: DataIndex;
}
export interface FilterConfirmProps {
    closeDropdown: boolean;
}
export declare type AlignType = 'left' | 'center' | 'right';
export interface ColumnFilterItem {
    text: string | number;
    value: string | number | boolean;
    children?: ColumnFilterItem[];
}
export declare type SortOrder = 'descend' | 'ascend' | null;
export declare type CompareFn<T> = (a: T, b: T, sortOrder?: SortOrder) => number;
export declare type FilterValue = (Key | boolean)[];
export declare type FilterKey = Key[] | null;
export interface FilterDropdownProps {
    prefixCls: string;
    confirm: (param?: FilterConfirmProps) => void;
    clearFilters?: () => void;
    filters?: ColumnFilterItem[];
    /** @deprecated Please use `open` instead */
    visible: boolean;
    open: boolean;
}
export interface CellType {
    key?: Key;
    class?: string;
    style?: CSSProperties;
    colSpan?: number;
    rowSpan?: number;
}
export interface HeaderCellType {
    key?: Key;
    class?: string;
    style?: CSSProperties;
    column?: FinallyColumnType;
    colSpan?: number;
    rowSpan?: number;
    hasSubColumns?: boolean;
    colStart?: number;
    colEnd?: number;
}
export interface RenderedCell {
    props?: CellType;
    children?: any;
}
export declare type CellRenderArgs = {
    record: any;
    column: ColumnType<DefaultRecordType> | ColumnGroupType<DefaultRecordType>;
    text: any;
    value: any;
    oldValue?: any;
    index: number;
    recordIndexs: number[];
    openEditor: () => void;
    closeEditor: () => void;
};
export interface ContextmenuPopupArg<RecordT, ColumnT> extends Omit<Partial<CellRenderArgs>, 'column' | 'record'> {
    column?: ColumnT;
    record?: RecordT;
    event: MouseEvent;
    isExpand?: boolean;
    hidePopup: () => void;
}
export declare type MenuFilterProps = {
    prefixCls: string;
    setSelectedKeys: (selectedKeys: Key[]) => void;
    selectedKeysRef: Ref<Key[]>;
    confirm: () => void;
    clearFilters: () => void;
    filters: ColumnFilterItem[];
};
export interface MenuPopupArg<ColumnT> {
    column: ColumnT;
    event: MouseEvent;
    hidePopup: () => void;
    filter: MenuFilterProps;
}
export interface CellTooltip {
    placement?: 'top' | 'left' | 'right' | 'bottom' | 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight' | 'leftTop' | 'leftBottom' | 'rightTop' | 'rightBottom';
    color?: String;
    overlayStyle?: CSSProperties;
    overlayClassName?: String;
    title?: (args: CellRenderArgs) => any;
    align?: TooltipAlignConfig;
    shouldOpen?: (isEllipsis: boolean, args: Omit<CellRenderArgs, 'openEditor' | 'closeEditor'>) => boolean;
    allowEnter?: boolean;
    showArrow?: boolean;
}
export interface ValueParserParams<RecordType = DefaultRecordType, TValue = any> {
    newValue: TValue;
    oldValue: TValue;
    record: RecordType;
    recordIndexs: number[];
    column: ColumnType<RecordType>;
}
export interface EditableValueParams<RecordType = DefaultRecordType, TValue = any> {
    value: TValue;
    record: RecordType;
    recordIndexs: number[];
    column: ColumnType<RecordType>;
}
export interface ValueParserFunc<T = any, TValue = any> {
    (params: ValueParserParams<T, TValue>): TValue | null | undefined;
}
export interface ValueGetterFunc<T = any, TValue = any> {
    (params: EditableValueParams<T, TValue>): string | null | undefined;
}
declare type CellEditorSlot = 'cellEditorSlot';
export declare type EditableTrigger = 'click' | 'dblClick' | 'contextmenu';
export interface ColumnType<RecordType = DefaultRecordType> extends ColumnSharedType {
    colSpan?: number;
    dataIndex?: DataIndex;
    key?: Key;
    rowSpan?: number;
    width?: number;
    minWidth?: number;
    maxWidth?: number;
    resizable?: boolean;
    flex?: number;
    autoHeight?: boolean;
    tooltip?: CellTooltip;
    hidden?: boolean;
    sorter?: boolean | CompareFn<RecordType> | {
        compare?: CompareFn<RecordType>;
        /** Config multiple sorter order priority */
        multiple?: number;
    };
    sortOrder?: SortOrder;
    defaultSortOrder?: SortOrder;
    sortDirections?: SortOrder[];
    showSorterTooltip?: boolean | TooltipProps;
    filtered?: boolean;
    filters?: ColumnFilterItem[];
    filterIcon?: ({ filtered }: {
        filtered: Boolean;
    }) => any;
    filterDropdown?: (props: FilterDropdownProps) => any;
    filterMultiple?: boolean;
    filteredValue?: FilterValue | null;
    defaultFilteredValue?: FilterValue | null;
    onFilter?: (value: string | number | boolean, record: RecordType) => boolean;
    showFilter?: boolean;
    showMenu?: boolean | 'hover';
    /** @deprecated Please use `filterDropdownOpen` instead */
    filterDropdownVisible?: boolean;
    /** @deprecated Please use `onFilterDropdownOpenChange` instead */
    onFilterDropdownVisibleChange?: (open: boolean) => void;
    filterDropdownOpen?: boolean;
    onFilterDropdownOpenChange?: (open: boolean) => void;
    customFilterDropdown?: boolean;
    getPopupContainer?: GetPopupContainer;
    customCell?: (obj: CellInfoOptions<RecordType>) => Record<string, any>;
    customHeaderCell?: (column: ColumnType<RecordType>) => Record<string, any>;
    customRender?: (opt: {
        value: any;
        text: any;
        record: RecordType;
        index: number;
        column: ColumnType<RecordType>;
    }) => any | RenderedCell;
    editable?: boolean | CellEditorSlot | ((params: EditableValueParams<RecordType>) => boolean | CellEditorSlot);
    editableTrigger?: EditableTrigger | EditableTrigger[];
    valueParser?: ValueParserFunc<RecordType>;
    valueGetter?: ValueGetterFunc<RecordType>;
    valueSetter?: (params: ValueParserParams<RecordType>) => boolean | Promise<any>;
    valueChange?: (e: Event, params: ValueParserParams<RecordType>) => void;
    rowDrag?: boolean | ((arg: {
        record: RecordType;
        column: ColumnType<RecordType>;
    }) => boolean);
    drag?: boolean;
    allowSelection?: boolean;
    /** @deprecated Please use `v-slot:customFilterIcon` `v-slot:bodyCell` `v-slot:headerCell` instead */
    slots?: {
        filterIcon?: string;
        filterDropdown?: string;
        customRender?: string;
        title?: string;
    };
}
export interface ColumnGroupType<RecordType = DefaultRecordType> extends ColumnType<RecordType> {
    children?: ColumnsType<RecordType>;
}
export declare type ColumnsType<RecordType = DefaultRecordType> = (ColumnGroupType<RecordType> | ColumnType<RecordType>)[];
export interface FinallyColumnType<RecordType = DefaultRecordType> extends ColumnType<RecordType> {
    finallyWidth?: number;
    rowSpan?: number;
    height?: number;
    left?: number;
    top?: number;
    type?: 'checkbox' | 'expand' | 'rowIndex' | 'draggable';
    columnKey: Key;
    columnIndex: number;
    children?: FinallyColumnType<RecordType>[];
    originColumn?: ColumnsType[number];
    __Internal__Column__?: boolean;
    showTitle: boolean;
    fixed?: 'left' | 'right';
}
declare type CellInfo = {
    columnKey: Key;
    rowKey: Key;
};
export interface CellInfoOptions<T = DefaultRecordType> {
    record: T;
    rowIndex: number;
    column: ColumnType<T>;
}
export interface ProcessCellForExportParams<RecordType = DefaultRecordType> {
    value: any;
    record: RecordType;
    index: number;
    recordIndexs: number[];
    column: ColumnType<RecordType>;
}
export interface ProcessHeaderForExportParams<RecordType = DefaultRecordType> {
    column: ColumnType<RecordType>;
}
export interface ShouldRowBeSkippedParams<RecordType = DefaultRecordType> {
    record: RecordType;
    index: number;
}
export interface BaseExportParams<RecordType = DefaultRecordType> {
    /** Output file name (without extension). Default: 'export' */
    fileName?: string;
    /**
     * Which rows to export:
     * - 'all': raw dataSource (no sorting/filtering applied)
     * - 'filteredAndSorted': after sort + filter, all pages (default)
     */
    exportedRows?: 'all' | 'filteredAndSorted';
    /** Specific row keys to export. When provided, only these rows are exported. */
    rowKeys?: Key[];
    /** Specific column keys to include. When omitted, all visible data columns are used. */
    columnKeys?: Key[];
    /** Include hidden columns in the export. Default: false */
    allColumns?: boolean;
    /** Skip the column header row. Default: false */
    skipColumnHeaders?: boolean;
    /** Skip column group header rows. Default: false */
    skipColumnGroupHeaders?: boolean;
    /** Format cell values for export */
    processCellCallback?: (params: ProcessCellForExportParams<RecordType>) => string;
    /** Format header text for export */
    processHeaderCallback?: (params: ProcessHeaderForExportParams<RecordType>) => string;
    /** Return true to skip a specific row */
    shouldRowBeSkipped?: (params: ShouldRowBeSkippedParams<RecordType>) => boolean;
    /**
     * Prepend a serial number column to the exported data.
     * - `true`: default header '#', values 1, 2, 3…
     * - `string`: custom header title, values 1, 2, 3…
     * - `{ title?, render }`: full control — render(index) returns the cell value
     */
    serialNumber?: boolean | string | {
        title?: string;
        render: (index: number) => string | number;
    };
}
export interface CsvExportParams<RecordType = DefaultRecordType> extends BaseExportParams<RecordType> {
    /** Column separator character. Default: ',' */
    columnSeparator?: string;
    /** Suppress download and return CSV string instead. Default: false */
    suppressDownload?: boolean;
}
export interface ExcelExportParams<RecordType = DefaultRecordType> extends BaseExportParams<RecordType> {
    /** Sheet name. Default: 'Sheet1' */
    sheetName?: string;
    /** Suppress download and return workbook object instead. Default: false */
    suppressDownload?: boolean;
}
export interface ExportMergeCell {
    /** Start row index (0-based, within the full sheet including headers) */
    row: number;
    /** Start column index (0-based) */
    col: number;
    /** Number of rows to merge (1 = no merge) */
    rowSpan: number;
    /** Number of columns to merge (1 = no merge) */
    colSpan: number;
}
export interface ExcelExportModule {
    createAndDownload(options: {
        fileName: string;
        sheetName: string;
        headerRows: string[][];
        dataRows: string[][];
        merges: ExportMergeCell[];
        suppressDownload: boolean;
    }): any;
}
export interface TableExposeType {
    scrollTo: (pos: string | Position, behavior: 'auto' | 'smooth') => void;
    scrollLeft?: Ref<number>;
    scrollTop?: Ref<number>;
    getSelectedRange: () => SelectedRangeItem[];
    clearAllSelectedRange: () => void;
    copySelectedRange: () => void;
    appendCellToSelectedRange: (cell: AppendCellRange) => void;
    openEditor: (cellInfos: CellInfo[]) => void;
    closeEditor: (cellInfos?: CellInfo[]) => void;
    ensureRowVisible: (rowKey: Key) => void;
    ensureColumnVisible: (columnKey: Key) => void;
    exportDataAsCsv: (params?: CsvExportParams) => string | void;
    exportDataAsExcel: (params?: ExcelExportParams) => any;
}
export interface DragRowsHandleInfo {
    y: number;
    top: number;
    height: number;
    rowKey: Key;
    centerY: number;
    record: DefaultRecordType;
    indexs: number[];
}
export interface DragColumnHandleInfo {
    x: number;
    left: number;
    width: number;
    columnKey: Key;
    centerX: number;
    indexs: number[];
}
export interface DragRowEventInfo {
    top: number;
    height: number;
    dir: typeof DOWN | typeof UP;
    rowKey: Key;
    record: DefaultRecordType;
    event: MouseEvent | Touch;
    column: ColumnType;
    preTargetInfo: DragRowsHandleInfo | null;
    nextTargetInfo: DragRowsHandleInfo | null;
    insertToRowKey: Key;
    dragRowKeys?: Key[];
    dragRecords?: DefaultRecordType[];
}
export interface RowDragGhostArg<RecordT, ColumnT> {
    record: RecordT;
    column: ColumnT;
    icon: VNode;
    allowed: boolean;
    dragging: boolean;
    event: MouseEvent | Touch;
    preTargetInfo: DragRowsHandleInfo | null;
    nextTargetInfo: DragRowsHandleInfo | null;
    dragCount?: number;
    dragRecords?: RecordT[];
}
export interface DragColumnEventInfo {
    event: MouseEvent | Touch;
    column: ColumnType;
    targetColumn: ColumnType;
    dir: typeof LEFT | typeof RIGHT;
}
export interface ColumnDragGhostArg<ColumnT> {
    column: ColumnT;
    icon: VNode;
    allowed: boolean;
    dragging: boolean;
    event: MouseEvent | Touch;
    targetColumn: ColumnT;
}
export interface CustomHeaderCheckboxProps {
    prefixCls: string;
    indeterminate: boolean;
    checked: boolean;
    disabled: boolean;
}