export namespace FanTable {
    function install(Vue: any): void;
}
export var VeCheckbox: any;
export var VeCheckboxGroup: any;
export namespace VeContextmenu {
    function install(Vue: any): void;
}
export namespace VeDropdown {
    function install(Vue: any): void;
}
export namespace VeIcon {
    function install(Vue: any): void;
}
export function VeLoading(options?: {}): import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import("vue").ComponentProvideOptions>, {}, {}, "", {}, any> | null;
export namespace VeLoading {
    function install(app: any): void;
}
export namespace VeLocale {
    function getMessage(): any;
    function use(lang: any): void;
    function update(lang?: {}): void;
}
export namespace VePagination {
    function install(Vue: any): void;
}
export namespace VeRadio {
    function install(Vue: any): void;
}
export namespace VeSelect {
    function install(Vue: any): void;
}
export namespace VeTable {
    import name = COMPS_NAME.FAN_TABLE;
    export { name };
    export let directives: {
        'click-outside': {
            mounted(el: any, binding: any, vNode: any): void;
            unmounted(el: any): void;
        };
    };
    export namespace components {
        export { VueDomResizeObserver };
        export { ColumnResizer };
        export { ColGroup };
        export { TableHeader };
        export { TableBody };
        export { TableFooter };
        export { EditInput };
        export { Selection };
        export { VeContextmenu };
    }
    export function provide(): {
        eventCenter: any;
    };
    export namespace props {
        namespace tableData {
            let required: boolean;
            let type: ArrayConstructor;
        }
        namespace footerData {
            let type_1: ArrayConstructor;
            export { type_1 as type };
            function _default(): never[];
            export { _default as default };
        }
        namespace showHeader {
            let type_2: BooleanConstructor;
            export { type_2 as type };
            let _default_1: boolean;
            export { _default_1 as default };
        }
        namespace columns {
            let type_3: ArrayConstructor;
            export { type_3 as type };
            let required_1: boolean;
            export { required_1 as required };
        }
        namespace rowKeyFieldName {
            let type_4: StringConstructor;
            export { type_4 as type };
            let _default_2: null;
            export { _default_2 as default };
        }
        namespace scrollWidth {
            let type_5: (StringConstructor | NumberConstructor)[];
            export { type_5 as type };
            let _default_3: null;
            export { _default_3 as default };
        }
        namespace maxHeight {
            let type_6: (StringConstructor | NumberConstructor)[];
            export { type_6 as type };
            let _default_4: null;
            export { _default_4 as default };
        }
        namespace fixedHeader {
            let type_7: BooleanConstructor;
            export { type_7 as type };
            let _default_5: boolean;
            export { _default_5 as default };
        }
        namespace fixedFooter {
            let type_8: BooleanConstructor;
            export { type_8 as type };
            let _default_6: boolean;
            export { _default_6 as default };
        }
        namespace borderAround {
            let type_9: BooleanConstructor;
            export { type_9 as type };
            let _default_7: boolean;
            export { _default_7 as default };
        }
        namespace borderX {
            let type_10: BooleanConstructor;
            export { type_10 as type };
            let _default_8: boolean;
            export { _default_8 as default };
        }
        namespace borderY {
            let type_11: BooleanConstructor;
            export { type_11 as type };
            let _default_9: boolean;
            export { _default_9 as default };
        }
        namespace eventCustomOption {
            let type_12: ObjectConstructor;
            export { type_12 as type };
            function _default_10(): null;
            export { _default_10 as default };
        }
        namespace cellStyleOption {
            let type_13: ObjectConstructor;
            export { type_13 as type };
            function _default_11(): null;
            export { _default_11 as default };
        }
        namespace cellSpanOption {
            let type_14: ObjectConstructor;
            export { type_14 as type };
            function _default_12(): null;
            export { _default_12 as default };
        }
        namespace rowStyleOption {
            let type_15: ObjectConstructor;
            export { type_15 as type };
            function _default_13(): null;
            export { _default_13 as default };
        }
        namespace virtualScrollOption {
            let type_16: ObjectConstructor;
            export { type_16 as type };
            let _default_14: null;
            export { _default_14 as default };
        }
        namespace sortOption {
            let type_17: ObjectConstructor;
            export { type_17 as type };
            function _default_15(): null;
            export { _default_15 as default };
        }
        namespace expandOption {
            let type_18: ObjectConstructor;
            export { type_18 as type };
            function _default_16(): null;
            export { _default_16 as default };
        }
        namespace checkboxOption {
            let type_19: ObjectConstructor;
            export { type_19 as type };
            function _default_17(): null;
            export { _default_17 as default };
        }
        namespace radioOption {
            let type_20: ObjectConstructor;
            export { type_20 as type };
            function _default_18(): null;
            export { _default_18 as default };
        }
        namespace cellSelectionOption {
            let type_21: ObjectConstructor;
            export { type_21 as type };
            function _default_19(): null;
            export { _default_19 as default };
        }
        namespace cellAutofillOption {
            let type_22: (ObjectConstructor | BooleanConstructor)[];
            export { type_22 as type };
            function _default_20(): null;
            export { _default_20 as default };
        }
        namespace editOption {
            let type_23: ObjectConstructor;
            export { type_23 as type };
            function _default_21(): null;
            export { _default_21 as default };
        }
        namespace columnHiddenOption {
            let type_24: ObjectConstructor;
            export { type_24 as type };
            function _default_22(): null;
            export { _default_22 as default };
        }
        namespace contextmenuHeaderOption {
            let type_25: ObjectConstructor;
            export { type_25 as type };
            function _default_23(): null;
            export { _default_23 as default };
        }
        namespace contextmenuBodyOption {
            let type_26: ObjectConstructor;
            export { type_26 as type };
            function _default_24(): null;
            export { _default_24 as default };
        }
        namespace clipboardOption {
            let type_27: ObjectConstructor;
            export { type_27 as type };
            function _default_25(): null;
            export { _default_25 as default };
        }
        namespace columnWidthResizeOption {
            let type_28: ObjectConstructor;
            export { type_28 as type };
            function _default_26(): null;
            export { _default_26 as default };
        }
    }
    export function data(): {
        eventCenter: {
            all: any;
            on: (t: any, e: any) => void;
            off: (t: any, e: any) => void;
            emit: (t: any, e: any) => void;
        };
        hooks: {};
        parentRendered: boolean;
        tableViewportWidth: number;
        columnsOptionResetTime: number;
        tableRootRef: string;
        tableContainerWrapperRef: string;
        tableContainerRef: string;
        tableRef: string;
        tableBodyRef: string;
        tableContentWrapperRef: string;
        virtualPhantomRef: string;
        editInputRef: string;
        cellSelectionRef: string;
        contextmenuRef: string;
        cloneColumns: never[];
        isGroupHeader: boolean;
        headerRows: never[];
        footerRows: never[];
        colgroups: never[];
        groupColumns: never[];
        hiddenColumns: never[];
        virtualScrollVisibleData: never[];
        virtualScrollVisibleIndexs: {
            start: number;
            end: number;
        };
        defaultVirtualScrollBufferScale: number;
        defaultVirtualScrollMinRowHeight: number;
        defaultPlaceholderPerScrollingRowCount: number;
        virtualScrollStartIndex: number;
        previewVirtualScrollStartIndex: number;
        virtualScrollEndIndex: number;
        showVirtualScrollingPlaceholder: boolean;
        disablePointerEventsTimeoutId: null;
        isLeftScrolling: boolean;
        isRightScrolling: boolean;
        isVerticalScrolling: boolean;
        hasXScrollBar: boolean;
        hasYScrollBar: boolean;
        scrollBarWidth: number;
        previewTableContainerScrollLeft: null;
        headerIndicatorColKeys: {
            startColKey: string;
            startColKeyIndex: number;
            endColKey: string;
            endColKeyIndex: number;
        };
        bodyIndicatorRowKeys: {
            startRowKey: string;
            startRowKeyIndex: number;
            endRowKey: string;
            endRowKeyIndex: number;
        };
        cellSelectionData: {
            currentCell: {
                rowKey: string;
                colKey: string;
                rowIndex: number;
            };
            normalEndCell: {
                rowKey: string;
                colKey: string;
                rowIndex: number;
            };
            autoFillEndCell: {
                rowKey: string;
                colKey: string;
            };
        };
        cellSelectionRangeData: {
            leftColKey: string;
            rightColKey: string;
            topRowKey: string;
            bottomRowKey: string;
        };
        isHeaderCellMousedown: boolean;
        isBodyCellMousedown: boolean;
        isBodyOperationColumnMousedown: boolean;
        isAutofillStarting: boolean;
        autofillingDirection: null;
        currentCellSelectionType: string;
        tableOffestHeight: number;
        tableHeight: number;
        highlightRowKey: string;
        editingCell: {
            rowKey: string;
            colKey: string;
            row: null;
            column: null;
        };
        editorInputStartValue: string;
        enableStopEditing: boolean;
        contextmenuEventTarget: string;
        contextmenuOptions: never[];
        isColumnResizerHover: boolean;
        isColumnResizing: boolean;
    };
    export namespace computed {
        function actualRenderTableData(): any;
        function allRowKeys(): any;
        function virtualScrollBufferCount(): number;
        function virtualScrollVisibleCount(): number;
        function tableContainerWrapperStyle(): {
            width: string;
        };
        function tableContainerStyle(): {
            'max-height': any;
            height: any;
        };
        function tableStyle(): {
            width: any;
        };
        function tableClass(): {
            [x: string]: any;
        };
        function tableContainerClass(): {
            [x: string]: any;
        };
        function tableBodyClass(): {
            [x: string]: boolean;
        };
        function isVirtualScroll(): any;
        function hasFixedColumn(): any;
        function hasLeftFixedColumn(): any;
        function hasRightFixedColumn(): any;
        function isCellEditing(): boolean;
        function hasEditColumn(): any;
        function enableHeaderContextmenu(): boolean;
        function enableBodyContextmenu(): boolean;
        function contextMenuType(): string;
        function enableCellSelection(): boolean;
        function enableClipboard(): any;
        function enableColumnResize(): boolean;
        function headerTotalHeight(): number;
        function footerTotalHeight(): any;
    }
    export let watch: {
        tableData: {
            handler(newVal: any, oldVal: any): void;
            deep: boolean;
            immediate: boolean;
        };
        allRowKeys: {
            handler(newVal: any): void;
            immediate: boolean;
        };
        columns: {
            handler(newVal: any, oldVal: any): void;
            immediate: boolean;
        };
        cloneColumns: {
            handler(): void;
            immediate: boolean;
        };
        groupColumns: {
            handler(val: any): void;
            immediate: boolean;
        };
        footerData: {
            handler(val: any): void;
            immediate: boolean;
        };
        'virtualScrollOption.enable': {
            handler(newVal: any): void;
            immediate: boolean;
        };
        isAutofillStarting: {
            handler(val: any): void;
        };
        'cellSelectionData.currentCell': {
            handler: () => void;
            deep: boolean;
            immediate: boolean;
        };
        'cellSelectionData.normalEndCell': {
            handler: () => void;
            deep: boolean;
            immediate: boolean;
        };
        headerIndicatorColKeys: {
            handler: () => void;
            deep: boolean;
        };
        bodyIndicatorRowKeys: {
            handler: () => void;
            deep: boolean;
        };
    };
    export function created(): void;
    export function mounted(): void;
    export function unmounted(): void;
    export let methods: {
        [x: string]: (keyCode: any, nextRowKey: any) => void;
        initHeaderRows(): void;
        initFooterRows(): void;
        headerRowHeightChange({ rowIndex, height }: {
            rowIndex: any;
            height: any;
        }): void;
        footRowHeightChange({ rowIndex, height }: {
            rowIndex: any;
            height: any;
        }): void;
        bodyCellWidthChange(colWidths: any): void;
        setColumnWidth({ colKey, width }: {
            colKey: any;
            width: any;
        }): void;
        updateColgroupsBySortChange(sortColumns: any): void;
        initColumnWidthByColumnResize(): void;
        initColumns(): void;
        showOrHideColumns(): void;
        initGroupColumns(): void;
        getScrollBarWidth(): number;
        selectedAllChange({ isSelected }: {
            isSelected: any;
        }): void;
        setSelectedAllInfo({ isSelected, isIndeterminate }: {
            isSelected: any;
            isIndeterminate: any;
        }): void;
        cellSelectionCurrentCellChange({ rowKey, colKey }: {
            rowKey: any;
            colKey: any;
        }): void;
        cellSelectionNormalEndCellChange({ rowKey, colKey }: {
            rowKey: any;
            colKey: any;
        }): void;
        cellSelectionAutofillCellChange({ rowKey, colKey }: {
            rowKey: any;
            colKey: any;
        }): void;
        clearCellSelectionCurrentCell(): void;
        clearCellSelectionNormalEndCell(): void;
        clearCellSelectionAutofillEndCell(): void;
        headerIndicatorColKeysChange({ startColKey, endColKey }: {
            startColKey: any;
            endColKey: any;
        }): void;
        clearHeaderIndicatorColKeys(): void;
        bodyIndicatorRowKeysChange({ startRowKey, endRowKey }: {
            startRowKey: any;
            endRowKey: any;
        }): void;
        clearBodyIndicatorRowKeys(): void;
        setCellSelectionByAutofill(): false | undefined;
        cellSelectionRangeDataChange(newData: any): void;
        autofillingDirectionChange(direction: any): void;
        setCurrentCellSelectionType(): void;
        dealKeydownEvent(event: any): void;
        selectCellByDirection({ direction }: {
            direction: any;
        }): void;
        columnToVisible(nextColumn: any): false | undefined;
        rowToVisible(keyCode: any, nextRowKey: any): void;
        setVirtualScrollVisibleData(): void;
        getVirtualScrollAboveCount(): number;
        getVirtualScrollBelowCount(): number;
        getVirtualViewPhantom(): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }> | null;
        initVirtualScrollPositions(): void;
        bodyRowHeightChange({ rowKey, height }: {
            rowKey: any;
            height: any;
        }): void;
        setVirtualPhantomHeight(): void;
        setVirtualScrollStartOffset(): void;
        setTableContentTopValue({ top }: {
            top: any;
        }): void;
        getVirtualScrollStartIndex(scrollTop?: number): number | null;
        virtualScrollBinarySearch(list: any, value: any): number | null;
        tableContainerVirtualScrollHandler(tableContainerRef: any): void;
        debounceScrollEnded(): void;
        debounceScrollEndedCallback(): void;
        initVirtualScroll(): void;
        setScrolling(tableContainerRef: any): void;
        setScrollBarStatus(): void;
        initScrolling(): void;
        tableClickOutside(e: any): false | undefined;
        saveCellWhenStopEditing(): false | undefined;
        cellSelectionByClick({ rowData, column }: {
            rowData: any;
            column: any;
        }): void;
        bodyCellContextmenu({ event, rowData, column }: {
            event: any;
            rowData: any;
            column: any;
        }): void;
        bodyCellDoubleClick({ event, rowData, column }: {
            event: any;
            rowData: any;
            column: any;
        }): false | undefined;
        bodyCellClick({ event, rowData, column }: {
            event: any;
            rowData: any;
            column: any;
        }): void;
        bodyCellMousedown({ event, rowData, column }: {
            event: any;
            rowData: any;
            column: any;
        }): false | undefined;
        bodyCellMouseover({ event, rowData, column }: {
            event: any;
            rowData: any;
            column: any;
        }): false | undefined;
        bodyCellMousemove({ event, rowData, column }: {
            event: any;
            rowData: any;
            column: any;
        }): void;
        bodyCellMouseup({ event, rowData, column }: {
            event: any;
            rowData: any;
            column: any;
        }): void;
        headerCellClick({ event, column }: {
            event: any;
            column: any;
        }): void;
        headerCellContextmenu({ event, column }: {
            event: any;
            column: any;
        }): void;
        setContextmenuOptions(column: any): void;
        headerCellMousedown({ event, column }: {
            event: any;
            column: any;
        }): false | undefined;
        headerCellMouseover({ event, column }: {
            event: any;
            column: any;
        }): void;
        headerCellMousemove({ event, column }: {
            event: any;
            column: any;
        }): void;
        headerCellMouseleave({ event, column }: {
            event: any;
            column: any;
        }): void;
        headerMouseleave(event: any): void;
        tableContainerMouseup(): void;
        cellSelectionCornerMousedown({ event }: {
            event: any;
        }): void;
        cellSelectionCornerMouseup({ event }: {
            event: any;
        }): void;
        isEditColumn(colKey: any): any;
        editCellByClick({ isDblclick, rowKey, colKey }: {
            isDblclick: any;
            rowKey: any;
            colKey: any;
        }): false | undefined;
        setEditingCell({ rowKey, colKey, column, row }: {
            rowKey: any;
            colKey: any;
            column: any;
            row: any;
        }): void;
        updateEditingCellValue(value: any): void;
        clearEditingCell(): void;
        contextmenuItemClick(type: any): void;
        headerContextmenuItemClick(type: any): false | undefined;
        bodyContextmenuItemClick(type: any): false | undefined;
        editorCopy(event: any): false | undefined;
        editorPaste(event: any): false | undefined;
        editorCut(event: any): false | undefined;
        deleteCellSelectionRangeValue(): false | undefined;
        setRangeCellSelectionByHeaderIndicator(): false | undefined;
        setRangeCellSelectionByBodyIndicator(): false | undefined;
        setIsColumnResizerHover(val: any): void;
        setIsColumnResizing(val: any): void;
        setCellSelection(receive: any): false | undefined;
    };
    export function render(): any;
}
declare namespace index {
    export { install };
    export { version };
    export { VeCheckbox };
    export { VeCheckboxGroup };
    export { VeContextmenu };
    export { VeDropdown };
    export { VeIcon };
    export { VeLoading };
    export { VeLocale };
    export { VePagination };
    export { VeRadio };
    export { VeSelect };
    export { VeTable };
    export { FanTable };
}
export function install(app: any): void;
export var version: string;
declare namespace COMPS_NAME {
    let FAN_TABLE: string;
    let FAN_TABLE_THADER: string;
    let FAN_TABLE_THADER_TR: string;
    let FAN_TABLE_THADER_Th: string;
    let FAN_TABLE_HEADER_CHECKBOX_CONTENT: string;
    let FAN_TABLE_HEADER_FILTER_CONTENT: string;
    let FAN_TABLE_HEADER_FILTER_CUSTOM_CONTENT: string;
    let FAN_TABLE_BODY: string;
    let FAN_TABLE_BODY_TR: string;
    let FAN_TABLE_BODY_TR_SCROLLING: string;
    let FAN_TABLE_BODY_CHECKBOX_CONTENT: string;
    let FAN_TABLE_BODY_RADIO_CONTENT: string;
    let FAN_TABLE_BODY_TD: string;
    let FAN_TABLE_COLGROUP: string;
    let FAN_TABLE_FOOTER: string;
    let FAN_TABLE_EXPAND_TR: string;
    let FAN_TABLE_EXPAND_TR_ICON: string;
    let FAN_TABLE_EDIT_INPUT: string;
    let FAN_TABLE_SELECTION: string;
    let FAN_TABLE_COLUMN_RESISZER: string;
}
declare namespace VueDomResizeObserver {
    let name_1: string;
    export { name_1 as name };
    export namespace props_1 {
        namespace tagName {
            let type_29: StringConstructor;
            export { type_29 as type };
            let required_2: boolean;
            export { required_2 as required };
        }
        namespace id {
            let type_30: (StringConstructor | NumberConstructor)[];
            export { type_30 as type };
            let _default_27: null;
            export { _default_27 as default };
        }
    }
    export { props_1 as props };
    export let emits: string[];
    export function mounted(): void;
    export function unmounted(): void;
    export namespace methods_1 {
        function resizeListener(contentRect: any): void;
    }
    export { methods_1 as methods };
    export function render(): any;
}
declare namespace ColumnResizer {
    import name_2 = COMPS_NAME.FAN_TABLE_COLUMN_RESISZER;
    export { name_2 as name };
    export namespace props_2 {
        export namespace parentRendered {
            let type_31: BooleanConstructor;
            export { type_31 as type };
            let required_3: boolean;
            export { required_3 as required };
        }
        export namespace tableContainerEl {
            let type_32: {
                new (): HTMLDivElement;
                prototype: HTMLDivElement;
            };
            export { type_32 as type };
            let _default_28: null;
            export { _default_28 as default };
        }
        export namespace hooks {
            let type_33: ObjectConstructor;
            export { type_33 as type };
            let required_4: boolean;
            export { required_4 as required };
        }
        export namespace colgroups {
            let type_34: ArrayConstructor;
            export { type_34 as type };
            let required_5: boolean;
            export { required_5 as required };
        }
        export namespace isColumnResizerHover {
            let type_35: BooleanConstructor;
            export { type_35 as type };
            let required_6: boolean;
            export { required_6 as required };
        }
        export namespace isColumnResizing {
            let type_36: BooleanConstructor;
            export { type_36 as type };
            let required_7: boolean;
            export { required_7 as required };
        }
        export namespace setIsColumnResizerHover {
            let type_37: FunctionConstructor;
            export { type_37 as type };
            let required_8: boolean;
            export { required_8 as required };
        }
        export namespace setIsColumnResizing {
            let type_38: FunctionConstructor;
            export { type_38 as type };
            let required_9: boolean;
            export { required_9 as required };
        }
        export namespace setColumnWidth {
            let type_39: FunctionConstructor;
            export { type_39 as type };
            let required_10: boolean;
            export { required_10 as required };
        }
        export namespace columnWidthResizeOption_1 {
            let type_40: ObjectConstructor;
            export { type_40 as type };
            function _default_29(): null;
            export { _default_29 as default };
        }
        export { columnWidthResizeOption_1 as columnWidthResizeOption };
    }
    export { props_2 as props };
    export function data(): {
        columnResizerStartX: number;
        currentResizingColumn: null;
        columnResizerHandlerWidth: number;
        columnResizerRect: {
            top: number;
            left: number;
            height: number;
        };
    };
    export namespace computed_1 {
        function columnMinWidth(): number;
    }
    export { computed_1 as computed };
    export namespace watch_1 {
        export namespace parentRendered_1 {
            function handler(val: any): void;
            let immediate: boolean;
        }
        export { parentRendered_1 as parentRendered };
    }
    export { watch_1 as watch };
    export namespace methods_2 {
        function initColumnResizerPosition({ event, column }: {
            event: any;
            column: any;
        }): false | undefined;
        function setColumnResizerPositionByDrag(event: any): void;
        function columnResizerHandlerMousedown({ event }: {
            event: any;
        }): void;
        function columnResizerMouseup(event: any): false | undefined;
        function clearColumnResizerStatus(): void;
    }
    export { methods_2 as methods };
    export function render(): any;
}
declare namespace ColGroup {
    import name_3 = COMPS_NAME.FAN_TABLE_COLGROUP;
    export { name_3 as name };
    export namespace props_3 {
        export namespace colgroups_1 {
            let type_41: ArrayConstructor;
            export { type_41 as type };
            let required_11: boolean;
            export { required_11 as required };
        }
        export { colgroups_1 as colgroups };
        export namespace enableColumnResize {
            let type_42: BooleanConstructor;
            export { type_42 as type };
            let required_12: boolean;
            export { required_12 as required };
        }
    }
    export { props_3 as props };
    export namespace methods_3 {
        function getValByUnit(item: any): any;
    }
    export { methods_3 as methods };
    export function render(): any;
}
declare namespace TableHeader {
    import name_4 = COMPS_NAME.FAN_TABLE_THADER;
    export { name_4 as name };
    export namespace components_1 {
        export { HeaderTr };
    }
    export { components_1 as components };
    export let inject: string[];
    export namespace props_4 {
        export namespace columnsOptionResetTime {
            let type_43: NumberConstructor;
            export { type_43 as type };
            let _default_30: number;
            export { _default_30 as default };
        }
        export namespace groupColumns {
            let type_44: ArrayConstructor;
            export { type_44 as type };
            let required_13: boolean;
            export { required_13 as required };
        }
        export namespace colgroups_2 {
            let type_45: ArrayConstructor;
            export { type_45 as type };
            let required_14: boolean;
            export { required_14 as required };
        }
        export { colgroups_2 as colgroups };
        export namespace fixedHeader_1 {
            let type_46: BooleanConstructor;
            export { type_46 as type };
            let required_15: boolean;
            export { required_15 as required };
        }
        export { fixedHeader_1 as fixedHeader };
        export namespace isGroupHeader {
            let type_47: BooleanConstructor;
            export { type_47 as type };
            let required_16: boolean;
            export { required_16 as required };
        }
        export namespace cellSelectionData {
            let type_48: ObjectConstructor;
            export { type_48 as type };
            function _default_31(): null;
            export { _default_31 as default };
        }
        export namespace cellSelectionRangeData {
            let type_49: ObjectConstructor;
            export { type_49 as type };
            function _default_32(): null;
            export { _default_32 as default };
        }
        export namespace headerIndicatorColKeys {
            let type_50: ObjectConstructor;
            export { type_50 as type };
            function _default_33(): null;
            export { _default_33 as default };
        }
        export namespace headerRows {
            let type_51: ArrayConstructor;
            export { type_51 as type };
            function _default_34(): never[];
            export { _default_34 as default };
        }
        export namespace checkboxOption_1 {
            let type_52: ObjectConstructor;
            export { type_52 as type };
            function _default_35(): null;
            export { _default_35 as default };
        }
        export { checkboxOption_1 as checkboxOption };
        export namespace sortOption_1 {
            let type_53: ObjectConstructor;
            export { type_53 as type };
            function _default_36(): null;
            export { _default_36 as default };
        }
        export { sortOption_1 as sortOption };
        export namespace cellStyleOption_1 {
            let type_54: ObjectConstructor;
            export { type_54 as type };
            function _default_37(): null;
            export { _default_37 as default };
        }
        export { cellStyleOption_1 as cellStyleOption };
        export namespace eventCustomOption_1 {
            let type_55: ObjectConstructor;
            export { type_55 as type };
            function _default_38(): null;
            export { _default_38 as default };
        }
        export { eventCustomOption_1 as eventCustomOption };
    }
    export { props_4 as props };
    export function data(): {
        sortColumns: {};
    };
    export namespace computed_2 {
        function headerClass(): any;
    }
    export { computed_2 as computed };
    export namespace watch_2 {
        export namespace colgroups_3 {
            export function handler(): void;
            let immediate_1: boolean;
            export { immediate_1 as immediate };
        }
        export { colgroups_3 as colgroups };
    }
    export { watch_2 as watch };
    export function mounted(): void;
    export namespace methods_4 {
        function sortChange({ currentField, sortResult }: {
            currentField: any;
            sortResult: any;
        }): void;
        function initSortColumns(): void;
    }
    export { methods_4 as methods };
    export function render(): any;
}
declare var TableBody: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    tableViewportWidth: {
        type: NumberConstructor;
        default: number;
    };
    columnsOptionResetTime: {
        type: NumberConstructor;
        default: number;
    };
    colgroups: {
        type: ArrayConstructor;
        required: true;
    };
    actualRenderTableData: {
        type: ArrayConstructor;
        required: true;
    };
    hasFixedColumn: {
        type: BooleanConstructor;
        default: boolean;
    };
    allRowKeys: {
        type: ArrayConstructor;
        required: true;
    };
    expandOption: {
        type: ObjectConstructor;
        default: () => null;
    };
    checkboxOption: {
        type: ObjectConstructor;
        default: () => null;
    };
    radioOption: {
        type: ObjectConstructor;
        default: () => null;
    };
    virtualScrollOption: {
        type: ObjectConstructor;
        default: null;
    };
    isVirtualScroll: {
        type: BooleanConstructor;
        default: boolean;
    };
    showVirtualScrollingPlaceholder: {
        type: BooleanConstructor;
        default: boolean;
    };
    rowKeyFieldName: {
        type: StringConstructor;
        default: null;
    };
    cellStyleOption: {
        type: ObjectConstructor;
        default: () => null;
    };
    cellSpanOption: {
        type: ObjectConstructor;
        default: () => null;
    };
    highlightRowKey: {
        type: (StringConstructor | NumberConstructor)[];
        default: null;
    };
    eventCustomOption: {
        type: ObjectConstructor;
        default: () => null;
    };
    cellSelectionOption: {
        type: ObjectConstructor;
        default: () => null;
    };
    cellSelectionData: {
        type: ObjectConstructor;
        default: () => null;
    };
    cellSelectionRangeData: {
        type: ObjectConstructor;
        default: () => null;
    };
    bodyIndicatorRowKeys: {
        type: ObjectConstructor;
        default: () => null;
    };
    editOption: {
        type: ObjectConstructor;
        default: () => null;
    };
}>, {}, {
    colsWidths: Map<any, any>;
    internalExpandRowkeys: never[];
    internalCheckboxSelectedRowKeys: never[];
    internalRadioSelectedRowKey: null;
    virtualScrollPreviewRenderedRowKeys: never[];
    virtualScrollRepeatRenderedRowKeys: never[];
}, {
    columnCollection(): any[];
    expandColumn(): unknown;
    isControlledExpand(): boolean;
    expandedRowkeys(): any;
    disableCheckboxSelectedRowKeys(): any[];
    disableCheckboxUnselectedRowKeys(): any[];
    isCheckboxSelectedAll(): boolean;
    isCheckboxIndeterminate(): boolean;
    isControlledRadio(): boolean;
}, {
    isLastLeftFixedColumn(column: any): boolean;
    isfirstRightFixedColumn(column: any): boolean;
    expandRowChange(rowData: any, rowIndex: any): false | undefined;
    rowClick({ rowData, rowIndex }: {
        rowData: any;
        rowIndex: any;
    }): false | undefined;
    isExpandRow({ rowData, rowIndex }: {
        rowData: any;
        rowIndex: any;
    }): boolean;
    tdSizeChange({ key, width }: {
        key: any;
        width: any;
    }): void;
    initInternalExpandRowKeys(): false | undefined;
    getExpandRowComp({ rowData, rowIndex }: {
        rowData: any;
        rowIndex: any;
    }): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
    }> | null;
    sendToCheckboxAll(): void;
    initInternalRadioSelectedRowKey(): false | undefined;
    initInternalCheckboxSelectedRowKeys(): false | undefined;
    resetInternalCheckboxSelectedRowKeys(): void;
    checkboxSelectedRowChange({ rowKey, isSelected }: {
        rowKey: any;
        isSelected: any;
    }): void;
    checkboxSelectedAllChange({ isSelected }: {
        isSelected: any;
    }): void;
    radioSelectedRowChange({ rowKey }: {
        rowKey: any;
    }): void;
    getTrKey({ rowData, rowIndex }: {
        rowData: any;
        rowIndex: any;
    }): any;
    renderingRowKeys(rowKeys: any): void;
}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("highlightRowChange" | "bodyCellWidthChange")[], "highlightRowChange" | "bodyCellWidthChange", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    tableViewportWidth: {
        type: NumberConstructor;
        default: number;
    };
    columnsOptionResetTime: {
        type: NumberConstructor;
        default: number;
    };
    colgroups: {
        type: ArrayConstructor;
        required: true;
    };
    actualRenderTableData: {
        type: ArrayConstructor;
        required: true;
    };
    hasFixedColumn: {
        type: BooleanConstructor;
        default: boolean;
    };
    allRowKeys: {
        type: ArrayConstructor;
        required: true;
    };
    expandOption: {
        type: ObjectConstructor;
        default: () => null;
    };
    checkboxOption: {
        type: ObjectConstructor;
        default: () => null;
    };
    radioOption: {
        type: ObjectConstructor;
        default: () => null;
    };
    virtualScrollOption: {
        type: ObjectConstructor;
        default: null;
    };
    isVirtualScroll: {
        type: BooleanConstructor;
        default: boolean;
    };
    showVirtualScrollingPlaceholder: {
        type: BooleanConstructor;
        default: boolean;
    };
    rowKeyFieldName: {
        type: StringConstructor;
        default: null;
    };
    cellStyleOption: {
        type: ObjectConstructor;
        default: () => null;
    };
    cellSpanOption: {
        type: ObjectConstructor;
        default: () => null;
    };
    highlightRowKey: {
        type: (StringConstructor | NumberConstructor)[];
        default: null;
    };
    eventCustomOption: {
        type: ObjectConstructor;
        default: () => null;
    };
    cellSelectionOption: {
        type: ObjectConstructor;
        default: () => null;
    };
    cellSelectionData: {
        type: ObjectConstructor;
        default: () => null;
    };
    cellSelectionRangeData: {
        type: ObjectConstructor;
        default: () => null;
    };
    bodyIndicatorRowKeys: {
        type: ObjectConstructor;
        default: () => null;
    };
    editOption: {
        type: ObjectConstructor;
        default: () => null;
    };
}>> & Readonly<{
    onHighlightRowChange?: ((...args: any[]) => any) | undefined;
    onBodyCellWidthChange?: ((...args: any[]) => any) | undefined;
}>, {
    cellSelectionRangeData: Record<string, any>;
    bodyIndicatorRowKeys: Record<string, any>;
    rowKeyFieldName: string;
    cellSelectionData: Record<string, any>;
    tableViewportWidth: number;
    columnsOptionResetTime: number;
    hasFixedColumn: boolean;
    expandOption: Record<string, any>;
    checkboxOption: Record<string, any>;
    radioOption: Record<string, any>;
    virtualScrollOption: Record<string, any>;
    isVirtualScroll: boolean;
    showVirtualScrollingPlaceholder: boolean;
    cellStyleOption: Record<string, any>;
    cellSpanOption: Record<string, any>;
    highlightRowKey: string | number;
    eventCustomOption: Record<string, any>;
    cellSelectionOption: Record<string, any>;
    editOption: Record<string, any>;
}, {}, {
    BodyTr: {
        name: string;
        components: {
            BodyTd: {
                name: string;
                components: {
                    BodyCheckboxContent: {
                        name: string;
                        inject: string[];
                        props: {
                            checkboxOption: {
                                type: ObjectConstructor;
                                default: () => null;
                            };
                            rowKey: {
                                type: (StringConstructor | NumberConstructor)[];
                                required: boolean;
                            };
                            internalCheckboxSelectedRowKeys: {
                                type: ArrayConstructor;
                                default: () => null;
                            };
                        };
                        data(): {
                            isSelected: boolean;
                        };
                        computed: {
                            disabled(): boolean | undefined;
                            isControlledProp(): any;
                        };
                        watch: {
                            internalCheckboxSelectedRowKeys: {
                                handler: () => void;
                                immediate: boolean;
                            };
                        };
                        methods: {
                            initSelected(): void;
                            selectedChange(isSelected: any): void;
                        };
                        render(): any;
                    };
                    ExpandTrIcon: {
                        name: string;
                        props: {
                            column: {
                                type: ObjectConstructor;
                                required: boolean;
                            };
                            expandOption: {
                                type: ObjectConstructor;
                                default: () => null;
                            };
                            rowData: {
                                type: ObjectConstructor;
                                required: boolean;
                            };
                            expandedRowkeys: {
                                type: ArrayConstructor;
                                default: () => never[];
                            };
                            rowKeyFieldName: {
                                type: StringConstructor;
                                default: null;
                            };
                            cellClick: {
                                type: FunctionConstructor;
                                default: null;
                            };
                        };
                        computed: {
                            isExpanded(): any;
                            expandRowIconContainerClass(): {
                                [x: string]: boolean | (() => any);
                            };
                        };
                        render(): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }> | null;
                    };
                };
                inject: string[];
                props: {
                    rowData: {
                        type: ObjectConstructor;
                        required: boolean;
                    };
                    column: {
                        type: ObjectConstructor;
                        required: boolean;
                    };
                    columnCollection: {
                        type: ArrayConstructor;
                        required: boolean;
                    };
                    rowIndex: {
                        type: NumberConstructor;
                        required: boolean;
                    };
                    colgroups: {
                        type: ArrayConstructor;
                        required: boolean;
                    };
                    rowKeyFieldName: {
                        type: StringConstructor;
                        default: null;
                    };
                    allRowKeys: {
                        type: ArrayConstructor;
                        required: boolean;
                    };
                    expandOption: {
                        type: ObjectConstructor;
                        default: () => null;
                    };
                    isExpandRow: {
                        type: BooleanConstructor;
                        required: boolean;
                    };
                    expandedRowkeys: {
                        type: ArrayConstructor;
                        default: () => never[];
                    };
                    checkboxOption: {
                        type: ObjectConstructor;
                        default: () => null;
                    };
                    internalCheckboxSelectedRowKeys: {
                        type: ArrayConstructor;
                        default: () => null;
                    };
                    radioOption: {
                        type: ObjectConstructor;
                        default: () => null;
                    };
                    internalRadioSelectedRowKey: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: null;
                    };
                    cellStyleOption: {
                        type: ObjectConstructor;
                        default: () => null;
                    };
                    eventCustomOption: {
                        type: ObjectConstructor;
                        default: () => null;
                    };
                    cellSelectionData: {
                        type: ObjectConstructor;
                        default: () => null;
                    };
                    cellSelectionRangeData: {
                        type: ObjectConstructor;
                        default: () => null;
                    };
                    bodyIndicatorRowKeys: {
                        type: ObjectConstructor;
                        default: () => null;
                    };
                    cellSpanOption: {
                        type: ObjectConstructor;
                        default: () => null;
                    };
                    editOption: {
                        type: ObjectConstructor;
                        default: () => null;
                    };
                };
                emits: string[];
                data(): {
                    rawCellValue: string;
                };
                computed: {
                    currentColumnCollectionItem(): any;
                    currentRowKey(): any;
                };
                watch: {
                    rowData: {
                        handler(rowData: any): void;
                        deep: boolean;
                        immediate: boolean;
                    };
                };
                methods: {
                    bodyTdStyle(): {};
                    bodyTdClass(): {
                        [x: string]: boolean;
                    };
                    getEllipsisContentStyle(): {
                        '-webkit-line-clamp': any;
                    };
                    getRenderContent(h: any): any;
                    getCheckboxContent(): any;
                    getRadioContent(): any;
                    getCellSpan(): {
                        rowspan: number;
                        colspan: number;
                    };
                    cellClick(e: any, fn: any): false | undefined;
                    cellDblclick(e: any, fn: any): void;
                    cellContextmenu(e: any, fn: any): void;
                    cellMouseenter(e: any, fn: any): void;
                    cellMouseleave(e: any, fn: any): void;
                    cellMousemove(e: any, fn: any): void;
                    cellMouseover(e: any, fn: any): void;
                    cellMousedown(e: any, fn: any): void;
                    cellMouseup(e: any, fn: any): void;
                };
                render(h: any): any;
            };
        };
        inject: string[];
        props: {
            rowData: {
                type: ObjectConstructor;
                required: boolean;
            };
            rowIndex: {
                type: NumberConstructor;
                required: boolean;
            };
            colgroups: {
                type: ArrayConstructor;
                required: boolean;
            };
            columnCollection: {
                type: ArrayConstructor;
                required: boolean;
            };
            rowKeyFieldName: {
                type: StringConstructor;
                default: null;
            };
            allRowKeys: {
                type: ArrayConstructor;
                required: boolean;
            };
            expandOption: {
                type: ObjectConstructor;
                default: () => null;
            };
            isExpandRow: {
                type: BooleanConstructor;
                required: boolean;
            };
            expandedRowkeys: {
                type: ArrayConstructor;
                default: () => never[];
            };
            expandRowChange: {
                type: FunctionConstructor;
                default: null;
            };
            checkboxOption: {
                type: ObjectConstructor;
                default: () => null;
            };
            internalCheckboxSelectedRowKeys: {
                type: ArrayConstructor;
                default: () => null;
            };
            radioOption: {
                type: ObjectConstructor;
                default: () => null;
            };
            internalRadioSelectedRowKey: {
                type: (StringConstructor | NumberConstructor)[];
                default: null;
            };
            isVirtualScroll: {
                type: BooleanConstructor;
                default: boolean;
            };
            cellStyleOption: {
                type: ObjectConstructor;
                default: () => null;
            };
            highlightRowKey: {
                type: (StringConstructor | NumberConstructor)[];
                default: null;
            };
            eventCustomOption: {
                type: ObjectConstructor;
                default: () => null;
            };
            cellSelectionData: {
                type: ObjectConstructor;
                default: () => null;
            };
            cellSelectionRangeData: {
                type: ObjectConstructor;
                default: () => null;
            };
            bodyIndicatorRowKeys: {
                type: ObjectConstructor;
                default: () => null;
            };
            cellSpanOption: {
                type: ObjectConstructor;
                default: () => null;
            };
            editOption: {
                type: ObjectConstructor;
                default: () => null;
            };
        };
        computed: {
            currentRowKey(): any;
        };
        methods: {
            trClass(): {
                [x: string]: boolean;
            };
            rowClick(e: any, fn: any): void;
            rowDblclick(e: any, fn: any): void;
            rowContextmenu(e: any, fn: any): void;
            rowMouseenter(e: any, fn: any): void;
            rowMouseleave(e: any, fn: any): void;
            rowMousemove(e: any, fn: any): void;
            rowMouseover(e: any, fn: any): void;
            rowMousedown(e: any, fn: any): void;
            rowMouseup(e: any, fn: any): void;
        };
        render(): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>;
    };
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
declare namespace TableFooter {
    import name_5 = COMPS_NAME.FAN_TABLE_FOOTER;
    export { name_5 as name };
    export namespace props_5 {
        export namespace colgroups_4 {
            let type_56: ArrayConstructor;
            export { type_56 as type };
            let required_17: boolean;
            export { required_17 as required };
        }
        export { colgroups_4 as colgroups };
        export namespace footerData_1 {
            let type_57: ArrayConstructor;
            export { type_57 as type };
            let required_18: boolean;
            export { required_18 as required };
        }
        export { footerData_1 as footerData };
        export namespace hasFixedColumn {
            let type_58: BooleanConstructor;
            export { type_58 as type };
            let _default_39: boolean;
            export { _default_39 as default };
        }
        export namespace allRowKeys {
            let type_59: ArrayConstructor;
            export { type_59 as type };
            let required_19: boolean;
            export { required_19 as required };
        }
        export namespace rowKeyFieldName_1 {
            let type_60: StringConstructor;
            export { type_60 as type };
            let _default_40: null;
            export { _default_40 as default };
        }
        export { rowKeyFieldName_1 as rowKeyFieldName };
        export namespace cellStyleOption_2 {
            let type_61: ObjectConstructor;
            export { type_61 as type };
            function _default_41(): null;
            export { _default_41 as default };
        }
        export { cellStyleOption_2 as cellStyleOption };
        export namespace eventCustomOption_2 {
            let type_62: ObjectConstructor;
            export { type_62 as type };
            function _default_42(): null;
            export { _default_42 as default };
        }
        export { eventCustomOption_2 as eventCustomOption };
        export namespace footerRows {
            let type_63: ArrayConstructor;
            export { type_63 as type };
            function _default_43(): never[];
            export { _default_43 as default };
        }
        export namespace fixedFooter_1 {
            let type_64: BooleanConstructor;
            export { type_64 as type };
            let _default_44: boolean;
            export { _default_44 as default };
        }
        export { fixedFooter_1 as fixedFooter };
        export namespace cellSpanOption_1 {
            let type_65: ObjectConstructor;
            export { type_65 as type };
            function _default_45(): null;
            export { _default_45 as default };
        }
        export { cellSpanOption_1 as cellSpanOption };
    }
    export { props_5 as props };
    export namespace computed_3 {
        function footerClass(): any;
    }
    export { computed_3 as computed };
    export namespace methods_5 {
        function getTrKey({ rowData, rowIndex }: {
            rowData: any;
            rowIndex: any;
        }): any;
    }
    export { methods_5 as methods };
    export function render(): any;
}
declare namespace EditInput {
    import name_6 = COMPS_NAME.FAN_TABLE_EDIT_INPUT;
    export { name_6 as name };
    export namespace directives_1 {
        export { focus };
    }
    export { directives_1 as directives };
    export namespace props_6 {
        export namespace parentRendered_2 {
            let type_66: BooleanConstructor;
            export { type_66 as type };
            let required_20: boolean;
            export { required_20 as required };
        }
        export { parentRendered_2 as parentRendered };
        export namespace hooks_1 {
            let type_67: ObjectConstructor;
            export { type_67 as type };
            let required_21: boolean;
            export { required_21 as required };
        }
        export { hooks_1 as hooks };
        export namespace inputStartValue {
            let type_68: (StringConstructor | NumberConstructor)[];
            export { type_68 as type };
            let required_22: boolean;
            export { required_22 as required };
        }
        export namespace rowKeyFieldName_2 {
            let type_69: StringConstructor;
            export { type_69 as type };
            let _default_46: null;
            export { _default_46 as default };
        }
        export { rowKeyFieldName_2 as rowKeyFieldName };
        export namespace tableData_1 {
            let type_70: ArrayConstructor;
            export { type_70 as type };
            let required_23: boolean;
            export { required_23 as required };
        }
        export { tableData_1 as tableData };
        export namespace colgroups_5 {
            let type_71: ArrayConstructor;
            export { type_71 as type };
            let required_24: boolean;
            export { required_24 as required };
        }
        export { colgroups_5 as colgroups };
        export namespace cellSelectionData_1 {
            let type_72: ObjectConstructor;
            export { type_72 as type };
            let required_25: boolean;
            export { required_25 as required };
        }
        export { cellSelectionData_1 as cellSelectionData };
        export namespace editingCell {
            let type_73: ObjectConstructor;
            export { type_73 as type };
            let required_26: boolean;
            export { required_26 as required };
        }
        export namespace isCellEditing {
            let type_74: BooleanConstructor;
            export { type_74 as type };
            let required_27: boolean;
            export { required_27 as required };
        }
        export namespace hasXScrollBar {
            let type_75: BooleanConstructor;
            export { type_75 as type };
            let required_28: boolean;
            export { required_28 as required };
        }
        export namespace hasYScrollBar {
            let type_76: BooleanConstructor;
            export { type_76 as type };
            let required_29: boolean;
            export { required_29 as required };
        }
        export namespace hasRightFixedColumn {
            let type_77: BooleanConstructor;
            export { type_77 as type };
            let required_30: boolean;
            export { required_30 as required };
        }
        export namespace scrollBarWidth {
            let type_78: NumberConstructor;
            export { type_78 as type };
            let required_31: boolean;
            export { required_31 as required };
        }
    }
    export { props_6 as props };
    let emits_1: string[];
    export { emits_1 as emits };
    export function data(): {
        textareaInputRef: string;
        rawCellValue: string;
        displayTextarea: boolean;
        overflowViewport: boolean;
        textareaRect: {
            left: number;
            top: number;
        };
        tableEl: null;
        cellEl: null;
        autoResize: null;
        isEditCellFocus: boolean;
    };
    export namespace computed_4 {
        function currentColumn(): any;
        function containerClass(): any;
        function containerStyle(): {};
        function textareaClass(): {
            [x: string]: boolean;
        };
    }
    export { computed_4 as computed };
    let watch_3: {
        parentRendered: {
            handler(val: any): void;
            immediate: boolean;
        };
        'cellSelectionData.currentCell': {
            handler(val: any): void;
            deep: boolean;
            immediate: boolean;
        };
        'cellSelectionData.normalEndCell': {
            handler: (val: any) => void;
            deep: boolean;
            immediate: boolean;
        };
        isCellEditing: {
            handler: (val: any) => void;
            deep: boolean;
            immediate: boolean;
        };
        inputStartValue: {
            handler: () => void;
            immediate: boolean;
        };
    };
    export { watch_3 as watch };
    export function created(): void;
    export function mounted(): void;
    export function unmounted(): void;
    let methods_6: {
        [x: string]: (val: any) => void;
        setTableEl(): void;
        setCellEl(): void;
        setTextareaPosition(): void;
        showTextarea(): void;
        hideTextarea(): void;
        textareaUnObserve(): void;
        setRawCellValue(): void;
        textareaValueChange(val: any): void;
    };
    export { methods_6 as methods };
    export function render(): any;
}
declare namespace Selection {
    let name_7: string;
    export { name_7 as name };
    let inject_1: string[];
    export { inject_1 as inject };
    export namespace props_7 {
        export namespace tableEl {
            let type_79: {
                new (): HTMLTableElement;
                prototype: HTMLTableElement;
            };
            export { type_79 as type };
            let _default_47: null;
            export { _default_47 as default };
        }
        export namespace allRowKeys_1 {
            let type_80: ArrayConstructor;
            export { type_80 as type };
            let required_32: boolean;
            export { required_32 as required };
        }
        export { allRowKeys_1 as allRowKeys };
        export namespace colgroups_6 {
            let type_81: ArrayConstructor;
            export { type_81 as type };
            let required_33: boolean;
            export { required_33 as required };
        }
        export { colgroups_6 as colgroups };
        export namespace parentRendered_3 {
            let type_82: BooleanConstructor;
            export { type_82 as type };
            let required_34: boolean;
            export { required_34 as required };
        }
        export { parentRendered_3 as parentRendered };
        export namespace hooks_2 {
            let type_83: ObjectConstructor;
            export { type_83 as type };
            let required_35: boolean;
            export { required_35 as required };
        }
        export { hooks_2 as hooks };
        export namespace cellAutofillOption_1 {
            let type_84: (ObjectConstructor | BooleanConstructor)[];
            export { type_84 as type };
            function _default_48(): null;
            export { _default_48 as default };
        }
        export { cellAutofillOption_1 as cellAutofillOption };
        export namespace cellSelectionData_2 {
            let type_85: ObjectConstructor;
            export { type_85 as type };
            let required_36: boolean;
            export { required_36 as required };
        }
        export { cellSelectionData_2 as cellSelectionData };
        export namespace cellSelectionRangeData_1 {
            let type_86: ObjectConstructor;
            export { type_86 as type };
            let required_37: boolean;
            export { required_37 as required };
        }
        export { cellSelectionRangeData_1 as cellSelectionRangeData };
        export namespace isAutofillStarting {
            let type_87: BooleanConstructor;
            export { type_87 as type };
            let required_38: boolean;
            export { required_38 as required };
        }
        export namespace currentCellSelectionType {
            let type_88: StringConstructor;
            export { type_88 as type };
            let _default_49: string;
            export { _default_49 as default };
        }
        export namespace showVirtualScrollingPlaceholder {
            let type_89: BooleanConstructor;
            export { type_89 as type };
            let _default_50: boolean;
            export { _default_50 as default };
        }
        export namespace isVirtualScroll {
            let type_90: BooleanConstructor;
            export { type_90 as type };
            let _default_51: boolean;
            export { _default_51 as default };
        }
        export namespace virtualScrollVisibleIndexs {
            let type_91: ObjectConstructor;
            export { type_91 as type };
            let required_39: boolean;
            export { required_39 as required };
        }
        export namespace isCellEditing_1 {
            let type_92: BooleanConstructor;
            export { type_92 as type };
            let _default_52: boolean;
            export { _default_52 as default };
        }
        export { isCellEditing_1 as isCellEditing };
    }
    export { props_7 as props };
    let emits_2: string[];
    export { emits_2 as emits };
    export function data(): {
        currentCellEl: null;
        normalEndCellEl: null;
        autoFillEndCellEl: null;
        cellSelectionRect: {
            currentCellRect: {
                left: number;
                top: number;
                width: number;
                height: number;
            };
            normalEndCellRect: {
                left: number;
                top: number;
                width: number;
                height: number;
            };
            autoFillEndCellRect: {
                left: number;
                top: number;
                width: number;
                height: number;
            };
        };
    };
    export namespace computed_5 {
        function selectionBordersVisibility(): boolean;
        function showCorner(): boolean;
        function cornerCellInfo(): {
            isLastColumn: boolean;
            isLastRow: boolean;
        };
        function isFirstSelectionRow(): any;
        function isFirstSelectionCol(): any;
        function isFirstNotFixedSelectionCol(): boolean;
    }
    export { computed_5 as computed };
    let watch_4: {
        parentRendered: {
            handler: (val: any) => void;
            immediate: boolean;
        };
        'cellSelectionData.currentCell': {
            handler: (val: any) => void;
            deep: boolean;
            immediate: boolean;
        };
        'cellSelectionData.normalEndCell': {
            handler: (val: any) => void;
            deep: boolean;
            immediate: boolean;
        };
        'cellSelectionData.autoFillEndCell': {
            handler: (val: any) => void;
            deep: boolean;
            immediate: boolean;
        };
    };
    export { watch_4 as watch };
    export function created(): void;
    let methods_7: {
        [x: string]: (({ cellEl, tableLeft, tableTop }: {
            cellEl: any;
            tableLeft: any;
            tableTop: any;
        }) => false | {
            left: number;
            top: number;
            width: any;
            height: any;
        } | undefined) | (({ tableLeft, tableTop, colKey, isFirstRow, isLastRow }: {
            tableLeft: any;
            tableTop: any;
            colKey: any;
            isFirstRow: any;
            isLastRow: any;
        }) => any) | (({ type }: {
            type: any;
        }) => false | undefined) | (({ areaPostions, fixedType }: {
            areaPostions: any;
            fixedType: any;
        }) => false | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }> | null) | (({ borderWidth, borderHeight, topBorder, rightBorder, bottomBorder, leftBorder, corner, className, fixedType, totalColKeys, fixedColKeys }: {
            borderWidth: any;
            borderHeight: any;
            topBorder: any;
            rightBorder: any;
            bottomBorder: any;
            leftBorder: any;
            corner: any;
            className: any;
            fixedType: any;
            totalColKeys: any;
            fixedColKeys: any;
        }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }> | null);
        resetCellPositions(): void;
        setCellEls(): void;
        setCellSelectionRangeData(): void;
        getCellPosition({ cellEl, tableLeft, tableTop }: {
            cellEl: any;
            tableLeft: any;
            tableTop: any;
        }): false | {
            left: number;
            top: number;
            width: any;
            height: any;
        } | undefined;
        getCellPositionByColKey({ tableLeft, tableTop, colKey, isFirstRow, isLastRow }: {
            tableLeft: any;
            tableTop: any;
            colKey: any;
            isFirstRow: any;
            isLastRow: any;
        }): any;
        setSelectionPositions({ type }: {
            type: any;
        }): false | undefined;
        getSelectionCurrent({ fixedType }: {
            fixedType: any;
        }): {
            selectionCurrent: null;
            autoFillArea: null;
        };
        getSelectionAreas({ fixedType }: {
            fixedType: any;
        }): {
            normalArea: null;
            autoFillArea: null;
        };
        getSelectionAutofillArea({ areaPostions, fixedType }: {
            areaPostions: any;
            fixedType: any;
        }): false | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }> | null;
        getBorders({ borderWidth, borderHeight, topBorder, rightBorder, bottomBorder, leftBorder, corner, className, fixedType, totalColKeys, fixedColKeys }: {
            borderWidth: any;
            borderHeight: any;
            topBorder: any;
            rightBorder: any;
            bottomBorder: any;
            leftBorder: any;
            corner: any;
            className: any;
            fixedType: any;
            totalColKeys: any;
            fixedColKeys: any;
        }): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }> | null;
        getAreaLayer({ borderWidth, borderHeight, topBorder, className, fixedType, totalColKeys, fixedColKeys }: {
            borderWidth: any;
            borderHeight: any;
            topBorder: any;
            className: any;
            fixedType: any;
            totalColKeys: any;
            fixedColKeys: any;
        }): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }> | null;
        getTableFirstRowCellByColKey(colKey: any): any;
        getTableLastRowCellByColKey(colKey: any): any;
        getTableCellEl({ rowKey, colKey }: {
            rowKey: any;
            colKey: any;
        }): any;
        setCurrentCellEl(): void;
        setNormalEndCellEl(): void;
        setAutofillEndCellEl(): void;
        clearAutofillEndCellRect(): void;
    };
    export { methods_7 as methods };
    export function render(): any;
}
declare namespace HeaderTr {
    import name_8 = COMPS_NAME.FAN_TABLE_THADER_TR;
    export { name_8 as name };
    export namespace components_2 {
        export { VueDomResizeObserver };
        export { HeaderTh };
    }
    export { components_2 as components };
    let inject_2: string[];
    export { inject_2 as inject };
    export namespace props_8 {
        export namespace columnsOptionResetTime_1 {
            let type_93: NumberConstructor;
            export { type_93 as type };
            let _default_53: number;
            export { _default_53 as default };
        }
        export { columnsOptionResetTime_1 as columnsOptionResetTime };
        export namespace groupColumn {
            let type_94: ArrayConstructor;
            export { type_94 as type };
            let required_40: boolean;
            export { required_40 as required };
        }
        export namespace headerRows_1 {
            let type_95: ArrayConstructor;
            export { type_95 as type };
            function _default_54(): never[];
            export { _default_54 as default };
        }
        export { headerRows_1 as headerRows };
        export namespace colgroups_7 {
            let type_96: ArrayConstructor;
            export { type_96 as type };
            let required_41: boolean;
            export { required_41 as required };
        }
        export { colgroups_7 as colgroups };
        export namespace fixedHeader_2 {
            let type_97: BooleanConstructor;
            export { type_97 as type };
            let required_42: boolean;
            export { required_42 as required };
        }
        export { fixedHeader_2 as fixedHeader };
        export namespace isGroupHeader_1 {
            let type_98: BooleanConstructor;
            export { type_98 as type };
            let required_43: boolean;
            export { required_43 as required };
        }
        export { isGroupHeader_1 as isGroupHeader };
        export namespace rowIndex {
            let type_99: NumberConstructor;
            export { type_99 as type };
            let required_44: boolean;
            export { required_44 as required };
        }
        export namespace cellSelectionData_3 {
            let type_100: ObjectConstructor;
            export { type_100 as type };
            function _default_55(): null;
            export { _default_55 as default };
        }
        export { cellSelectionData_3 as cellSelectionData };
        export namespace cellSelectionRangeData_2 {
            let type_101: ObjectConstructor;
            export { type_101 as type };
            function _default_56(): null;
            export { _default_56 as default };
        }
        export { cellSelectionRangeData_2 as cellSelectionRangeData };
        export namespace headerIndicatorColKeys_1 {
            let type_102: ObjectConstructor;
            export { type_102 as type };
            function _default_57(): null;
            export { _default_57 as default };
        }
        export { headerIndicatorColKeys_1 as headerIndicatorColKeys };
        export namespace checkboxOption_2 {
            let type_103: ObjectConstructor;
            export { type_103 as type };
            function _default_58(): null;
            export { _default_58 as default };
        }
        export { checkboxOption_2 as checkboxOption };
        export namespace sortOption_2 {
            let type_104: ObjectConstructor;
            export { type_104 as type };
            function _default_59(): null;
            export { _default_59 as default };
        }
        export { sortOption_2 as sortOption };
        export namespace sortColumns {
            let type_105: ObjectConstructor;
            export { type_105 as type };
            function _default_60(): null;
            export { _default_60 as default };
        }
        export namespace cellStyleOption_3 {
            let type_106: ObjectConstructor;
            export { type_106 as type };
            function _default_61(): null;
            export { _default_61 as default };
        }
        export { cellStyleOption_3 as cellStyleOption };
        export namespace eventCustomOption_3 {
            let type_107: ObjectConstructor;
            export { type_107 as type };
            function _default_62(): null;
            export { _default_62 as default };
        }
        export { eventCustomOption_3 as eventCustomOption };
    }
    export { props_8 as props };
    export namespace methods_8 {
        function trHeightChange({ height }: {
            height: any;
        }): void;
        function rowClick(e: any, fn: any): void;
        function rowDblclick(e: any, fn: any): void;
        function rowContextmenu(e: any, fn: any): void;
        function rowMouseenter(e: any, fn: any): void;
        function rowMouseleave(e: any, fn: any): void;
        function rowMousemove(e: any, fn: any): void;
        function rowMouseover(e: any, fn: any): void;
        function rowMousedown(e: any, fn: any): void;
        function rowMouseup(e: any, fn: any): void;
    }
    export { methods_8 as methods };
    export function render(): any;
}
declare namespace focus {
    function updated(el: any, binding: any, vnode: any): void;
    function unmounted(el: any, { value }: {
        value: any;
    }): void;
}
declare namespace HeaderTh {
    import name_9 = COMPS_NAME.FAN_TABLE_THADER_Th;
    export { name_9 as name };
    let inject_3: string[];
    export { inject_3 as inject };
    export namespace props_9 {
        export namespace groupColumn_1 {
            let type_108: ArrayConstructor;
            export { type_108 as type };
            let required_45: boolean;
            export { required_45 as required };
        }
        export { groupColumn_1 as groupColumn };
        export namespace groupColumnItem {
            let type_109: ObjectConstructor;
            export { type_109 as type };
            let required_46: boolean;
            export { required_46 as required };
        }
        export namespace colgroups_8 {
            let type_110: ArrayConstructor;
            export { type_110 as type };
            let required_47: boolean;
            export { required_47 as required };
        }
        export { colgroups_8 as colgroups };
        export namespace headerRows_2 {
            let type_111: ArrayConstructor;
            export { type_111 as type };
            function _default_63(): never[];
            export { _default_63 as default };
        }
        export { headerRows_2 as headerRows };
        export namespace fixedHeader_3 {
            let type_112: BooleanConstructor;
            export { type_112 as type };
        }
        export { fixedHeader_3 as fixedHeader };
        export namespace isGroupHeader_2 {
            let type_113: BooleanConstructor;
            export { type_113 as type };
            let required_48: boolean;
            export { required_48 as required };
        }
        export { isGroupHeader_2 as isGroupHeader };
        export namespace rowIndex_1 {
            let type_114: NumberConstructor;
            export { type_114 as type };
            let required_49: boolean;
            export { required_49 as required };
        }
        export { rowIndex_1 as rowIndex };
        export namespace cellSelectionData_4 {
            let type_115: ObjectConstructor;
            export { type_115 as type };
            function _default_64(): null;
            export { _default_64 as default };
        }
        export { cellSelectionData_4 as cellSelectionData };
        export namespace cellSelectionRangeData_3 {
            let type_116: ObjectConstructor;
            export { type_116 as type };
            function _default_65(): null;
            export { _default_65 as default };
        }
        export { cellSelectionRangeData_3 as cellSelectionRangeData };
        export namespace headerIndicatorColKeys_2 {
            let type_117: ObjectConstructor;
            export { type_117 as type };
            function _default_66(): null;
            export { _default_66 as default };
        }
        export { headerIndicatorColKeys_2 as headerIndicatorColKeys };
        export namespace checkboxOption_3 {
            let type_118: ObjectConstructor;
            export { type_118 as type };
            function _default_67(): null;
            export { _default_67 as default };
        }
        export { checkboxOption_3 as checkboxOption };
        export namespace sortOption_3 {
            let type_119: ObjectConstructor;
            export { type_119 as type };
            function _default_68(): null;
            export { _default_68 as default };
        }
        export { sortOption_3 as sortOption };
        export namespace sortColumns_1 {
            let type_120: ObjectConstructor;
            export { type_120 as type };
            function _default_69(): null;
            export { _default_69 as default };
        }
        export { sortColumns_1 as sortColumns };
        export namespace cellStyleOption_4 {
            let type_121: ObjectConstructor;
            export { type_121 as type };
            function _default_70(): null;
            export { _default_70 as default };
        }
        export { cellStyleOption_4 as cellStyleOption };
        export namespace eventCustomOption_4 {
            let type_122: ObjectConstructor;
            export { type_122 as type };
            function _default_71(): null;
            export { _default_71 as default };
        }
        export { eventCustomOption_4 as eventCustomOption };
    }
    export { props_9 as props };
    export namespace computed_6 {
        function isLastLeftFixedColumn(): boolean;
        function isfirstRightFixedColumn(): boolean;
        function isLastCloumn(): boolean;
        function isSortableCloumn(): boolean;
    }
    export { computed_6 as computed };
    export namespace methods_9 {
        function getTheadThClass({ fixed }: {
            fixed: any;
        }): any;
        function getTheadThStyle({ _keys, align, fixed }: {
            _keys: any;
            align: any;
            fixed: any;
        }, rowIndex: any): {
            'text-align': any;
            left: string | number;
            right: string | number;
            top: number;
        };
        function getCheckboxContent(): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }> | null;
        function sortChange(): void;
        function getSortContent(): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }> | null;
        function getFilterContent(): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }> | null;
        function getFilterCustomContent(): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }> | null;
        function cellClick(e: any, fn: any): void;
        function cellDblclick(e: any, fn: any): void;
        function cellContextmenu(e: any, fn: any): void;
        function cellMouseenter(e: any, fn: any): void;
        function cellMouseleave(e: any, fn: any): void;
        function cellMousemove(e: any, fn: any): void;
        function cellMouseover(e: any, fn: any): void;
        function cellMousedown(e: any, fn: any): void;
        function cellMouseup(e: any, fn: any): void;
    }
    export { methods_9 as methods };
    export function render(h: any): any;
}
export { index as default };