import BoButton from './bo-button/index.vue';
declare const install: (app: any) => void;
export { install, BoButton };
declare const _default: {
    ElLoading: {
        install(app: import("vue").App<any>): void;
        directive: {
            mounted(el: any, binding: any): void;
            updated(el: any, binding: any): void;
            unmounted(el: any): void;
        };
        service: (options?: import("element-plus/lib/el-loading/src/loading.type").ILoadingOptions) => import("element-plus/lib/el-loading/src/loading.type").ILoadingInstance;
    };
    ElInfiniteScroll: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").ObjectDirective<HTMLElement & {
        ElInfiniteScroll: {
            container: Window | HTMLElement;
            containerEl: HTMLElement;
            instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
            delay: number;
            lastScrollTop: number;
            cb: () => void;
            onScroll: () => void;
            observer?: MutationObserver;
        };
    }, () => void>>;
    BoButton: import("vue").DefineComponent<{}, {}, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}> & {
        [x: string & `on${string}`]: never;
    }, {}>;
    ElCheckbox: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        modelValue: {
            type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
            default: () => any;
        };
        label: {
            type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
        };
        indeterminate: BooleanConstructor;
        disabled: BooleanConstructor;
        checked: BooleanConstructor;
        name: {
            type: StringConstructor;
            default: any;
        };
        trueLabel: {
            type: (NumberConstructor | StringConstructor)[];
            default: any;
        };
        falseLabel: {
            type: (NumberConstructor | StringConstructor)[];
            default: any;
        };
        id: {
            type: StringConstructor;
            default: any;
        };
        controls: {
            type: StringConstructor;
            default: any;
        };
        border: BooleanConstructor;
        size: {
            type: import("vue").PropType<any>;
            validator: (val: string) => boolean;
        };
    }, {
        isChecked: import("vue").ComputedRef<any>;
        isDisabled: import("vue").ComputedRef<any>;
        checkboxSize: import("vue").ComputedRef<any>;
        model: import("vue").WritableComputedRef<any>;
        handleChange: (e: InputEvent) => void;
        focus: import("vue").Ref<boolean>;
        size: import("vue").ComputedRef<string>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "change")[], "update:modelValue" | "change", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        indeterminate: boolean;
        disabled: boolean;
        checked: boolean;
        border: boolean;
    } & {
        modelValue?: string | number | boolean;
        label?: unknown;
        name?: string;
        trueLabel?: string | number;
        falseLabel?: string | number;
        id?: string;
        controls?: string;
        size?: unknown;
    }>, {
        modelValue: string | number | boolean;
        indeterminate: boolean;
        disabled: boolean;
        checked: boolean;
        name: string;
        trueLabel: string | number;
        falseLabel: string | number;
        id: string;
        controls: string;
        border: boolean;
    }>>;
    ElCheckboxGroup: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{}, {}, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}> & {
        [x: string & `on${string}`]: never;
    }, {}>>;
    ElCheckboxButton: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{}, {}, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}> & {
        [x: string & `on${string}`]: never;
    }, {}>>;
    ElSelect: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        name: StringConstructor;
        id: StringConstructor;
        modelValue: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor | ArrayConstructor)[];
        autocomplete: {
            type: StringConstructor;
            default: string;
        };
        automaticDropdown: BooleanConstructor;
        size: {
            type: import("vue").PropType<any>;
            validator: (val: string) => boolean;
        };
        disabled: BooleanConstructor;
        clearable: BooleanConstructor;
        filterable: BooleanConstructor;
        allowCreate: BooleanConstructor;
        loading: BooleanConstructor;
        popperClass: {
            type: StringConstructor;
            default: string;
        };
        remote: BooleanConstructor;
        loadingText: StringConstructor;
        noMatchText: StringConstructor;
        noDataText: StringConstructor;
        remoteMethod: FunctionConstructor;
        filterMethod: FunctionConstructor;
        multiple: BooleanConstructor;
        multipleLimit: {
            type: NumberConstructor;
            default: number;
        };
        placeholder: {
            type: StringConstructor;
        };
        defaultFirstOption: BooleanConstructor;
        reserveKeyword: BooleanConstructor;
        valueKey: {
            type: StringConstructor;
            default: string;
        };
        collapseTags: BooleanConstructor;
        popperAppendToBody: {
            type: BooleanConstructor;
            default: boolean;
        };
        clearIcon: {
            type: StringConstructor;
            default: string;
        };
    }, {
        tagInMultiLine: import("vue").Ref<boolean>;
        prefixWidth: any;
        selectSize: import("vue").ComputedRef<any>;
        readonly: import("vue").ComputedRef<any>;
        handleResize: () => void;
        collapseTagSize: import("vue").ComputedRef<"small" | "mini">;
        debouncedOnInputChange: import("lodash").DebouncedFunc<() => void>;
        debouncedQueryChange: import("lodash").DebouncedFunc<(e: any) => void>;
        deletePrevTag: (e: any) => void;
        deleteTag: (event: any, tag: any) => void;
        deleteSelected: (event: any) => void;
        handleOptionSelect: (option: any, byClick: any) => void;
        scrollToOption: (option: any) => void;
        inputWidth: import("vue").Ref<number>;
        selected: any;
        inputLength: import("vue").Ref<number>;
        filteredOptionsCount: import("vue").Ref<number>;
        visible: import("vue").Ref<boolean>;
        softFocus: import("vue").Ref<boolean>;
        selectedLabel: import("vue").Ref<string>;
        hoverIndex: import("vue").Ref<number>;
        query: import("vue").Ref<string>;
        inputHovering: import("vue").Ref<boolean>;
        currentPlaceholder: import("vue").Ref<string>;
        menuVisibleOnFocus: import("vue").Ref<boolean>;
        isOnComposition: import("vue").Ref<boolean>;
        isSilentBlur: import("vue").Ref<boolean>;
        options: import("vue").Ref<Map<any, any>>;
        resetInputHeight: () => void;
        managePlaceholder: () => void;
        showClose: import("vue").ComputedRef<boolean>;
        selectDisabled: import("vue").ComputedRef<any>;
        iconClass: import("vue").ComputedRef<"" | "arrow-up is-reverse" | "arrow-up">;
        showNewOption: import("vue").ComputedRef<boolean>;
        emptyText: import("vue").ComputedRef<any>;
        toggleLastOptionHitState: (hit?: boolean) => any;
        resetInputState: (e: KeyboardEvent) => void;
        handleComposition: (event: any) => void;
        handleMenuEnter: () => void;
        handleFocus: (event: any) => void;
        blur: () => void;
        handleBlur: (event: Event) => void;
        handleClearClick: (event: Event) => void;
        handleClose: () => void;
        toggleMenu: () => void;
        selectOption: () => void;
        getValueKey: (item: any) => any;
        navigateOptions: (direction: any) => void;
        dropMenuVisible: import("vue").ComputedRef<boolean>;
        focus: () => void;
        reference: any;
        input: any;
        popper: any;
        popperPaneRef: import("vue").ComputedRef<any>;
        tags: any;
        selectWrapper: import("vue").Ref<HTMLElement>;
        scrollbar: any;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "change" | "remove-tag" | "clear" | "visible-change" | "focus" | "blur")[], "update:modelValue" | "change" | "remove-tag" | "clear" | "visible-change" | "focus" | "blur", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        disabled: boolean;
        valueKey: string;
        autocomplete: string;
        automaticDropdown: boolean;
        clearable: boolean;
        filterable: boolean;
        allowCreate: boolean;
        loading: boolean;
        popperClass: string;
        remote: boolean;
        multiple: boolean;
        multipleLimit: number;
        defaultFirstOption: boolean;
        reserveKeyword: boolean;
        collapseTags: boolean;
        popperAppendToBody: boolean;
        clearIcon: string;
    } & {
        name?: string;
        id?: string;
        modelValue?: unknown;
        size?: unknown;
        loadingText?: string;
        noMatchText?: string;
        noDataText?: string;
        remoteMethod?: Function;
        filterMethod?: Function;
        placeholder?: string;
    }>, {
        disabled: boolean;
        valueKey: string;
        autocomplete: string;
        automaticDropdown: boolean;
        clearable: boolean;
        filterable: boolean;
        allowCreate: boolean;
        loading: boolean;
        popperClass: string;
        remote: boolean;
        multiple: boolean;
        multipleLimit: number;
        defaultFirstOption: boolean;
        reserveKeyword: boolean;
        collapseTags: boolean;
        popperAppendToBody: boolean;
        clearIcon: string;
    }>>;
    ElOption: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        value: {
            required: true;
            type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
        };
        label: (NumberConstructor | StringConstructor)[];
        created: BooleanConstructor;
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, {
        currentLabel: import("vue").ComputedRef<any>;
        itemSelected: import("vue").ComputedRef<boolean>;
        isDisabled: import("vue").ComputedRef<any>;
        select: import("element-plus/lib/el-select/src/token").SelectContext;
        hoverItem: () => void;
        visible: import("vue").Ref<boolean>;
        hover: import("vue").Ref<boolean>;
        selectOptionClick: () => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        value: unknown;
        disabled: boolean;
        created: boolean;
    } & {
        label?: string | number;
    }>, {
        disabled: boolean;
        created: boolean;
    }>>;
    ElTimePicker: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        isRange: {
            type: BooleanConstructor;
            default: boolean;
        };
        name: {
            type: (StringConstructor | ArrayConstructor)[];
            default: string;
        };
        popperClass: {
            type: StringConstructor;
            default: string;
        };
        format: {
            type: StringConstructor;
        };
        valueFormat: {
            type: import("vue").PropType<string>;
        };
        type: {
            type: StringConstructor;
            default: string;
        };
        clearable: {
            type: BooleanConstructor;
            default: boolean;
        };
        clearIcon: {
            type: StringConstructor;
            default: string;
        };
        editable: {
            type: BooleanConstructor;
            default: boolean;
        };
        prefixIcon: {
            type: StringConstructor;
            default: string;
        };
        size: {
            type: import("vue").PropType<any>;
            validator: (val: string) => boolean;
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        placeholder: {
            type: StringConstructor;
            default: string;
        };
        popperOptions: {
            type: import("vue").PropType<import("@popperjs/core").Options>;
            default: () => {};
        };
        modelValue: {
            type: import("vue").PropType<string | Date | Date[]>;
            default: string;
        };
        rangeSeparator: {
            type: StringConstructor;
            default: string;
        };
        startPlaceholder: StringConstructor;
        endPlaceholder: StringConstructor;
        defaultValue: {
            type: import("vue").PropType<Date | Date[]>;
        };
        defaultTime: {
            type: import("vue").PropType<Date | Date[]>;
        };
        disabledHours: {
            type: FunctionConstructor;
        };
        disabledMinutes: {
            type: FunctionConstructor;
        };
        disabledSeconds: {
            type: FunctionConstructor;
        };
        disabledDate: {
            type: FunctionConstructor;
        };
        cellClassName: {
            type: FunctionConstructor;
        };
        shortcuts: {
            type: ArrayConstructor;
            default: () => any[];
        };
        arrowControl: {
            type: BooleanConstructor;
            default: boolean;
        };
        validateEvent: {
            type: BooleanConstructor;
            default: boolean;
        };
        unlinkPanels: BooleanConstructor;
    }, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
    }>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        isRange: boolean;
        name: string | unknown[];
        popperClass: string;
        type: string;
        clearable: boolean;
        clearIcon: string;
        editable: boolean;
        prefixIcon: string;
        readonly: boolean;
        disabled: boolean;
        placeholder: string;
        popperOptions: import("@popperjs/core").Options;
        modelValue: string | Date | Date[];
        rangeSeparator: string;
        shortcuts: unknown[];
        arrowControl: boolean;
        validateEvent: boolean;
        unlinkPanels: boolean;
    } & {
        format?: string;
        valueFormat?: string;
        size?: unknown;
        startPlaceholder?: string;
        endPlaceholder?: string;
        defaultValue?: Date | Date[];
        defaultTime?: Date | Date[];
        disabledHours?: Function;
        disabledMinutes?: Function;
        disabledSeconds?: Function;
        disabledDate?: Function;
        cellClassName?: Function;
    }>, {
        isRange: boolean;
        name: string | unknown[];
        popperClass: string;
        type: string;
        clearable: boolean;
        clearIcon: string;
        editable: boolean;
        prefixIcon: string;
        readonly: boolean;
        disabled: boolean;
        placeholder: string;
        popperOptions: import("@popperjs/core").Options;
        modelValue: string | Date | Date[];
        rangeSeparator: string;
        shortcuts: unknown[];
        arrowControl: boolean;
        validateEvent: boolean;
        unlinkPanels: boolean;
    }>>;
    ElRadio: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        modelValue: {
            type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
            default: string;
        };
        label: {
            type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
            default: string;
        };
        disabled: BooleanConstructor;
        name: {
            type: StringConstructor;
            default: string;
        };
        border: BooleanConstructor;
        size: {
            type: import("vue").PropType<any>;
            validator: (val: string) => boolean;
        };
    }, {
        focus: import("vue").Ref<boolean>;
        isGroup: import("vue").ComputedRef<boolean>;
        isDisabled: import("vue").ComputedRef<any>;
        model: import("vue").WritableComputedRef<string | number | boolean>;
        tabIndex: import("vue").ComputedRef<0 | -1>;
        radioSize: import("vue").ComputedRef<any>;
        handleChange: () => void;
        radioRef: import("vue").Ref<HTMLInputElement>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "change")[], "update:modelValue" | "change", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        modelValue: string | number | boolean;
        label: string | number | boolean;
        disabled: boolean;
        name: string;
        border: boolean;
    } & {
        size?: unknown;
    }>, {
        modelValue: string | number | boolean;
        label: string | number | boolean;
        disabled: boolean;
        name: string;
        border: boolean;
    }>>;
    ElRadioGroup: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{}, {}, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}> & {
        [x: string & `on${string}`]: never;
    }, {}>>;
    ElRadioButton: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{}, {}, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}> & {
        [x: string & `on${string}`]: never;
    }, {}>>;
    ElSwitch: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        modelValue: {
            type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
            default: boolean;
        };
        value: {
            type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        width: {
            type: NumberConstructor;
            default: number;
        };
        activeIconClass: {
            type: StringConstructor;
            default: string;
        };
        inactiveIconClass: {
            type: StringConstructor;
            default: string;
        };
        activeText: {
            type: StringConstructor;
            default: string;
        };
        inactiveText: {
            type: StringConstructor;
            default: string;
        };
        activeColor: {
            type: StringConstructor;
            default: string;
        };
        inactiveColor: {
            type: StringConstructor;
            default: string;
        };
        borderColor: {
            type: StringConstructor;
            default: string;
        };
        activeValue: {
            type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
            default: boolean;
        };
        inactiveValue: {
            type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
            default: boolean;
        };
        name: {
            type: StringConstructor;
            default: string;
        };
        validateEvent: {
            type: BooleanConstructor;
            default: boolean;
        };
        id: StringConstructor;
        loading: {
            type: BooleanConstructor;
            default: boolean;
        };
        beforeChange: import("vue").PropType<() => boolean | Promise<boolean>>;
    }, {
        input: any;
        core: any;
        switchDisabled: import("vue").ComputedRef<boolean>;
        checked: import("vue").ComputedRef<boolean>;
        handleChange: () => void;
        switchValue: () => void;
        focus: () => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "change" | "input")[], "update:modelValue" | "change" | "input", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        value: string | number | boolean;
        modelValue: string | number | boolean;
        disabled: boolean;
        width: number;
        activeIconClass: string;
        inactiveIconClass: string;
        activeText: string;
        inactiveText: string;
        activeColor: string;
        inactiveColor: string;
        borderColor: string;
        activeValue: string | number | boolean;
        inactiveValue: string | number | boolean;
        name: string;
        validateEvent: boolean;
        loading: boolean;
    } & {
        id?: string;
        beforeChange?: () => boolean | Promise<boolean>;
    }>, {
        value: string | number | boolean;
        modelValue: string | number | boolean;
        disabled: boolean;
        width: number;
        activeIconClass: string;
        inactiveIconClass: string;
        activeText: string;
        inactiveText: string;
        activeColor: string;
        inactiveColor: string;
        borderColor: string;
        activeValue: string | number | boolean;
        inactiveValue: string | number | boolean;
        name: string;
        validateEvent: boolean;
        loading: boolean;
    }>>;
    ElDatePicker: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<any, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
    }>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<({
        [x: string]: any;
    } & {
        [x: number]: any;
    }) | {
        [x: string]: any;
    }>, {} | {
        [x: string]: any;
    }>>;
    ElUpload: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        action: {
            type: StringConstructor;
            required: true;
        };
        headers: {
            type: import("vue").PropType<Headers>;
            default: () => {};
        };
        data: {
            type: ObjectConstructor;
            default: () => {};
        };
        multiple: {
            type: BooleanConstructor;
            default: boolean;
        };
        name: {
            type: StringConstructor;
            default: string;
        };
        drag: {
            type: BooleanConstructor;
            default: boolean;
        };
        withCredentials: BooleanConstructor;
        showFileList: {
            type: BooleanConstructor;
            default: boolean;
        };
        accept: {
            type: StringConstructor;
            default: string;
        };
        type: {
            type: StringConstructor;
            default: string;
        };
        beforeUpload: {
            type: ((new (...args: any[]) => import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>) | (() => import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>) | {
                (): import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>;
                new (): any;
                readonly prototype: any;
            }) | ((new (...args: any[]) => import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>) | (() => import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>) | {
                (): import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>;
                new (): any;
                readonly prototype: any;
            })[];
            default: () => void;
        };
        beforeRemove: {
            type: ((new (...args: any[]) => import("element-plus/lib/el-upload/src/upload.type").FileHandler<boolean>) | (() => import("element-plus/lib/el-upload/src/upload.type").FileHandler<boolean>) | {
                (): import("element-plus/lib/el-upload/src/upload.type").FileHandler<boolean>;
                new (): any;
                readonly prototype: any;
            }) | ((new (...args: any[]) => import("element-plus/lib/el-upload/src/upload.type").FileHandler<boolean>) | (() => import("element-plus/lib/el-upload/src/upload.type").FileHandler<boolean>) | {
                (): import("element-plus/lib/el-upload/src/upload.type").FileHandler<boolean>;
                new (): any;
                readonly prototype: any;
            })[];
            default: () => void;
        };
        onRemove: {
            type: ((new (...args: any[]) => import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>) | (() => import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>) | {
                (): import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>;
                new (): any;
                readonly prototype: any;
            }) | ((new (...args: any[]) => import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>) | (() => import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>) | {
                (): import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>;
                new (): any;
                readonly prototype: any;
            })[];
            default: () => void;
        };
        onChange: {
            type: ((new (...args: any[]) => import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>) | (() => import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>) | {
                (): import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>;
                new (): any;
                readonly prototype: any;
            }) | ((new (...args: any[]) => import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>) | (() => import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>) | {
                (): import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>;
                new (): any;
                readonly prototype: any;
            })[];
            default: () => void;
        };
        onPreview: {
            type: import("vue").PropType<() => void>;
            default: () => void;
        };
        onSuccess: {
            type: ((new (...args: any[]) => import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<any>) | (() => import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<any>) | {
                (): import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<any>;
                new (): any;
                readonly prototype: any;
            }) | ((new (...args: any[]) => import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<any>) | (() => import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<any>) | {
                (): import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<any>;
                new (): any;
                readonly prototype: any;
            })[];
            default: () => void;
        };
        onProgress: {
            type: ((new (...args: any[]) => import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<ProgressEvent<EventTarget>>) | (() => import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<ProgressEvent<EventTarget>>) | {
                (): import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<ProgressEvent<EventTarget>>;
                new (): any;
                readonly prototype: any;
            }) | ((new (...args: any[]) => import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<ProgressEvent<EventTarget>>) | (() => import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<ProgressEvent<EventTarget>>) | {
                (): import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<ProgressEvent<EventTarget>>;
                new (): any;
                readonly prototype: any;
            })[];
            default: () => void;
        };
        onError: {
            type: ((new (...args: any[]) => import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<Error>) | (() => import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<Error>) | {
                (): import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<Error>;
                new (): any;
                readonly prototype: any;
            }) | ((new (...args: any[]) => import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<Error>) | (() => import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<Error>) | {
                (): import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<Error>;
                new (): any;
                readonly prototype: any;
            })[];
            default: () => void;
        };
        fileList: {
            type: import("vue").PropType<import("element-plus/lib/el-upload/src/upload.type").UploadFile[]>;
            default: () => import("element-plus/lib/el-upload/src/upload.type").UploadFile[];
        };
        autoUpload: {
            type: BooleanConstructor;
            default: boolean;
        };
        listType: {
            type: import("vue").PropType<import("element-plus/lib/el-upload/src/upload.type").ListType>;
            default: import("element-plus/lib/el-upload/src/upload.type").ListType;
        };
        httpRequest: {
            type: FunctionConstructor;
            default: typeof import("element-plus/lib/el-upload/src/ajax").default;
        };
        disabled: BooleanConstructor;
        limit: {
            type: import("vue").PropType<number>;
            default: any;
        };
        onExceed: {
            type: FunctionConstructor;
            default: () => () => void;
        };
    }, {
        abort: (file: import("element-plus/lib/el-upload/src/upload.type").UploadFile) => void;
        dragOver: import("vue").Ref<boolean>;
        draging: import("vue").Ref<boolean>;
        handleError: (err: Error, rawFile: import("element-plus/lib/el-upload/src/upload.type").ElFile) => void;
        handleProgress: (ev: import("element-plus/lib/el-upload/src/upload.type").ElUploadProgressEvent, rawFile: import("element-plus/lib/el-upload/src/upload.type").ElFile) => void;
        handleRemove: (file: import("element-plus/lib/el-upload/src/upload.type").UploadFile, raw: import("element-plus/lib/el-upload/src/upload.type").ElFile) => void;
        handleStart: (rawFile: import("element-plus/lib/el-upload/src/upload.type").ElFile) => void;
        handleSuccess: (res: any, rawFile: import("element-plus/lib/el-upload/src/upload.type").ElFile) => void;
        uploadDisabled: import("vue").ComputedRef<any>;
        uploadFiles: import("vue").Ref<{
            name: string;
            percentage?: number;
            status: import("element-plus/lib/el-upload/src/upload.type").UploadStatus;
            size: number;
            response?: unknown;
            uid: number;
            url?: string;
            raw: {
                uid: number;
                readonly lastModified: number;
                readonly name: string;
                readonly size: number;
                readonly type: string;
                arrayBuffer: {
                    (): Promise<ArrayBuffer>;
                    (): Promise<ArrayBuffer>;
                    (): Promise<ArrayBuffer>;
                };
                slice: {
                    (start?: number, end?: number, contentType?: string): Blob;
                    (start?: number, end?: number, contentType?: string): Blob;
                    (start?: number, end?: number, contentType?: string): Blob;
                };
                stream: {
                    (): ReadableStream<any>;
                    (): ReadableStream<any>;
                    (): ReadableStream<any>;
                };
                text: {
                    (): Promise<string>;
                    (): Promise<string>;
                    (): Promise<string>;
                };
            };
        }[]>;
        uploadRef: import("vue").Ref<{
            abort: (file: import("element-plus/lib/el-upload/src/upload.type").UploadFile) => void;
            upload: (file: import("element-plus/lib/el-upload/src/upload.type").ElFile) => void;
        }>;
        submit: () => void;
        clearFiles: () => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        disabled: boolean;
        type: string;
        action: string;
        name: string;
        data: Record<string, any>;
        headers: Headers;
        withCredentials: boolean;
        multiple: boolean;
        accept: string;
        onProgress: import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<ProgressEvent<EventTarget>>;
        onSuccess: import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<any>;
        onError: import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<Error>;
        beforeUpload: import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>;
        drag: boolean;
        onPreview: () => void;
        onRemove: import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>;
        fileList: import("element-plus/lib/el-upload/src/upload.type").UploadFile[];
        autoUpload: boolean;
        listType: import("element-plus/lib/el-upload/src/upload.type").ListType;
        httpRequest: Function;
        onExceed: Function;
        showFileList: boolean;
        beforeRemove: import("element-plus/lib/el-upload/src/upload.type").FileHandler<boolean>;
        onChange: import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>;
    } & {
        limit?: number;
    }>, {
        disabled: boolean;
        type: string;
        name: string;
        data: Record<string, any>;
        headers: Headers;
        withCredentials: boolean;
        multiple: boolean;
        accept: string;
        onProgress: import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<ProgressEvent<EventTarget>>;
        onSuccess: import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<any>;
        onError: import("element-plus/lib/el-upload/src/upload.type").FileResultHandler<Error>;
        beforeUpload: import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>;
        drag: boolean;
        onPreview: () => void;
        onRemove: import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>;
        fileList: import("element-plus/lib/el-upload/src/upload.type").UploadFile[];
        autoUpload: boolean;
        listType: import("element-plus/lib/el-upload/src/upload.type").ListType;
        httpRequest: Function;
        limit: number;
        onExceed: Function;
        showFileList: boolean;
        beforeRemove: import("element-plus/lib/el-upload/src/upload.type").FileHandler<boolean>;
        onChange: import("element-plus/lib/el-upload/src/upload.type").FileHandler<void>;
    }>>;
    ElPagination: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        total: {
            type: NumberConstructor;
        };
        pageSize: {
            type: NumberConstructor;
        };
        defaultPageSize: {
            type: NumberConstructor;
        };
        currentPage: {
            type: NumberConstructor;
        };
        defaultCurrentPage: {
            type: NumberConstructor;
        };
        pageCount: {
            type: NumberConstructor;
        };
        pagerCount: {
            type: NumberConstructor;
            validator: (value: number) => boolean;
            default: number;
        };
        layout: {
            type: StringConstructor;
            default: string;
        };
        pageSizes: {
            type: ArrayConstructor;
            default: () => number[];
        };
        popperClass: {
            type: StringConstructor;
            default: string;
        };
        prevText: {
            type: StringConstructor;
            default: string;
        };
        nextText: {
            type: StringConstructor;
            default: string;
        };
        small: BooleanConstructor;
        background: BooleanConstructor;
        disabled: BooleanConstructor;
        hideOnSinglePage: BooleanConstructor;
    }, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
    }>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:current-page" | "update:page-size" | "size-change" | "current-change" | "prev-click" | "next-click")[], "update:current-page" | "update:page-size" | "size-change" | "current-change" | "prev-click" | "next-click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        disabled: boolean;
        prevText: string;
        nextText: string;
        small: boolean;
        popperClass: string;
        pageSizes: unknown[];
        pagerCount: number;
        layout: string;
        background: boolean;
        hideOnSinglePage: boolean;
    } & {
        currentPage?: number;
        pageCount?: number;
        total?: number;
        pageSize?: number;
        defaultPageSize?: number;
        defaultCurrentPage?: number;
    }>, {
        disabled: boolean;
        prevText: string;
        nextText: string;
        small: boolean;
        popperClass: string;
        pageSizes: unknown[];
        pagerCount: number;
        layout: string;
        background: boolean;
        hideOnSinglePage: boolean;
    }>>;
    ElDialog: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        appendToBody: {
            type: BooleanConstructor;
            default: boolean;
        };
        beforeClose: {
            type: import("vue").PropType<(...args: any[]) => unknown>;
        };
        destroyOnClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        center: {
            type: BooleanConstructor;
            default: boolean;
        };
        customClass: {
            type: StringConstructor;
            default: string;
        };
        closeOnClickModal: {
            type: BooleanConstructor;
            default: boolean;
        };
        closeOnPressEscape: {
            type: BooleanConstructor;
            default: boolean;
        };
        fullscreen: {
            type: BooleanConstructor;
            default: boolean;
        };
        lockScroll: {
            type: BooleanConstructor;
            default: boolean;
        };
        modal: {
            type: BooleanConstructor;
            default: boolean;
        };
        showClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        title: {
            type: StringConstructor;
            default: string;
        };
        openDelay: {
            type: NumberConstructor;
            default: number;
        };
        closeDelay: {
            type: NumberConstructor;
            default: number;
        };
        top: {
            type: StringConstructor;
            default: string;
        };
        modelValue: {
            type: BooleanConstructor;
            required: true;
        };
        modalClass: StringConstructor;
        width: {
            type: (NumberConstructor | StringConstructor)[];
            default: string;
            validator: (val: string | number) => boolean;
        };
        zIndex: {
            type: NumberConstructor;
        };
    }, {
        dialogRef: import("vue").Ref<HTMLElement>;
        afterEnter: () => void;
        afterLeave: () => void;
        beforeLeave: () => void;
        handleClose: () => void;
        onModalClick: () => void;
        closed: import("vue").Ref<boolean>;
        style: import("vue").ComputedRef<import("vue").CSSProperties>;
        rendered: import("vue").Ref<boolean>;
        modalRef: import("vue").Ref<HTMLElement>;
        visible: import("vue").Ref<boolean>;
        zIndex: import("vue").Ref<number>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "open" | "opened" | "close" | "closed")[], "update:modelValue" | "open" | "opened" | "close" | "closed", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        appendToBody: boolean;
        destroyOnClose: boolean;
        center: boolean;
        customClass: string;
        closeOnClickModal: boolean;
        closeOnPressEscape: boolean;
        fullscreen: boolean;
        lockScroll: boolean;
        modal: boolean;
        showClose: boolean;
        title: string;
        openDelay: number;
        closeDelay: number;
        top: string;
        modelValue: boolean;
        width: string | number;
    } & {
        beforeClose?: (...args: any[]) => unknown;
        modalClass?: string;
        zIndex?: number;
    }>, {
        appendToBody: boolean;
        destroyOnClose: boolean;
        center: boolean;
        customClass: string;
        closeOnClickModal: boolean;
        closeOnPressEscape: boolean;
        fullscreen: boolean;
        lockScroll: boolean;
        modal: boolean;
        showClose: boolean;
        title: string;
        openDelay: number;
        closeDelay: number;
        top: string;
        width: string | number;
    }>>;
    ElTooltip: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{}, {
        popper: any;
        onUpdateVisible: (val: any) => void;
        updatePopper: () => any;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{}>, {}>>;
    ElInput: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        modelValue: {
            type: (NumberConstructor | StringConstructor)[];
            default: string;
        };
        type: {
            type: StringConstructor;
            default: string;
        };
        size: {
            type: import("vue").PropType<any>;
            validator: (val: string) => boolean;
        };
        resize: {
            type: import("vue").PropType<"none" | "both" | "horizontal" | "vertical">;
            validator: (val: string) => boolean;
        };
        autosize: {
            type: import("vue").PropType<boolean | {
                minRows?: number;
                maxRows?: number;
            }>;
            default: boolean;
        };
        autocomplete: {
            type: StringConstructor;
            default: string;
        };
        placeholder: {
            type: StringConstructor;
        };
        form: {
            type: StringConstructor;
            default: string;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean;
        };
        clearable: {
            type: BooleanConstructor;
            default: boolean;
        };
        showPassword: {
            type: BooleanConstructor;
            default: boolean;
        };
        showWordLimit: {
            type: BooleanConstructor;
            default: boolean;
        };
        suffixIcon: {
            type: StringConstructor;
            default: string;
        };
        prefixIcon: {
            type: StringConstructor;
            default: string;
        };
        label: {
            type: StringConstructor;
        };
        tabindex: {
            type: (NumberConstructor | StringConstructor)[];
        };
        validateEvent: {
            type: BooleanConstructor;
            default: boolean;
        };
        inputStyle: {
            type: ObjectConstructor;
            default: () => {};
        };
        maxlength: {
            type: (NumberConstructor | StringConstructor)[];
        };
    }, {
        input: any;
        textarea: any;
        attrs: import("vue").Ref<{}>;
        inputSize: import("vue").ComputedRef<any>;
        validateState: import("vue").ComputedRef<any>;
        validateIcon: import("vue").ComputedRef<any>;
        computedTextareaStyle: import("vue").ComputedRef<{
            resize: "none" | "both" | "horizontal" | "vertical";
        }>;
        resizeTextarea: () => void;
        inputDisabled: import("vue").ComputedRef<any>;
        showClear: import("vue").ComputedRef<boolean>;
        showPwdVisible: import("vue").ComputedRef<boolean>;
        isWordLimitVisible: import("vue").ComputedRef<boolean>;
        textLength: import("vue").ComputedRef<number>;
        hovering: import("vue").Ref<boolean>;
        inputExceed: import("vue").ComputedRef<boolean>;
        passwordVisible: import("vue").Ref<boolean>;
        inputOrTextarea: import("vue").ComputedRef<any>;
        handleInput: (event: any) => void;
        handleChange: (event: any) => void;
        handleFocus: (event: any) => void;
        handleBlur: (event: any) => void;
        handleCompositionStart: () => void;
        handleCompositionUpdate: (event: any) => void;
        handleCompositionEnd: (event: any) => void;
        handlePasswordVisible: () => void;
        clear: () => void;
        select: () => void;
        focus: () => void;
        blur: () => void;
        getSuffixVisible: () => any;
        onMouseLeave: (e: any) => void;
        onMouseEnter: (e: any) => void;
        handleKeydown: (e: any) => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "change" | "clear" | "focus" | "blur" | "input" | "mouseleave" | "mouseenter" | "keydown")[], "update:modelValue" | "change" | "clear" | "focus" | "blur" | "input" | "mouseleave" | "mouseenter" | "keydown", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        modelValue: string | number;
        type: string;
        autosize: boolean;
        autocomplete: string;
        form: string;
        disabled: boolean;
        readonly: boolean;
        clearable: boolean;
        showPassword: boolean;
        showWordLimit: boolean;
        suffixIcon: string;
        prefixIcon: string;
        validateEvent: boolean;
        inputStyle: Record<string, any>;
    } & {
        size?: unknown;
        resize?: "none" | "both" | "horizontal" | "vertical";
        placeholder?: string;
        label?: string;
        tabindex?: string | number;
        maxlength?: string | number;
    }>, {
        modelValue: string | number;
        type: string;
        autosize: boolean;
        autocomplete: string;
        form: string;
        disabled: boolean;
        readonly: boolean;
        clearable: boolean;
        showPassword: boolean;
        showWordLimit: boolean;
        suffixIcon: string;
        prefixIcon: string;
        validateEvent: boolean;
        inputStyle: Record<string, any>;
    }>>;
    ElInputNumber: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<Readonly<import("vue").ComponentPropsOptions<{
        [x: string]: unknown;
    }>>, {
        input: any;
        displayValue: import("vue").ComputedRef<string | number>;
        handleInput: (value: any) => any;
        handleInputChange: (value: any) => void;
        controlsAtRight: import("vue").ComputedRef<boolean>;
        decrease: () => void;
        increase: () => void;
        inputNumberSize: import("vue").ComputedRef<any>;
        inputNumberDisabled: import("vue").ComputedRef<any>;
        maxDisabled: import("vue").ComputedRef<boolean>;
        minDisabled: import("vue").ComputedRef<boolean>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "change" | "focus" | "blur" | "input")[], "update:modelValue" | "change" | "focus" | "blur" | "input", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<({
        [x: number]: string;
    } & {
        length?: number;
        toString?: string;
        toLocaleString?: string;
        concat?: string[];
        join?: string;
        slice?: string[];
        indexOf?: {
            (searchElement: string, fromIndex?: number): number;
            (searchElement: string, fromIndex?: number): number;
        };
        lastIndexOf?: {
            (searchElement: string, fromIndex?: number): number;
            (searchElement: string, fromIndex?: number): number;
        };
        every?: {
            <S extends string>(predicate: (value: string, index: number, array: readonly string[]) => value is S, thisArg?: any): this is readonly S[];
            (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any): boolean;
            <S_1 extends string>(predicate: (value: string, index: number, array: readonly string[]) => value is S_1, thisArg?: any): this is readonly S_1[];
            (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any): boolean;
        };
        some?: {
            (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any): boolean;
            (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any): boolean;
        };
        forEach?: {
            (callbackfn: (value: string, index: number, array: readonly string[]) => void, thisArg?: any): void;
            (callbackfn: (value: string, index: number, array: readonly string[]) => void, thisArg?: any): void;
        };
        map?: {
            <U>(callbackfn: (value: string, index: number, array: readonly string[]) => U, thisArg?: any): U[];
            <U_1>(callbackfn: (value: string, index: number, array: readonly string[]) => U_1, thisArg?: any): U_1[];
        };
        filter?: {
            <S_2 extends string>(predicate: (value: string, index: number, array: readonly string[]) => value is S_2, thisArg?: any): S_2[];
            (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any): string[];
            <S_3 extends string>(predicate: (value: string, index: number, array: readonly string[]) => value is S_3, thisArg?: any): S_3[];
            (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any): string[];
        };
        reduce?: {
            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string): string;
            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string, initialValue: string): string;
            <U_2>(callbackfn: (previousValue: U_2, currentValue: string, currentIndex: number, array: readonly string[]) => U_2, initialValue: U_2): U_2;
            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string): string;
            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string, initialValue: string): string;
            <U_3>(callbackfn: (previousValue: U_3, currentValue: string, currentIndex: number, array: readonly string[]) => U_3, initialValue: U_3): U_3;
        };
        reduceRight?: {
            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string): string;
            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string, initialValue: string): string;
            <U_4>(callbackfn: (previousValue: U_4, currentValue: string, currentIndex: number, array: readonly string[]) => U_4, initialValue: U_4): U_4;
            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string): string;
            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string, initialValue: string): string;
            <U_5>(callbackfn: (previousValue: U_5, currentValue: string, currentIndex: number, array: readonly string[]) => U_5, initialValue: U_5): U_5;
        };
        find?: {
            <S_4 extends string>(predicate: (this: void, value: string, index: number, obj: readonly string[]) => value is S_4, thisArg?: any): S_4;
            (predicate: (value: string, index: number, obj: readonly string[]) => unknown, thisArg?: any): string;
            <S_5 extends string>(predicate: (this: void, value: string, index: number, obj: readonly string[]) => value is S_5, thisArg?: any): S_5;
            (predicate: (value: string, index: number, obj: readonly string[]) => unknown, thisArg?: any): string;
        };
        findIndex?: {
            (predicate: (value: string, index: number, obj: readonly string[]) => unknown, thisArg?: any): number;
            (predicate: (value: string, index: number, obj: readonly string[]) => unknown, thisArg?: any): number;
        };
        entries?: IterableIterator<[number, string]>;
        keys?: IterableIterator<number>;
        values?: IterableIterator<string>;
        includes?: {
            (searchElement: string, fromIndex?: number): boolean;
            (searchElement: string, fromIndex?: number): boolean;
        };
        flatMap?: {
            <U_6, This = undefined>(callback: (this: This, value: string, index: number, array: string[]) => U_6 | readonly U_6[], thisArg?: This): U_6[];
            <U_7, This_1 = undefined>(callback: (this: This_1, value: string, index: number, array: string[]) => U_7 | readonly U_7[], thisArg?: This_1): U_7[];
        };
        flat?: unknown[];
        [Symbol.iterator]?: IterableIterator<string>;
    }) | {
        [x: string]: unknown;
    }>, {} | {
        [x: number]: string;
    }>>;
    ElPopover: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{}, any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{}>, {}>>;
    ElAlert: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        title: {
            type: StringConstructor;
            default: string;
        };
        description: {
            type: StringConstructor;
            default: string;
        };
        type: {
            type: import("vue").PropType<"error" | "success" | "info" | "warning">;
            default: string;
        };
        closable: {
            type: BooleanConstructor;
            default: boolean;
        };
        closeText: {
            type: StringConstructor;
            default: string;
        };
        showIcon: BooleanConstructor;
        center: BooleanConstructor;
        effect: {
            type: StringConstructor;
            default: string;
            validator: (value: string) => boolean;
        };
    }, {
        visible: import("vue").Ref<boolean>;
        typeClass: import("vue").ComputedRef<string>;
        iconClass: import("vue").ComputedRef<any>;
        isBigIcon: import("vue").ComputedRef<"" | "is-big">;
        isBoldTitle: import("vue").ComputedRef<"" | "is-bold">;
        close: (evt: any) => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "close"[], "close", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        title: string;
        description: string;
        type: "error" | "success" | "info" | "warning";
        closable: boolean;
        closeText: string;
        showIcon: boolean;
        center: boolean;
        effect: string;
    }>, {
        title: string;
        description: string;
        type: "error" | "success" | "info" | "warning";
        closable: boolean;
        closeText: string;
        showIcon: boolean;
        center: boolean;
        effect: string;
    }>>;
    ElRow: any;
    ElCol: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        tag: {
            type: StringConstructor;
            default: string;
        };
        span: {
            type: NumberConstructor;
            default: number;
        };
        offset: {
            type: NumberConstructor;
            default: number;
        };
        pull: {
            type: NumberConstructor;
            default: number;
        };
        push: {
            type: NumberConstructor;
            default: number;
        };
        xs: {
            type: import("vue").PropType<number | {
                span: number;
                offset: number;
            }>;
            default: () => {
                span: number;
                offset: number;
            };
        };
        sm: {
            type: import("vue").PropType<number | {
                span: number;
                offset: number;
            }>;
            default: () => {
                span: number;
                offset: number;
            };
        };
        md: {
            type: import("vue").PropType<number | {
                span: number;
                offset: number;
            }>;
            default: () => {
                span: number;
                offset: number;
            };
        };
        lg: {
            type: import("vue").PropType<number | {
                span: number;
                offset: number;
            }>;
            default: () => {
                span: number;
                offset: number;
            };
        };
        xl: {
            type: import("vue").PropType<number | {
                span: number;
                offset: number;
            }>;
            default: () => {
                span: number;
                offset: number;
            };
        };
    }, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
    }>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        tag: string;
        span: number;
        offset: number;
        pull: number;
        push: number;
        xs: number | {
            span: number;
            offset: number;
        };
        sm: number | {
            span: number;
            offset: number;
        };
        md: number | {
            span: number;
            offset: number;
        };
        lg: number | {
            span: number;
            offset: number;
        };
        xl: number | {
            span: number;
            offset: number;
        };
    }>, {
        tag: string;
        span: number;
        offset: number;
        pull: number;
        push: number;
        xs: number | {
            span: number;
            offset: number;
        };
        sm: number | {
            span: number;
            offset: number;
        };
        md: number | {
            span: number;
            offset: number;
        };
        lg: number | {
            span: number;
            offset: number;
        };
        xl: number | {
            span: number;
            offset: number;
        };
    }>>;
    ElTree: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        data: {
            type: ArrayConstructor;
        };
        emptyText: {
            type: StringConstructor;
        };
        renderAfterExpand: {
            type: BooleanConstructor;
            default: boolean;
        };
        nodeKey: StringConstructor;
        checkStrictly: BooleanConstructor;
        defaultExpandAll: BooleanConstructor;
        expandOnClickNode: {
            type: BooleanConstructor;
            default: boolean;
        };
        checkOnClickNode: BooleanConstructor;
        checkDescendants: {
            type: BooleanConstructor;
            default: boolean;
        };
        autoExpandParent: {
            type: BooleanConstructor;
            default: boolean;
        };
        defaultCheckedKeys: ArrayConstructor;
        defaultExpandedKeys: ArrayConstructor;
        currentNodeKey: import("vue").PropType<string | number>;
        renderContent: FunctionConstructor;
        showCheckbox: {
            type: BooleanConstructor;
            default: boolean;
        };
        draggable: {
            type: BooleanConstructor;
            default: boolean;
        };
        allowDrag: FunctionConstructor;
        allowDrop: FunctionConstructor;
        props: {
            type: ObjectConstructor;
            default(): {
                children: string;
                label: string;
                disabled: string;
            };
        };
        lazy: {
            type: BooleanConstructor;
            default: boolean;
        };
        highlightCurrent: BooleanConstructor;
        load: FunctionConstructor;
        filterNodeMethod: FunctionConstructor;
        accordion: BooleanConstructor;
        indent: {
            type: NumberConstructor;
            default: number;
        };
        iconClass: StringConstructor;
    }, {
        store: import("vue").Ref<{
            currentNode: {
                id: number;
                text: string;
                checked: boolean;
                indeterminate: boolean;
                data: {
                    [x: string]: any;
                };
                expanded: boolean;
                parent: any;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean;
                isLeaf: boolean;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                initialize: () => void;
                setData: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData) => void;
                readonly label: string;
                readonly key: import("element-plus/lib/el-tree/src/tree.type").TreeKey;
                readonly disabled: boolean;
                readonly nextSibling: any;
                readonly previousSibling: any;
                contains: (target: import("element-plus/lib/el-tree/src/model/node").default, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus/lib/el-tree/src/model/node").default | import("element-plus/lib/el-tree/src/tree.type").FakeNode, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus/lib/el-tree/src/model/node").default | import("element-plus/lib/el-tree/src/tree.type").FakeNode, ref: import("element-plus/lib/el-tree/src/model/node").default) => void;
                insertAfter: (child: import("element-plus/lib/el-tree/src/model/node").default | import("element-plus/lib/el-tree/src/tree.type").FakeNode, ref: import("element-plus/lib/el-tree/src/model/node").default) => void;
                removeChild: (child: import("element-plus/lib/el-tree/src/model/node").default) => void;
                removeChildByData: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData) => void;
                expand: (callback?: () => void, expandParent?: boolean) => void;
                doCreateChildren: (array: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[], defaultProps?: import("element-plus/lib/el-tree/src/tree.type").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[];
                updateChildren: () => void;
                loadData: (callback: (node: import("element-plus/lib/el-tree/src/model/node").default) => void, defaultProps?: import("element-plus/lib/el-tree/src/tree.type").TreeNodeLoadedDefaultProps) => void;
            };
            currentNodeKey: import("element-plus/lib/el-tree/src/tree.type").TreeKey;
            nodesMap: {
                [x: string]: {
                    id: number;
                    text: string;
                    checked: boolean;
                    indeterminate: boolean;
                    data: {
                        [x: string]: any;
                    };
                    expanded: boolean;
                    parent: any;
                    visible: boolean;
                    isCurrent: boolean;
                    store: any;
                    isLeafByUser: boolean;
                    isLeaf: boolean;
                    canFocus: boolean;
                    level: number;
                    loaded: boolean;
                    childNodes: any[];
                    loading: boolean;
                    initialize: () => void;
                    setData: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData) => void;
                    readonly label: string;
                    readonly key: import("element-plus/lib/el-tree/src/tree.type").TreeKey;
                    readonly disabled: boolean;
                    readonly nextSibling: any;
                    readonly previousSibling: any;
                    contains: (target: import("element-plus/lib/el-tree/src/model/node").default, deep?: boolean) => boolean;
                    remove: () => void;
                    insertChild: (child?: import("element-plus/lib/el-tree/src/model/node").default | import("element-plus/lib/el-tree/src/tree.type").FakeNode, index?: number, batch?: boolean) => void;
                    insertBefore: (child: import("element-plus/lib/el-tree/src/model/node").default | import("element-plus/lib/el-tree/src/tree.type").FakeNode, ref: import("element-plus/lib/el-tree/src/model/node").default) => void;
                    insertAfter: (child: import("element-plus/lib/el-tree/src/model/node").default | import("element-plus/lib/el-tree/src/tree.type").FakeNode, ref: import("element-plus/lib/el-tree/src/model/node").default) => void;
                    removeChild: (child: import("element-plus/lib/el-tree/src/model/node").default) => void;
                    removeChildByData: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData) => void;
                    expand: (callback?: () => void, expandParent?: boolean) => void;
                    doCreateChildren: (array: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[], defaultProps?: import("element-plus/lib/el-tree/src/tree.type").TreeNodeLoadedDefaultProps) => void;
                    collapse: () => void;
                    shouldLoadData: () => boolean;
                    updateLeafState: () => void;
                    setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                    getChildren: (forceInit?: boolean) => import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[];
                    updateChildren: () => void;
                    loadData: (callback: (node: import("element-plus/lib/el-tree/src/model/node").default) => void, defaultProps?: import("element-plus/lib/el-tree/src/tree.type").TreeNodeLoadedDefaultProps) => void;
                };
            };
            root: {
                id: number;
                text: string;
                checked: boolean;
                indeterminate: boolean;
                data: {
                    [x: string]: any;
                };
                expanded: boolean;
                parent: any;
                visible: boolean;
                isCurrent: boolean;
                store: any;
                isLeafByUser: boolean;
                isLeaf: boolean;
                canFocus: boolean;
                level: number;
                loaded: boolean;
                childNodes: any[];
                loading: boolean;
                initialize: () => void;
                setData: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData) => void;
                readonly label: string;
                readonly key: import("element-plus/lib/el-tree/src/tree.type").TreeKey;
                readonly disabled: boolean;
                readonly nextSibling: any;
                readonly previousSibling: any;
                contains: (target: import("element-plus/lib/el-tree/src/model/node").default, deep?: boolean) => boolean;
                remove: () => void;
                insertChild: (child?: import("element-plus/lib/el-tree/src/model/node").default | import("element-plus/lib/el-tree/src/tree.type").FakeNode, index?: number, batch?: boolean) => void;
                insertBefore: (child: import("element-plus/lib/el-tree/src/model/node").default | import("element-plus/lib/el-tree/src/tree.type").FakeNode, ref: import("element-plus/lib/el-tree/src/model/node").default) => void;
                insertAfter: (child: import("element-plus/lib/el-tree/src/model/node").default | import("element-plus/lib/el-tree/src/tree.type").FakeNode, ref: import("element-plus/lib/el-tree/src/model/node").default) => void;
                removeChild: (child: import("element-plus/lib/el-tree/src/model/node").default) => void;
                removeChildByData: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData) => void;
                expand: (callback?: () => void, expandParent?: boolean) => void;
                doCreateChildren: (array: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[], defaultProps?: import("element-plus/lib/el-tree/src/tree.type").TreeNodeLoadedDefaultProps) => void;
                collapse: () => void;
                shouldLoadData: () => boolean;
                updateLeafState: () => void;
                setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
                getChildren: (forceInit?: boolean) => import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[];
                updateChildren: () => void;
                loadData: (callback: (node: import("element-plus/lib/el-tree/src/model/node").default) => void, defaultProps?: import("element-plus/lib/el-tree/src/tree.type").TreeNodeLoadedDefaultProps) => void;
            };
            data: {
                [x: string]: any;
            }[];
            lazy: boolean;
            load: import("element-plus/lib/el-tree/src/tree.type").LoadFunction;
            filterNodeMethod: import("element-plus/lib/el-tree/src/tree.type").FilterNodeMethodFunction;
            key: import("element-plus/lib/el-tree/src/tree.type").TreeKey;
            defaultCheckedKeys: import("element-plus/lib/el-tree/src/tree.type").TreeKey[];
            checkStrictly: boolean;
            defaultExpandedKeys: import("element-plus/lib/el-tree/src/tree.type").TreeKey[];
            autoExpandParent: boolean;
            defaultExpandAll: boolean;
            checkDescendants: boolean;
            props: {
                children: string;
                label: string;
                disabled: string;
                isLeaf?: boolean;
            };
            initialize: () => void;
            filter: (value: any) => void;
            setData: (newVal: import("element-plus/lib/el-tree/src/tree.type").TreeData) => void;
            getNode: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey) => import("element-plus/lib/el-tree/src/model/node").default;
            insertBefore: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData, refData: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey) => void;
            insertAfter: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData, refData: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey) => void;
            remove: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/model/node").default) => void;
            append: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData, parentData: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey | import("element-plus/lib/el-tree/src/model/node").default) => void;
            _initDefaultCheckedNodes: () => void;
            _initDefaultCheckedNode: (node: import("element-plus/lib/el-tree/src/model/node").default) => void;
            setDefaultCheckedKey: (newVal: import("element-plus/lib/el-tree/src/tree.type").TreeKey[]) => void;
            registerNode: (node: import("element-plus/lib/el-tree/src/model/node").default) => void;
            deregisterNode: (node: import("element-plus/lib/el-tree/src/model/node").default) => void;
            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[];
            getCheckedKeys: (leafOnly?: boolean) => import("element-plus/lib/el-tree/src/tree.type").TreeKey[];
            getHalfCheckedNodes: () => import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[];
            getHalfCheckedKeys: () => import("element-plus/lib/el-tree/src/tree.type").TreeKey[];
            _getAllNodes: () => import("element-plus/lib/el-tree/src/model/node").default[];
            updateChildren: (key: import("element-plus/lib/el-tree/src/tree.type").TreeKey, data: import("element-plus/lib/el-tree/src/tree.type").TreeData) => void;
            _setCheckedKeys: (key: import("element-plus/lib/el-tree/src/tree.type").TreeKey, leafOnly: boolean, checkedKeys: {
                [key: string]: boolean;
            }) => void;
            setCheckedNodes: (array: import("element-plus/lib/el-tree/src/model/node").default[], leafOnly?: boolean) => void;
            setCheckedKeys: (keys: import("element-plus/lib/el-tree/src/tree.type").TreeKey[], leafOnly?: boolean) => void;
            setDefaultExpandedKeys: (keys: import("element-plus/lib/el-tree/src/tree.type").TreeKey[]) => void;
            setChecked: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey, checked: boolean, deep: boolean) => void;
            getCurrentNode: () => import("element-plus/lib/el-tree/src/model/node").default;
            setCurrentNode: (currentNode: import("element-plus/lib/el-tree/src/model/node").default) => void;
            setUserCurrentNode: (node: import("element-plus/lib/el-tree/src/model/node").default, shouldAutoExpandParent?: boolean) => void;
            setCurrentNodeKey: (key: import("element-plus/lib/el-tree/src/tree.type").TreeKey, shouldAutoExpandParent?: boolean) => void;
        }>;
        root: import("vue").Ref<{
            id: number;
            text: string;
            checked: boolean;
            indeterminate: boolean;
            data: {
                [x: string]: any;
            };
            expanded: boolean;
            parent: any;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any;
                currentNodeKey: import("element-plus/lib/el-tree/src/tree.type").TreeKey;
                nodesMap: {
                    [x: string]: any;
                };
                root: any;
                data: {
                    [x: string]: any;
                }[];
                lazy: boolean;
                load: import("element-plus/lib/el-tree/src/tree.type").LoadFunction;
                filterNodeMethod: import("element-plus/lib/el-tree/src/tree.type").FilterNodeMethodFunction;
                key: import("element-plus/lib/el-tree/src/tree.type").TreeKey;
                defaultCheckedKeys: import("element-plus/lib/el-tree/src/tree.type").TreeKey[];
                checkStrictly: boolean;
                defaultExpandedKeys: import("element-plus/lib/el-tree/src/tree.type").TreeKey[];
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children: string;
                    label: string;
                    disabled: string;
                    isLeaf?: boolean;
                };
                initialize: () => void;
                filter: (value: any) => void;
                setData: (newVal: import("element-plus/lib/el-tree/src/tree.type").TreeData) => void;
                getNode: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey) => import("element-plus/lib/el-tree/src/model/node").default;
                insertBefore: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData, refData: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey) => void;
                insertAfter: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData, refData: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey) => void;
                remove: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/model/node").default) => void;
                append: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData, parentData: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey | import("element-plus/lib/el-tree/src/model/node").default) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: import("element-plus/lib/el-tree/src/model/node").default) => void;
                setDefaultCheckedKey: (newVal: import("element-plus/lib/el-tree/src/tree.type").TreeKey[]) => void;
                registerNode: (node: import("element-plus/lib/el-tree/src/model/node").default) => void;
                deregisterNode: (node: import("element-plus/lib/el-tree/src/model/node").default) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => import("element-plus/lib/el-tree/src/tree.type").TreeKey[];
                getHalfCheckedNodes: () => import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[];
                getHalfCheckedKeys: () => import("element-plus/lib/el-tree/src/tree.type").TreeKey[];
                _getAllNodes: () => import("element-plus/lib/el-tree/src/model/node").default[];
                updateChildren: (key: import("element-plus/lib/el-tree/src/tree.type").TreeKey, data: import("element-plus/lib/el-tree/src/tree.type").TreeData) => void;
                _setCheckedKeys: (key: import("element-plus/lib/el-tree/src/tree.type").TreeKey, leafOnly: boolean, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: import("element-plus/lib/el-tree/src/model/node").default[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: import("element-plus/lib/el-tree/src/tree.type").TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: import("element-plus/lib/el-tree/src/tree.type").TreeKey[]) => void;
                setChecked: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => import("element-plus/lib/el-tree/src/model/node").default;
                setCurrentNode: (currentNode: import("element-plus/lib/el-tree/src/model/node").default) => void;
                setUserCurrentNode: (node: import("element-plus/lib/el-tree/src/model/node").default, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: import("element-plus/lib/el-tree/src/tree.type").TreeKey, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean;
            isLeaf: boolean;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            initialize: () => void;
            setData: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData) => void;
            readonly label: string;
            readonly key: import("element-plus/lib/el-tree/src/tree.type").TreeKey;
            readonly disabled: boolean;
            readonly nextSibling: any;
            readonly previousSibling: any;
            contains: (target: import("element-plus/lib/el-tree/src/model/node").default, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus/lib/el-tree/src/model/node").default | import("element-plus/lib/el-tree/src/tree.type").FakeNode, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus/lib/el-tree/src/model/node").default | import("element-plus/lib/el-tree/src/tree.type").FakeNode, ref: import("element-plus/lib/el-tree/src/model/node").default) => void;
            insertAfter: (child: import("element-plus/lib/el-tree/src/model/node").default | import("element-plus/lib/el-tree/src/tree.type").FakeNode, ref: import("element-plus/lib/el-tree/src/model/node").default) => void;
            removeChild: (child: import("element-plus/lib/el-tree/src/model/node").default) => void;
            removeChildByData: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData) => void;
            expand: (callback?: () => void, expandParent?: boolean) => void;
            doCreateChildren: (array: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[], defaultProps?: import("element-plus/lib/el-tree/src/tree.type").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[];
            updateChildren: () => void;
            loadData: (callback: (node: import("element-plus/lib/el-tree/src/model/node").default) => void, defaultProps?: import("element-plus/lib/el-tree/src/tree.type").TreeNodeLoadedDefaultProps) => void;
        }>;
        currentNode: import("vue").Ref<{
            id: number;
            text: string;
            checked: boolean;
            indeterminate: boolean;
            data: {
                [x: string]: any;
            };
            expanded: boolean;
            parent: any;
            visible: boolean;
            isCurrent: boolean;
            store: {
                currentNode: any;
                currentNodeKey: import("element-plus/lib/el-tree/src/tree.type").TreeKey;
                nodesMap: {
                    [x: string]: any;
                };
                root: any;
                data: {
                    [x: string]: any;
                }[];
                lazy: boolean;
                load: import("element-plus/lib/el-tree/src/tree.type").LoadFunction;
                filterNodeMethod: import("element-plus/lib/el-tree/src/tree.type").FilterNodeMethodFunction;
                key: import("element-plus/lib/el-tree/src/tree.type").TreeKey;
                defaultCheckedKeys: import("element-plus/lib/el-tree/src/tree.type").TreeKey[];
                checkStrictly: boolean;
                defaultExpandedKeys: import("element-plus/lib/el-tree/src/tree.type").TreeKey[];
                autoExpandParent: boolean;
                defaultExpandAll: boolean;
                checkDescendants: boolean;
                props: {
                    children: string;
                    label: string;
                    disabled: string;
                    isLeaf?: boolean;
                };
                initialize: () => void;
                filter: (value: any) => void;
                setData: (newVal: import("element-plus/lib/el-tree/src/tree.type").TreeData) => void;
                getNode: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey) => import("element-plus/lib/el-tree/src/model/node").default;
                insertBefore: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData, refData: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey) => void;
                insertAfter: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData, refData: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey) => void;
                remove: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/model/node").default) => void;
                append: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData, parentData: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey | import("element-plus/lib/el-tree/src/model/node").default) => void;
                _initDefaultCheckedNodes: () => void;
                _initDefaultCheckedNode: (node: import("element-plus/lib/el-tree/src/model/node").default) => void;
                setDefaultCheckedKey: (newVal: import("element-plus/lib/el-tree/src/tree.type").TreeKey[]) => void;
                registerNode: (node: import("element-plus/lib/el-tree/src/model/node").default) => void;
                deregisterNode: (node: import("element-plus/lib/el-tree/src/model/node").default) => void;
                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[];
                getCheckedKeys: (leafOnly?: boolean) => import("element-plus/lib/el-tree/src/tree.type").TreeKey[];
                getHalfCheckedNodes: () => import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[];
                getHalfCheckedKeys: () => import("element-plus/lib/el-tree/src/tree.type").TreeKey[];
                _getAllNodes: () => import("element-plus/lib/el-tree/src/model/node").default[];
                updateChildren: (key: import("element-plus/lib/el-tree/src/tree.type").TreeKey, data: import("element-plus/lib/el-tree/src/tree.type").TreeData) => void;
                _setCheckedKeys: (key: import("element-plus/lib/el-tree/src/tree.type").TreeKey, leafOnly: boolean, checkedKeys: {
                    [key: string]: boolean;
                }) => void;
                setCheckedNodes: (array: import("element-plus/lib/el-tree/src/model/node").default[], leafOnly?: boolean) => void;
                setCheckedKeys: (keys: import("element-plus/lib/el-tree/src/tree.type").TreeKey[], leafOnly?: boolean) => void;
                setDefaultExpandedKeys: (keys: import("element-plus/lib/el-tree/src/tree.type").TreeKey[]) => void;
                setChecked: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey, checked: boolean, deep: boolean) => void;
                getCurrentNode: () => import("element-plus/lib/el-tree/src/model/node").default;
                setCurrentNode: (currentNode: import("element-plus/lib/el-tree/src/model/node").default) => void;
                setUserCurrentNode: (node: import("element-plus/lib/el-tree/src/model/node").default, shouldAutoExpandParent?: boolean) => void;
                setCurrentNodeKey: (key: import("element-plus/lib/el-tree/src/tree.type").TreeKey, shouldAutoExpandParent?: boolean) => void;
            };
            isLeafByUser: boolean;
            isLeaf: boolean;
            canFocus: boolean;
            level: number;
            loaded: boolean;
            childNodes: any[];
            loading: boolean;
            initialize: () => void;
            setData: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData) => void;
            readonly label: string;
            readonly key: import("element-plus/lib/el-tree/src/tree.type").TreeKey;
            readonly disabled: boolean;
            readonly nextSibling: any;
            readonly previousSibling: any;
            contains: (target: import("element-plus/lib/el-tree/src/model/node").default, deep?: boolean) => boolean;
            remove: () => void;
            insertChild: (child?: import("element-plus/lib/el-tree/src/model/node").default | import("element-plus/lib/el-tree/src/tree.type").FakeNode, index?: number, batch?: boolean) => void;
            insertBefore: (child: import("element-plus/lib/el-tree/src/model/node").default | import("element-plus/lib/el-tree/src/tree.type").FakeNode, ref: import("element-plus/lib/el-tree/src/model/node").default) => void;
            insertAfter: (child: import("element-plus/lib/el-tree/src/model/node").default | import("element-plus/lib/el-tree/src/tree.type").FakeNode, ref: import("element-plus/lib/el-tree/src/model/node").default) => void;
            removeChild: (child: import("element-plus/lib/el-tree/src/model/node").default) => void;
            removeChildByData: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData) => void;
            expand: (callback?: () => void, expandParent?: boolean) => void;
            doCreateChildren: (array: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[], defaultProps?: import("element-plus/lib/el-tree/src/tree.type").TreeNodeLoadedDefaultProps) => void;
            collapse: () => void;
            shouldLoadData: () => boolean;
            updateLeafState: () => void;
            setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
            getChildren: (forceInit?: boolean) => import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[];
            updateChildren: () => void;
            loadData: (callback: (node: import("element-plus/lib/el-tree/src/model/node").default) => void, defaultProps?: import("element-plus/lib/el-tree/src/tree.type").TreeNodeLoadedDefaultProps) => void;
        }>;
        dragState: import("vue").Ref<{
            showDropIndicator: boolean;
            draggingNode: any;
            dropNode: any;
            allowDrop: boolean;
            dropType: any;
        }>;
        el$: import("vue").Ref<HTMLElement>;
        dropIndicator$: import("vue").Ref<HTMLElement>;
        isEmpty: import("vue").ComputedRef<boolean>;
        filter: (value: any) => void;
        getNodeKey: (node: import("element-plus/lib/el-tree/src/model/node").default) => any;
        getNodePath: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey) => import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[];
        getCheckedNodes: (leafOnly: boolean, includeHalfChecked: boolean) => import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[];
        getCheckedKeys: (leafOnly: boolean) => import("element-plus/lib/el-tree/src/tree.type").TreeKey[];
        getCurrentNode: () => import("element-plus/lib/el-tree/src/tree.type").TreeNodeData;
        getCurrentKey: () => any;
        setCheckedNodes: (nodes: import("element-plus/lib/el-tree/src/model/node").default[], leafOnly: boolean) => void;
        setCheckedKeys: (keys: any, leafOnly: boolean) => void;
        setChecked: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey, checked: boolean, deep: boolean) => void;
        getHalfCheckedNodes: () => import("element-plus/lib/el-tree/src/tree.type").TreeNodeData[];
        getHalfCheckedKeys: () => import("element-plus/lib/el-tree/src/tree.type").TreeKey[];
        setCurrentNode: (node: import("element-plus/lib/el-tree/src/model/node").default, shouldAutoExpandParent?: boolean) => void;
        setCurrentKey: (key: import("element-plus/lib/el-tree/src/tree.type").TreeKey, shouldAutoExpandParent?: boolean) => void;
        t: (...args: any[]) => string;
        getNode: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey) => import("element-plus/lib/el-tree/src/model/node").default;
        remove: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/model/node").default) => void;
        append: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData, parentNode: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey | import("element-plus/lib/el-tree/src/model/node").default) => void;
        insertBefore: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData, refNode: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey) => void;
        insertAfter: (data: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData, refNode: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData | import("element-plus/lib/el-tree/src/tree.type").TreeKey) => void;
        handleNodeExpand: (nodeData: import("element-plus/lib/el-tree/src/tree.type").TreeNodeData, node: import("element-plus/lib/el-tree/src/model/node").default, instance: import("vue").ComponentInternalInstance) => void;
        updateKeyChildren: (key: import("element-plus/lib/el-tree/src/tree.type").TreeKey, data: import("element-plus/lib/el-tree/src/tree.type").TreeData) => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("current-change" | "node-expand" | "check-change" | "node-click" | "node-contextmenu" | "node-collapse" | "check" | "node-drag-start" | "node-drag-end" | "node-drop" | "node-drag-leave" | "node-drag-enter" | "node-drag-over")[], "current-change" | "node-expand" | "check-change" | "node-click" | "node-contextmenu" | "node-collapse" | "check" | "node-drag-start" | "node-drag-end" | "node-drop" | "node-drag-leave" | "node-drag-enter" | "node-drag-over", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        props: Record<string, any>;
        accordion: boolean;
        renderAfterExpand: boolean;
        showCheckbox: boolean;
        lazy: boolean;
        checkStrictly: boolean;
        autoExpandParent: boolean;
        defaultExpandAll: boolean;
        checkDescendants: boolean;
        expandOnClickNode: boolean;
        checkOnClickNode: boolean;
        draggable: boolean;
        highlightCurrent: boolean;
        indent: number;
    } & {
        renderContent?: Function;
        data?: unknown[];
        currentNodeKey?: string | number;
        load?: Function;
        filterNodeMethod?: Function;
        defaultCheckedKeys?: unknown[];
        defaultExpandedKeys?: unknown[];
        emptyText?: string;
        nodeKey?: string;
        allowDrag?: Function;
        allowDrop?: Function;
        iconClass?: string;
    }>, {
        props: Record<string, any>;
        accordion: boolean;
        renderAfterExpand: boolean;
        showCheckbox: boolean;
        lazy: boolean;
        checkStrictly: boolean;
        autoExpandParent: boolean;
        defaultExpandAll: boolean;
        checkDescendants: boolean;
        expandOnClickNode: boolean;
        checkOnClickNode: boolean;
        draggable: boolean;
        highlightCurrent: boolean;
        indent: number;
    }>>;
    ElImage: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        appendToBody: {
            type: BooleanConstructor;
            default: boolean;
        };
        hideOnClickModal: {
            type: BooleanConstructor;
            default: boolean;
        };
        src: {
            type: StringConstructor;
            default: string;
        };
        fit: {
            type: StringConstructor;
            default: string;
        };
        lazy: {
            type: BooleanConstructor;
            default: boolean;
        };
        scrollContainer: {
            type: (ObjectConstructor | StringConstructor)[];
            default: any;
        };
        previewSrcList: {
            type: import("vue").PropType<string[]>;
            default: () => string[];
        };
        zIndex: {
            type: NumberConstructor;
            default: number;
        };
    }, {
        attrs: import("vue").Ref<{}>;
        loading: import("vue").Ref<boolean>;
        hasLoadError: import("vue").Ref<boolean>;
        showViewer: import("vue").Ref<boolean>;
        imgWidth: import("vue").Ref<number>;
        imgHeight: import("vue").Ref<number>;
        imageStyle: import("vue").ComputedRef<{
            width?: undefined;
            height?: undefined;
        } | {
            width: string;
            height: string;
        } | {
            width: string;
            height?: undefined;
        } | {
            height: string;
            width?: undefined;
        } | {
            'object-fit': string;
        }>;
        alignCenter: import("vue").ComputedRef<boolean>;
        preview: import("vue").ComputedRef<boolean>;
        imageIndex: import("vue").ComputedRef<number>;
        clickHandler: () => void;
        closeViewer: () => void;
        container: import("vue").Ref<HTMLElement>;
        handleError: (e: Event) => void;
        t: (...args: any[]) => string;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "error"[], "error", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        appendToBody: boolean;
        hideOnClickModal: boolean;
        src: string;
        fit: string;
        lazy: boolean;
        previewSrcList: string[];
        zIndex: number;
    } & {
        scrollContainer?: any;
    }>, {
        appendToBody: boolean;
        hideOnClickModal: boolean;
        src: string;
        fit: string;
        lazy: boolean;
        scrollContainer: any;
        previewSrcList: string[];
        zIndex: number;
    }>>;
    ElBacktop: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        visibilityHeight: {
            type: NumberConstructor;
            default: number;
        };
        target: {
            type: StringConstructor;
            default: string;
        };
        right: {
            type: NumberConstructor;
            default: number;
        };
        bottom: {
            type: NumberConstructor;
            default: number;
        };
    }, {
        el: any;
        container: any;
        visible: import("vue").Ref<boolean>;
        styleBottom: import("vue").ComputedRef<string>;
        styleRight: import("vue").ComputedRef<string>;
        handleClick: (event: any) => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        visibilityHeight: number;
        target: string;
        right: number;
        bottom: number;
    }>, {
        visibilityHeight: number;
        target: string;
        right: number;
        bottom: number;
    }>>;
    ElAutocomplete: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        valueKey: {
            type: StringConstructor;
            default: string;
        };
        modelValue: {
            type: (NumberConstructor | StringConstructor)[];
            default: string;
        };
        debounce: {
            type: NumberConstructor;
            default: number;
        };
        placement: {
            type: StringConstructor;
            validator: (val: string) => boolean;
            default: string;
        };
        fetchSuggestions: {
            type: import("vue").PropType<(queryString: string, cb: (data: any[]) => void) => void>;
            default: () => void;
        };
        popperClass: {
            type: StringConstructor;
            default: string;
        };
        triggerOnFocus: {
            type: BooleanConstructor;
            default: boolean;
        };
        selectWhenUnmatched: {
            type: BooleanConstructor;
            default: boolean;
        };
        hideLoading: {
            type: BooleanConstructor;
            default: boolean;
        };
        popperAppendToBody: {
            type: BooleanConstructor;
            default: boolean;
        };
        highlightFirstItem: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, {
        attrs: import("vue").Ref<{}>;
        suggestions: import("vue").Ref<any[]>;
        highlightedIndex: import("vue").Ref<number>;
        dropdownWidth: import("vue").Ref<string>;
        activated: import("vue").Ref<boolean>;
        suggestionDisabled: import("vue").Ref<boolean>;
        loading: import("vue").Ref<boolean>;
        inputRef: any;
        regionRef: any;
        popper: any;
        id: import("vue").ComputedRef<string>;
        suggestionVisible: import("vue").ComputedRef<boolean>;
        suggestionLoading: import("vue").ComputedRef<boolean>;
        getData: (queryString: any) => void;
        handleInput: (value: any) => void;
        handleChange: (value: any) => void;
        handleFocus: (e: any) => void;
        handleBlur: (e: any) => void;
        handleClear: () => void;
        handleKeyEnter: () => void;
        close: () => void;
        focus: () => void;
        select: (item: any) => void;
        highlight: (index: any) => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "change" | "clear" | "focus" | "blur" | "input" | "select")[], "update:modelValue" | "change" | "clear" | "focus" | "blur" | "input" | "select", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        valueKey: string;
        modelValue: string | number;
        debounce: number;
        placement: string;
        fetchSuggestions: (queryString: string, cb: (data: any[]) => void) => void;
        popperClass: string;
        triggerOnFocus: boolean;
        selectWhenUnmatched: boolean;
        hideLoading: boolean;
        popperAppendToBody: boolean;
        highlightFirstItem: boolean;
    }>, {
        valueKey: string;
        modelValue: string | number;
        debounce: number;
        placement: string;
        fetchSuggestions: (queryString: string, cb: (data: any[]) => void) => void;
        popperClass: string;
        triggerOnFocus: boolean;
        selectWhenUnmatched: boolean;
        hideLoading: boolean;
        popperAppendToBody: boolean;
        highlightFirstItem: boolean;
    }>>;
    ElDropdown: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        trigger: {
            type: StringConstructor;
            default: string;
        };
        type: StringConstructor;
        size: {
            type: StringConstructor;
            default: string;
        };
        splitButton: BooleanConstructor;
        hideOnClick: {
            type: BooleanConstructor;
            default: boolean;
        };
        placement: {
            type: StringConstructor;
            default: string;
        };
        showTimeout: {
            type: NumberConstructor;
            default: number;
        };
        hideTimeout: {
            type: NumberConstructor;
            default: number;
        };
        tabindex: {
            type: (NumberConstructor | StringConstructor)[];
            default: number;
        };
        effect: {
            type: StringConstructor;
            default: string;
        };
        maxHeight: {
            type: (NumberConstructor | StringConstructor)[];
            default: string;
        };
    }, {
        visible: import("vue").Ref<boolean>;
        scrollbar: any;
        wrapStyle: import("vue").ComputedRef<string>;
        dropdownSize: import("vue").ComputedRef<any>;
        handlerMainButtonClick: (event: any) => void;
        triggerVnode: import("vue").Ref<import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("visible-change" | "click" | "command")[], "visible-change" | "click" | "command", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        trigger: string;
        size: string;
        splitButton: boolean;
        hideOnClick: boolean;
        placement: string;
        showTimeout: number;
        hideTimeout: number;
        tabindex: string | number;
        effect: string;
        maxHeight: string | number;
    } & {
        type?: string;
    }>, {
        trigger: string;
        size: string;
        splitButton: boolean;
        hideOnClick: boolean;
        placement: string;
        showTimeout: number;
        hideTimeout: number;
        tabindex: string | number;
        effect: string;
        maxHeight: string | number;
    }>>;
    ElDropdownMenu: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{}, {}, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}> & {
        [x: string & `on${string}`]: never;
    }, {}>>;
    ElDropdownItem: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{}, {}, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}> & {
        [x: string & `on${string}`]: never;
    }, {}>>;
    ElLink: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        type: {
            type: ((new (...args: any[]) => ("success" | "info" | "warning" | "primary" | "danger" | "default") & {}) | (() => "success" | "info" | "warning" | "primary" | "danger" | "default")) | ((new (...args: any[]) => ("success" | "info" | "warning" | "primary" | "danger" | "default") & {}) | (() => "success" | "info" | "warning" | "primary" | "danger" | "default"))[];
            default: string;
            validator: (val: string) => boolean;
        };
        underline: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        href: {
            type: StringConstructor;
            default: string;
        };
        icon: {
            type: StringConstructor;
            default: string;
        };
    }, {
        handleClick: (event: Event) => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        type: "success" | "info" | "warning" | "primary" | "danger" | "default";
        underline: boolean;
        disabled: boolean;
        href: string;
        icon: string;
    }>, {
        type: "success" | "info" | "warning" | "primary" | "danger" | "default";
        underline: boolean;
        disabled: boolean;
        href: string;
        icon: string;
    }>>;
    ElDrawer: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        modelValue: {
            type: BooleanConstructor;
            required: true;
        };
        appendToBody: {
            type: BooleanConstructor;
            default: boolean;
        };
        beforeClose: import("vue").PropType<(hide: (cancel: boolean) => void) => void>;
        customClass: {
            type: StringConstructor;
            default: string;
        };
        direction: {
            type: import("vue").PropType<"ltr" | "rtl" | "ttb" | "btt">;
            default: string;
            validator: (val: "ltr" | "rtl" | "ttb" | "btt") => boolean;
        };
        showClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: (NumberConstructor | StringConstructor)[];
            default: string;
        };
        title: {
            type: StringConstructor;
            default: string;
        };
        closeOnClickModal: {
            type: BooleanConstructor;
            default: boolean;
        };
        withHeader: {
            type: BooleanConstructor;
            default: boolean;
        };
        openDelay: {
            type: NumberConstructor;
            default: number;
        };
        closeDelay: {
            type: NumberConstructor;
            default: number;
        };
        zIndex: NumberConstructor;
        modal: {
            type: BooleanConstructor;
            default: boolean;
        };
        modalFade: {
            type: BooleanConstructor;
            default: boolean;
        };
        modalClass: StringConstructor;
        lockScroll: {
            type: BooleanConstructor;
            default: boolean;
        };
        closeOnPressEscape: {
            type: BooleanConstructor;
            default: boolean;
        };
        destroyOnClose: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, any, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "open" | "opened" | "close" | "closed")[], "update:modelValue" | "open" | "opened" | "close" | "closed", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        modelValue: boolean;
        appendToBody: boolean;
        customClass: string;
        direction: "ltr" | "rtl" | "ttb" | "btt";
        showClose: boolean;
        size: string | number;
        title: string;
        closeOnClickModal: boolean;
        withHeader: boolean;
        openDelay: number;
        closeDelay: number;
        modal: boolean;
        modalFade: boolean;
        lockScroll: boolean;
        closeOnPressEscape: boolean;
        destroyOnClose: boolean;
    } & {
        beforeClose?: (hide: (cancel: boolean) => void) => void;
        zIndex?: number;
        modalClass?: string;
    }>, {
        appendToBody: boolean;
        customClass: string;
        direction: "ltr" | "rtl" | "ttb" | "btt";
        showClose: boolean;
        size: string | number;
        title: string;
        closeOnClickModal: boolean;
        withHeader: boolean;
        openDelay: number;
        closeDelay: number;
        modal: boolean;
        modalFade: boolean;
        lockScroll: boolean;
        closeOnPressEscape: boolean;
        destroyOnClose: boolean;
    }>>;
    ElTransfer: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        data: {
            type: import("vue").PropType<import("element-plus/lib/el-transfer/src/transfer").DataItem[]>;
            default: () => any[];
        };
        titles: {
            type: import("vue").PropType<[string, string]>;
            default: () => any[];
        };
        buttonTexts: {
            type: import("vue").PropType<[string, string]>;
            default: () => any[];
        };
        filterPlaceholder: {
            type: StringConstructor;
            default: string;
        };
        filterMethod: import("vue").PropType<(query: string, item: import("element-plus/lib/el-transfer/src/transfer").DataItem) => boolean>;
        leftDefaultChecked: {
            type: import("vue").PropType<import("element-plus/lib/el-transfer/src/transfer").Key[]>;
            default: () => any[];
        };
        rightDefaultChecked: {
            type: import("vue").PropType<import("element-plus/lib/el-transfer/src/transfer").Key[]>;
            default: () => any[];
        };
        renderContent: import("vue").PropType<(h: any, option: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>>;
        modelValue: {
            type: import("vue").PropType<import("element-plus/lib/el-transfer/src/transfer").Key[]>;
            default: () => any[];
        };
        format: {
            type: import("vue").PropType<import("element-plus/lib/el-transfer/src/transfer").Format>;
            default: () => {};
        };
        filterable: {
            type: BooleanConstructor;
            default: boolean;
        };
        props: {
            type: import("vue").PropType<import("element-plus/lib/el-transfer/src/transfer").Props>;
            default: () => {
                label: string;
                key: string;
                disabled: string;
            };
        };
        targetOrder: {
            type: import("vue").PropType<import("element-plus/lib/el-transfer/src/transfer").TargetOrder>;
            default: string;
            validator: (val: string) => boolean;
        };
    }, {
        hasButtonTexts: import("vue").ComputedRef<boolean>;
        leftPanelTitle: import("vue").ComputedRef<string>;
        rightPanelTitle: import("vue").ComputedRef<string>;
        panelFilterPlaceholder: import("vue").ComputedRef<string>;
        clearQuery: (which: "right" | "left") => void;
        optionRender: import("vue").ComputedRef<(option: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>[]>;
        leftChecked: import("vue").Ref<any[]>;
        rightChecked: import("vue").Ref<any[]>;
        sourceData: import("vue").ComputedRef<import("element-plus/lib/el-transfer/src/transfer").DataItem[]>;
        targetData: import("vue").ComputedRef<any[]>;
        onSourceCheckedChange: (val: import("element-plus/lib/el-transfer/src/transfer").Key[], movedKeys: import("element-plus/lib/el-transfer/src/transfer").Key[]) => void;
        onTargetCheckedChange: (val: import("element-plus/lib/el-transfer/src/transfer").Key[], movedKeys: import("element-plus/lib/el-transfer/src/transfer").Key[]) => void;
        addToLeft: () => void;
        addToRight: () => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "change" | "left-check-change" | "right-check-change")[], "update:modelValue" | "change" | "left-check-change" | "right-check-change", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        modelValue: import("element-plus/lib/el-transfer/src/transfer").Key[];
        titles: [string, string];
        filterPlaceholder: string;
        data: import("element-plus/lib/el-transfer/src/transfer").DataItem[];
        buttonTexts: [string, string];
        leftDefaultChecked: import("element-plus/lib/el-transfer/src/transfer").Key[];
        rightDefaultChecked: import("element-plus/lib/el-transfer/src/transfer").Key[];
        format: import("element-plus/lib/el-transfer/src/transfer").Format;
        filterable: boolean;
        props: import("element-plus/lib/el-transfer/src/transfer").Props;
        targetOrder: import("element-plus/lib/el-transfer/src/transfer").TargetOrder;
    } & {
        filterMethod?: (query: string, item: import("element-plus/lib/el-transfer/src/transfer").DataItem) => boolean;
        renderContent?: (h: any, option: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>;
    }>, {
        modelValue: import("element-plus/lib/el-transfer/src/transfer").Key[];
        titles: [string, string];
        filterPlaceholder: string;
        data: import("element-plus/lib/el-transfer/src/transfer").DataItem[];
        buttonTexts: [string, string];
        leftDefaultChecked: import("element-plus/lib/el-transfer/src/transfer").Key[];
        rightDefaultChecked: import("element-plus/lib/el-transfer/src/transfer").Key[];
        format: import("element-plus/lib/el-transfer/src/transfer").Format;
        filterable: boolean;
        props: import("element-plus/lib/el-transfer/src/transfer").Props;
        targetOrder: import("element-plus/lib/el-transfer/src/transfer").TargetOrder;
    }>>;
    ElTable: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        data: {
            type: import("vue").PropType<any[]>;
            default: () => any[];
        };
        size: StringConstructor;
        width: (NumberConstructor | StringConstructor)[];
        height: (NumberConstructor | StringConstructor)[];
        maxHeight: (NumberConstructor | StringConstructor)[];
        fit: {
            type: BooleanConstructor;
            default: boolean;
        };
        stripe: BooleanConstructor;
        border: BooleanConstructor;
        rowKey: import("vue").PropType<string | ((row: any) => string)>;
        showHeader: {
            type: BooleanConstructor;
            default: boolean;
        };
        showSummary: BooleanConstructor;
        sumText: StringConstructor;
        summaryMethod: import("vue").PropType<import("element-plus/lib/el-table/src/table/defaults").SummaryMethod<any>>;
        rowClassName: import("vue").PropType<import("element-plus/lib/el-table/src/table/defaults").ColumnCls<any>>;
        rowStyle: import("vue").PropType<import("element-plus/lib/el-table/src/table/defaults").ColumnStyle<any>>;
        cellClassName: import("vue").PropType<string | ((data: {
            row: any;
            rowIndex: number;
            column: import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>;
            columnIndex: number;
        }) => string)>;
        cellStyle: import("vue").PropType<import("vue").CSSProperties | ((data: {
            row: any;
            rowIndex: number;
            column: import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>;
            columnIndex: number;
        }) => import("vue").CSSProperties)>;
        headerRowClassName: import("vue").PropType<import("element-plus/lib/el-table/src/table/defaults").ColumnCls<any>>;
        headerRowStyle: import("vue").PropType<import("element-plus/lib/el-table/src/table/defaults").ColumnStyle<any>>;
        headerCellClassName: import("vue").PropType<string | ((data: {
            row: any;
            rowIndex: number;
            column: import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>;
            columnIndex: number;
        }) => string)>;
        headerCellStyle: import("vue").PropType<import("vue").CSSProperties | ((data: {
            row: any;
            rowIndex: number;
            column: import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>;
            columnIndex: number;
        }) => import("vue").CSSProperties)>;
        highlightCurrentRow: BooleanConstructor;
        currentRowKey: (NumberConstructor | StringConstructor)[];
        emptyText: StringConstructor;
        expandRowKeys: import("vue").PropType<any[]>;
        defaultExpandAll: BooleanConstructor;
        defaultSort: import("vue").PropType<import("element-plus/lib/el-table/src/table/defaults").Sort>;
        tooltipEffect: StringConstructor;
        spanMethod: import("vue").PropType<(data: {
            row: any;
            rowIndex: number;
            column: import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>;
            columnIndex: number;
        }) => number[] | {
            rowspan: number;
            colspan: number;
        }>;
        selectOnIndeterminate: {
            type: BooleanConstructor;
            default: boolean;
        };
        indent: {
            type: NumberConstructor;
            default: number;
        };
        treeProps: {
            type: import("vue").PropType<{
                hasChildren?: string;
                children?: string;
            }>;
            default: () => {
                hasChildren: string;
                children: string;
            };
        };
        lazy: BooleanConstructor;
        load: import("vue").PropType<(row: any, treeNode: import("element-plus/lib/el-table/src/table/defaults").TreeNode, resolve: (data: any[]) => void) => void>;
        style: {
            type: import("vue").PropType<import("vue").CSSProperties>;
            default: () => {};
        };
        className: {
            type: StringConstructor;
            default: string;
        };
    }, {
        layout: import("element-plus/lib/el-table/src/table-layout").default<any>;
        store: {
            mutations: {
                setData(states: {
                    _currentRowKey: import("vue").Ref<string>;
                    currentRow: import("vue").Ref<any>;
                    expandRowKeys: import("vue").Ref<string[]>;
                    treeData: import("vue").Ref<unknown>;
                    indent: import("vue").Ref<number>;
                    lazy: import("vue").Ref<boolean>;
                    lazyTreeNodeMap: import("vue").Ref<{}>;
                    lazyColumnIdentifier: import("vue").Ref<string>;
                    childrenColumnName: import("vue").Ref<string>;
                    expandRows: import("vue").Ref<any[]>;
                    defaultExpandAll: import("vue").Ref<boolean>;
                    rowKey: import("vue").Ref<string>;
                    data: import("vue").Ref<any[]>;
                    _data: import("vue").Ref<any[]>;
                    isComplex: import("vue").Ref<boolean>;
                    _columns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    originColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    columns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    fixedColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    rightFixedColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    leafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    fixedLeafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    rightFixedLeafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    leafColumnsLength: import("vue").Ref<number>;
                    fixedLeafColumnsLength: import("vue").Ref<number>;
                    rightFixedLeafColumnsLength: import("vue").Ref<number>;
                    isAllSelected: import("vue").Ref<boolean>;
                    selection: import("vue").Ref<any[]>;
                    reserveSelection: import("vue").Ref<boolean>;
                    selectOnIndeterminate: import("vue").Ref<boolean>;
                    selectable: import("vue").Ref<(row: any, index: number) => boolean>;
                    filters: import("vue").Ref<import("element-plus/lib/el-table/src/store").StoreFilter>;
                    filteredData: any;
                    sortingColumn: any;
                    sortProp: any;
                    sortOrder: any;
                    hoverRow: any;
                }, data: any[]): void;
                insertColumn(states: {
                    _currentRowKey: import("vue").Ref<string>;
                    currentRow: import("vue").Ref<any>;
                    expandRowKeys: import("vue").Ref<string[]>;
                    treeData: import("vue").Ref<unknown>;
                    indent: import("vue").Ref<number>;
                    lazy: import("vue").Ref<boolean>;
                    lazyTreeNodeMap: import("vue").Ref<{}>;
                    lazyColumnIdentifier: import("vue").Ref<string>;
                    childrenColumnName: import("vue").Ref<string>;
                    expandRows: import("vue").Ref<any[]>;
                    defaultExpandAll: import("vue").Ref<boolean>;
                    rowKey: import("vue").Ref<string>;
                    data: import("vue").Ref<any[]>;
                    _data: import("vue").Ref<any[]>;
                    isComplex: import("vue").Ref<boolean>;
                    _columns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    originColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    columns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    fixedColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    rightFixedColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    leafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    fixedLeafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    rightFixedLeafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    leafColumnsLength: import("vue").Ref<number>;
                    fixedLeafColumnsLength: import("vue").Ref<number>;
                    rightFixedLeafColumnsLength: import("vue").Ref<number>;
                    isAllSelected: import("vue").Ref<boolean>;
                    selection: import("vue").Ref<any[]>;
                    reserveSelection: import("vue").Ref<boolean>;
                    selectOnIndeterminate: import("vue").Ref<boolean>;
                    selectable: import("vue").Ref<(row: any, index: number) => boolean>;
                    filters: import("vue").Ref<import("element-plus/lib/el-table/src/store").StoreFilter>;
                    filteredData: any;
                    sortingColumn: any;
                    sortProp: any;
                    sortOrder: any;
                    hoverRow: any;
                }, column: import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>, parent: import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>): void;
                removeColumn(states: {
                    _currentRowKey: import("vue").Ref<string>;
                    currentRow: import("vue").Ref<any>;
                    expandRowKeys: import("vue").Ref<string[]>;
                    treeData: import("vue").Ref<unknown>;
                    indent: import("vue").Ref<number>;
                    lazy: import("vue").Ref<boolean>;
                    lazyTreeNodeMap: import("vue").Ref<{}>;
                    lazyColumnIdentifier: import("vue").Ref<string>;
                    childrenColumnName: import("vue").Ref<string>;
                    expandRows: import("vue").Ref<any[]>;
                    defaultExpandAll: import("vue").Ref<boolean>;
                    rowKey: import("vue").Ref<string>;
                    data: import("vue").Ref<any[]>;
                    _data: import("vue").Ref<any[]>;
                    isComplex: import("vue").Ref<boolean>;
                    _columns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    originColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    columns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    fixedColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    rightFixedColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    leafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    fixedLeafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    rightFixedLeafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    leafColumnsLength: import("vue").Ref<number>;
                    fixedLeafColumnsLength: import("vue").Ref<number>;
                    rightFixedLeafColumnsLength: import("vue").Ref<number>;
                    isAllSelected: import("vue").Ref<boolean>;
                    selection: import("vue").Ref<any[]>;
                    reserveSelection: import("vue").Ref<boolean>;
                    selectOnIndeterminate: import("vue").Ref<boolean>;
                    selectable: import("vue").Ref<(row: any, index: number) => boolean>;
                    filters: import("vue").Ref<import("element-plus/lib/el-table/src/store").StoreFilter>;
                    filteredData: any;
                    sortingColumn: any;
                    sortProp: any;
                    sortOrder: any;
                    hoverRow: any;
                }, column: import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>, parent: import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>): void;
                sort(states: {
                    _currentRowKey: import("vue").Ref<string>;
                    currentRow: import("vue").Ref<any>;
                    expandRowKeys: import("vue").Ref<string[]>;
                    treeData: import("vue").Ref<unknown>;
                    indent: import("vue").Ref<number>;
                    lazy: import("vue").Ref<boolean>;
                    lazyTreeNodeMap: import("vue").Ref<{}>;
                    lazyColumnIdentifier: import("vue").Ref<string>;
                    childrenColumnName: import("vue").Ref<string>;
                    expandRows: import("vue").Ref<any[]>;
                    defaultExpandAll: import("vue").Ref<boolean>;
                    rowKey: import("vue").Ref<string>;
                    data: import("vue").Ref<any[]>;
                    _data: import("vue").Ref<any[]>;
                    isComplex: import("vue").Ref<boolean>;
                    _columns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    originColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    columns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    fixedColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    rightFixedColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    leafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    fixedLeafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    rightFixedLeafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    leafColumnsLength: import("vue").Ref<number>;
                    fixedLeafColumnsLength: import("vue").Ref<number>;
                    rightFixedLeafColumnsLength: import("vue").Ref<number>;
                    isAllSelected: import("vue").Ref<boolean>;
                    selection: import("vue").Ref<any[]>;
                    reserveSelection: import("vue").Ref<boolean>;
                    selectOnIndeterminate: import("vue").Ref<boolean>;
                    selectable: import("vue").Ref<(row: any, index: number) => boolean>;
                    filters: import("vue").Ref<import("element-plus/lib/el-table/src/store").StoreFilter>;
                    filteredData: any;
                    sortingColumn: any;
                    sortProp: any;
                    sortOrder: any;
                    hoverRow: any;
                }, options: import("element-plus/lib/el-table/src/table/defaults").Sort): void;
                changeSortCondition(states: {
                    _currentRowKey: import("vue").Ref<string>;
                    currentRow: import("vue").Ref<any>;
                    expandRowKeys: import("vue").Ref<string[]>;
                    treeData: import("vue").Ref<unknown>;
                    indent: import("vue").Ref<number>;
                    lazy: import("vue").Ref<boolean>;
                    lazyTreeNodeMap: import("vue").Ref<{}>;
                    lazyColumnIdentifier: import("vue").Ref<string>;
                    childrenColumnName: import("vue").Ref<string>;
                    expandRows: import("vue").Ref<any[]>;
                    defaultExpandAll: import("vue").Ref<boolean>;
                    rowKey: import("vue").Ref<string>;
                    data: import("vue").Ref<any[]>;
                    _data: import("vue").Ref<any[]>;
                    isComplex: import("vue").Ref<boolean>;
                    _columns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    originColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    columns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    fixedColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    rightFixedColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    leafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    fixedLeafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    rightFixedLeafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    leafColumnsLength: import("vue").Ref<number>;
                    fixedLeafColumnsLength: import("vue").Ref<number>;
                    rightFixedLeafColumnsLength: import("vue").Ref<number>;
                    isAllSelected: import("vue").Ref<boolean>;
                    selection: import("vue").Ref<any[]>;
                    reserveSelection: import("vue").Ref<boolean>;
                    selectOnIndeterminate: import("vue").Ref<boolean>;
                    selectable: import("vue").Ref<(row: any, index: number) => boolean>;
                    filters: import("vue").Ref<import("element-plus/lib/el-table/src/store").StoreFilter>;
                    filteredData: any;
                    sortingColumn: any;
                    sortProp: any;
                    sortOrder: any;
                    hoverRow: any;
                }, options: import("element-plus/lib/el-table/src/table/defaults").Sort): void;
                filterChange(_states: {
                    _currentRowKey: import("vue").Ref<string>;
                    currentRow: import("vue").Ref<any>;
                    expandRowKeys: import("vue").Ref<string[]>;
                    treeData: import("vue").Ref<unknown>;
                    indent: import("vue").Ref<number>;
                    lazy: import("vue").Ref<boolean>;
                    lazyTreeNodeMap: import("vue").Ref<{}>;
                    lazyColumnIdentifier: import("vue").Ref<string>;
                    childrenColumnName: import("vue").Ref<string>;
                    expandRows: import("vue").Ref<any[]>;
                    defaultExpandAll: import("vue").Ref<boolean>;
                    rowKey: import("vue").Ref<string>;
                    data: import("vue").Ref<any[]>;
                    _data: import("vue").Ref<any[]>;
                    isComplex: import("vue").Ref<boolean>;
                    _columns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    originColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    columns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    fixedColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    rightFixedColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    leafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    fixedLeafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    rightFixedLeafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    leafColumnsLength: import("vue").Ref<number>;
                    fixedLeafColumnsLength: import("vue").Ref<number>;
                    rightFixedLeafColumnsLength: import("vue").Ref<number>;
                    isAllSelected: import("vue").Ref<boolean>;
                    selection: import("vue").Ref<any[]>;
                    reserveSelection: import("vue").Ref<boolean>;
                    selectOnIndeterminate: import("vue").Ref<boolean>;
                    selectable: import("vue").Ref<(row: any, index: number) => boolean>;
                    filters: import("vue").Ref<import("element-plus/lib/el-table/src/store").StoreFilter>;
                    filteredData: any;
                    sortingColumn: any;
                    sortProp: any;
                    sortOrder: any;
                    hoverRow: any;
                }, options: import("element-plus/lib/el-table/src/table/defaults").Filter<any>): void;
                toggleAllSelection(): void;
                rowSelectedChanged(_states: any, row: any): void;
                setHoverRow(states: {
                    _currentRowKey: import("vue").Ref<string>;
                    currentRow: import("vue").Ref<any>;
                    expandRowKeys: import("vue").Ref<string[]>;
                    treeData: import("vue").Ref<unknown>;
                    indent: import("vue").Ref<number>;
                    lazy: import("vue").Ref<boolean>;
                    lazyTreeNodeMap: import("vue").Ref<{}>;
                    lazyColumnIdentifier: import("vue").Ref<string>;
                    childrenColumnName: import("vue").Ref<string>;
                    expandRows: import("vue").Ref<any[]>;
                    defaultExpandAll: import("vue").Ref<boolean>;
                    rowKey: import("vue").Ref<string>;
                    data: import("vue").Ref<any[]>;
                    _data: import("vue").Ref<any[]>;
                    isComplex: import("vue").Ref<boolean>;
                    _columns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    originColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    columns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    fixedColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    rightFixedColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    leafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    fixedLeafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    rightFixedLeafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                    leafColumnsLength: import("vue").Ref<number>;
                    fixedLeafColumnsLength: import("vue").Ref<number>;
                    rightFixedLeafColumnsLength: import("vue").Ref<number>;
                    isAllSelected: import("vue").Ref<boolean>;
                    selection: import("vue").Ref<any[]>;
                    reserveSelection: import("vue").Ref<boolean>;
                    selectOnIndeterminate: import("vue").Ref<boolean>;
                    selectable: import("vue").Ref<(row: any, index: number) => boolean>;
                    filters: import("vue").Ref<import("element-plus/lib/el-table/src/store").StoreFilter>;
                    filteredData: any;
                    sortingColumn: any;
                    sortProp: any;
                    sortOrder: any;
                    hoverRow: any;
                }, row: any): void;
                setCurrentRow(_states: any, row: any): void;
            };
            commit: (name: "setData" | "insertColumn" | "removeColumn" | "sort" | "changeSortCondition" | "filterChange" | "toggleAllSelection" | "rowSelectedChanged" | "setHoverRow" | "setCurrentRow", ...args: any[]) => void;
            updateTableScrollY: () => void;
            assertRowKey: () => void;
            updateColumns: () => void;
            scheduleLayout: (needUpdateColumns?: boolean, immediate?: boolean) => void;
            isSelected: (row: any) => boolean;
            clearSelection: () => void;
            cleanSelection: () => void;
            toggleRowSelection: (row: any, selected?: any, emitChange?: boolean) => void;
            _toggleAllSelection: () => void;
            toggleAllSelection: any;
            updateSelectionByRowKey: () => void;
            updateAllSelected: () => void;
            updateFilters: (columns: any, values: any) => {};
            updateCurrentRow: (_currentRow: any) => void;
            updateSort: (column: any, prop: any, order: any) => void;
            execFilter: () => void;
            execSort: () => void;
            execQuery: (ignore?: any) => void;
            clearFilter: (columnKeys: any) => void;
            clearSort: () => void;
            toggleRowExpansion: (row: any, expanded?: boolean) => void;
            setExpandRowKeysAdapter: (val: string[]) => void;
            setCurrentRowKey: (key: string) => void;
            toggleRowExpansionAdapter: (row: any, expanded: boolean) => void;
            isRowExpanded: (row: any) => boolean;
            updateExpandRows: () => void;
            updateCurrentRowData: () => void;
            loadOrToggle: (row: any) => void;
            states: {
                _currentRowKey: import("vue").Ref<string>;
                currentRow: import("vue").Ref<any>;
                expandRowKeys: import("vue").Ref<string[]>;
                treeData: import("vue").Ref<unknown>;
                indent: import("vue").Ref<number>;
                lazy: import("vue").Ref<boolean>;
                lazyTreeNodeMap: import("vue").Ref<{}>;
                lazyColumnIdentifier: import("vue").Ref<string>;
                childrenColumnName: import("vue").Ref<string>;
                expandRows: import("vue").Ref<any[]>;
                defaultExpandAll: import("vue").Ref<boolean>;
                rowKey: import("vue").Ref<string>;
                data: import("vue").Ref<any[]>;
                _data: import("vue").Ref<any[]>;
                isComplex: import("vue").Ref<boolean>;
                _columns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                originColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                columns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                fixedColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                rightFixedColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                leafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                fixedLeafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                rightFixedLeafColumns: import("vue").Ref<import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>[]>;
                leafColumnsLength: import("vue").Ref<number>;
                fixedLeafColumnsLength: import("vue").Ref<number>;
                rightFixedLeafColumnsLength: import("vue").Ref<number>;
                isAllSelected: import("vue").Ref<boolean>;
                selection: import("vue").Ref<any[]>;
                reserveSelection: import("vue").Ref<boolean>;
                selectOnIndeterminate: import("vue").Ref<boolean>;
                selectable: import("vue").Ref<(row: any, index: number) => boolean>;
                filters: import("vue").Ref<import("element-plus/lib/el-table/src/store").StoreFilter>;
                filteredData: any;
                sortingColumn: any;
                sortProp: any;
                sortOrder: any;
                hoverRow: any;
            };
        };
        handleHeaderFooterMousewheel: (event: any, data: any) => void;
        handleMouseLeave: () => void;
        tableId: string;
        tableSize: import("vue").ComputedRef<any>;
        isHidden: import("vue").Ref<boolean>;
        isEmpty: import("vue").ComputedRef<boolean>;
        renderExpanded: any;
        resizeProxyVisible: import("vue").Ref<boolean>;
        resizeState: import("vue").Ref<{
            width: any;
            height: any;
        }>;
        isGroup: import("vue").Ref<boolean>;
        bodyWidth: import("vue").ComputedRef<string>;
        bodyHeight: import("vue").ComputedRef<{
            height: string;
            'max-height'?: undefined;
        } | {
            'max-height': string;
            height?: undefined;
        } | {
            height?: undefined;
            'max-height'?: undefined;
        }>;
        emptyBlockStyle: import("vue").ComputedRef<{
            width: string;
            height: string;
        }>;
        debouncedUpdateLayout: import("lodash").DebouncedFunc<() => void>;
        handleFixedMousewheel: (event: any, data: any) => void;
        fixedHeight: import("vue").ComputedRef<{
            bottom: number;
            height?: undefined;
        } | {
            bottom: string;
            height?: undefined;
        } | {
            height: string;
            bottom?: undefined;
        }>;
        fixedBodyHeight: import("vue").ComputedRef<{
            height: string;
            'max-height'?: undefined;
        } | {
            'max-height': string;
            height?: undefined;
        } | {
            height?: undefined;
            'max-height'?: undefined;
        }>;
        setCurrentRow: (row: any) => void;
        toggleRowSelection: (row: any, selected: boolean) => void;
        clearSelection: () => void;
        clearFilter: (columnKeys: string[]) => void;
        toggleAllSelection: () => void;
        toggleRowExpansion: (row: any, expanded: boolean) => void;
        clearSort: () => void;
        doLayout: () => void;
        sort: (prop: string, order: string) => void;
        t: (...args: any[]) => string;
        setDragVisible: (visible: boolean) => void;
        context: import("element-plus/lib/el-table/src/table/defaults").Table<any>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("current-change" | "select" | "select-all" | "selection-change" | "cell-mouse-enter" | "cell-mouse-leave" | "cell-contextmenu" | "cell-click" | "cell-dblclick" | "row-click" | "row-contextmenu" | "row-dblclick" | "header-click" | "header-contextmenu" | "sort-change" | "filter-change" | "header-dragend" | "expand-change")[], "current-change" | "select" | "select-all" | "selection-change" | "cell-mouse-enter" | "cell-mouse-leave" | "cell-contextmenu" | "cell-click" | "cell-dblclick" | "row-click" | "row-contextmenu" | "row-dblclick" | "header-click" | "header-contextmenu" | "sort-change" | "filter-change" | "header-dragend" | "expand-change", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        border: boolean;
        stripe: boolean;
        treeProps: {
            hasChildren: string;
            children: string;
        };
        data: any[];
        fit: boolean;
        showHeader: boolean;
        showSummary: boolean;
        highlightCurrentRow: boolean;
        defaultExpandAll: boolean;
        selectOnIndeterminate: boolean;
        indent: number;
        lazy: boolean;
        style: {};
        className: string;
    } & {
        defaultSort?: import("element-plus/lib/el-table/src/table/defaults").Sort;
        height?: string | number;
        rowClassName?: import("element-plus/lib/el-table/src/table/defaults").ColumnCls<any>;
        rowStyle?: unknown;
        tooltipEffect?: string;
        summaryMethod?: import("element-plus/lib/el-table/src/table/defaults").SummaryMethod<any>;
        sumText?: string;
        rowKey?: string | ((row: any) => string);
        cellClassName?: string | ((data: {
            row: any;
            rowIndex: number;
            column: import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>;
            columnIndex: number;
        }) => string);
        cellStyle?: unknown;
        headerRowClassName?: import("element-plus/lib/el-table/src/table/defaults").ColumnCls<any>;
        headerRowStyle?: unknown;
        headerCellClassName?: string | ((data: {
            row: any;
            rowIndex: number;
            column: import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>;
            columnIndex: number;
        }) => string);
        headerCellStyle?: unknown;
        expandRowKeys?: any[];
        spanMethod?: (data: {
            row: any;
            rowIndex: number;
            column: import("element-plus/lib/el-table/src/table-column/defaults").TableColumnCtx<any>;
            columnIndex: number;
        }) => number[] | {
            rowspan: number;
            colspan: number;
        };
        load?: (row: any, treeNode: import("element-plus/lib/el-table/src/table/defaults").TreeNode, resolve: (data: any[]) => void) => void;
        size?: string;
        width?: string | number;
        maxHeight?: string | number;
        currentRowKey?: string | number;
        emptyText?: string;
    }>, {
        border: boolean;
        stripe: boolean;
        treeProps: {
            hasChildren: string;
            children: string;
        };
        data: any[];
        fit: boolean;
        showHeader: boolean;
        showSummary: boolean;
        highlightCurrentRow: boolean;
        defaultExpandAll: boolean;
        selectOnIndeterminate: boolean;
        indent: number;
        lazy: boolean;
        style: {};
        className: string;
    }>>;
    ElTableColumn: any;
    ElTabs: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        type: {
            type: import("vue").PropType<import("element-plus/lib/el-tabs/src/tabs.vue").ITabType>;
            default: string;
        };
        activeName: {
            type: StringConstructor;
            default: string;
        };
        closable: BooleanConstructor;
        addable: BooleanConstructor;
        modelValue: {
            type: StringConstructor;
            default: string;
        };
        editable: BooleanConstructor;
        tabPosition: {
            type: import("vue").PropType<"top" | "right" | "bottom" | "left">;
            default: string;
        };
        beforeLeave: {
            type: import("vue").PropType<(newTabName: string, oldTabName: string) => boolean | void | Promise<void>>;
            default: any;
        };
        stretch: BooleanConstructor;
    }, {
        nav$: import("vue").Ref<import("vue").DefineComponent<{
            panes: {
                type: import("vue").PropType<import("element-plus/lib/el-tabs/src/tabs.vue").Pane[]>;
                default: () => import("element-plus/lib/el-tabs/src/tabs.vue").Pane[];
            };
            currentName: {
                type: StringConstructor;
                default: string;
            };
            editable: BooleanConstructor;
            onTabClick: {
                type: import("vue").PropType<(tab: import("element-plus/lib/el-tabs/src/tabs.vue").Pane, tabName: string, ev: Event) => void>;
                default: () => void;
            };
            onTabRemove: {
                type: import("vue").PropType<(tab: import("element-plus/lib/el-tabs/src/tabs.vue").Pane, ev: Event) => void>;
                default: () => void;
            };
            type: {
                type: import("vue").PropType<import("element-plus/lib/el-tabs/src/tabs.vue").ITabType>;
                default: string;
            };
            stretch: BooleanConstructor;
        }, {
            rootTabs: import("element-plus/lib/el-tabs/src/tabs.vue").RootTabs;
            scrollable: import("vue").Ref<boolean | {
                next?: boolean;
                prev?: number;
            }>;
            navOffset: import("vue").Ref<number>;
            isFocus: import("vue").Ref<boolean>;
            focusable: import("vue").Ref<boolean>;
            navScroll$: import("vue").Ref<HTMLElement>;
            nav$: import("vue").Ref<HTMLElement>;
            el$: import("vue").Ref<HTMLElement>;
            sizeName: import("vue").ComputedRef<"width" | "height">;
            navStyle: import("vue").ComputedRef<{
                transform: string;
            }>;
            scrollPrev: () => void;
            scrollNext: () => void;
            scrollToActiveTab: () => void;
            update: () => void;
            changeTab: (e: any) => void;
            setFocus: () => void;
            removeFocus: () => void;
            visibilityChangeHandler: () => void;
            windowBlurHandler: () => void;
            windowFocusHandler: () => void;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
            panes: import("element-plus/lib/el-tabs/src/tabs.vue").Pane[];
            currentName: string;
            editable: boolean;
            onTabClick: (tab: import("element-plus/lib/el-tabs/src/tabs.vue").Pane, tabName: string, ev: Event) => void;
            onTabRemove: (tab: import("element-plus/lib/el-tabs/src/tabs.vue").Pane, ev: Event) => void;
            type: import("element-plus/lib/el-tabs/src/tabs.vue").ITabType;
            stretch: boolean;
        }>, {
            panes: import("element-plus/lib/el-tabs/src/tabs.vue").Pane[];
            currentName: string;
            editable: boolean;
            onTabClick: (tab: import("element-plus/lib/el-tabs/src/tabs.vue").Pane, tabName: string, ev: Event) => void;
            onTabRemove: (tab: import("element-plus/lib/el-tabs/src/tabs.vue").Pane, ev: Event) => void;
            type: import("element-plus/lib/el-tabs/src/tabs.vue").ITabType;
            stretch: boolean;
        }>>;
        handleTabClick: (tab: any, tabName: any, event: any) => void;
        handleTabRemove: (pane: any, ev: any) => void;
        handleTabAdd: () => void;
        currentName: import("vue").Ref<string>;
        panes: import("vue").Ref<any[]>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "input" | "tab-click" | "edit" | "tab-remove" | "tab-add")[], "update:modelValue" | "input" | "tab-click" | "edit" | "tab-remove" | "tab-add", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        editable: boolean;
        type: import("element-plus/lib/el-tabs/src/tabs.vue").ITabType;
        stretch: boolean;
        activeName: string;
        closable: boolean;
        addable: boolean;
        modelValue: string;
        tabPosition: "top" | "right" | "bottom" | "left";
    } & {
        beforeLeave?: (newTabName: string, oldTabName: string) => boolean | void | Promise<void>;
    }>, {
        editable: boolean;
        type: import("element-plus/lib/el-tabs/src/tabs.vue").ITabType;
        stretch: boolean;
        activeName: string;
        closable: boolean;
        addable: boolean;
        modelValue: string;
        tabPosition: "top" | "right" | "bottom" | "left";
        beforeLeave: (newTabName: string, oldTabName: string) => boolean | void | Promise<void>;
    }>>;
    ElTabPane: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{}, {}, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}> & {
        [x: string & `on${string}`]: never;
    }, {}>>;
    ElScrollbar: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        height: {
            type: (NumberConstructor | StringConstructor)[];
            default: string;
        };
        maxHeight: {
            type: (NumberConstructor | StringConstructor)[];
            default: string;
        };
        native: {
            type: BooleanConstructor;
            default: boolean;
        };
        wrapStyle: {
            type: import("vue").PropType<string | import("vue").CSSProperties[]>;
            default: string;
        };
        wrapClass: {
            type: (StringConstructor | ArrayConstructor)[];
            default: string;
        };
        viewClass: {
            type: (StringConstructor | ArrayConstructor)[];
            default: string;
        };
        viewStyle: {
            type: (StringConstructor | ArrayConstructor)[];
            default: string;
        };
        noresize: BooleanConstructor;
        tag: {
            type: StringConstructor;
            default: string;
        };
        always: {
            type: BooleanConstructor;
            default: boolean;
        };
        minSize: {
            type: NumberConstructor;
            default: number;
        };
    }, {
        moveX: import("vue").Ref<number>;
        moveY: import("vue").Ref<number>;
        ratioX: import("vue").Ref<number>;
        ratioY: import("vue").Ref<number>;
        sizeWidth: import("vue").Ref<string>;
        sizeHeight: import("vue").Ref<string>;
        style: import("vue").ComputedRef<string | import("vue").CSSProperties[]>;
        scrollbar: any;
        wrap: any;
        resize: any;
        update: () => void;
        handleScroll: () => void;
        setScrollTop: (value: number) => void;
        setScrollLeft: (value: number) => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "scroll"[], "scroll", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        always: boolean;
        height: string | number;
        maxHeight: string | number;
        native: boolean;
        wrapStyle: string | import("vue").CSSProperties[];
        wrapClass: string | unknown[];
        viewClass: string | unknown[];
        viewStyle: string | unknown[];
        noresize: boolean;
        tag: string;
        minSize: number;
    }>, {
        always: boolean;
        height: string | number;
        maxHeight: string | number;
        native: boolean;
        wrapStyle: string | import("vue").CSSProperties[];
        wrapClass: string | unknown[];
        viewClass: string | unknown[];
        viewStyle: string | unknown[];
        noresize: boolean;
        tag: string;
        minSize: number;
    }>>;
    ElMenu: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{
        mode: {
            type: StringConstructor;
            default: string;
        };
        defaultActive: {
            type: StringConstructor;
            default: string;
        };
        defaultOpeneds: ArrayConstructor;
        uniqueOpened: BooleanConstructor;
        router: BooleanConstructor;
        menuTrigger: {
            type: StringConstructor;
            default: string;
        };
        collapse: BooleanConstructor;
        backgroundColor: {
            type: StringConstructor;
        };
        textColor: {
            type: StringConstructor;
        };
        activeTextColor: {
            type: StringConstructor;
        };
        collapseTransition: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, {
        hoverBackground: import("vue").ComputedRef<string>;
        isMenuPopup: import("vue").ComputedRef<boolean>;
        props: import("element-plus/lib/el-menu/src/menu").IMenuProps;
        open: (index: any) => void;
        close: (index: any) => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("open" | "close" | "select")[], "open" | "close" | "select", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        mode: string;
        defaultActive: string;
        uniqueOpened: boolean;
        router: boolean;
        menuTrigger: string;
        collapse: boolean;
        collapseTransition: boolean;
    } & {
        defaultOpeneds?: unknown[];
        backgroundColor?: string;
        textColor?: string;
        activeTextColor?: string;
    }>, {
        mode: string;
        defaultActive: string;
        uniqueOpened: boolean;
        router: boolean;
        menuTrigger: string;
        collapse: boolean;
        collapseTransition: boolean;
    }>>;
    ElSubmenu: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{}, {}, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}> & {
        [x: string & `on${string}`]: never;
    }, {}>>;
    ElMenuItem: import("element-plus/lib/utils/types").SFCWithInstall<import("vue").DefineComponent<{}, {}, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}> & {
        [x: string & `on${string}`]: never;
    }, {}>>;
    install: (app: any) => void;
};
export default _default;