hfn-components 0.6.1 → 0.6.2

package/es/components/htTarget/index.d.ts

@@ -0,0 +1,2028 @@
+export declare const HtTarget: import("hfn-components/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+    readonly fundType: {
+        readonly type: StringConstructor;
+        readonly default: "fund";
+    };
+    readonly targetType: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly dialogShow: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly targetData: {
+        readonly type: import("vue").PropType<import("./src/htTarget").target[]>;
+        readonly default: readonly [];
+    };
+}, {
+    props: import("@vue/shared").LooseRequired<{
+        readonly targetData: import("./src/htTarget").target[];
+        readonly fundType: string;
+        readonly targetType: string;
+        readonly dialogShow: boolean;
+        readonly onChoiceTarget?: ((...args: any[]) => any) | undefined;
+        readonly onChoiceCancel?: ((...args: any[]) => any) | undefined;
+    } & {}>;
+    emit: (event: "choiceTarget" | "choiceCancel", ...args: any[]) => void;
+    targetHead: import("vue").Ref<{
+        name: string;
+        key: string;
+    }[]>;
+    allfoot: import("vue").Ref<{
+        name: string;
+        key: string;
+        dealType: string;
+    }[]>;
+    selectedHead: import("vue").Ref<string>;
+    checkList: import("vue").Ref<string[]>;
+    dialogShow: import("vue").Ref<boolean>;
+    typeTag: import("vue").Ref<string>;
+    headChange: () => void;
+    typeChange: () => void;
+    selectedTree: import("vue").Ref<Record<string, string[]>>;
+    selectedList: import("vue").Ref<{
+        name: string;
+        key: string;
+        dealType: string;
+    }[]>;
+    selectedTarget: (val: string, headKey: string, type: string) => void;
+    deleteItem: (key: string) => void;
+    confirmTarge: () => void;
+    readonly ElDialog: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+        readonly appendToBody: BooleanConstructor;
+        readonly appendTo: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, "body", boolean>;
+        readonly beforeClose: {
+            readonly type: import("vue").PropType<import("element-plus").DialogBeforeCloseFn>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly destroyOnClose: BooleanConstructor;
+        readonly closeOnClickModal: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly closeOnPressEscape: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly lockScroll: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly modal: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly openDelay: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+        readonly closeDelay: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+        readonly top: {
+            readonly type: import("vue").PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly modelValue: BooleanConstructor;
+        readonly modalClass: StringConstructor;
+        readonly width: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly zIndex: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly trapFocus: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly headerAriaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+        readonly center: BooleanConstructor;
+        readonly alignCenter: BooleanConstructor;
+        readonly closeIcon: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly draggable: BooleanConstructor;
+        readonly overflow: BooleanConstructor;
+        readonly fullscreen: BooleanConstructor;
+        readonly showClose: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly ariaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            readonly appendToBody: BooleanConstructor;
+            readonly appendTo: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, "body", boolean>;
+            readonly beforeClose: {
+                readonly type: import("vue").PropType<import("element-plus").DialogBeforeCloseFn>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly destroyOnClose: BooleanConstructor;
+            readonly closeOnClickModal: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly closeOnPressEscape: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly lockScroll: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly modal: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly openDelay: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+            readonly closeDelay: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+            readonly top: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly modelValue: BooleanConstructor;
+            readonly modalClass: StringConstructor;
+            readonly width: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly zIndex: {
+                readonly type: import("vue").PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly trapFocus: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+            readonly headerAriaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+            readonly center: BooleanConstructor;
+            readonly alignCenter: BooleanConstructor;
+            readonly closeIcon: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly draggable: BooleanConstructor;
+            readonly overflow: BooleanConstructor;
+            readonly fullscreen: BooleanConstructor;
+            readonly showClose: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly ariaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+        }>> & {
+            onClose?: (() => any) | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            onOpen?: (() => any) | undefined;
+            onOpened?: (() => any) | undefined;
+            onClosed?: (() => any) | undefined;
+            onOpenAutoFocus?: (() => any) | undefined;
+            onCloseAutoFocus?: (() => any) | undefined;
+        }>>;
+        slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string | undefined) => string;
+            e: (element?: string | undefined) => string;
+            m: (modifier?: string | undefined) => string;
+            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+            em: (element?: string | undefined, modifier?: string | undefined) => string;
+            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        dialogRef: import("vue").Ref<HTMLElement | undefined>;
+        headerRef: import("vue").Ref<HTMLElement | undefined>;
+        dialogContentRef: import("vue").Ref<any>;
+        visible: import("vue").Ref<boolean>;
+        titleId: import("vue").Ref<string>;
+        bodyId: import("vue").Ref<string>;
+        style: import("vue").ComputedRef<import("vue").CSSProperties>;
+        overlayDialogStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+        rendered: import("vue").Ref<boolean>;
+        zIndex: import("vue").Ref<number>;
+        afterEnter: () => void;
+        afterLeave: () => void;
+        beforeLeave: () => void;
+        handleClose: () => void;
+        onModalClick: () => void;
+        onOpenAutoFocus: () => void;
+        onCloseAutoFocus: () => void;
+        onCloseRequested: () => void;
+        onFocusoutPrevented: (event: CustomEvent<any>) => void;
+        overlayEvent: {
+            onClick: (e: MouseEvent) => void;
+            onMousedown: (e: MouseEvent) => void;
+            onMouseup: (e: MouseEvent) => void;
+        };
+        draggable: import("vue").ComputedRef<boolean>;
+        ElOverlay: import("vue").DefineComponent<{
+            readonly mask: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly customMaskEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+            readonly overlayClass: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => string | string[] | Record<string, boolean>) | (() => string | string[] | Record<string, boolean>) | ((new (...args: any[]) => string | string[] | Record<string, boolean>) | (() => string | string[] | Record<string, boolean>))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly zIndex: {
+                readonly type: import("vue").PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            click: (evt: MouseEvent) => boolean;
+        }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            readonly mask: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly customMaskEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+            readonly overlayClass: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => string | string[] | Record<string, boolean>) | (() => string | string[] | Record<string, boolean>) | ((new (...args: any[]) => string | string[] | Record<string, boolean>) | (() => string | string[] | Record<string, boolean>))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly zIndex: {
+                readonly type: import("vue").PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & {
+            onClick?: ((evt: MouseEvent) => any) | undefined;
+        }, {
+            readonly mask: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
+            readonly customMaskEvent: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
+        }, {}>;
+        ElFocusTrap: import("vue").DefineComponent<{
+            loop: BooleanConstructor;
+            trapped: BooleanConstructor;
+            focusTrapEl: import("vue").PropType<HTMLElement>;
+            focusStartEl: {
+                type: import("vue").PropType<HTMLElement | "container" | "first">;
+                default: string;
+            };
+        }, {
+            onKeydown: (e: KeyboardEvent) => void;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focusAfterTrapped" | "focusAfterReleased" | "focusin" | "focusout" | "focusout-prevented" | "release-requested")[], "focusAfterTrapped" | "focusAfterReleased" | "focusin" | "focusout" | "focusout-prevented" | "release-requested", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            loop: BooleanConstructor;
+            trapped: BooleanConstructor;
+            focusTrapEl: import("vue").PropType<HTMLElement>;
+            focusStartEl: {
+                type: import("vue").PropType<HTMLElement | "container" | "first">;
+                default: string;
+            };
+        }>> & {
+            onFocusAfterReleased?: ((...args: any[]) => any) | undefined;
+            onFocusAfterTrapped?: ((...args: any[]) => any) | undefined;
+            onFocusin?: ((...args: any[]) => any) | undefined;
+            onFocusout?: ((...args: any[]) => any) | undefined;
+            "onFocusout-prevented"?: ((...args: any[]) => any) | undefined;
+            "onRelease-requested"?: ((...args: any[]) => any) | undefined;
+        }, {
+            trapped: boolean;
+            loop: boolean;
+            focusStartEl: HTMLElement | "container" | "first";
+        }, {}>;
+        ElDialogContent: import("vue").DefineComponent<{
+            readonly center: BooleanConstructor;
+            readonly alignCenter: BooleanConstructor;
+            readonly closeIcon: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly draggable: BooleanConstructor;
+            readonly overflow: BooleanConstructor;
+            readonly fullscreen: BooleanConstructor;
+            readonly showClose: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly ariaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+        }, {
+            t: import("element-plus").Translator;
+            Close: any;
+            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                readonly center: BooleanConstructor;
+                readonly alignCenter: BooleanConstructor;
+                readonly closeIcon: {
+                    readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly draggable: BooleanConstructor;
+                readonly overflow: BooleanConstructor;
+                readonly fullscreen: BooleanConstructor;
+                readonly showClose: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                readonly ariaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+            }>> & {
+                onClose?: (() => any) | undefined;
+            }>>;
+            dialogRef: import("vue").Ref<HTMLElement | undefined>;
+            headerRef: import("vue").Ref<HTMLElement | undefined>;
+            bodyId: import("vue").Ref<string>;
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string | undefined) => string;
+                e: (element?: string | undefined) => string;
+                m: (modifier?: string | undefined) => string;
+                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                em: (element?: string | undefined, modifier?: string | undefined) => string;
+                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            style: import("vue").ComputedRef<import("vue").CSSProperties>;
+            focusTrapRef: import("vue").Ref<HTMLElement | undefined>;
+            dialogKls: import("vue").ComputedRef<(string | {
+                [x: string]: boolean;
+            })[]>;
+            composedDialogRef: (el: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | Element | null) => void;
+            draggable: import("vue").ComputedRef<boolean>;
+            overflow: import("vue").ComputedRef<boolean>;
+            ElIcon: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+                readonly size: {
+                    readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly color: {
+                    readonly type: import("vue").PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }, {
+                props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                    readonly size: {
+                        readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly color: {
+                        readonly type: import("vue").PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                }>> & {
+                    [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+                }>>;
+                ns: {
+                    namespace: import("vue").ComputedRef<string>;
+                    b: (blockSuffix?: string | undefined) => string;
+                    e: (element?: string | undefined) => string;
+                    m: (modifier?: string | undefined) => string;
+                    be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                    em: (element?: string | undefined, modifier?: string | undefined) => string;
+                    bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                    bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                    is: {
+                        (name: string, state: boolean | undefined): string;
+                        (name: string): string;
+                    };
+                    cssVar: (object: Record<string, string>) => Record<string, string>;
+                    cssVarName: (name: string) => string;
+                    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                    cssVarBlockName: (name: string) => string;
+                };
+                style: import("vue").ComputedRef<import("vue").CSSProperties>;
+            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+                readonly size: {
+                    readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly color: {
+                    readonly type: import("vue").PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }>>, {}, {}>> & Record<string, any>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            close: () => boolean;
+        }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            readonly center: BooleanConstructor;
+            readonly alignCenter: BooleanConstructor;
+            readonly closeIcon: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly draggable: BooleanConstructor;
+            readonly overflow: BooleanConstructor;
+            readonly fullscreen: BooleanConstructor;
+            readonly showClose: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly ariaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+        }>> & {
+            onClose?: (() => any) | undefined;
+        }, {
+            readonly title: string;
+            readonly center: boolean;
+            readonly overflow: boolean;
+            readonly showClose: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
+            readonly ariaLevel: string;
+            readonly alignCenter: boolean;
+            readonly draggable: boolean;
+            readonly fullscreen: boolean;
+        }, {}>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        open: () => boolean;
+        opened: () => boolean;
+        close: () => boolean;
+        closed: () => boolean;
+        "update:modelValue": (value: boolean) => boolean;
+        openAutoFocus: () => boolean;
+        closeAutoFocus: () => boolean;
+    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly appendToBody: BooleanConstructor;
+        readonly appendTo: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, "body", boolean>;
+        readonly beforeClose: {
+            readonly type: import("vue").PropType<import("element-plus").DialogBeforeCloseFn>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly destroyOnClose: BooleanConstructor;
+        readonly closeOnClickModal: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly closeOnPressEscape: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly lockScroll: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly modal: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly openDelay: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+        readonly closeDelay: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+        readonly top: {
+            readonly type: import("vue").PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly modelValue: BooleanConstructor;
+        readonly modalClass: StringConstructor;
+        readonly width: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly zIndex: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly trapFocus: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly headerAriaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+        readonly center: BooleanConstructor;
+        readonly alignCenter: BooleanConstructor;
+        readonly closeIcon: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly draggable: BooleanConstructor;
+        readonly overflow: BooleanConstructor;
+        readonly fullscreen: BooleanConstructor;
+        readonly showClose: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly ariaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+    }>> & {
+        onClose?: (() => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        onOpen?: (() => any) | undefined;
+        onOpened?: (() => any) | undefined;
+        onClosed?: (() => any) | undefined;
+        onOpenAutoFocus?: (() => any) | undefined;
+        onCloseAutoFocus?: (() => any) | undefined;
+    }, {
+        readonly title: string;
+        readonly center: boolean;
+        readonly modelValue: boolean;
+        readonly appendTo: string;
+        readonly overflow: boolean;
+        readonly showClose: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
+        readonly ariaLevel: string;
+        readonly alignCenter: boolean;
+        readonly draggable: boolean;
+        readonly fullscreen: boolean;
+        readonly closeOnClickModal: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
+        readonly closeOnPressEscape: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
+        readonly lockScroll: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
+        readonly modal: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
+        readonly openDelay: number;
+        readonly closeDelay: number;
+        readonly trapFocus: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
+        readonly headerAriaLevel: string;
+        readonly appendToBody: boolean;
+        readonly destroyOnClose: boolean;
+    }, {}>> & Record<string, any>;
+    readonly ElButton: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+        readonly size: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
+        readonly icon: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "button" | "reset" | "submit", unknown, "button", boolean>;
+        readonly loading: BooleanConstructor;
+        readonly loadingIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, () => any, boolean>;
+        readonly plain: BooleanConstructor;
+        readonly text: BooleanConstructor;
+        readonly link: BooleanConstructor;
+        readonly bg: BooleanConstructor;
+        readonly autofocus: BooleanConstructor;
+        readonly round: BooleanConstructor;
+        readonly circle: BooleanConstructor;
+        readonly color: StringConstructor;
+        readonly dark: BooleanConstructor;
+        readonly autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+        readonly tag: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, "button", boolean>;
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
+            readonly icon: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "button" | "reset" | "submit", unknown, "button", boolean>;
+            readonly loading: BooleanConstructor;
+            readonly loadingIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, () => any, boolean>;
+            readonly plain: BooleanConstructor;
+            readonly text: BooleanConstructor;
+            readonly link: BooleanConstructor;
+            readonly bg: BooleanConstructor;
+            readonly autofocus: BooleanConstructor;
+            readonly round: BooleanConstructor;
+            readonly circle: BooleanConstructor;
+            readonly color: StringConstructor;
+            readonly dark: BooleanConstructor;
+            readonly autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+            readonly tag: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, "button", boolean>;
+        }>> & {
+            onClick?: ((evt: MouseEvent) => any) | undefined;
+        }>>;
+        emit: (event: "click", evt: MouseEvent) => void;
+        buttonStyle: import("vue").ComputedRef<Record<string, string>>;
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string | undefined) => string;
+            e: (element?: string | undefined) => string;
+            m: (modifier?: string | undefined) => string;
+            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+            em: (element?: string | undefined, modifier?: string | undefined) => string;
+            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        _ref: import("vue").Ref<HTMLButtonElement | undefined>;
+        _size: import("vue").ComputedRef<"" | "default" | "small" | "large">;
+        _type: import("vue").ComputedRef<"" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger">;
+        _disabled: import("vue").ComputedRef<boolean>;
+        _props: import("vue").ComputedRef<{
+            ariaDisabled: boolean;
+            disabled: boolean;
+            autofocus: boolean;
+            type: import("element-plus").ButtonType<StringConstructor, "button" | "reset" | "submit", unknown>;
+        } | {
+            ariaDisabled?: undefined;
+            disabled?: undefined;
+            autofocus?: undefined;
+            type?: undefined;
+        }>;
+        shouldAddSpace: import("vue").ComputedRef<boolean>;
+        handleClick: (evt: MouseEvent) => void;
+        buttonKls: import("vue").ComputedRef<string[]>;
+        ElIcon: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly color: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }, {
+            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                readonly size: {
+                    readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly color: {
+                    readonly type: import("vue").PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }>> & {
+                [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+            }>>;
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string | undefined) => string;
+                e: (element?: string | undefined) => string;
+                m: (modifier?: string | undefined) => string;
+                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                em: (element?: string | undefined, modifier?: string | undefined) => string;
+                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            style: import("vue").ComputedRef<import("vue").CSSProperties>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly color: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>>, {}, {}>> & Record<string, any>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        click: (evt: MouseEvent) => boolean;
+    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly size: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
+        readonly icon: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "button" | "reset" | "submit", unknown, "button", boolean>;
+        readonly loading: BooleanConstructor;
+        readonly loadingIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, () => any, boolean>;
+        readonly plain: BooleanConstructor;
+        readonly text: BooleanConstructor;
+        readonly link: BooleanConstructor;
+        readonly bg: BooleanConstructor;
+        readonly autofocus: BooleanConstructor;
+        readonly round: BooleanConstructor;
+        readonly circle: BooleanConstructor;
+        readonly color: StringConstructor;
+        readonly dark: BooleanConstructor;
+        readonly autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+        readonly tag: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, "button", boolean>;
+    }>> & {
+        onClick?: ((evt: MouseEvent) => any) | undefined;
+    }, {
+        readonly type: import("element-plus").ButtonType<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown>;
+        readonly link: boolean;
+        readonly dark: boolean;
+        readonly disabled: boolean;
+        readonly text: boolean;
+        readonly autofocus: boolean;
+        readonly round: boolean;
+        readonly circle: boolean;
+        readonly tag: import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>;
+        readonly loading: boolean;
+        readonly nativeType: import("element-plus").ButtonType<StringConstructor, "button" | "reset" | "submit", unknown>;
+        readonly loadingIcon: import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>;
+        readonly autoInsertSpace: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
+        readonly plain: boolean;
+        readonly bg: boolean;
+    }, {}>> & {
+        ButtonGroup: import("vue").DefineComponent<{
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
+        }, {
+            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                readonly size: {
+                    readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
+            }>> & {
+                [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+            }>>;
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string | undefined) => string;
+                e: (element?: string | undefined) => string;
+                m: (modifier?: string | undefined) => string;
+                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                em: (element?: string | undefined, modifier?: string | undefined) => string;
+                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
+        }>>, {
+            readonly type: import("element-plus").ButtonType<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown>;
+        }, {}>;
+    };
+    readonly ElRow: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+        readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+        readonly gutter: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+        readonly justify: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "center" | "start" | "end" | "space-around" | "space-between" | "space-evenly", unknown, "start", boolean>;
+        readonly align: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "top" | "bottom" | "middle", unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+            readonly gutter: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+            readonly justify: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "center" | "start" | "end" | "space-around" | "space-between" | "space-evenly", unknown, "start", boolean>;
+            readonly align: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "top" | "bottom" | "middle", unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & {
+            [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+        }>>;
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string | undefined) => string;
+            e: (element?: string | undefined) => string;
+            m: (modifier?: string | undefined) => string;
+            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+            em: (element?: string | undefined, modifier?: string | undefined) => string;
+            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        gutter: import("vue").ComputedRef<number>;
+        style: import("vue").ComputedRef<import("vue").CSSProperties>;
+        rowKls: import("vue").ComputedRef<string[]>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+        readonly gutter: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+        readonly justify: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "center" | "start" | "end" | "space-around" | "space-between" | "space-evenly", unknown, "start", boolean>;
+        readonly align: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "top" | "bottom" | "middle", unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>>, {
+        readonly justify: import("element-plus").ButtonType<StringConstructor, "center" | "start" | "end" | "space-around" | "space-between" | "space-evenly", unknown>;
+        readonly tag: string;
+        readonly gutter: number;
+    }, {}>> & Record<string, any>;
+    readonly ElCol: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+        readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+        readonly span: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 24, boolean>;
+        readonly offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+        readonly pull: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+        readonly push: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+        readonly xs: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown, () => import("element-plus").UploadData<{}>, boolean>;
+        readonly sm: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown, () => import("element-plus").UploadData<{}>, boolean>;
+        readonly md: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown, () => import("element-plus").UploadData<{}>, boolean>;
+        readonly lg: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown, () => import("element-plus").UploadData<{}>, boolean>;
+        readonly xl: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown, () => import("element-plus").UploadData<{}>, boolean>;
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+            readonly span: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 24, boolean>;
+            readonly offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+            readonly pull: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+            readonly push: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+            readonly xs: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown, () => import("element-plus").UploadData<{}>, boolean>;
+            readonly sm: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown, () => import("element-plus").UploadData<{}>, boolean>;
+            readonly md: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown, () => import("element-plus").UploadData<{}>, boolean>;
+            readonly lg: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown, () => import("element-plus").UploadData<{}>, boolean>;
+            readonly xl: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown, () => import("element-plus").UploadData<{}>, boolean>;
+        }>> & {
+            [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+        }>>;
+        gutter: import("vue").ComputedRef<number>;
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string | undefined) => string;
+            e: (element?: string | undefined) => string;
+            m: (modifier?: string | undefined) => string;
+            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+            em: (element?: string | undefined, modifier?: string | undefined) => string;
+            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        style: import("vue").ComputedRef<import("vue").CSSProperties>;
+        colKls: import("vue").ComputedRef<(string | string[])[]>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+        readonly span: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 24, boolean>;
+        readonly offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+        readonly pull: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+        readonly push: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+        readonly xs: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown, () => import("element-plus").UploadData<{}>, boolean>;
+        readonly sm: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown, () => import("element-plus").UploadData<{}>, boolean>;
+        readonly md: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown, () => import("element-plus").UploadData<{}>, boolean>;
+        readonly lg: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown, () => import("element-plus").UploadData<{}>, boolean>;
+        readonly xl: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown, () => import("element-plus").UploadData<{}>, boolean>;
+    }>>, {
+        readonly offset: number;
+        readonly push: number;
+        readonly tag: string;
+        readonly span: number;
+        readonly pull: number;
+        readonly xs: import("element-plus").ButtonType<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown>;
+        readonly sm: import("element-plus").ButtonType<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown>;
+        readonly md: import("element-plus").ButtonType<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown>;
+        readonly lg: import("element-plus").ButtonType<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown>;
+        readonly xl: import("element-plus").ButtonType<(new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize) | ((new (...args: any[]) => number | import("element-plus").ColSizeObject) | (() => import("element-plus").ColSize))[], unknown, unknown>;
+    }, {}>> & Record<string, any>;
+    readonly ElRadioGroup: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+        readonly ariaLabel: StringConstructor;
+        readonly id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+        readonly size: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly modelValue: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, undefined, boolean>;
+        readonly fill: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+        readonly textColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+        readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            readonly ariaLabel: StringConstructor;
+            readonly id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly modelValue: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, undefined, boolean>;
+            readonly fill: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+            readonly textColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+            readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        }>> & {
+            onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+            "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+        }>>;
+        emit: ((event: "update:modelValue", val: string | number | boolean | undefined) => void) & ((event: "change", val: string | number | boolean | undefined) => void);
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string | undefined) => string;
+            e: (element?: string | undefined) => string;
+            m: (modifier?: string | undefined) => string;
+            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+            em: (element?: string | undefined, modifier?: string | undefined) => string;
+            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        radioId: import("vue").Ref<string>;
+        radioGroupRef: import("vue").Ref<HTMLDivElement | undefined>;
+        formItem: import("element-plus").FormItemContext | undefined;
+        groupId: import("vue").Ref<string | undefined>;
+        isLabeledByFormItem: import("vue").ComputedRef<boolean>;
+        changeEvent: (value: import("element-plus").ButtonType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown> | undefined) => void;
+        name: import("vue").ComputedRef<string>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (val: string | number | boolean | undefined) => boolean;
+        change: (val: string | number | boolean | undefined) => boolean;
+    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly ariaLabel: StringConstructor;
+        readonly id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+        readonly size: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly modelValue: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, undefined, boolean>;
+        readonly fill: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+        readonly textColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+        readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    }>> & {
+        onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+        "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+    }, {
+        readonly fill: string;
+        readonly modelValue: import("element-plus").ButtonType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>;
+        readonly id: string;
+        readonly disabled: boolean;
+        readonly name: string;
+        readonly label: string;
+        readonly validateEvent: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
+        readonly textColor: string;
+    }, {}>>;
+    readonly ElRadio: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+        readonly border: BooleanConstructor;
+        readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+        readonly size: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly label: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+        readonly value: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+        readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            readonly border: BooleanConstructor;
+            readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly label: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+            readonly value: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+            readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+        }>> & {
+            onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+            "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+        }>>;
+        emit: ((event: "update:modelValue", val: string | number | boolean | undefined) => void) & ((event: "change", val: string | number | boolean | undefined) => void);
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string | undefined) => string;
+            e: (element?: string | undefined) => string;
+            m: (modifier?: string | undefined) => string;
+            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+            em: (element?: string | undefined, modifier?: string | undefined) => string;
+            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        radioRef: import("vue").Ref<HTMLInputElement | undefined>;
+        radioGroup: import("element-plus").RadioGroupContext | undefined;
+        focus: import("vue").Ref<boolean>;
+        size: import("vue").ComputedRef<"" | "default" | "small" | "large">;
+        disabled: import("vue").ComputedRef<boolean>;
+        modelValue: import("vue").WritableComputedRef<import("element-plus").ButtonType<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown> | undefined>;
+        actualValue: import("vue").ComputedRef<import("element-plus").ButtonType<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown> | undefined>;
+        handleChange: () => void;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (val: string | number | boolean | undefined) => boolean;
+        change: (val: string | number | boolean | undefined) => boolean;
+    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly border: BooleanConstructor;
+        readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+        readonly size: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly label: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+        readonly value: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+        readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    }>> & {
+        onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+        "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+    }, {
+        readonly value: import("element-plus").ButtonType<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown>;
+        readonly modelValue: import("element-plus").ButtonType<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown>;
+        readonly disabled: boolean;
+        readonly name: string;
+        readonly label: import("element-plus").ButtonType<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown>;
+        readonly border: boolean;
+    }, {}>> & {
+        RadioButton: import("vue").DefineComponent<{
+            readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly label: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+            readonly value: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+            readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+        }, {
+            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+                readonly size: {
+                    readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly disabled: BooleanConstructor;
+                readonly label: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+                readonly value: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+                readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+            }>> & {
+                [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+            }>>;
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string | undefined) => string;
+                e: (element?: string | undefined) => string;
+                m: (modifier?: string | undefined) => string;
+                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                em: (element?: string | undefined, modifier?: string | undefined) => string;
+                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            radioRef: import("vue").Ref<HTMLInputElement | undefined>;
+            focus: import("vue").Ref<boolean>;
+            size: import("vue").ComputedRef<"" | "default" | "small" | "large">;
+            disabled: import("vue").ComputedRef<boolean>;
+            modelValue: import("vue").WritableComputedRef<import("element-plus").ButtonType<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown> | undefined>;
+            radioGroup: import("element-plus").RadioGroupContext | undefined;
+            actualValue: import("vue").ComputedRef<import("element-plus").ButtonType<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown> | undefined>;
+            activeStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly label: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+            readonly value: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+            readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+        }>>, {
+            readonly value: import("element-plus").ButtonType<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown>;
+            readonly modelValue: import("element-plus").ButtonType<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown>;
+            readonly disabled: boolean;
+            readonly name: string;
+            readonly label: import("element-plus").ButtonType<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown>;
+        }, {}>;
+        RadioGroup: import("vue").DefineComponent<{
+            readonly ariaLabel: StringConstructor;
+            readonly id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly modelValue: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, undefined, boolean>;
+            readonly fill: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+            readonly textColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+            readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        }, {
+            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                readonly ariaLabel: StringConstructor;
+                readonly id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+                readonly size: {
+                    readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly disabled: BooleanConstructor;
+                readonly modelValue: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, undefined, boolean>;
+                readonly fill: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                readonly label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+                readonly textColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+                readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            }>> & {
+                onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+                "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+            }>>;
+            emit: ((event: "update:modelValue", val: string | number | boolean | undefined) => void) & ((event: "change", val: string | number | boolean | undefined) => void);
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string | undefined) => string;
+                e: (element?: string | undefined) => string;
+                m: (modifier?: string | undefined) => string;
+                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                em: (element?: string | undefined, modifier?: string | undefined) => string;
+                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            radioId: import("vue").Ref<string>;
+            radioGroupRef: import("vue").Ref<HTMLDivElement | undefined>;
+            formItem: import("element-plus").FormItemContext | undefined;
+            groupId: import("vue").Ref<string | undefined>;
+            isLabeledByFormItem: import("vue").ComputedRef<boolean>;
+            changeEvent: (value: import("element-plus").ButtonType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown> | undefined) => void;
+            name: import("vue").ComputedRef<string>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (val: string | number | boolean | undefined) => boolean;
+            change: (val: string | number | boolean | undefined) => boolean;
+        }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            readonly ariaLabel: StringConstructor;
+            readonly id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly modelValue: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, undefined, boolean>;
+            readonly fill: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+            readonly textColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+            readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        }>> & {
+            onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+            "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+        }, {
+            readonly fill: string;
+            readonly modelValue: import("element-plus").ButtonType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>;
+            readonly id: string;
+            readonly disabled: boolean;
+            readonly name: string;
+            readonly label: string;
+            readonly validateEvent: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
+            readonly textColor: string;
+        }, {}>;
+    };
+    readonly ElCheckboxGroup: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+        readonly ariaLabel: StringConstructor;
+        readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType) | ((new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
+        readonly disabled: BooleanConstructor;
+        readonly min: NumberConstructor;
+        readonly max: NumberConstructor;
+        readonly size: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly label: StringConstructor;
+        readonly fill: StringConstructor;
+        readonly textColor: StringConstructor;
+        readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+        readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            readonly ariaLabel: StringConstructor;
+            readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType) | ((new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
+            readonly disabled: BooleanConstructor;
+            readonly min: NumberConstructor;
+            readonly max: NumberConstructor;
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly label: StringConstructor;
+            readonly fill: StringConstructor;
+            readonly textColor: StringConstructor;
+            readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+            readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        }>> & {
+            onChange?: ((val: import("element-plus").CheckboxValueType[]) => any) | undefined;
+            "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxGroupValueType) => any) | undefined;
+        }>>;
+        emit: ((event: "update:modelValue", val: import("element-plus").CheckboxGroupValueType) => void) & ((event: "change", val: import("element-plus").CheckboxValueType[]) => void);
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string | undefined) => string;
+            e: (element?: string | undefined) => string;
+            m: (modifier?: string | undefined) => string;
+            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+            em: (element?: string | undefined, modifier?: string | undefined) => string;
+            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        formItem: import("element-plus").FormItemContext | undefined;
+        groupId: import("vue").Ref<string | undefined>;
+        isLabeledByFormItem: import("vue").ComputedRef<boolean>;
+        changeEvent: (value: import("element-plus").CheckboxGroupValueType) => Promise<void>;
+        modelValue: import("vue").WritableComputedRef<import("element-plus").CheckboxGroupValueType>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (val: import("element-plus").CheckboxGroupValueType) => boolean;
+        change: (val: import("element-plus").CheckboxValueType[]) => boolean;
+    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly ariaLabel: StringConstructor;
+        readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType) | ((new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
+        readonly disabled: BooleanConstructor;
+        readonly min: NumberConstructor;
+        readonly max: NumberConstructor;
+        readonly size: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly label: StringConstructor;
+        readonly fill: StringConstructor;
+        readonly textColor: StringConstructor;
+        readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+        readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    }>> & {
+        onChange?: ((val: import("element-plus").CheckboxValueType[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxGroupValueType) => any) | undefined;
+    }, {
+        readonly modelValue: import("element-plus").CheckboxGroupValueType;
+        readonly disabled: boolean;
+        readonly validateEvent: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
+        readonly tag: string;
+    }, {}>>;
+    readonly ElCheckbox: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+        ariaControls: StringConstructor;
+        modelValue: {
+            type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        label: {
+            type: (StringConstructor | BooleanConstructor | NumberConstructor | ObjectConstructor)[];
+            default: undefined;
+        };
+        value: {
+            type: (StringConstructor | BooleanConstructor | NumberConstructor | ObjectConstructor)[];
+            default: undefined;
+        };
+        indeterminate: BooleanConstructor;
+        disabled: BooleanConstructor;
+        checked: BooleanConstructor;
+        name: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        trueValue: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        falseValue: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        trueLabel: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        falseLabel: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        id: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        controls: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        border: BooleanConstructor;
+        size: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        tabindex: (StringConstructor | NumberConstructor)[];
+        validateEvent: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            ariaControls: StringConstructor;
+            modelValue: {
+                type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+                default: undefined;
+            };
+            label: {
+                type: (StringConstructor | BooleanConstructor | NumberConstructor | ObjectConstructor)[];
+                default: undefined;
+            };
+            value: {
+                type: (StringConstructor | BooleanConstructor | NumberConstructor | ObjectConstructor)[];
+                default: undefined;
+            };
+            indeterminate: BooleanConstructor;
+            disabled: BooleanConstructor;
+            checked: BooleanConstructor;
+            name: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            trueValue: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: undefined;
+            };
+            falseValue: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: undefined;
+            };
+            trueLabel: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: undefined;
+            };
+            falseLabel: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: undefined;
+            };
+            id: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            controls: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            border: BooleanConstructor;
+            size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            tabindex: (StringConstructor | NumberConstructor)[];
+            validateEvent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & {
+            onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
+            "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
+        }>>;
+        slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        inputId: import("vue").Ref<string | undefined>;
+        isLabeledByFormItem: import("vue").ComputedRef<boolean>;
+        isChecked: import("vue").ComputedRef<boolean>;
+        isDisabled: import("vue").ComputedRef<boolean>;
+        isFocused: import("vue").Ref<boolean>;
+        checkboxSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;
+        hasOwnLabel: import("vue").ComputedRef<boolean>;
+        model: import("vue").WritableComputedRef<any>;
+        actualValue: import("vue").ComputedRef<string | number | boolean | Record<string, any> | undefined>;
+        handleChange: (e: Event) => void;
+        onClickRoot: (e: MouseEvent) => Promise<void>;
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string | undefined) => string;
+            e: (element?: string | undefined) => string;
+            m: (modifier?: string | undefined) => string;
+            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+            em: (element?: string | undefined, modifier?: string | undefined) => string;
+            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        compKls: import("vue").ComputedRef<string[]>;
+        spanKls: import("vue").ComputedRef<string[]>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (val: import("element-plus").CheckboxValueType) => boolean;
+        change: (val: import("element-plus").CheckboxValueType) => boolean;
+    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        ariaControls: StringConstructor;
+        modelValue: {
+            type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        label: {
+            type: (StringConstructor | BooleanConstructor | NumberConstructor | ObjectConstructor)[];
+            default: undefined;
+        };
+        value: {
+            type: (StringConstructor | BooleanConstructor | NumberConstructor | ObjectConstructor)[];
+            default: undefined;
+        };
+        indeterminate: BooleanConstructor;
+        disabled: BooleanConstructor;
+        checked: BooleanConstructor;
+        name: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        trueValue: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        falseValue: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        trueLabel: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        falseLabel: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        id: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        controls: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        border: BooleanConstructor;
+        size: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        tabindex: (StringConstructor | NumberConstructor)[];
+        validateEvent: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & {
+        onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
+        "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
+    }, {
+        value: string | number | boolean | Record<string, any>;
+        modelValue: string | number | boolean;
+        id: string;
+        disabled: boolean;
+        name: string;
+        label: string | number | boolean | Record<string, any>;
+        validateEvent: boolean;
+        border: boolean;
+        indeterminate: boolean;
+        checked: boolean;
+        trueValue: string | number;
+        falseValue: string | number;
+        trueLabel: string | number;
+        falseLabel: string | number;
+        controls: string;
+    }, {}>> & {
+        CheckboxButton: import("vue").DefineComponent<{
+            ariaControls: StringConstructor;
+            modelValue: {
+                type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+                default: undefined;
+            };
+            label: {
+                type: (StringConstructor | BooleanConstructor | NumberConstructor | ObjectConstructor)[];
+                default: undefined;
+            };
+            value: {
+                type: (StringConstructor | BooleanConstructor | NumberConstructor | ObjectConstructor)[];
+                default: undefined;
+            };
+            indeterminate: BooleanConstructor;
+            disabled: BooleanConstructor;
+            checked: BooleanConstructor;
+            name: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            trueValue: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: undefined;
+            };
+            falseValue: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: undefined;
+            };
+            trueLabel: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: undefined;
+            };
+            falseLabel: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: undefined;
+            };
+            id: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            controls: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            border: BooleanConstructor;
+            size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            tabindex: (StringConstructor | NumberConstructor)[];
+            validateEvent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }, {
+            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                ariaControls: StringConstructor;
+                modelValue: {
+                    type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+                    default: undefined;
+                };
+                label: {
+                    type: (StringConstructor | BooleanConstructor | NumberConstructor | ObjectConstructor)[];
+                    default: undefined;
+                };
+                value: {
+                    type: (StringConstructor | BooleanConstructor | NumberConstructor | ObjectConstructor)[];
+                    default: undefined;
+                };
+                indeterminate: BooleanConstructor;
+                disabled: BooleanConstructor;
+                checked: BooleanConstructor;
+                name: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                trueValue: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: undefined;
+                };
+                falseValue: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: undefined;
+                };
+                trueLabel: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: undefined;
+                };
+                falseLabel: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: undefined;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                controls: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                border: BooleanConstructor;
+                size: {
+                    readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                tabindex: (StringConstructor | NumberConstructor)[];
+                validateEvent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & {
+                onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
+                "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
+            }>>;
+            slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            isFocused: import("vue").Ref<boolean>;
+            isChecked: import("vue").ComputedRef<boolean>;
+            isDisabled: import("vue").ComputedRef<boolean>;
+            checkboxButtonSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;
+            model: import("vue").WritableComputedRef<any>;
+            actualValue: import("vue").ComputedRef<string | number | boolean | Record<string, any> | undefined>;
+            handleChange: (e: Event) => void;
+            checkboxGroup: ({
+                modelValue?: import("vue").WritableComputedRef<any> | undefined;
+                changeEvent?: ((...args: any) => any) | undefined;
+            } & import("vue").ToRefs<Pick<import("element-plus").CheckboxGroupProps, "fill" | "size" | "disabled" | "validateEvent" | "max" | "min" | "textColor">>) | undefined;
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string | undefined) => string;
+                e: (element?: string | undefined) => string;
+                m: (modifier?: string | undefined) => string;
+                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                em: (element?: string | undefined, modifier?: string | undefined) => string;
+                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            activeStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+            labelKls: import("vue").ComputedRef<string[]>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (val: import("element-plus").CheckboxValueType) => boolean;
+            change: (val: import("element-plus").CheckboxValueType) => boolean;
+        }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            ariaControls: StringConstructor;
+            modelValue: {
+                type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+                default: undefined;
+            };
+            label: {
+                type: (StringConstructor | BooleanConstructor | NumberConstructor | ObjectConstructor)[];
+                default: undefined;
+            };
+            value: {
+                type: (StringConstructor | BooleanConstructor | NumberConstructor | ObjectConstructor)[];
+                default: undefined;
+            };
+            indeterminate: BooleanConstructor;
+            disabled: BooleanConstructor;
+            checked: BooleanConstructor;
+            name: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            trueValue: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: undefined;
+            };
+            falseValue: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: undefined;
+            };
+            trueLabel: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: undefined;
+            };
+            falseLabel: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: undefined;
+            };
+            id: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            controls: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            border: BooleanConstructor;
+            size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            tabindex: (StringConstructor | NumberConstructor)[];
+            validateEvent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & {
+            onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
+            "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
+        }, {
+            value: string | number | boolean | Record<string, any>;
+            modelValue: string | number | boolean;
+            id: string;
+            disabled: boolean;
+            name: string;
+            label: string | number | boolean | Record<string, any>;
+            validateEvent: boolean;
+            border: boolean;
+            indeterminate: boolean;
+            checked: boolean;
+            trueValue: string | number;
+            falseValue: string | number;
+            trueLabel: string | number;
+            falseLabel: string | number;
+            controls: string;
+        }, {}>;
+        CheckboxGroup: import("vue").DefineComponent<{
+            readonly ariaLabel: StringConstructor;
+            readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType) | ((new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
+            readonly disabled: BooleanConstructor;
+            readonly min: NumberConstructor;
+            readonly max: NumberConstructor;
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly label: StringConstructor;
+            readonly fill: StringConstructor;
+            readonly textColor: StringConstructor;
+            readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+            readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        }, {
+            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                readonly ariaLabel: StringConstructor;
+                readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType) | ((new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
+                readonly disabled: BooleanConstructor;
+                readonly min: NumberConstructor;
+                readonly max: NumberConstructor;
+                readonly size: {
+                    readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly label: StringConstructor;
+                readonly fill: StringConstructor;
+                readonly textColor: StringConstructor;
+                readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+                readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            }>> & {
+                onChange?: ((val: import("element-plus").CheckboxValueType[]) => any) | undefined;
+                "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxGroupValueType) => any) | undefined;
+            }>>;
+            emit: ((event: "update:modelValue", val: import("element-plus").CheckboxGroupValueType) => void) & ((event: "change", val: import("element-plus").CheckboxValueType[]) => void);
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string | undefined) => string;
+                e: (element?: string | undefined) => string;
+                m: (modifier?: string | undefined) => string;
+                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                em: (element?: string | undefined, modifier?: string | undefined) => string;
+                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            formItem: import("element-plus").FormItemContext | undefined;
+            groupId: import("vue").Ref<string | undefined>;
+            isLabeledByFormItem: import("vue").ComputedRef<boolean>;
+            changeEvent: (value: import("element-plus").CheckboxGroupValueType) => Promise<void>;
+            modelValue: import("vue").WritableComputedRef<import("element-plus").CheckboxGroupValueType>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (val: import("element-plus").CheckboxGroupValueType) => boolean;
+            change: (val: import("element-plus").CheckboxValueType[]) => boolean;
+        }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            readonly ariaLabel: StringConstructor;
+            readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType) | ((new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
+            readonly disabled: BooleanConstructor;
+            readonly min: NumberConstructor;
+            readonly max: NumberConstructor;
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly label: StringConstructor;
+            readonly fill: StringConstructor;
+            readonly textColor: StringConstructor;
+            readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+            readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        }>> & {
+            onChange?: ((val: import("element-plus").CheckboxValueType[]) => any) | undefined;
+            "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxGroupValueType) => any) | undefined;
+        }, {
+            readonly modelValue: import("element-plus").CheckboxGroupValueType;
+            readonly disabled: boolean;
+            readonly validateEvent: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
+            readonly tag: string;
+        }, {}>;
+    };
+    readonly ElRadioButton: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+        readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+        readonly size: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly label: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+        readonly value: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+        readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly label: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+            readonly value: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+            readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+        }>> & {
+            [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+        }>>;
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string | undefined) => string;
+            e: (element?: string | undefined) => string;
+            m: (modifier?: string | undefined) => string;
+            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+            em: (element?: string | undefined, modifier?: string | undefined) => string;
+            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        radioRef: import("vue").Ref<HTMLInputElement | undefined>;
+        focus: import("vue").Ref<boolean>;
+        size: import("vue").ComputedRef<"" | "default" | "small" | "large">;
+        disabled: import("vue").ComputedRef<boolean>;
+        modelValue: import("vue").WritableComputedRef<import("element-plus").ButtonType<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown> | undefined>;
+        radioGroup: import("element-plus").RadioGroupContext | undefined;
+        actualValue: import("vue").ComputedRef<import("element-plus").ButtonType<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown> | undefined>;
+        activeStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+        readonly size: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly label: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+        readonly value: import("element-plus/es/utils").EpPropFinalized<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown, undefined, boolean>;
+        readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    }>>, {
+        readonly value: import("element-plus").ButtonType<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown>;
+        readonly modelValue: import("element-plus").ButtonType<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown>;
+        readonly disabled: boolean;
+        readonly name: string;
+        readonly label: import("element-plus").ButtonType<(StringConstructor | BooleanConstructor | NumberConstructor)[], unknown, unknown>;
+    }, {}>>;
+    readonly BASIC_KEY: {
+        name: string;
+        key: string;
+        dealType: string;
+        type: string;
+    }[];
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("choiceTarget" | "choiceCancel")[], "choiceTarget" | "choiceCancel", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly fundType: {
+        readonly type: StringConstructor;
+        readonly default: "fund";
+    };
+    readonly targetType: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly dialogShow: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly targetData: {
+        readonly type: import("vue").PropType<import("./src/htTarget").target[]>;
+        readonly default: readonly [];
+    };
+}>> & {
+    onChoiceTarget?: ((...args: any[]) => any) | undefined;
+    onChoiceCancel?: ((...args: any[]) => any) | undefined;
+}, {
+    readonly targetData: import("./src/htTarget").target[];
+    readonly fundType: string;
+    readonly targetType: string;
+    readonly dialogShow: boolean;
+}, {}>> & Record<string, any>;
+export default HtTarget;
+export * from './src/htTarget.vue';