import type { App } from 'vue';
import type { ArcoOptions } from '../_utils/types';
import _Transfer from './transfer';
declare const Transfer: {
    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        data: {
            type: import("vue").PropType<import("./interface").TransferItem[]>;
            default: () => never[];
        };
        modelValue: {
            type: import("vue").PropType<string[]>;
            default: undefined;
        };
        defaultValue: {
            type: import("vue").PropType<string[]>;
            default: () => never[];
        };
        selected: {
            type: import("vue").PropType<string[]>;
            default: undefined;
        };
        defaultSelected: {
            type: import("vue").PropType<string[]>;
            default: () => never[];
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        simple: {
            type: BooleanConstructor;
            default: boolean;
        };
        oneWay: {
            type: BooleanConstructor;
            default: boolean;
        };
        showSearch: {
            type: BooleanConstructor;
            default: boolean;
        };
        showSelectAll: {
            type: BooleanConstructor;
            default: boolean;
        };
        title: {
            type: import("vue").PropType<string[]>;
            default: () => string[];
        };
        sourceInputSearchProps: {
            type: ObjectConstructor;
        };
        targetInputSearchProps: {
            type: ObjectConstructor;
        };
    }>> & Readonly<{
        onChange?: ((value: string[]) => any) | undefined;
        "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
        onSelect?: ((selected: string[]) => any) | undefined;
        onSearch?: ((value: string, type: "source" | "target") => any) | undefined;
        "onUpdate:selected"?: ((selected: string[]) => any) | undefined;
    }>, {
        prefixCls: string;
        cls: import("vue").ComputedRef<(string | {
            [x: string]: boolean;
        })[]>;
        dataInfo: import("vue").ComputedRef<{
            sourceInfo: import("./interface").DataInfo;
            targetInfo: import("./interface").DataInfo;
        }>;
        computedSelected: import("vue").ComputedRef<string[]>;
        mergedDisabled: import("vue").ComputedRef<boolean>;
        sourceTitle: import("vue").ComputedRef<string>;
        targetTitle: import("vue").ComputedRef<string>;
        handleClick: (target: "source" | "target") => void;
        handleSearch: (value: string, type: "source" | "target") => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        'update:modelValue': (value: string[]) => true;
        'update:selected': (selected: string[]) => true;
        change: (value: string[]) => true;
        select: (selected: string[]) => true;
        search: (value: string, type: "source" | "target") => true;
    }, import("vue").PublicProps, {
        disabled: boolean;
        defaultValue: string[];
        modelValue: string[];
        data: import("./interface").TransferItem[];
        title: string[];
        simple: boolean;
        selected: string[];
        showSearch: boolean;
        showSelectAll: boolean;
        defaultSelected: string[];
        oneWay: boolean;
    }, true, {}, {}, {
        ArcoButton: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                type: {
                    type: import("vue").PropType<"text" | "dashed" | "outline" | "primary" | "secondary">;
                };
                shape: {
                    type: import("vue").PropType<"circle" | "round" | "square">;
                };
                status: {
                    type: import("vue").PropType<"normal" | "success" | "warning" | "danger">;
                };
                size: {
                    type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                };
                long: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                };
                htmlType: {
                    type: import("vue").PropType<string>;
                    default: string;
                };
                autofocus: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                href: StringConstructor;
            }>> & Readonly<{
                onClick?: ((ev: MouseEvent) => any) | undefined;
            }>, {
                prefixCls: string;
                cls: import("vue").ComputedRef<(string | {
                    [x: string]: boolean;
                })[]>;
                mergedDisabled: import("vue").ComputedRef<boolean>;
                handleClick: (ev: MouseEvent) => void;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                click: (ev: MouseEvent) => true;
            }, import("vue").PublicProps, {
                disabled: boolean;
                autofocus: boolean;
                loading: boolean;
                long: boolean;
                htmlType: string;
            }, true, {}, {}, {
                IconLoading: any;
            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("vue").ExtractPropTypes<{
                type: {
                    type: import("vue").PropType<"text" | "dashed" | "outline" | "primary" | "secondary">;
                };
                shape: {
                    type: import("vue").PropType<"circle" | "round" | "square">;
                };
                status: {
                    type: import("vue").PropType<"normal" | "success" | "warning" | "danger">;
                };
                size: {
                    type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                };
                long: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                };
                htmlType: {
                    type: import("vue").PropType<string>;
                    default: string;
                };
                autofocus: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                href: StringConstructor;
            }>> & Readonly<{
                onClick?: ((ev: MouseEvent) => any) | undefined;
            }>, {
                prefixCls: string;
                cls: import("vue").ComputedRef<(string | {
                    [x: string]: boolean;
                })[]>;
                mergedDisabled: import("vue").ComputedRef<boolean>;
                handleClick: (ev: MouseEvent) => void;
            }, {}, {}, {}, {
                disabled: boolean;
                autofocus: boolean;
                loading: boolean;
                long: boolean;
                htmlType: string;
            }>;
            __isFragment?: undefined;
            __isTeleport?: undefined;
            __isSuspense?: undefined;
        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            type: {
                type: import("vue").PropType<"text" | "dashed" | "outline" | "primary" | "secondary">;
            };
            shape: {
                type: import("vue").PropType<"circle" | "round" | "square">;
            };
            status: {
                type: import("vue").PropType<"normal" | "success" | "warning" | "danger">;
            };
            size: {
                type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
            };
            long: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
            };
            htmlType: {
                type: import("vue").PropType<string>;
                default: string;
            };
            autofocus: {
                type: BooleanConstructor;
                default: boolean;
            };
            href: StringConstructor;
        }>> & Readonly<{
            onClick?: ((ev: MouseEvent) => any) | undefined;
        }>, {
            prefixCls: string;
            cls: import("vue").ComputedRef<(string | {
                [x: string]: boolean;
            })[]>;
            mergedDisabled: import("vue").ComputedRef<boolean>;
            handleClick: (ev: MouseEvent) => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            click: (ev: MouseEvent) => true;
        }, string, {
            disabled: boolean;
            autofocus: boolean;
            loading: boolean;
            long: boolean;
            htmlType: string;
        }, {}, string, {}, {
            IconLoading: any;
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
            Group: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                type: {
                    type: import("vue").PropType<"text" | "dashed" | "outline" | "primary" | "secondary">;
                };
                status: {
                    type: import("vue").PropType<"normal" | "success" | "warning" | "danger">;
                };
                shape: {
                    type: import("vue").PropType<"circle" | "round" | "square">;
                };
                size: {
                    type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                };
                disabled: {
                    type: BooleanConstructor;
                };
            }>, {
                prefixCls: string;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                type: {
                    type: import("vue").PropType<"text" | "dashed" | "outline" | "primary" | "secondary">;
                };
                status: {
                    type: import("vue").PropType<"normal" | "success" | "warning" | "danger">;
                };
                shape: {
                    type: import("vue").PropType<"circle" | "round" | "square">;
                };
                size: {
                    type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                };
                disabled: {
                    type: BooleanConstructor;
                };
            }>> & Readonly<{}>, {
                disabled: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            install: (app: App<any>, options?: ArcoOptions | undefined) => void;
        };
        TransferView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            type: {
                type: import("vue").PropType<"source" | "target">;
            };
            dataInfo: {
                type: import("vue").PropType<import("./interface").DataInfo>;
                required: true;
            };
            title: StringConstructor;
            data: {
                type: import("vue").PropType<import("./interface").TransferItem[]>;
                required: true;
            };
            disabled: BooleanConstructor;
            allowClear: BooleanConstructor;
            selected: {
                type: import("vue").PropType<string[]>;
                required: true;
            };
            showSearch: BooleanConstructor;
            showSelectAll: BooleanConstructor;
            simple: BooleanConstructor;
            inputSearchProps: {
                type: ObjectConstructor;
            };
        }>, {
            prefixCls: string;
            filteredData: import("vue").ComputedRef<import("./interface").TransferItem[]>;
            filter: import("vue").Ref<string, string>;
            checked: import("vue").ComputedRef<boolean>;
            indeterminate: import("vue").ComputedRef<boolean>;
            countSelected: import("vue").ComputedRef<number>;
            countRendered: import("vue").ComputedRef<number>;
            handleSelectAllChange: (checked: boolean) => void;
            handleSearch: (value: string) => void;
            handleClear: () => void;
            transferCtx: import("./context").TransferContext | undefined;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "search"[], "search", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            type: {
                type: import("vue").PropType<"source" | "target">;
            };
            dataInfo: {
                type: import("vue").PropType<import("./interface").DataInfo>;
                required: true;
            };
            title: StringConstructor;
            data: {
                type: import("vue").PropType<import("./interface").TransferItem[]>;
                required: true;
            };
            disabled: BooleanConstructor;
            allowClear: BooleanConstructor;
            selected: {
                type: import("vue").PropType<string[]>;
                required: true;
            };
            showSearch: BooleanConstructor;
            showSelectAll: BooleanConstructor;
            simple: BooleanConstructor;
            inputSearchProps: {
                type: ObjectConstructor;
            };
        }>> & Readonly<{
            onSearch?: ((...args: any[]) => any) | undefined;
        }>, {
            disabled: boolean;
            allowClear: boolean;
            simple: boolean;
            showSearch: boolean;
            showSelectAll: boolean;
        }, {}, {
            Empty: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                description: StringConstructor;
                imgSrc: StringConstructor;
                inConfigProvider: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                [key: string]: any;
            }>[] | import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                description: StringConstructor;
                imgSrc: StringConstructor;
                inConfigProvider: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{}>, {
                inConfigProvider: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            Checkbox: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                    modelValue: {
                        type: import("vue").PropType<boolean | (string | number | boolean)[]>;
                        default: undefined;
                    };
                    defaultChecked: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    value: {
                        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    indeterminate: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    uninjectGroupContext: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & Readonly<{
                    onChange?: ((value: boolean | (string | number | boolean)[], ev: Event) => any) | undefined;
                    "onUpdate:modelValue"?: ((value: boolean | (string | number | boolean)[]) => any) | undefined;
                }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                    'update:modelValue': (value: boolean | (string | number | boolean)[]) => true;
                    change: (value: boolean | (string | number | boolean)[], ev: Event) => true;
                }, import("vue").PublicProps, {
                    disabled: boolean;
                    modelValue: boolean | (string | number | boolean)[];
                    defaultChecked: boolean;
                    indeterminate: boolean;
                    uninjectGroupContext: boolean;
                }, true, {}, {}, {
                    IconCheck: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    IconHover: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        prefix: {
                            type: StringConstructor;
                        };
                        size: {
                            type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                            default: string;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>, {
                        prefixCls: string;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        prefix: {
                            type: StringConstructor;
                        };
                        size: {
                            type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                            default: string;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>> & Readonly<{}>, {
                        size: "mini" | "small" | "medium" | "large";
                        disabled: boolean;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("vue").ExtractPropTypes<{
                    modelValue: {
                        type: import("vue").PropType<boolean | (string | number | boolean)[]>;
                        default: undefined;
                    };
                    defaultChecked: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    value: {
                        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    indeterminate: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    uninjectGroupContext: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & Readonly<{
                    onChange?: ((value: boolean | (string | number | boolean)[], ev: Event) => any) | undefined;
                    "onUpdate:modelValue"?: ((value: boolean | (string | number | boolean)[]) => any) | undefined;
                }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
                    disabled: boolean;
                    modelValue: boolean | (string | number | boolean)[];
                    defaultChecked: boolean;
                    indeterminate: boolean;
                    uninjectGroupContext: boolean;
                }>;
                __isFragment?: undefined;
                __isTeleport?: undefined;
                __isSuspense?: undefined;
            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                modelValue: {
                    type: import("vue").PropType<boolean | (string | number | boolean)[]>;
                    default: undefined;
                };
                defaultChecked: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                value: {
                    type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                indeterminate: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                uninjectGroupContext: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onChange?: ((value: boolean | (string | number | boolean)[], ev: Event) => any) | undefined;
                "onUpdate:modelValue"?: ((value: boolean | (string | number | boolean)[]) => any) | undefined;
            }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                'update:modelValue': (value: boolean | (string | number | boolean)[]) => true;
                change: (value: boolean | (string | number | boolean)[], ev: Event) => true;
            }, string, {
                disabled: boolean;
                modelValue: boolean | (string | number | boolean)[];
                defaultChecked: boolean;
                indeterminate: boolean;
                uninjectGroupContext: boolean;
            }, {}, string, {}, {
                IconCheck: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                IconHover: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    prefix: {
                        type: StringConstructor;
                    };
                    size: {
                        type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                        default: string;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>, {
                    prefixCls: string;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    prefix: {
                        type: StringConstructor;
                    };
                    size: {
                        type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                        default: string;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & Readonly<{}>, {
                    size: "mini" | "small" | "medium" | "large";
                    disabled: boolean;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                Group: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    modelValue: {
                        type: import("vue").PropType<(string | number | boolean)[]>;
                        default: undefined;
                    };
                    defaultValue: {
                        type: import("vue").PropType<(string | number | boolean)[]>;
                        default: () => never[];
                    };
                    max: {
                        type: NumberConstructor;
                    };
                    options: {
                        type: import("vue").PropType<(string | number | import("..").CheckboxOption)[]>;
                    };
                    direction: {
                        type: import("vue").PropType<"horizontal" | "vertical">;
                        default: string;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                    'update:modelValue': (value: (string | number | boolean)[]) => true;
                    change: (value: (string | number | boolean)[], ev: Event) => true;
                }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    modelValue: {
                        type: import("vue").PropType<(string | number | boolean)[]>;
                        default: undefined;
                    };
                    defaultValue: {
                        type: import("vue").PropType<(string | number | boolean)[]>;
                        default: () => never[];
                    };
                    max: {
                        type: NumberConstructor;
                    };
                    options: {
                        type: import("vue").PropType<(string | number | import("..").CheckboxOption)[]>;
                    };
                    direction: {
                        type: import("vue").PropType<"horizontal" | "vertical">;
                        default: string;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & Readonly<{
                    onChange?: ((value: (string | number | boolean)[], ev: Event) => any) | undefined;
                    "onUpdate:modelValue"?: ((value: (string | number | boolean)[]) => any) | undefined;
                }>, {
                    disabled: boolean;
                    defaultValue: (string | number | boolean)[];
                    modelValue: (string | number | boolean)[];
                    direction: "horizontal" | "vertical";
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                install: (app: App<any>, options?: ArcoOptions | undefined) => void;
            };
            IconHover: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                prefix: {
                    type: StringConstructor;
                };
                size: {
                    type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                    default: string;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>, {
                prefixCls: string;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                prefix: {
                    type: StringConstructor;
                };
                size: {
                    type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                    default: string;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{}>, {
                size: "mini" | "small" | "medium" | "large";
                disabled: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            IconDelete: any;
            InputSearch: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                searchButton: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                };
                buttonText: {
                    type: StringConstructor;
                };
                buttonProps: {
                    type: import("vue").PropType<import("..").ButtonProps>;
                };
            }>, {
                inputRef: import("vue").Ref<any, any>;
                render: () => import("vue/jsx-runtime").JSX.Element;
            }, {}, {}, {
                focus(): void;
                blur(): void;
            }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                search: (value: string, ev: MouseEvent) => true;
            }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                searchButton: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                };
                buttonText: {
                    type: StringConstructor;
                };
                buttonProps: {
                    type: import("vue").PropType<import("..").ButtonProps>;
                };
            }>> & Readonly<{
                onSearch?: ((value: string, ev: MouseEvent) => any) | undefined;
            }>, {
                disabled: boolean;
                loading: boolean;
                searchButton: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            List: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                    data: {
                        type: import("vue").PropType<any[]>;
                    };
                    size: {
                        type: import("vue").PropType<"small" | "medium" | "large">;
                        default: string;
                    };
                    bordered: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    split: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    hoverable: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    paginationProps: {
                        type: import("vue").PropType<import("..").PaginationProps>;
                    };
                    gridProps: {
                        type: ObjectConstructor;
                    };
                    maxHeight: {
                        type: import("vue").PropType<string | number>;
                        default: number;
                    };
                    bottomOffset: {
                        type: NumberConstructor;
                        default: number;
                    };
                    virtualListProps: {
                        type: import("vue").PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
                    };
                    scrollbar: {
                        type: import("vue").PropType<boolean | import("..").ScrollbarProps>;
                        default: boolean;
                    };
                }>> & Readonly<{
                    onScroll?: (() => any) | undefined;
                    onReachBottom?: (() => any) | undefined;
                    onPageChange?: ((page: number) => any) | undefined;
                    onPageSizeChange?: ((pageSize: number) => any) | undefined;
                }>, {
                    virtualListRef: import("vue").Ref<any, any>;
                    render: () => import("vue/jsx-runtime").JSX.Element;
                }, {}, {}, {
                    scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
                }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                    scroll: () => true;
                    reachBottom: () => true;
                    pageChange: (page: number) => true;
                    pageSizeChange: (pageSize: number) => true;
                }, import("vue").PublicProps, {
                    size: "small" | "medium" | "large";
                    loading: boolean;
                    bordered: boolean;
                    scrollbar: boolean | import("..").ScrollbarProps;
                    maxHeight: string | number;
                    split: boolean;
                    hoverable: boolean;
                    bottomOffset: number;
                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("vue").ExtractPropTypes<{
                    data: {
                        type: import("vue").PropType<any[]>;
                    };
                    size: {
                        type: import("vue").PropType<"small" | "medium" | "large">;
                        default: string;
                    };
                    bordered: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    split: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    hoverable: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    paginationProps: {
                        type: import("vue").PropType<import("..").PaginationProps>;
                    };
                    gridProps: {
                        type: ObjectConstructor;
                    };
                    maxHeight: {
                        type: import("vue").PropType<string | number>;
                        default: number;
                    };
                    bottomOffset: {
                        type: NumberConstructor;
                        default: number;
                    };
                    virtualListProps: {
                        type: import("vue").PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
                    };
                    scrollbar: {
                        type: import("vue").PropType<boolean | import("..").ScrollbarProps>;
                        default: boolean;
                    };
                }>> & Readonly<{
                    onScroll?: (() => any) | undefined;
                    onReachBottom?: (() => any) | undefined;
                    onPageChange?: ((page: number) => any) | undefined;
                    onPageSizeChange?: ((pageSize: number) => any) | undefined;
                }>, {
                    virtualListRef: import("vue").Ref<any, any>;
                    render: () => import("vue/jsx-runtime").JSX.Element;
                }, {}, {}, {
                    scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
                }, {
                    size: "small" | "medium" | "large";
                    loading: boolean;
                    bordered: boolean;
                    scrollbar: boolean | import("..").ScrollbarProps;
                    maxHeight: string | number;
                    split: boolean;
                    hoverable: boolean;
                    bottomOffset: number;
                }>;
                __isFragment?: undefined;
                __isTeleport?: undefined;
                __isSuspense?: undefined;
            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                data: {
                    type: import("vue").PropType<any[]>;
                };
                size: {
                    type: import("vue").PropType<"small" | "medium" | "large">;
                    default: string;
                };
                bordered: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                split: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hoverable: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                paginationProps: {
                    type: import("vue").PropType<import("..").PaginationProps>;
                };
                gridProps: {
                    type: ObjectConstructor;
                };
                maxHeight: {
                    type: import("vue").PropType<string | number>;
                    default: number;
                };
                bottomOffset: {
                    type: NumberConstructor;
                    default: number;
                };
                virtualListProps: {
                    type: import("vue").PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
                };
                scrollbar: {
                    type: import("vue").PropType<boolean | import("..").ScrollbarProps>;
                    default: boolean;
                };
            }>> & Readonly<{
                onScroll?: (() => any) | undefined;
                onReachBottom?: (() => any) | undefined;
                onPageChange?: ((page: number) => any) | undefined;
                onPageSizeChange?: ((pageSize: number) => any) | undefined;
            }>, {
                virtualListRef: import("vue").Ref<any, any>;
                render: () => import("vue/jsx-runtime").JSX.Element;
            }, {}, {}, {
                scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
            }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                scroll: () => true;
                reachBottom: () => true;
                pageChange: (page: number) => true;
                pageSizeChange: (pageSize: number) => true;
            }, string, {
                size: "small" | "medium" | "large";
                loading: boolean;
                bordered: boolean;
                scrollbar: boolean | import("..").ScrollbarProps;
                maxHeight: string | number;
                split: boolean;
                hoverable: boolean;
                bottomOffset: number;
            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                Item: {
                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                        actionLayout: {
                            type: import("vue").PropType<"horizontal" | "vertical">;
                            default: string;
                        };
                    }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                        actionLayout: "horizontal" | "vertical";
                    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import("vue").ExtractPropTypes<{
                        actionLayout: {
                            type: import("vue").PropType<"horizontal" | "vertical">;
                            default: string;
                        };
                    }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
                        actionLayout: "horizontal" | "vertical";
                    }>;
                    __isFragment?: undefined;
                    __isTeleport?: undefined;
                    __isSuspense?: undefined;
                } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                    actionLayout: {
                        type: import("vue").PropType<"horizontal" | "vertical">;
                        default: string;
                    };
                }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
                    actionLayout: "horizontal" | "vertical";
                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                    Meta: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        title: StringConstructor;
                        description: StringConstructor;
                    }>, {
                        prefixCls: string;
                        hasContent: boolean;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        title: StringConstructor;
                        description: StringConstructor;
                    }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                };
                install: (app: App<any>, options?: ArcoOptions | undefined) => void;
            };
            TransferListItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                type: {
                    type: import("vue").PropType<"source" | "target">;
                };
                data: {
                    type: import("vue").PropType<import("./interface").TransferItem>;
                    required: true;
                };
                allowClear: {
                    type: BooleanConstructor;
                };
                disabled: {
                    type: BooleanConstructor;
                };
                draggable: {
                    type: BooleanConstructor;
                };
                simple: BooleanConstructor;
            }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                type: {
                    type: import("vue").PropType<"source" | "target">;
                };
                data: {
                    type: import("vue").PropType<import("./interface").TransferItem>;
                    required: true;
                };
                allowClear: {
                    type: BooleanConstructor;
                };
                disabled: {
                    type: BooleanConstructor;
                };
                draggable: {
                    type: BooleanConstructor;
                };
                simple: BooleanConstructor;
            }>> & Readonly<{}>, {
                disabled: boolean;
                allowClear: boolean;
                draggable: boolean;
                simple: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            Scrollbar: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                    type: {
                        type: import("vue").PropType<"embed" | "track">;
                        default: string;
                    };
                    outerClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
                    outerStyle: {
                        type: import("vue").PropType<import("vue").StyleValue>;
                    };
                    hide: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disableHorizontal: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disableVertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & Readonly<{
                    onScroll?: ((ev: Event) => any) | undefined;
                }>, {
                    prefixCls: string;
                    cls: import("vue").ComputedRef<(string | Record<string, any> | undefined)[]>;
                    style: import("vue").ComputedRef<import("vue").StyleValue[]>;
                    containerRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                    horizontalThumbRef: import("vue").Ref<any, any>;
                    verticalThumbRef: import("vue").Ref<any, any>;
                    horizontalData: import("vue").Ref<import("../scrollbar/interface").ThumbData | undefined, import("../scrollbar/interface").ThumbData | undefined>;
                    verticalData: import("vue").Ref<import("../scrollbar/interface").ThumbData | undefined, import("../scrollbar/interface").ThumbData | undefined>;
                    isBoth: import("vue").Ref<boolean, boolean>;
                    hasHorizontalScrollbar: import("vue").ComputedRef<boolean>;
                    hasVerticalScrollbar: import("vue").ComputedRef<boolean>;
                    handleResize: () => void;
                    handleScroll: (ev: Event) => void;
                    handleHorizontalScroll: (offset: number) => void;
                    handleVerticalScroll: (offset: number) => void;
                }, {}, {}, {
                    scrollTo(options?: number | {
                        left?: number | undefined;
                        top?: number | undefined;
                    } | undefined, y?: number | undefined): void;
                    scrollTop(top: number): void;
                    scrollLeft(left: number): void;
                }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                    scroll: (ev: Event) => true;
                }, import("vue").PublicProps, {
                    type: "embed" | "track";
                    hide: boolean;
                    disableHorizontal: boolean;
                    disableVertical: boolean;
                }, true, {}, {}, {
                    ResizeObserver: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        watchOnUpdated: BooleanConstructor;
                    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                        [key: string]: any;
                    }>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "resize"[], "resize", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        watchOnUpdated: BooleanConstructor;
                    }>> & Readonly<{
                        onResize?: ((...args: any[]) => any) | undefined;
                    }>, {
                        watchOnUpdated: boolean;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    Thumb: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        data: {
                            type: import("vue").PropType<import("../scrollbar/interface").ThumbData>;
                        };
                        direction: {
                            type: import("vue").PropType<"horizontal" | "vertical">;
                            default: string;
                        };
                        alwaysShow: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        both: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>, {
                        visible: import("vue").Ref<boolean, boolean>;
                        trackRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                        thumbRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                        prefixCls: string;
                        thumbCls: import("vue").ComputedRef<(string | {
                            [x: string]: boolean;
                        })[]>;
                        thumbStyle: import("vue").ComputedRef<{
                            [x: string]: string;
                        }>;
                        handleThumbMouseDown: (ev: MouseEvent) => void;
                        handleTrackClick: (ev: MouseEvent) => void;
                        setOffset: (_offset: number) => void;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "scroll"[], "scroll", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        data: {
                            type: import("vue").PropType<import("../scrollbar/interface").ThumbData>;
                        };
                        direction: {
                            type: import("vue").PropType<"horizontal" | "vertical">;
                            default: string;
                        };
                        alwaysShow: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        both: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>> & Readonly<{
                        onScroll?: ((...args: any[]) => any) | undefined;
                    }>, {
                        direction: "horizontal" | "vertical";
                        both: boolean;
                        alwaysShow: boolean;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("vue").ExtractPropTypes<{
                    type: {
                        type: import("vue").PropType<"embed" | "track">;
                        default: string;
                    };
                    outerClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
                    outerStyle: {
                        type: import("vue").PropType<import("vue").StyleValue>;
                    };
                    hide: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disableHorizontal: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disableVertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & Readonly<{
                    onScroll?: ((ev: Event) => any) | undefined;
                }>, {
                    prefixCls: string;
                    cls: import("vue").ComputedRef<(string | Record<string, any> | undefined)[]>;
                    style: import("vue").ComputedRef<import("vue").StyleValue[]>;
                    containerRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                    horizontalThumbRef: import("vue").Ref<any, any>;
                    verticalThumbRef: import("vue").Ref<any, any>;
                    horizontalData: import("vue").Ref<import("../scrollbar/interface").ThumbData | undefined, import("../scrollbar/interface").ThumbData | undefined>;
                    verticalData: import("vue").Ref<import("../scrollbar/interface").ThumbData | undefined, import("../scrollbar/interface").ThumbData | undefined>;
                    isBoth: import("vue").Ref<boolean, boolean>;
                    hasHorizontalScrollbar: import("vue").ComputedRef<boolean>;
                    hasVerticalScrollbar: import("vue").ComputedRef<boolean>;
                    handleResize: () => void;
                    handleScroll: (ev: Event) => void;
                    handleHorizontalScroll: (offset: number) => void;
                    handleVerticalScroll: (offset: number) => void;
                }, {}, {}, {
                    scrollTo(options?: number | {
                        left?: number | undefined;
                        top?: number | undefined;
                    } | undefined, y?: number | undefined): void;
                    scrollTop(top: number): void;
                    scrollLeft(left: number): void;
                }, {
                    type: "embed" | "track";
                    hide: boolean;
                    disableHorizontal: boolean;
                    disableVertical: boolean;
                }>;
                __isFragment?: undefined;
                __isTeleport?: undefined;
                __isSuspense?: undefined;
            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                type: {
                    type: import("vue").PropType<"embed" | "track">;
                    default: string;
                };
                outerClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
                outerStyle: {
                    type: import("vue").PropType<import("vue").StyleValue>;
                };
                hide: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disableHorizontal: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disableVertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onScroll?: ((ev: Event) => any) | undefined;
            }>, {
                prefixCls: string;
                cls: import("vue").ComputedRef<(string | Record<string, any> | undefined)[]>;
                style: import("vue").ComputedRef<import("vue").StyleValue[]>;
                containerRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                horizontalThumbRef: import("vue").Ref<any, any>;
                verticalThumbRef: import("vue").Ref<any, any>;
                horizontalData: import("vue").Ref<import("../scrollbar/interface").ThumbData | undefined, import("../scrollbar/interface").ThumbData | undefined>;
                verticalData: import("vue").Ref<import("../scrollbar/interface").ThumbData | undefined, import("../scrollbar/interface").ThumbData | undefined>;
                isBoth: import("vue").Ref<boolean, boolean>;
                hasHorizontalScrollbar: import("vue").ComputedRef<boolean>;
                hasVerticalScrollbar: import("vue").ComputedRef<boolean>;
                handleResize: () => void;
                handleScroll: (ev: Event) => void;
                handleHorizontalScroll: (offset: number) => void;
                handleVerticalScroll: (offset: number) => void;
            }, {}, {}, {
                scrollTo(options?: number | {
                    left?: number | undefined;
                    top?: number | undefined;
                } | undefined, y?: number | undefined): void;
                scrollTop(top: number): void;
                scrollLeft(left: number): void;
            }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                scroll: (ev: Event) => true;
            }, string, {
                type: "embed" | "track";
                hide: boolean;
                disableHorizontal: boolean;
                disableVertical: boolean;
            }, {}, string, {}, {
                ResizeObserver: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    watchOnUpdated: BooleanConstructor;
                }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "resize"[], "resize", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    watchOnUpdated: BooleanConstructor;
                }>> & Readonly<{
                    onResize?: ((...args: any[]) => any) | undefined;
                }>, {
                    watchOnUpdated: boolean;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                Thumb: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    data: {
                        type: import("vue").PropType<import("../scrollbar/interface").ThumbData>;
                    };
                    direction: {
                        type: import("vue").PropType<"horizontal" | "vertical">;
                        default: string;
                    };
                    alwaysShow: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    both: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>, {
                    visible: import("vue").Ref<boolean, boolean>;
                    trackRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                    thumbRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                    prefixCls: string;
                    thumbCls: import("vue").ComputedRef<(string | {
                        [x: string]: boolean;
                    })[]>;
                    thumbStyle: import("vue").ComputedRef<{
                        [x: string]: string;
                    }>;
                    handleThumbMouseDown: (ev: MouseEvent) => void;
                    handleTrackClick: (ev: MouseEvent) => void;
                    setOffset: (_offset: number) => void;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "scroll"[], "scroll", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    data: {
                        type: import("vue").PropType<import("../scrollbar/interface").ThumbData>;
                    };
                    direction: {
                        type: import("vue").PropType<"horizontal" | "vertical">;
                        default: string;
                    };
                    alwaysShow: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    both: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & Readonly<{
                    onScroll?: ((...args: any[]) => any) | undefined;
                }>, {
                    direction: "horizontal" | "vertical";
                    both: boolean;
                    alwaysShow: boolean;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                install: (app: App<any>, options?: ArcoOptions | undefined) => void;
            };
        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        IconLeft: any;
        IconRight: any;
    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        data: {
            type: import("vue").PropType<import("./interface").TransferItem[]>;
            default: () => never[];
        };
        modelValue: {
            type: import("vue").PropType<string[]>;
            default: undefined;
        };
        defaultValue: {
            type: import("vue").PropType<string[]>;
            default: () => never[];
        };
        selected: {
            type: import("vue").PropType<string[]>;
            default: undefined;
        };
        defaultSelected: {
            type: import("vue").PropType<string[]>;
            default: () => never[];
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        simple: {
            type: BooleanConstructor;
            default: boolean;
        };
        oneWay: {
            type: BooleanConstructor;
            default: boolean;
        };
        showSearch: {
            type: BooleanConstructor;
            default: boolean;
        };
        showSelectAll: {
            type: BooleanConstructor;
            default: boolean;
        };
        title: {
            type: import("vue").PropType<string[]>;
            default: () => string[];
        };
        sourceInputSearchProps: {
            type: ObjectConstructor;
        };
        targetInputSearchProps: {
            type: ObjectConstructor;
        };
    }>> & Readonly<{
        onChange?: ((value: string[]) => any) | undefined;
        "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
        onSelect?: ((selected: string[]) => any) | undefined;
        onSearch?: ((value: string, type: "source" | "target") => any) | undefined;
        "onUpdate:selected"?: ((selected: string[]) => any) | undefined;
    }>, {
        prefixCls: string;
        cls: import("vue").ComputedRef<(string | {
            [x: string]: boolean;
        })[]>;
        dataInfo: import("vue").ComputedRef<{
            sourceInfo: import("./interface").DataInfo;
            targetInfo: import("./interface").DataInfo;
        }>;
        computedSelected: import("vue").ComputedRef<string[]>;
        mergedDisabled: import("vue").ComputedRef<boolean>;
        sourceTitle: import("vue").ComputedRef<string>;
        targetTitle: import("vue").ComputedRef<string>;
        handleClick: (target: "source" | "target") => void;
        handleSearch: (value: string, type: "source" | "target") => void;
    }, {}, {}, {}, {
        disabled: boolean;
        defaultValue: string[];
        modelValue: string[];
        data: import("./interface").TransferItem[];
        title: string[];
        simple: boolean;
        selected: string[];
        showSearch: boolean;
        showSelectAll: boolean;
        defaultSelected: string[];
        oneWay: boolean;
    }>;
    __isFragment?: undefined;
    __isTeleport?: undefined;
    __isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
    data: {
        type: import("vue").PropType<import("./interface").TransferItem[]>;
        default: () => never[];
    };
    modelValue: {
        type: import("vue").PropType<string[]>;
        default: undefined;
    };
    defaultValue: {
        type: import("vue").PropType<string[]>;
        default: () => never[];
    };
    selected: {
        type: import("vue").PropType<string[]>;
        default: undefined;
    };
    defaultSelected: {
        type: import("vue").PropType<string[]>;
        default: () => never[];
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    simple: {
        type: BooleanConstructor;
        default: boolean;
    };
    oneWay: {
        type: BooleanConstructor;
        default: boolean;
    };
    showSearch: {
        type: BooleanConstructor;
        default: boolean;
    };
    showSelectAll: {
        type: BooleanConstructor;
        default: boolean;
    };
    title: {
        type: import("vue").PropType<string[]>;
        default: () => string[];
    };
    sourceInputSearchProps: {
        type: ObjectConstructor;
    };
    targetInputSearchProps: {
        type: ObjectConstructor;
    };
}>> & Readonly<{
    onChange?: ((value: string[]) => any) | undefined;
    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
    onSelect?: ((selected: string[]) => any) | undefined;
    onSearch?: ((value: string, type: "source" | "target") => any) | undefined;
    "onUpdate:selected"?: ((selected: string[]) => any) | undefined;
}>, {
    prefixCls: string;
    cls: import("vue").ComputedRef<(string | {
        [x: string]: boolean;
    })[]>;
    dataInfo: import("vue").ComputedRef<{
        sourceInfo: import("./interface").DataInfo;
        targetInfo: import("./interface").DataInfo;
    }>;
    computedSelected: import("vue").ComputedRef<string[]>;
    mergedDisabled: import("vue").ComputedRef<boolean>;
    sourceTitle: import("vue").ComputedRef<string>;
    targetTitle: import("vue").ComputedRef<string>;
    handleClick: (target: "source" | "target") => void;
    handleSearch: (value: string, type: "source" | "target") => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    'update:modelValue': (value: string[]) => true;
    'update:selected': (selected: string[]) => true;
    change: (value: string[]) => true;
    select: (selected: string[]) => true;
    search: (value: string, type: "source" | "target") => true;
}, string, {
    disabled: boolean;
    defaultValue: string[];
    modelValue: string[];
    data: import("./interface").TransferItem[];
    title: string[];
    simple: boolean;
    selected: string[];
    showSearch: boolean;
    showSelectAll: boolean;
    defaultSelected: string[];
    oneWay: boolean;
}, {}, string, {}, {
    ArcoButton: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            type: {
                type: import("vue").PropType<"text" | "dashed" | "outline" | "primary" | "secondary">;
            };
            shape: {
                type: import("vue").PropType<"circle" | "round" | "square">;
            };
            status: {
                type: import("vue").PropType<"normal" | "success" | "warning" | "danger">;
            };
            size: {
                type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
            };
            long: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
            };
            htmlType: {
                type: import("vue").PropType<string>;
                default: string;
            };
            autofocus: {
                type: BooleanConstructor;
                default: boolean;
            };
            href: StringConstructor;
        }>> & Readonly<{
            onClick?: ((ev: MouseEvent) => any) | undefined;
        }>, {
            prefixCls: string;
            cls: import("vue").ComputedRef<(string | {
                [x: string]: boolean;
            })[]>;
            mergedDisabled: import("vue").ComputedRef<boolean>;
            handleClick: (ev: MouseEvent) => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            click: (ev: MouseEvent) => true;
        }, import("vue").PublicProps, {
            disabled: boolean;
            autofocus: boolean;
            loading: boolean;
            long: boolean;
            htmlType: string;
        }, true, {}, {}, {
            IconLoading: any;
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            type: {
                type: import("vue").PropType<"text" | "dashed" | "outline" | "primary" | "secondary">;
            };
            shape: {
                type: import("vue").PropType<"circle" | "round" | "square">;
            };
            status: {
                type: import("vue").PropType<"normal" | "success" | "warning" | "danger">;
            };
            size: {
                type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
            };
            long: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
            };
            htmlType: {
                type: import("vue").PropType<string>;
                default: string;
            };
            autofocus: {
                type: BooleanConstructor;
                default: boolean;
            };
            href: StringConstructor;
        }>> & Readonly<{
            onClick?: ((ev: MouseEvent) => any) | undefined;
        }>, {
            prefixCls: string;
            cls: import("vue").ComputedRef<(string | {
                [x: string]: boolean;
            })[]>;
            mergedDisabled: import("vue").ComputedRef<boolean>;
            handleClick: (ev: MouseEvent) => void;
        }, {}, {}, {}, {
            disabled: boolean;
            autofocus: boolean;
            loading: boolean;
            long: boolean;
            htmlType: string;
        }>;
        __isFragment?: undefined;
        __isTeleport?: undefined;
        __isSuspense?: undefined;
    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
        type: {
            type: import("vue").PropType<"text" | "dashed" | "outline" | "primary" | "secondary">;
        };
        shape: {
            type: import("vue").PropType<"circle" | "round" | "square">;
        };
        status: {
            type: import("vue").PropType<"normal" | "success" | "warning" | "danger">;
        };
        size: {
            type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
        };
        long: {
            type: BooleanConstructor;
            default: boolean;
        };
        loading: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
        };
        htmlType: {
            type: import("vue").PropType<string>;
            default: string;
        };
        autofocus: {
            type: BooleanConstructor;
            default: boolean;
        };
        href: StringConstructor;
    }>> & Readonly<{
        onClick?: ((ev: MouseEvent) => any) | undefined;
    }>, {
        prefixCls: string;
        cls: import("vue").ComputedRef<(string | {
            [x: string]: boolean;
        })[]>;
        mergedDisabled: import("vue").ComputedRef<boolean>;
        handleClick: (ev: MouseEvent) => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        click: (ev: MouseEvent) => true;
    }, string, {
        disabled: boolean;
        autofocus: boolean;
        loading: boolean;
        long: boolean;
        htmlType: string;
    }, {}, string, {}, {
        IconLoading: any;
    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
        Group: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            type: {
                type: import("vue").PropType<"text" | "dashed" | "outline" | "primary" | "secondary">;
            };
            status: {
                type: import("vue").PropType<"normal" | "success" | "warning" | "danger">;
            };
            shape: {
                type: import("vue").PropType<"circle" | "round" | "square">;
            };
            size: {
                type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
            };
            disabled: {
                type: BooleanConstructor;
            };
        }>, {
            prefixCls: string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            type: {
                type: import("vue").PropType<"text" | "dashed" | "outline" | "primary" | "secondary">;
            };
            status: {
                type: import("vue").PropType<"normal" | "success" | "warning" | "danger">;
            };
            shape: {
                type: import("vue").PropType<"circle" | "round" | "square">;
            };
            size: {
                type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
            };
            disabled: {
                type: BooleanConstructor;
            };
        }>> & Readonly<{}>, {
            disabled: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        install: (app: App<any>, options?: ArcoOptions | undefined) => void;
    };
    TransferView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        type: {
            type: import("vue").PropType<"source" | "target">;
        };
        dataInfo: {
            type: import("vue").PropType<import("./interface").DataInfo>;
            required: true;
        };
        title: StringConstructor;
        data: {
            type: import("vue").PropType<import("./interface").TransferItem[]>;
            required: true;
        };
        disabled: BooleanConstructor;
        allowClear: BooleanConstructor;
        selected: {
            type: import("vue").PropType<string[]>;
            required: true;
        };
        showSearch: BooleanConstructor;
        showSelectAll: BooleanConstructor;
        simple: BooleanConstructor;
        inputSearchProps: {
            type: ObjectConstructor;
        };
    }>, {
        prefixCls: string;
        filteredData: import("vue").ComputedRef<import("./interface").TransferItem[]>;
        filter: import("vue").Ref<string, string>;
        checked: import("vue").ComputedRef<boolean>;
        indeterminate: import("vue").ComputedRef<boolean>;
        countSelected: import("vue").ComputedRef<number>;
        countRendered: import("vue").ComputedRef<number>;
        handleSelectAllChange: (checked: boolean) => void;
        handleSearch: (value: string) => void;
        handleClear: () => void;
        transferCtx: import("./context").TransferContext | undefined;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "search"[], "search", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        type: {
            type: import("vue").PropType<"source" | "target">;
        };
        dataInfo: {
            type: import("vue").PropType<import("./interface").DataInfo>;
            required: true;
        };
        title: StringConstructor;
        data: {
            type: import("vue").PropType<import("./interface").TransferItem[]>;
            required: true;
        };
        disabled: BooleanConstructor;
        allowClear: BooleanConstructor;
        selected: {
            type: import("vue").PropType<string[]>;
            required: true;
        };
        showSearch: BooleanConstructor;
        showSelectAll: BooleanConstructor;
        simple: BooleanConstructor;
        inputSearchProps: {
            type: ObjectConstructor;
        };
    }>> & Readonly<{
        onSearch?: ((...args: any[]) => any) | undefined;
    }>, {
        disabled: boolean;
        allowClear: boolean;
        simple: boolean;
        showSearch: boolean;
        showSelectAll: boolean;
    }, {}, {
        Empty: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            description: StringConstructor;
            imgSrc: StringConstructor;
            inConfigProvider: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>[] | import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            description: StringConstructor;
            imgSrc: StringConstructor;
            inConfigProvider: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{}>, {
            inConfigProvider: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        Checkbox: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                modelValue: {
                    type: import("vue").PropType<boolean | (string | number | boolean)[]>;
                    default: undefined;
                };
                defaultChecked: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                value: {
                    type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                indeterminate: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                uninjectGroupContext: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onChange?: ((value: boolean | (string | number | boolean)[], ev: Event) => any) | undefined;
                "onUpdate:modelValue"?: ((value: boolean | (string | number | boolean)[]) => any) | undefined;
            }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                'update:modelValue': (value: boolean | (string | number | boolean)[]) => true;
                change: (value: boolean | (string | number | boolean)[], ev: Event) => true;
            }, import("vue").PublicProps, {
                disabled: boolean;
                modelValue: boolean | (string | number | boolean)[];
                defaultChecked: boolean;
                indeterminate: boolean;
                uninjectGroupContext: boolean;
            }, true, {}, {}, {
                IconCheck: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                IconHover: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    prefix: {
                        type: StringConstructor;
                    };
                    size: {
                        type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                        default: string;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>, {
                    prefixCls: string;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    prefix: {
                        type: StringConstructor;
                    };
                    size: {
                        type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                        default: string;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & Readonly<{}>, {
                    size: "mini" | "small" | "medium" | "large";
                    disabled: boolean;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("vue").ExtractPropTypes<{
                modelValue: {
                    type: import("vue").PropType<boolean | (string | number | boolean)[]>;
                    default: undefined;
                };
                defaultChecked: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                value: {
                    type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                indeterminate: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                uninjectGroupContext: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onChange?: ((value: boolean | (string | number | boolean)[], ev: Event) => any) | undefined;
                "onUpdate:modelValue"?: ((value: boolean | (string | number | boolean)[]) => any) | undefined;
            }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
                disabled: boolean;
                modelValue: boolean | (string | number | boolean)[];
                defaultChecked: boolean;
                indeterminate: boolean;
                uninjectGroupContext: boolean;
            }>;
            __isFragment?: undefined;
            __isTeleport?: undefined;
            __isSuspense?: undefined;
        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            modelValue: {
                type: import("vue").PropType<boolean | (string | number | boolean)[]>;
                default: undefined;
            };
            defaultChecked: {
                type: BooleanConstructor;
                default: boolean;
            };
            value: {
                type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            indeterminate: {
                type: BooleanConstructor;
                default: boolean;
            };
            uninjectGroupContext: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            onChange?: ((value: boolean | (string | number | boolean)[], ev: Event) => any) | undefined;
            "onUpdate:modelValue"?: ((value: boolean | (string | number | boolean)[]) => any) | undefined;
        }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            'update:modelValue': (value: boolean | (string | number | boolean)[]) => true;
            change: (value: boolean | (string | number | boolean)[], ev: Event) => true;
        }, string, {
            disabled: boolean;
            modelValue: boolean | (string | number | boolean)[];
            defaultChecked: boolean;
            indeterminate: boolean;
            uninjectGroupContext: boolean;
        }, {}, string, {}, {
            IconCheck: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            IconHover: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                prefix: {
                    type: StringConstructor;
                };
                size: {
                    type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                    default: string;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>, {
                prefixCls: string;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                prefix: {
                    type: StringConstructor;
                };
                size: {
                    type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                    default: string;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{}>, {
                size: "mini" | "small" | "medium" | "large";
                disabled: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
            Group: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                modelValue: {
                    type: import("vue").PropType<(string | number | boolean)[]>;
                    default: undefined;
                };
                defaultValue: {
                    type: import("vue").PropType<(string | number | boolean)[]>;
                    default: () => never[];
                };
                max: {
                    type: NumberConstructor;
                };
                options: {
                    type: import("vue").PropType<(string | number | import("..").CheckboxOption)[]>;
                };
                direction: {
                    type: import("vue").PropType<"horizontal" | "vertical">;
                    default: string;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                'update:modelValue': (value: (string | number | boolean)[]) => true;
                change: (value: (string | number | boolean)[], ev: Event) => true;
            }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                modelValue: {
                    type: import("vue").PropType<(string | number | boolean)[]>;
                    default: undefined;
                };
                defaultValue: {
                    type: import("vue").PropType<(string | number | boolean)[]>;
                    default: () => never[];
                };
                max: {
                    type: NumberConstructor;
                };
                options: {
                    type: import("vue").PropType<(string | number | import("..").CheckboxOption)[]>;
                };
                direction: {
                    type: import("vue").PropType<"horizontal" | "vertical">;
                    default: string;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onChange?: ((value: (string | number | boolean)[], ev: Event) => any) | undefined;
                "onUpdate:modelValue"?: ((value: (string | number | boolean)[]) => any) | undefined;
            }>, {
                disabled: boolean;
                defaultValue: (string | number | boolean)[];
                modelValue: (string | number | boolean)[];
                direction: "horizontal" | "vertical";
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            install: (app: App<any>, options?: ArcoOptions | undefined) => void;
        };
        IconHover: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            prefix: {
                type: StringConstructor;
            };
            size: {
                type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                default: string;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>, {
            prefixCls: string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            prefix: {
                type: StringConstructor;
            };
            size: {
                type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
                default: string;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{}>, {
            size: "mini" | "small" | "medium" | "large";
            disabled: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        IconDelete: any;
        InputSearch: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            searchButton: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
            };
            buttonText: {
                type: StringConstructor;
            };
            buttonProps: {
                type: import("vue").PropType<import("..").ButtonProps>;
            };
        }>, {
            inputRef: import("vue").Ref<any, any>;
            render: () => import("vue/jsx-runtime").JSX.Element;
        }, {}, {}, {
            focus(): void;
            blur(): void;
        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            search: (value: string, ev: MouseEvent) => true;
        }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            searchButton: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: import("vue").PropType<"mini" | "small" | "medium" | "large">;
            };
            buttonText: {
                type: StringConstructor;
            };
            buttonProps: {
                type: import("vue").PropType<import("..").ButtonProps>;
            };
        }>> & Readonly<{
            onSearch?: ((value: string, ev: MouseEvent) => any) | undefined;
        }>, {
            disabled: boolean;
            loading: boolean;
            searchButton: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        List: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                data: {
                    type: import("vue").PropType<any[]>;
                };
                size: {
                    type: import("vue").PropType<"small" | "medium" | "large">;
                    default: string;
                };
                bordered: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                split: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hoverable: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                paginationProps: {
                    type: import("vue").PropType<import("..").PaginationProps>;
                };
                gridProps: {
                    type: ObjectConstructor;
                };
                maxHeight: {
                    type: import("vue").PropType<string | number>;
                    default: number;
                };
                bottomOffset: {
                    type: NumberConstructor;
                    default: number;
                };
                virtualListProps: {
                    type: import("vue").PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
                };
                scrollbar: {
                    type: import("vue").PropType<boolean | import("..").ScrollbarProps>;
                    default: boolean;
                };
            }>> & Readonly<{
                onScroll?: (() => any) | undefined;
                onReachBottom?: (() => any) | undefined;
                onPageChange?: ((page: number) => any) | undefined;
                onPageSizeChange?: ((pageSize: number) => any) | undefined;
            }>, {
                virtualListRef: import("vue").Ref<any, any>;
                render: () => import("vue/jsx-runtime").JSX.Element;
            }, {}, {}, {
                scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
            }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                scroll: () => true;
                reachBottom: () => true;
                pageChange: (page: number) => true;
                pageSizeChange: (pageSize: number) => true;
            }, import("vue").PublicProps, {
                size: "small" | "medium" | "large";
                loading: boolean;
                bordered: boolean;
                scrollbar: boolean | import("..").ScrollbarProps;
                maxHeight: string | number;
                split: boolean;
                hoverable: boolean;
                bottomOffset: number;
            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("vue").ExtractPropTypes<{
                data: {
                    type: import("vue").PropType<any[]>;
                };
                size: {
                    type: import("vue").PropType<"small" | "medium" | "large">;
                    default: string;
                };
                bordered: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                split: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hoverable: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                paginationProps: {
                    type: import("vue").PropType<import("..").PaginationProps>;
                };
                gridProps: {
                    type: ObjectConstructor;
                };
                maxHeight: {
                    type: import("vue").PropType<string | number>;
                    default: number;
                };
                bottomOffset: {
                    type: NumberConstructor;
                    default: number;
                };
                virtualListProps: {
                    type: import("vue").PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
                };
                scrollbar: {
                    type: import("vue").PropType<boolean | import("..").ScrollbarProps>;
                    default: boolean;
                };
            }>> & Readonly<{
                onScroll?: (() => any) | undefined;
                onReachBottom?: (() => any) | undefined;
                onPageChange?: ((page: number) => any) | undefined;
                onPageSizeChange?: ((pageSize: number) => any) | undefined;
            }>, {
                virtualListRef: import("vue").Ref<any, any>;
                render: () => import("vue/jsx-runtime").JSX.Element;
            }, {}, {}, {
                scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
            }, {
                size: "small" | "medium" | "large";
                loading: boolean;
                bordered: boolean;
                scrollbar: boolean | import("..").ScrollbarProps;
                maxHeight: string | number;
                split: boolean;
                hoverable: boolean;
                bottomOffset: number;
            }>;
            __isFragment?: undefined;
            __isTeleport?: undefined;
            __isSuspense?: undefined;
        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            data: {
                type: import("vue").PropType<any[]>;
            };
            size: {
                type: import("vue").PropType<"small" | "medium" | "large">;
                default: string;
            };
            bordered: {
                type: BooleanConstructor;
                default: boolean;
            };
            split: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            hoverable: {
                type: BooleanConstructor;
                default: boolean;
            };
            paginationProps: {
                type: import("vue").PropType<import("..").PaginationProps>;
            };
            gridProps: {
                type: ObjectConstructor;
            };
            maxHeight: {
                type: import("vue").PropType<string | number>;
                default: number;
            };
            bottomOffset: {
                type: NumberConstructor;
                default: number;
            };
            virtualListProps: {
                type: import("vue").PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
            };
            scrollbar: {
                type: import("vue").PropType<boolean | import("..").ScrollbarProps>;
                default: boolean;
            };
        }>> & Readonly<{
            onScroll?: (() => any) | undefined;
            onReachBottom?: (() => any) | undefined;
            onPageChange?: ((page: number) => any) | undefined;
            onPageSizeChange?: ((pageSize: number) => any) | undefined;
        }>, {
            virtualListRef: import("vue").Ref<any, any>;
            render: () => import("vue/jsx-runtime").JSX.Element;
        }, {}, {}, {
            scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            scroll: () => true;
            reachBottom: () => true;
            pageChange: (page: number) => true;
            pageSizeChange: (pageSize: number) => true;
        }, string, {
            size: "small" | "medium" | "large";
            loading: boolean;
            bordered: boolean;
            scrollbar: boolean | import("..").ScrollbarProps;
            maxHeight: string | number;
            split: boolean;
            hoverable: boolean;
            bottomOffset: number;
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
            Item: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                    actionLayout: {
                        type: import("vue").PropType<"horizontal" | "vertical">;
                        default: string;
                    };
                }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                    actionLayout: "horizontal" | "vertical";
                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("vue").ExtractPropTypes<{
                    actionLayout: {
                        type: import("vue").PropType<"horizontal" | "vertical">;
                        default: string;
                    };
                }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
                    actionLayout: "horizontal" | "vertical";
                }>;
                __isFragment?: undefined;
                __isTeleport?: undefined;
                __isSuspense?: undefined;
            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                actionLayout: {
                    type: import("vue").PropType<"horizontal" | "vertical">;
                    default: string;
                };
            }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
                actionLayout: "horizontal" | "vertical";
            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                Meta: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    title: StringConstructor;
                    description: StringConstructor;
                }>, {
                    prefixCls: string;
                    hasContent: boolean;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    title: StringConstructor;
                    description: StringConstructor;
                }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            };
            install: (app: App<any>, options?: ArcoOptions | undefined) => void;
        };
        TransferListItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            type: {
                type: import("vue").PropType<"source" | "target">;
            };
            data: {
                type: import("vue").PropType<import("./interface").TransferItem>;
                required: true;
            };
            allowClear: {
                type: BooleanConstructor;
            };
            disabled: {
                type: BooleanConstructor;
            };
            draggable: {
                type: BooleanConstructor;
            };
            simple: BooleanConstructor;
        }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            type: {
                type: import("vue").PropType<"source" | "target">;
            };
            data: {
                type: import("vue").PropType<import("./interface").TransferItem>;
                required: true;
            };
            allowClear: {
                type: BooleanConstructor;
            };
            disabled: {
                type: BooleanConstructor;
            };
            draggable: {
                type: BooleanConstructor;
            };
            simple: BooleanConstructor;
        }>> & Readonly<{}>, {
            disabled: boolean;
            allowClear: boolean;
            draggable: boolean;
            simple: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        Scrollbar: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                type: {
                    type: import("vue").PropType<"embed" | "track">;
                    default: string;
                };
                outerClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
                outerStyle: {
                    type: import("vue").PropType<import("vue").StyleValue>;
                };
                hide: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disableHorizontal: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disableVertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onScroll?: ((ev: Event) => any) | undefined;
            }>, {
                prefixCls: string;
                cls: import("vue").ComputedRef<(string | Record<string, any> | undefined)[]>;
                style: import("vue").ComputedRef<import("vue").StyleValue[]>;
                containerRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                horizontalThumbRef: import("vue").Ref<any, any>;
                verticalThumbRef: import("vue").Ref<any, any>;
                horizontalData: import("vue").Ref<import("../scrollbar/interface").ThumbData | undefined, import("../scrollbar/interface").ThumbData | undefined>;
                verticalData: import("vue").Ref<import("../scrollbar/interface").ThumbData | undefined, import("../scrollbar/interface").ThumbData | undefined>;
                isBoth: import("vue").Ref<boolean, boolean>;
                hasHorizontalScrollbar: import("vue").ComputedRef<boolean>;
                hasVerticalScrollbar: import("vue").ComputedRef<boolean>;
                handleResize: () => void;
                handleScroll: (ev: Event) => void;
                handleHorizontalScroll: (offset: number) => void;
                handleVerticalScroll: (offset: number) => void;
            }, {}, {}, {
                scrollTo(options?: number | {
                    left?: number | undefined;
                    top?: number | undefined;
                } | undefined, y?: number | undefined): void;
                scrollTop(top: number): void;
                scrollLeft(left: number): void;
            }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                scroll: (ev: Event) => true;
            }, import("vue").PublicProps, {
                type: "embed" | "track";
                hide: boolean;
                disableHorizontal: boolean;
                disableVertical: boolean;
            }, true, {}, {}, {
                ResizeObserver: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    watchOnUpdated: BooleanConstructor;
                }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "resize"[], "resize", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    watchOnUpdated: BooleanConstructor;
                }>> & Readonly<{
                    onResize?: ((...args: any[]) => any) | undefined;
                }>, {
                    watchOnUpdated: boolean;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                Thumb: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    data: {
                        type: import("vue").PropType<import("../scrollbar/interface").ThumbData>;
                    };
                    direction: {
                        type: import("vue").PropType<"horizontal" | "vertical">;
                        default: string;
                    };
                    alwaysShow: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    both: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>, {
                    visible: import("vue").Ref<boolean, boolean>;
                    trackRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                    thumbRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                    prefixCls: string;
                    thumbCls: import("vue").ComputedRef<(string | {
                        [x: string]: boolean;
                    })[]>;
                    thumbStyle: import("vue").ComputedRef<{
                        [x: string]: string;
                    }>;
                    handleThumbMouseDown: (ev: MouseEvent) => void;
                    handleTrackClick: (ev: MouseEvent) => void;
                    setOffset: (_offset: number) => void;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "scroll"[], "scroll", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    data: {
                        type: import("vue").PropType<import("../scrollbar/interface").ThumbData>;
                    };
                    direction: {
                        type: import("vue").PropType<"horizontal" | "vertical">;
                        default: string;
                    };
                    alwaysShow: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    both: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & Readonly<{
                    onScroll?: ((...args: any[]) => any) | undefined;
                }>, {
                    direction: "horizontal" | "vertical";
                    both: boolean;
                    alwaysShow: boolean;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("vue").ExtractPropTypes<{
                type: {
                    type: import("vue").PropType<"embed" | "track">;
                    default: string;
                };
                outerClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
                outerStyle: {
                    type: import("vue").PropType<import("vue").StyleValue>;
                };
                hide: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disableHorizontal: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disableVertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onScroll?: ((ev: Event) => any) | undefined;
            }>, {
                prefixCls: string;
                cls: import("vue").ComputedRef<(string | Record<string, any> | undefined)[]>;
                style: import("vue").ComputedRef<import("vue").StyleValue[]>;
                containerRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                horizontalThumbRef: import("vue").Ref<any, any>;
                verticalThumbRef: import("vue").Ref<any, any>;
                horizontalData: import("vue").Ref<import("../scrollbar/interface").ThumbData | undefined, import("../scrollbar/interface").ThumbData | undefined>;
                verticalData: import("vue").Ref<import("../scrollbar/interface").ThumbData | undefined, import("../scrollbar/interface").ThumbData | undefined>;
                isBoth: import("vue").Ref<boolean, boolean>;
                hasHorizontalScrollbar: import("vue").ComputedRef<boolean>;
                hasVerticalScrollbar: import("vue").ComputedRef<boolean>;
                handleResize: () => void;
                handleScroll: (ev: Event) => void;
                handleHorizontalScroll: (offset: number) => void;
                handleVerticalScroll: (offset: number) => void;
            }, {}, {}, {
                scrollTo(options?: number | {
                    left?: number | undefined;
                    top?: number | undefined;
                } | undefined, y?: number | undefined): void;
                scrollTop(top: number): void;
                scrollLeft(left: number): void;
            }, {
                type: "embed" | "track";
                hide: boolean;
                disableHorizontal: boolean;
                disableVertical: boolean;
            }>;
            __isFragment?: undefined;
            __isTeleport?: undefined;
            __isSuspense?: undefined;
        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            type: {
                type: import("vue").PropType<"embed" | "track">;
                default: string;
            };
            outerClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
            outerStyle: {
                type: import("vue").PropType<import("vue").StyleValue>;
            };
            hide: {
                type: BooleanConstructor;
                default: boolean;
            };
            disableHorizontal: {
                type: BooleanConstructor;
                default: boolean;
            };
            disableVertical: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            onScroll?: ((ev: Event) => any) | undefined;
        }>, {
            prefixCls: string;
            cls: import("vue").ComputedRef<(string | Record<string, any> | undefined)[]>;
            style: import("vue").ComputedRef<import("vue").StyleValue[]>;
            containerRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
            horizontalThumbRef: import("vue").Ref<any, any>;
            verticalThumbRef: import("vue").Ref<any, any>;
            horizontalData: import("vue").Ref<import("../scrollbar/interface").ThumbData | undefined, import("../scrollbar/interface").ThumbData | undefined>;
            verticalData: import("vue").Ref<import("../scrollbar/interface").ThumbData | undefined, import("../scrollbar/interface").ThumbData | undefined>;
            isBoth: import("vue").Ref<boolean, boolean>;
            hasHorizontalScrollbar: import("vue").ComputedRef<boolean>;
            hasVerticalScrollbar: import("vue").ComputedRef<boolean>;
            handleResize: () => void;
            handleScroll: (ev: Event) => void;
            handleHorizontalScroll: (offset: number) => void;
            handleVerticalScroll: (offset: number) => void;
        }, {}, {}, {
            scrollTo(options?: number | {
                left?: number | undefined;
                top?: number | undefined;
            } | undefined, y?: number | undefined): void;
            scrollTop(top: number): void;
            scrollLeft(left: number): void;
        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            scroll: (ev: Event) => true;
        }, string, {
            type: "embed" | "track";
            hide: boolean;
            disableHorizontal: boolean;
            disableVertical: boolean;
        }, {}, string, {}, {
            ResizeObserver: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                watchOnUpdated: BooleanConstructor;
            }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                [key: string]: any;
            }>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "resize"[], "resize", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                watchOnUpdated: BooleanConstructor;
            }>> & Readonly<{
                onResize?: ((...args: any[]) => any) | undefined;
            }>, {
                watchOnUpdated: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            Thumb: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                data: {
                    type: import("vue").PropType<import("../scrollbar/interface").ThumbData>;
                };
                direction: {
                    type: import("vue").PropType<"horizontal" | "vertical">;
                    default: string;
                };
                alwaysShow: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                both: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>, {
                visible: import("vue").Ref<boolean, boolean>;
                trackRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                thumbRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
                prefixCls: string;
                thumbCls: import("vue").ComputedRef<(string | {
                    [x: string]: boolean;
                })[]>;
                thumbStyle: import("vue").ComputedRef<{
                    [x: string]: string;
                }>;
                handleThumbMouseDown: (ev: MouseEvent) => void;
                handleTrackClick: (ev: MouseEvent) => void;
                setOffset: (_offset: number) => void;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "scroll"[], "scroll", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                data: {
                    type: import("vue").PropType<import("../scrollbar/interface").ThumbData>;
                };
                direction: {
                    type: import("vue").PropType<"horizontal" | "vertical">;
                    default: string;
                };
                alwaysShow: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                both: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onScroll?: ((...args: any[]) => any) | undefined;
            }>, {
                direction: "horizontal" | "vertical";
                both: boolean;
                alwaysShow: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
            install: (app: App<any>, options?: ArcoOptions | undefined) => void;
        };
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    IconLeft: any;
    IconRight: any;
} & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
    install: (app: App, options?: ArcoOptions | undefined) => void;
};
export declare type TransferInstance = InstanceType<typeof _Transfer>;
export default Transfer;