@xdmp-open/ui-admin 0.1.0

package/dist/modules/system-user/index.vue.d.ts

@@ -0,0 +1,2027 @@
+import { checkPermission } from '../../context';
+declare const _default: import('vue').DefineComponent<{}, {}, {
+    total: number;
+    id: string;
+    currentUser: string;
+    departId: string;
+    tableLoading: boolean;
+    treeLoading: boolean;
+    isAdmin: boolean;
+    list: any[];
+    departTree: any[];
+    roleSelectOpt: any[];
+    listQuery: {
+        pageNo: number;
+        pageSize: number;
+        query: {
+            keyword: string;
+            departId: string;
+            roleIds: any[];
+        };
+    };
+    departForm: any;
+}, {}, {
+    checkPermission: typeof checkPermission;
+    getDepartTree(): Promise<void>;
+    getUserRole(): Promise<void>;
+    getUserList(): Promise<void>;
+    reset(): void;
+    search(): void;
+    onDepart(): void;
+    deleteDepart(data: any): void;
+    handleSizeChange(val: number): void;
+    handleCurrentChange(val: number): void;
+    handleMoreCommand(command: string, row: any): void;
+    handleResetPassword(row: any): void;
+    handleChangeStatus(row: any, enabledFlag: string): void;
+    handleChangeLock(row: any, lockedFlag: string): void;
+    handlerDelete(row: any): void;
+    detail(data: any): void;
+    showAddMember(): void;
+    showAddDepart(data: any, type: string): void;
+    handleNodeClick(data: any): Promise<void>;
+    getCurrentUserRole(username: string): Promise<void>;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+    addUserDrawer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        roleList: {
+            type: import('vue').PropType<any[]>;
+            default: () => never[];
+        };
+        subjectTree: {
+            type: import('vue').PropType<any[]>;
+            default: () => never[];
+        };
+    }>, {}, {
+        size: string;
+        title: string;
+        projectId: string;
+        previewImgUrl: string;
+        hasSubgourp: string;
+        userInfo: {};
+        isDetail: boolean;
+        showPassword: boolean;
+        loading: boolean;
+        editMode: boolean;
+        isAdmin: boolean;
+        isAdminCode: boolean;
+        treeSelectData: any[];
+        defaultData: any[];
+        defaultProps: {
+            children: string;
+            label: string;
+            disabled: string;
+        };
+        roleTypeList: {
+            value: string;
+            label: string;
+        }[];
+        roleGenderList: {
+            value: string;
+            label: string;
+        }[];
+        bucketName: any;
+        ruleForm: {
+            roleIds: any[];
+            username: string;
+            fullname: string;
+            phone: string;
+            departId: string;
+            type: string;
+            gender: string;
+            avatar: string;
+            projectIds: any[];
+        };
+        rules: {
+            username: {
+                required: boolean;
+                validator: (rule: any, value: any, callback: any) => void;
+                trigger: string;
+            }[];
+            fullname: {
+                required: boolean;
+                message: string;
+                trigger: string;
+            }[];
+            phone: {
+                required: boolean;
+                validator: (rule: any, value: any, callback: any) => void;
+                trigger: string;
+            }[];
+            roleIds: {
+                required: boolean;
+                message: string;
+                trigger: string;
+            }[];
+            type: {
+                required: boolean;
+                message: string;
+                trigger: string;
+            }[];
+            gender: {
+                required: boolean;
+                message: string;
+                trigger: string;
+            }[];
+            projectIds: {
+                required: boolean;
+                validator: (rule: any, value: any, callback: any) => void;
+                trigger: string;
+            }[];
+        };
+    }, {}, {
+        handlefilterRole(value: any): void;
+        submitForm(formName?: string): void;
+        init(departId: any, data?: any, isAdmin?: boolean): Promise<void>;
+        resetForm(formName?: string): void;
+        cancel(): void;
+        getCheckedKeys(e: any, checked: boolean): void;
+        deleteSelectChild(select: any[], data: any, list: any[]): void;
+        getProjectTree(params: any): Promise<void>;
+        filterChildren(list: any[]): void;
+        childPushId(list: any[]): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "reload"[], "reload", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        roleList: {
+            type: import('vue').PropType<any[]>;
+            default: () => never[];
+        };
+        subjectTree: {
+            type: import('vue').PropType<any[]>;
+            default: () => never[];
+        };
+    }>> & Readonly<{
+        onReload?: ((...args: any[]) => any) | undefined;
+    }>, {
+        roleList: any[];
+        subjectTree: any[];
+    }, {}, {
+        uiapDrawer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            submitText: {
+                type: StringConstructor;
+                default: string;
+            };
+            sureText: {
+                type: StringConstructor;
+                default: string;
+            };
+            showFooter: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            title: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            drawer: boolean;
+            direction: "rtl";
+            loading: boolean;
+        }, {}, {
+            handleClose(done: () => void): void;
+            showLoading(): void;
+            hideLoading(): void;
+            init(): void;
+            submit(): void;
+            cancelForm(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("submit" | "cancel")[], "submit" | "cancel", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            submitText: {
+                type: StringConstructor;
+                default: string;
+            };
+            sureText: {
+                type: StringConstructor;
+                default: string;
+            };
+            showFooter: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            title: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{
+            onSubmit?: ((...args: any[]) => any) | undefined;
+            onCancel?: ((...args: any[]) => any) | undefined;
+        }>, {
+            size: string;
+            title: string;
+            submitText: string;
+            sureText: string;
+            showFooter: boolean;
+        }, {}, {
+            ElDrawer: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').DrawerProps> & Readonly<{
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                    onOpen?: (() => any) | undefined;
+                    onOpened?: (() => any) | undefined;
+                    onClose?: (() => any) | undefined;
+                    onClosed?: (() => any) | undefined;
+                    onOpenAutoFocus?: (() => any) | undefined;
+                    onCloseAutoFocus?: (() => any) | undefined;
+                    onResize?: ((evt: MouseEvent, size: number) => any) | undefined;
+                    "onResize-start"?: ((evt: MouseEvent, size: number) => any) | undefined;
+                    "onResize-end"?: ((evt: MouseEvent, size: number) => any) | undefined;
+                }>, {
+                    handleClose: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    "update:modelValue": (value: boolean) => void;
+                    open: () => void;
+                    opened: () => void;
+                    close: () => void;
+                    closed: () => void;
+                    openAutoFocus: () => void;
+                    closeAutoFocus: () => void;
+                    resize: (evt: MouseEvent, size: number) => void;
+                    "resize-start": (evt: MouseEvent, size: number) => void;
+                    "resize-end": (evt: MouseEvent, size: number) => void;
+                }, import('vue').PublicProps, {
+                    direction: "ltr" | "rtl" | "ttb" | "btt";
+                    size: string | number;
+                    title: string;
+                    appendTo: string | HTMLElement;
+                    closeOnClickModal: boolean;
+                    closeOnPressEscape: boolean;
+                    lockScroll: boolean;
+                    modal: boolean;
+                    openDelay: number;
+                    closeDelay: number;
+                    modalClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    headerAriaLevel: string;
+                    transition: import('element-plus').DialogTransition;
+                    alignCenter: boolean;
+                    draggable: boolean;
+                    overflow: boolean;
+                    headerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    bodyClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    footerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    showClose: boolean;
+                    ariaLevel: string;
+                    withHeader: boolean;
+                    modalFade: boolean;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').DrawerProps> & Readonly<{
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                    onOpen?: (() => any) | undefined;
+                    onOpened?: (() => any) | undefined;
+                    onClose?: (() => any) | undefined;
+                    onClosed?: (() => any) | undefined;
+                    onOpenAutoFocus?: (() => any) | undefined;
+                    onCloseAutoFocus?: (() => any) | undefined;
+                    onResize?: ((evt: MouseEvent, size: number) => any) | undefined;
+                    "onResize-start"?: ((evt: MouseEvent, size: number) => any) | undefined;
+                    "onResize-end"?: ((evt: MouseEvent, size: number) => any) | undefined;
+                }>, {
+                    handleClose: () => void;
+                }, {}, {}, {}, {
+                    direction: "ltr" | "rtl" | "ttb" | "btt";
+                    size: string | number;
+                    title: string;
+                    appendTo: string | HTMLElement;
+                    closeOnClickModal: boolean;
+                    closeOnPressEscape: boolean;
+                    lockScroll: boolean;
+                    modal: boolean;
+                    openDelay: number;
+                    closeDelay: number;
+                    modalClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    headerAriaLevel: string;
+                    transition: import('element-plus').DialogTransition;
+                    alignCenter: boolean;
+                    draggable: boolean;
+                    overflow: boolean;
+                    headerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    bodyClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    footerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    showClose: boolean;
+                    ariaLevel: string;
+                    withHeader: boolean;
+                    modalFade: boolean;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').DrawerProps> & Readonly<{
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                onOpen?: (() => any) | undefined;
+                onOpened?: (() => any) | undefined;
+                onClose?: (() => any) | undefined;
+                onClosed?: (() => any) | undefined;
+                onOpenAutoFocus?: (() => any) | undefined;
+                onCloseAutoFocus?: (() => any) | undefined;
+                onResize?: ((evt: MouseEvent, size: number) => any) | undefined;
+                "onResize-start"?: ((evt: MouseEvent, size: number) => any) | undefined;
+                "onResize-end"?: ((evt: MouseEvent, size: number) => any) | undefined;
+            }>, {
+                handleClose: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (value: boolean) => void;
+                open: () => void;
+                opened: () => void;
+                close: () => void;
+                closed: () => void;
+                openAutoFocus: () => void;
+                closeAutoFocus: () => void;
+                resize: (evt: MouseEvent, size: number) => void;
+                "resize-start": (evt: MouseEvent, size: number) => void;
+                "resize-end": (evt: MouseEvent, size: number) => void;
+            }, string, {
+                direction: "ltr" | "rtl" | "ttb" | "btt";
+                size: string | number;
+                title: string;
+                appendTo: string | HTMLElement;
+                closeOnClickModal: boolean;
+                closeOnPressEscape: boolean;
+                lockScroll: boolean;
+                modal: boolean;
+                openDelay: number;
+                closeDelay: number;
+                modalClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                headerAriaLevel: string;
+                transition: import('element-plus').DialogTransition;
+                alignCenter: boolean;
+                draggable: boolean;
+                overflow: boolean;
+                headerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                bodyClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                footerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                showClose: boolean;
+                ariaLevel: string;
+                withHeader: boolean;
+                modalFade: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    header?: (props: {
+                        close: () => void;
+                        titleId: string;
+                        titleClass: string;
+                    }) => any;
+                } & {
+                    title?: (props: {}) => any;
+                } & {
+                    default?: (props: {}) => any;
+                } & {
+                    footer?: (props: {}) => any;
+                };
+            })>;
+            ElButton: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').ButtonProps> & Readonly<{
+                    onClick?: ((evt: MouseEvent) => any) | undefined;
+                }>, {
+                    ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                    disabled: import('vue').ComputedRef<boolean>;
+                    shouldAddSpace: import('vue').ComputedRef<boolean>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    click: (evt: MouseEvent) => void;
+                }, import('vue').PublicProps, {
+                    type: import('element-plus').ButtonType;
+                    text: boolean;
+                    disabled: boolean;
+                    round: boolean;
+                    dashed: boolean;
+                    nativeType: import('element-plus').ButtonNativeType;
+                    loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                    plain: boolean;
+                    autoInsertSpace: boolean;
+                    tag: string | import('vue').Component;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').ButtonProps> & Readonly<{
+                    onClick?: ((evt: MouseEvent) => any) | undefined;
+                }>, {
+                    ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                    disabled: import('vue').ComputedRef<boolean>;
+                    shouldAddSpace: import('vue').ComputedRef<boolean>;
+                }, {}, {}, {}, {
+                    type: import('element-plus').ButtonType;
+                    text: boolean;
+                    disabled: boolean;
+                    round: boolean;
+                    dashed: boolean;
+                    nativeType: import('element-plus').ButtonNativeType;
+                    loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                    plain: boolean;
+                    autoInsertSpace: boolean;
+                    tag: string | import('vue').Component;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').ButtonProps> & Readonly<{
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+            }>, {
+                ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                disabled: import('vue').ComputedRef<boolean>;
+                shouldAddSpace: import('vue').ComputedRef<boolean>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                click: (evt: MouseEvent) => void;
+            }, string, {
+                type: import('element-plus').ButtonType;
+                text: boolean;
+                disabled: boolean;
+                round: boolean;
+                dashed: boolean;
+                nativeType: import('element-plus').ButtonNativeType;
+                loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                plain: boolean;
+                autoInsertSpace: boolean;
+                tag: string | import('vue').Component;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    loading?: (props: {}) => any;
+                } & {
+                    icon?: (props: {}) => any;
+                } & {
+                    default?: (props: {}) => any;
+                };
+            }) & import('vue').ObjectPlugin & {
+                setPropsDefaults: (defaults: {
+                    readonly size?: "" | "default" | "small" | "large" | (() => "" | "default" | "small" | "large") | undefined;
+                    readonly disabled?: boolean | (() => boolean) | undefined;
+                    readonly type?: "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger" | (() => "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger") | undefined;
+                    readonly icon?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                        new (...args: any[]): any;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } | (() => (import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined) & {}) | undefined;
+                    readonly nativeType?: "button" | "submit" | "reset" | (() => "button" | "submit" | "reset") | undefined;
+                    readonly loading?: boolean | (() => boolean) | undefined;
+                    readonly loadingIcon?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                        new (...args: any[]): any;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } | (() => (import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined) & {}) | undefined;
+                    readonly plain?: boolean | (() => boolean) | undefined;
+                    readonly text?: boolean | (() => boolean) | undefined;
+                    readonly link?: boolean | (() => boolean) | undefined;
+                    readonly bg?: boolean | (() => boolean) | undefined;
+                    readonly autofocus?: boolean | (() => boolean) | undefined;
+                    readonly round?: boolean | (() => boolean) | undefined;
+                    readonly circle?: boolean | (() => boolean) | undefined;
+                    readonly dashed?: boolean | (() => boolean) | undefined;
+                    readonly color?: string | (() => string) | undefined;
+                    readonly dark?: boolean | (() => boolean) | undefined;
+                    readonly autoInsertSpace?: boolean | (() => boolean) | undefined;
+                    readonly tag?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                        new (...args: any[]): any;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } | (() => (string | import('vue').Component | undefined) & {}) | undefined;
+                }) => void;
+            } & {
+                ButtonGroup: {
+                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                        direction: "horizontal" | "vertical";
+                        type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
+                        direction: "horizontal" | "vertical";
+                        type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                    }>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & import('vue').ComponentOptionsBase<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                    direction: "horizontal" | "vertical";
+                    type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                    $slots: {
+                        default?: (props: {}) => any;
+                    };
+                });
+            };
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        AvatarUpload: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            modelValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            accept: {
+                type: StringConstructor;
+                default: string;
+            };
+            maxSize: {
+                type: NumberConstructor;
+                default: number;
+            };
+            bucketName: {
+                type: StringConstructor;
+                default: string;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: NumberConstructor;
+                default: number;
+            };
+            immediate: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {
+            previewUrl: string;
+            loading: boolean;
+        }, {
+            sizeStyle(): Record<string, string>;
+        }, {
+            openFileDialog(): void;
+            fetchPreview(fileId: string): Promise<void>;
+            revokePreview(): void;
+            blobFromResponse(response: Blob): Promise<string>;
+            handleBeforeUpload(file: File): boolean;
+            handleChange(): void;
+            handleUpload(options: any): Promise<void>;
+            handleClear(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("update:modelValue" | "clear" | "change" | "upload-success" | "upload-error")[], "update:modelValue" | "clear" | "change" | "upload-success" | "upload-error", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            modelValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            accept: {
+                type: StringConstructor;
+                default: string;
+            };
+            maxSize: {
+                type: NumberConstructor;
+                default: number;
+            };
+            bucketName: {
+                type: StringConstructor;
+                default: string;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: NumberConstructor;
+                default: number;
+            };
+            immediate: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+            onChange?: ((...args: any[]) => any) | undefined;
+            onClear?: ((...args: any[]) => any) | undefined;
+            "onUpload-success"?: ((...args: any[]) => any) | undefined;
+            "onUpload-error"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            size: number;
+            modelValue: string;
+            disabled: boolean;
+            accept: string;
+            immediate: boolean;
+            maxSize: number;
+            bucketName: string;
+        }, {}, {
+            UserFilled: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            Delete: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            Loading: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ElImage: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').ImageProps> & Readonly<{
+                    onClose?: (() => any) | undefined;
+                    onError?: ((evt: Event) => any) | undefined;
+                    onShow?: (() => any) | undefined;
+                    onLoad?: ((evt: Event) => any) | undefined;
+                    onSwitch?: ((val: number) => any) | undefined;
+                }>, {
+                    showPreview: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    close: () => void;
+                    error: (evt: Event) => void;
+                    show: () => void;
+                    load: (evt: Event) => void;
+                    switch: (val: number) => void;
+                }, import('vue').PublicProps, {
+                    closeOnPressEscape: boolean;
+                    infinite: boolean;
+                    scale: number;
+                    src: string;
+                    fit: import('element-plus').ImageFitType;
+                    initialIndex: number;
+                    previewSrcList: string[];
+                    zoomRate: number;
+                    minScale: number;
+                    maxScale: number;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').ImageProps> & Readonly<{
+                    onClose?: (() => any) | undefined;
+                    onError?: ((evt: Event) => any) | undefined;
+                    onShow?: (() => any) | undefined;
+                    onLoad?: ((evt: Event) => any) | undefined;
+                    onSwitch?: ((val: number) => any) | undefined;
+                }>, {
+                    showPreview: () => void;
+                }, {}, {}, {}, {
+                    closeOnPressEscape: boolean;
+                    infinite: boolean;
+                    scale: number;
+                    src: string;
+                    fit: import('element-plus').ImageFitType;
+                    initialIndex: number;
+                    previewSrcList: string[];
+                    zoomRate: number;
+                    minScale: number;
+                    maxScale: number;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').ImageProps> & Readonly<{
+                onClose?: (() => any) | undefined;
+                onError?: ((evt: Event) => any) | undefined;
+                onShow?: (() => any) | undefined;
+                onLoad?: ((evt: Event) => any) | undefined;
+                onSwitch?: ((val: number) => any) | undefined;
+            }>, {
+                showPreview: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                close: () => void;
+                error: (evt: Event) => void;
+                show: () => void;
+                load: (evt: Event) => void;
+                switch: (val: number) => void;
+            }, string, {
+                closeOnPressEscape: boolean;
+                infinite: boolean;
+                scale: number;
+                src: string;
+                fit: import('element-plus').ImageFitType;
+                initialIndex: number;
+                previewSrcList: string[];
+                zoomRate: number;
+                minScale: number;
+                maxScale: number;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    error?: (props: {}) => any;
+                } & {
+                    placeholder?: (props: {}) => any;
+                } & {
+                    viewer?: (props: {}) => any;
+                } & {
+                    progress?: (props: {
+                        activeIndex: number;
+                        total: number;
+                    }) => any;
+                } & {
+                    toolbar?: (props: {
+                        actions: (action: import('element-plus').ImageViewerAction, options?: {}) => void;
+                        prev: () => void;
+                        next: () => void;
+                        reset: () => void;
+                        activeIndex: number;
+                        setActiveItem: (index: number) => void;
+                    }) => any;
+                } & {
+                    "viewer-error"?: (props: {
+                        activeIndex: number;
+                        src: string;
+                    }) => any;
+                };
+            })>;
+            ElIcon: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    default?: (props: {}) => any;
+                };
+            })>;
+            ElUpload: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').UploadProps> & Readonly<{}>, {
+                    abort: (file?: import('element-plus').UploadFile) => void;
+                    submit: () => void;
+                    clearFiles: (states?: import('element-plus').UploadStatus[]) => void;
+                    handleStart: (rawFile: import('element-plus').UploadRawFile) => void;
+                    handleRemove: (file: import('element-plus').UploadFile | import('element-plus').UploadRawFile) => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                    name: string;
+                    onChange: import('element-plus').UploadHooks["onChange"];
+                    disabled: boolean;
+                    onError: import('element-plus').UploadHooks["onError"];
+                    onProgress: import('element-plus').UploadHooks["onProgress"];
+                    data: import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData> | ((rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData>);
+                    beforeUpload: import('element-plus').UploadHooks["beforeUpload"];
+                    onRemove: import('element-plus').UploadHooks["onRemove"];
+                    onPreview: import('element-plus').UploadHooks["onPreview"];
+                    onSuccess: import('element-plus').UploadHooks["onSuccess"];
+                    onExceed: import('element-plus').UploadHooks["onExceed"];
+                    action: string;
+                    method: string;
+                    showFileList: boolean;
+                    accept: string;
+                    fileList: import('element-plus').UploadUserFile[];
+                    autoUpload: boolean;
+                    listType: import('element-plus').ListType;
+                    httpRequest: import('element-plus').UploadRequestHandler;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').UploadProps> & Readonly<{}>, {
+                    abort: (file?: import('element-plus').UploadFile) => void;
+                    submit: () => void;
+                    clearFiles: (states?: import('element-plus').UploadStatus[]) => void;
+                    handleStart: (rawFile: import('element-plus').UploadRawFile) => void;
+                    handleRemove: (file: import('element-plus').UploadFile | import('element-plus').UploadRawFile) => void;
+                }, {}, {}, {}, {
+                    name: string;
+                    onChange: import('element-plus').UploadHooks["onChange"];
+                    disabled: boolean;
+                    onError: import('element-plus').UploadHooks["onError"];
+                    onProgress: import('element-plus').UploadHooks["onProgress"];
+                    data: import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData> | ((rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData>);
+                    beforeUpload: import('element-plus').UploadHooks["beforeUpload"];
+                    onRemove: import('element-plus').UploadHooks["onRemove"];
+                    onPreview: import('element-plus').UploadHooks["onPreview"];
+                    onSuccess: import('element-plus').UploadHooks["onSuccess"];
+                    onExceed: import('element-plus').UploadHooks["onExceed"];
+                    action: string;
+                    method: string;
+                    showFileList: boolean;
+                    accept: string;
+                    fileList: import('element-plus').UploadUserFile[];
+                    autoUpload: boolean;
+                    listType: import('element-plus').ListType;
+                    httpRequest: import('element-plus').UploadRequestHandler;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').UploadProps> & Readonly<{}>, {
+                abort: (file?: import('element-plus').UploadFile) => void;
+                submit: () => void;
+                clearFiles: (states?: import('element-plus').UploadStatus[]) => void;
+                handleStart: (rawFile: import('element-plus').UploadRawFile) => void;
+                handleRemove: (file: import('element-plus').UploadFile | import('element-plus').UploadRawFile) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                name: string;
+                onChange: import('element-plus').UploadHooks["onChange"];
+                disabled: boolean;
+                onError: import('element-plus').UploadHooks["onError"];
+                onProgress: import('element-plus').UploadHooks["onProgress"];
+                data: import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData> | ((rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData>);
+                beforeUpload: import('element-plus').UploadHooks["beforeUpload"];
+                onRemove: import('element-plus').UploadHooks["onRemove"];
+                onPreview: import('element-plus').UploadHooks["onPreview"];
+                onSuccess: import('element-plus').UploadHooks["onSuccess"];
+                onExceed: import('element-plus').UploadHooks["onExceed"];
+                action: string;
+                method: string;
+                showFileList: boolean;
+                accept: string;
+                fileList: import('element-plus').UploadUserFile[];
+                autoUpload: boolean;
+                listType: import('element-plus').ListType;
+                httpRequest: import('element-plus').UploadRequestHandler;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    file?: (props: {
+                        file: import('element-plus').UploadFile;
+                        index: number;
+                    }) => any;
+                } & {
+                    trigger?: (props: {}) => any;
+                } & {
+                    default?: (props: {}) => any;
+                } & {
+                    trigger?: (props: {}) => any;
+                } & {
+                    default?: (props: {}) => any;
+                } & {
+                    default?: (props: {}) => any;
+                } & {
+                    tip?: (props: {}) => any;
+                } & {
+                    file?: (props: {
+                        file: import('element-plus').UploadFile;
+                        index: number;
+                    }) => any;
+                };
+            })>;
+            ElButton: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').ButtonProps> & Readonly<{
+                    onClick?: ((evt: MouseEvent) => any) | undefined;
+                }>, {
+                    ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                    disabled: import('vue').ComputedRef<boolean>;
+                    shouldAddSpace: import('vue').ComputedRef<boolean>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    click: (evt: MouseEvent) => void;
+                }, import('vue').PublicProps, {
+                    type: import('element-plus').ButtonType;
+                    text: boolean;
+                    disabled: boolean;
+                    round: boolean;
+                    dashed: boolean;
+                    nativeType: import('element-plus').ButtonNativeType;
+                    loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                    plain: boolean;
+                    autoInsertSpace: boolean;
+                    tag: string | import('vue').Component;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').ButtonProps> & Readonly<{
+                    onClick?: ((evt: MouseEvent) => any) | undefined;
+                }>, {
+                    ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                    disabled: import('vue').ComputedRef<boolean>;
+                    shouldAddSpace: import('vue').ComputedRef<boolean>;
+                }, {}, {}, {}, {
+                    type: import('element-plus').ButtonType;
+                    text: boolean;
+                    disabled: boolean;
+                    round: boolean;
+                    dashed: boolean;
+                    nativeType: import('element-plus').ButtonNativeType;
+                    loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                    plain: boolean;
+                    autoInsertSpace: boolean;
+                    tag: string | import('vue').Component;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').ButtonProps> & Readonly<{
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+            }>, {
+                ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                disabled: import('vue').ComputedRef<boolean>;
+                shouldAddSpace: import('vue').ComputedRef<boolean>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                click: (evt: MouseEvent) => void;
+            }, string, {
+                type: import('element-plus').ButtonType;
+                text: boolean;
+                disabled: boolean;
+                round: boolean;
+                dashed: boolean;
+                nativeType: import('element-plus').ButtonNativeType;
+                loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                plain: boolean;
+                autoInsertSpace: boolean;
+                tag: string | import('vue').Component;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    loading?: (props: {}) => any;
+                } & {
+                    icon?: (props: {}) => any;
+                } & {
+                    default?: (props: {}) => any;
+                };
+            }) & import('vue').ObjectPlugin & {
+                setPropsDefaults: (defaults: {
+                    readonly size?: "" | "default" | "small" | "large" | (() => "" | "default" | "small" | "large") | undefined;
+                    readonly disabled?: boolean | (() => boolean) | undefined;
+                    readonly type?: "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger" | (() => "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger") | undefined;
+                    readonly icon?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                        new (...args: any[]): any;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } | (() => (import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined) & {}) | undefined;
+                    readonly nativeType?: "button" | "submit" | "reset" | (() => "button" | "submit" | "reset") | undefined;
+                    readonly loading?: boolean | (() => boolean) | undefined;
+                    readonly loadingIcon?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                        new (...args: any[]): any;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } | (() => (import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined) & {}) | undefined;
+                    readonly plain?: boolean | (() => boolean) | undefined;
+                    readonly text?: boolean | (() => boolean) | undefined;
+                    readonly link?: boolean | (() => boolean) | undefined;
+                    readonly bg?: boolean | (() => boolean) | undefined;
+                    readonly autofocus?: boolean | (() => boolean) | undefined;
+                    readonly round?: boolean | (() => boolean) | undefined;
+                    readonly circle?: boolean | (() => boolean) | undefined;
+                    readonly dashed?: boolean | (() => boolean) | undefined;
+                    readonly color?: string | (() => string) | undefined;
+                    readonly dark?: boolean | (() => boolean) | undefined;
+                    readonly autoInsertSpace?: boolean | (() => boolean) | undefined;
+                    readonly tag?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                        new (...args: any[]): any;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } | (() => (string | import('vue').Component | undefined) & {}) | undefined;
+                }) => void;
+            } & {
+                ButtonGroup: {
+                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                        direction: "horizontal" | "vertical";
+                        type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
+                        direction: "horizontal" | "vertical";
+                        type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                    }>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & import('vue').ComponentOptionsBase<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                    direction: "horizontal" | "vertical";
+                    type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                    $slots: {
+                        default?: (props: {}) => any;
+                    };
+                });
+            };
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    addDepartDrawer: import('vue').DefineComponent<{}, {}, {
+        title: string;
+        size: string;
+        id: string;
+        treeLoading: boolean;
+        departForm: {
+            name: string;
+            parentId: string;
+            type: string;
+            avatar: string;
+        };
+        treeList: any[];
+        departTypeList: {
+            label: string;
+            value: string;
+        }[];
+        loading: boolean;
+        bucketName: any;
+        isDetail: boolean;
+        modeType: string;
+        rules: {
+            name: {
+                required: boolean;
+                validator: (rule: any, value: any, callback: any) => void;
+                trigger: string;
+            }[];
+            parentId: {
+                required: boolean;
+                message: string;
+                trigger: string;
+            }[];
+            type: {
+                required: boolean;
+                message: string;
+                trigger: string;
+            }[];
+        };
+    }, {}, {
+        init(data: any, type: string): Promise<void>;
+        getDepartList(): Promise<void>;
+        updateParentId(id: any): void;
+        handleChangeTree(data: any): void;
+        submitForm(): void;
+        cancel(): void;
+        setDisabledChild(data: any[]): void;
+        setDisabledSelect(data: any[]): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+        uiapDrawer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            submitText: {
+                type: StringConstructor;
+                default: string;
+            };
+            sureText: {
+                type: StringConstructor;
+                default: string;
+            };
+            showFooter: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            title: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            drawer: boolean;
+            direction: "rtl";
+            loading: boolean;
+        }, {}, {
+            handleClose(done: () => void): void;
+            showLoading(): void;
+            hideLoading(): void;
+            init(): void;
+            submit(): void;
+            cancelForm(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("submit" | "cancel")[], "submit" | "cancel", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            submitText: {
+                type: StringConstructor;
+                default: string;
+            };
+            sureText: {
+                type: StringConstructor;
+                default: string;
+            };
+            showFooter: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            title: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{
+            onSubmit?: ((...args: any[]) => any) | undefined;
+            onCancel?: ((...args: any[]) => any) | undefined;
+        }>, {
+            size: string;
+            title: string;
+            submitText: string;
+            sureText: string;
+            showFooter: boolean;
+        }, {}, {
+            ElDrawer: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').DrawerProps> & Readonly<{
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                    onOpen?: (() => any) | undefined;
+                    onOpened?: (() => any) | undefined;
+                    onClose?: (() => any) | undefined;
+                    onClosed?: (() => any) | undefined;
+                    onOpenAutoFocus?: (() => any) | undefined;
+                    onCloseAutoFocus?: (() => any) | undefined;
+                    onResize?: ((evt: MouseEvent, size: number) => any) | undefined;
+                    "onResize-start"?: ((evt: MouseEvent, size: number) => any) | undefined;
+                    "onResize-end"?: ((evt: MouseEvent, size: number) => any) | undefined;
+                }>, {
+                    handleClose: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    "update:modelValue": (value: boolean) => void;
+                    open: () => void;
+                    opened: () => void;
+                    close: () => void;
+                    closed: () => void;
+                    openAutoFocus: () => void;
+                    closeAutoFocus: () => void;
+                    resize: (evt: MouseEvent, size: number) => void;
+                    "resize-start": (evt: MouseEvent, size: number) => void;
+                    "resize-end": (evt: MouseEvent, size: number) => void;
+                }, import('vue').PublicProps, {
+                    direction: "ltr" | "rtl" | "ttb" | "btt";
+                    size: string | number;
+                    title: string;
+                    appendTo: string | HTMLElement;
+                    closeOnClickModal: boolean;
+                    closeOnPressEscape: boolean;
+                    lockScroll: boolean;
+                    modal: boolean;
+                    openDelay: number;
+                    closeDelay: number;
+                    modalClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    headerAriaLevel: string;
+                    transition: import('element-plus').DialogTransition;
+                    alignCenter: boolean;
+                    draggable: boolean;
+                    overflow: boolean;
+                    headerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    bodyClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    footerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    showClose: boolean;
+                    ariaLevel: string;
+                    withHeader: boolean;
+                    modalFade: boolean;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').DrawerProps> & Readonly<{
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                    onOpen?: (() => any) | undefined;
+                    onOpened?: (() => any) | undefined;
+                    onClose?: (() => any) | undefined;
+                    onClosed?: (() => any) | undefined;
+                    onOpenAutoFocus?: (() => any) | undefined;
+                    onCloseAutoFocus?: (() => any) | undefined;
+                    onResize?: ((evt: MouseEvent, size: number) => any) | undefined;
+                    "onResize-start"?: ((evt: MouseEvent, size: number) => any) | undefined;
+                    "onResize-end"?: ((evt: MouseEvent, size: number) => any) | undefined;
+                }>, {
+                    handleClose: () => void;
+                }, {}, {}, {}, {
+                    direction: "ltr" | "rtl" | "ttb" | "btt";
+                    size: string | number;
+                    title: string;
+                    appendTo: string | HTMLElement;
+                    closeOnClickModal: boolean;
+                    closeOnPressEscape: boolean;
+                    lockScroll: boolean;
+                    modal: boolean;
+                    openDelay: number;
+                    closeDelay: number;
+                    modalClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    headerAriaLevel: string;
+                    transition: import('element-plus').DialogTransition;
+                    alignCenter: boolean;
+                    draggable: boolean;
+                    overflow: boolean;
+                    headerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    bodyClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    footerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    showClose: boolean;
+                    ariaLevel: string;
+                    withHeader: boolean;
+                    modalFade: boolean;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').DrawerProps> & Readonly<{
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                onOpen?: (() => any) | undefined;
+                onOpened?: (() => any) | undefined;
+                onClose?: (() => any) | undefined;
+                onClosed?: (() => any) | undefined;
+                onOpenAutoFocus?: (() => any) | undefined;
+                onCloseAutoFocus?: (() => any) | undefined;
+                onResize?: ((evt: MouseEvent, size: number) => any) | undefined;
+                "onResize-start"?: ((evt: MouseEvent, size: number) => any) | undefined;
+                "onResize-end"?: ((evt: MouseEvent, size: number) => any) | undefined;
+            }>, {
+                handleClose: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (value: boolean) => void;
+                open: () => void;
+                opened: () => void;
+                close: () => void;
+                closed: () => void;
+                openAutoFocus: () => void;
+                closeAutoFocus: () => void;
+                resize: (evt: MouseEvent, size: number) => void;
+                "resize-start": (evt: MouseEvent, size: number) => void;
+                "resize-end": (evt: MouseEvent, size: number) => void;
+            }, string, {
+                direction: "ltr" | "rtl" | "ttb" | "btt";
+                size: string | number;
+                title: string;
+                appendTo: string | HTMLElement;
+                closeOnClickModal: boolean;
+                closeOnPressEscape: boolean;
+                lockScroll: boolean;
+                modal: boolean;
+                openDelay: number;
+                closeDelay: number;
+                modalClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                headerAriaLevel: string;
+                transition: import('element-plus').DialogTransition;
+                alignCenter: boolean;
+                draggable: boolean;
+                overflow: boolean;
+                headerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                bodyClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                footerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                showClose: boolean;
+                ariaLevel: string;
+                withHeader: boolean;
+                modalFade: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    header?: (props: {
+                        close: () => void;
+                        titleId: string;
+                        titleClass: string;
+                    }) => any;
+                } & {
+                    title?: (props: {}) => any;
+                } & {
+                    default?: (props: {}) => any;
+                } & {
+                    footer?: (props: {}) => any;
+                };
+            })>;
+            ElButton: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').ButtonProps> & Readonly<{
+                    onClick?: ((evt: MouseEvent) => any) | undefined;
+                }>, {
+                    ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                    disabled: import('vue').ComputedRef<boolean>;
+                    shouldAddSpace: import('vue').ComputedRef<boolean>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    click: (evt: MouseEvent) => void;
+                }, import('vue').PublicProps, {
+                    type: import('element-plus').ButtonType;
+                    text: boolean;
+                    disabled: boolean;
+                    round: boolean;
+                    dashed: boolean;
+                    nativeType: import('element-plus').ButtonNativeType;
+                    loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                    plain: boolean;
+                    autoInsertSpace: boolean;
+                    tag: string | import('vue').Component;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').ButtonProps> & Readonly<{
+                    onClick?: ((evt: MouseEvent) => any) | undefined;
+                }>, {
+                    ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                    disabled: import('vue').ComputedRef<boolean>;
+                    shouldAddSpace: import('vue').ComputedRef<boolean>;
+                }, {}, {}, {}, {
+                    type: import('element-plus').ButtonType;
+                    text: boolean;
+                    disabled: boolean;
+                    round: boolean;
+                    dashed: boolean;
+                    nativeType: import('element-plus').ButtonNativeType;
+                    loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                    plain: boolean;
+                    autoInsertSpace: boolean;
+                    tag: string | import('vue').Component;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').ButtonProps> & Readonly<{
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+            }>, {
+                ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                disabled: import('vue').ComputedRef<boolean>;
+                shouldAddSpace: import('vue').ComputedRef<boolean>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                click: (evt: MouseEvent) => void;
+            }, string, {
+                type: import('element-plus').ButtonType;
+                text: boolean;
+                disabled: boolean;
+                round: boolean;
+                dashed: boolean;
+                nativeType: import('element-plus').ButtonNativeType;
+                loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                plain: boolean;
+                autoInsertSpace: boolean;
+                tag: string | import('vue').Component;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    loading?: (props: {}) => any;
+                } & {
+                    icon?: (props: {}) => any;
+                } & {
+                    default?: (props: {}) => any;
+                };
+            }) & import('vue').ObjectPlugin & {
+                setPropsDefaults: (defaults: {
+                    readonly size?: "" | "default" | "small" | "large" | (() => "" | "default" | "small" | "large") | undefined;
+                    readonly disabled?: boolean | (() => boolean) | undefined;
+                    readonly type?: "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger" | (() => "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger") | undefined;
+                    readonly icon?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                        new (...args: any[]): any;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } | (() => (import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined) & {}) | undefined;
+                    readonly nativeType?: "button" | "submit" | "reset" | (() => "button" | "submit" | "reset") | undefined;
+                    readonly loading?: boolean | (() => boolean) | undefined;
+                    readonly loadingIcon?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                        new (...args: any[]): any;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } | (() => (import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined) & {}) | undefined;
+                    readonly plain?: boolean | (() => boolean) | undefined;
+                    readonly text?: boolean | (() => boolean) | undefined;
+                    readonly link?: boolean | (() => boolean) | undefined;
+                    readonly bg?: boolean | (() => boolean) | undefined;
+                    readonly autofocus?: boolean | (() => boolean) | undefined;
+                    readonly round?: boolean | (() => boolean) | undefined;
+                    readonly circle?: boolean | (() => boolean) | undefined;
+                    readonly dashed?: boolean | (() => boolean) | undefined;
+                    readonly color?: string | (() => string) | undefined;
+                    readonly dark?: boolean | (() => boolean) | undefined;
+                    readonly autoInsertSpace?: boolean | (() => boolean) | undefined;
+                    readonly tag?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                        new (...args: any[]): any;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } | (() => (string | import('vue').Component | undefined) & {}) | undefined;
+                }) => void;
+            } & {
+                ButtonGroup: {
+                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                        direction: "horizontal" | "vertical";
+                        type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
+                        direction: "horizontal" | "vertical";
+                        type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                    }>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & import('vue').ComponentOptionsBase<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                    direction: "horizontal" | "vertical";
+                    type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                    $slots: {
+                        default?: (props: {}) => any;
+                    };
+                });
+            };
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        AvatarUpload: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            modelValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            accept: {
+                type: StringConstructor;
+                default: string;
+            };
+            maxSize: {
+                type: NumberConstructor;
+                default: number;
+            };
+            bucketName: {
+                type: StringConstructor;
+                default: string;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: NumberConstructor;
+                default: number;
+            };
+            immediate: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {
+            previewUrl: string;
+            loading: boolean;
+        }, {
+            sizeStyle(): Record<string, string>;
+        }, {
+            openFileDialog(): void;
+            fetchPreview(fileId: string): Promise<void>;
+            revokePreview(): void;
+            blobFromResponse(response: Blob): Promise<string>;
+            handleBeforeUpload(file: File): boolean;
+            handleChange(): void;
+            handleUpload(options: any): Promise<void>;
+            handleClear(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("update:modelValue" | "clear" | "change" | "upload-success" | "upload-error")[], "update:modelValue" | "clear" | "change" | "upload-success" | "upload-error", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            modelValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            accept: {
+                type: StringConstructor;
+                default: string;
+            };
+            maxSize: {
+                type: NumberConstructor;
+                default: number;
+            };
+            bucketName: {
+                type: StringConstructor;
+                default: string;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: NumberConstructor;
+                default: number;
+            };
+            immediate: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+            onChange?: ((...args: any[]) => any) | undefined;
+            onClear?: ((...args: any[]) => any) | undefined;
+            "onUpload-success"?: ((...args: any[]) => any) | undefined;
+            "onUpload-error"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            size: number;
+            modelValue: string;
+            disabled: boolean;
+            accept: string;
+            immediate: boolean;
+            maxSize: number;
+            bucketName: string;
+        }, {}, {
+            UserFilled: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            Delete: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            Loading: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ElImage: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').ImageProps> & Readonly<{
+                    onClose?: (() => any) | undefined;
+                    onError?: ((evt: Event) => any) | undefined;
+                    onShow?: (() => any) | undefined;
+                    onLoad?: ((evt: Event) => any) | undefined;
+                    onSwitch?: ((val: number) => any) | undefined;
+                }>, {
+                    showPreview: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    close: () => void;
+                    error: (evt: Event) => void;
+                    show: () => void;
+                    load: (evt: Event) => void;
+                    switch: (val: number) => void;
+                }, import('vue').PublicProps, {
+                    closeOnPressEscape: boolean;
+                    infinite: boolean;
+                    scale: number;
+                    src: string;
+                    fit: import('element-plus').ImageFitType;
+                    initialIndex: number;
+                    previewSrcList: string[];
+                    zoomRate: number;
+                    minScale: number;
+                    maxScale: number;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').ImageProps> & Readonly<{
+                    onClose?: (() => any) | undefined;
+                    onError?: ((evt: Event) => any) | undefined;
+                    onShow?: (() => any) | undefined;
+                    onLoad?: ((evt: Event) => any) | undefined;
+                    onSwitch?: ((val: number) => any) | undefined;
+                }>, {
+                    showPreview: () => void;
+                }, {}, {}, {}, {
+                    closeOnPressEscape: boolean;
+                    infinite: boolean;
+                    scale: number;
+                    src: string;
+                    fit: import('element-plus').ImageFitType;
+                    initialIndex: number;
+                    previewSrcList: string[];
+                    zoomRate: number;
+                    minScale: number;
+                    maxScale: number;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').ImageProps> & Readonly<{
+                onClose?: (() => any) | undefined;
+                onError?: ((evt: Event) => any) | undefined;
+                onShow?: (() => any) | undefined;
+                onLoad?: ((evt: Event) => any) | undefined;
+                onSwitch?: ((val: number) => any) | undefined;
+            }>, {
+                showPreview: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                close: () => void;
+                error: (evt: Event) => void;
+                show: () => void;
+                load: (evt: Event) => void;
+                switch: (val: number) => void;
+            }, string, {
+                closeOnPressEscape: boolean;
+                infinite: boolean;
+                scale: number;
+                src: string;
+                fit: import('element-plus').ImageFitType;
+                initialIndex: number;
+                previewSrcList: string[];
+                zoomRate: number;
+                minScale: number;
+                maxScale: number;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    error?: (props: {}) => any;
+                } & {
+                    placeholder?: (props: {}) => any;
+                } & {
+                    viewer?: (props: {}) => any;
+                } & {
+                    progress?: (props: {
+                        activeIndex: number;
+                        total: number;
+                    }) => any;
+                } & {
+                    toolbar?: (props: {
+                        actions: (action: import('element-plus').ImageViewerAction, options?: {}) => void;
+                        prev: () => void;
+                        next: () => void;
+                        reset: () => void;
+                        activeIndex: number;
+                        setActiveItem: (index: number) => void;
+                    }) => any;
+                } & {
+                    "viewer-error"?: (props: {
+                        activeIndex: number;
+                        src: string;
+                    }) => any;
+                };
+            })>;
+            ElIcon: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    default?: (props: {}) => any;
+                };
+            })>;
+            ElUpload: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').UploadProps> & Readonly<{}>, {
+                    abort: (file?: import('element-plus').UploadFile) => void;
+                    submit: () => void;
+                    clearFiles: (states?: import('element-plus').UploadStatus[]) => void;
+                    handleStart: (rawFile: import('element-plus').UploadRawFile) => void;
+                    handleRemove: (file: import('element-plus').UploadFile | import('element-plus').UploadRawFile) => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                    name: string;
+                    onChange: import('element-plus').UploadHooks["onChange"];
+                    disabled: boolean;
+                    onError: import('element-plus').UploadHooks["onError"];
+                    onProgress: import('element-plus').UploadHooks["onProgress"];
+                    data: import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData> | ((rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData>);
+                    beforeUpload: import('element-plus').UploadHooks["beforeUpload"];
+                    onRemove: import('element-plus').UploadHooks["onRemove"];
+                    onPreview: import('element-plus').UploadHooks["onPreview"];
+                    onSuccess: import('element-plus').UploadHooks["onSuccess"];
+                    onExceed: import('element-plus').UploadHooks["onExceed"];
+                    action: string;
+                    method: string;
+                    showFileList: boolean;
+                    accept: string;
+                    fileList: import('element-plus').UploadUserFile[];
+                    autoUpload: boolean;
+                    listType: import('element-plus').ListType;
+                    httpRequest: import('element-plus').UploadRequestHandler;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').UploadProps> & Readonly<{}>, {
+                    abort: (file?: import('element-plus').UploadFile) => void;
+                    submit: () => void;
+                    clearFiles: (states?: import('element-plus').UploadStatus[]) => void;
+                    handleStart: (rawFile: import('element-plus').UploadRawFile) => void;
+                    handleRemove: (file: import('element-plus').UploadFile | import('element-plus').UploadRawFile) => void;
+                }, {}, {}, {}, {
+                    name: string;
+                    onChange: import('element-plus').UploadHooks["onChange"];
+                    disabled: boolean;
+                    onError: import('element-plus').UploadHooks["onError"];
+                    onProgress: import('element-plus').UploadHooks["onProgress"];
+                    data: import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData> | ((rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData>);
+                    beforeUpload: import('element-plus').UploadHooks["beforeUpload"];
+                    onRemove: import('element-plus').UploadHooks["onRemove"];
+                    onPreview: import('element-plus').UploadHooks["onPreview"];
+                    onSuccess: import('element-plus').UploadHooks["onSuccess"];
+                    onExceed: import('element-plus').UploadHooks["onExceed"];
+                    action: string;
+                    method: string;
+                    showFileList: boolean;
+                    accept: string;
+                    fileList: import('element-plus').UploadUserFile[];
+                    autoUpload: boolean;
+                    listType: import('element-plus').ListType;
+                    httpRequest: import('element-plus').UploadRequestHandler;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').UploadProps> & Readonly<{}>, {
+                abort: (file?: import('element-plus').UploadFile) => void;
+                submit: () => void;
+                clearFiles: (states?: import('element-plus').UploadStatus[]) => void;
+                handleStart: (rawFile: import('element-plus').UploadRawFile) => void;
+                handleRemove: (file: import('element-plus').UploadFile | import('element-plus').UploadRawFile) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                name: string;
+                onChange: import('element-plus').UploadHooks["onChange"];
+                disabled: boolean;
+                onError: import('element-plus').UploadHooks["onError"];
+                onProgress: import('element-plus').UploadHooks["onProgress"];
+                data: import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData> | ((rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData>);
+                beforeUpload: import('element-plus').UploadHooks["beforeUpload"];
+                onRemove: import('element-plus').UploadHooks["onRemove"];
+                onPreview: import('element-plus').UploadHooks["onPreview"];
+                onSuccess: import('element-plus').UploadHooks["onSuccess"];
+                onExceed: import('element-plus').UploadHooks["onExceed"];
+                action: string;
+                method: string;
+                showFileList: boolean;
+                accept: string;
+                fileList: import('element-plus').UploadUserFile[];
+                autoUpload: boolean;
+                listType: import('element-plus').ListType;
+                httpRequest: import('element-plus').UploadRequestHandler;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    file?: (props: {
+                        file: import('element-plus').UploadFile;
+                        index: number;
+                    }) => any;
+                } & {
+                    trigger?: (props: {}) => any;
+                } & {
+                    default?: (props: {}) => any;
+                } & {
+                    trigger?: (props: {}) => any;
+                } & {
+                    default?: (props: {}) => any;
+                } & {
+                    default?: (props: {}) => any;
+                } & {
+                    tip?: (props: {}) => any;
+                } & {
+                    file?: (props: {
+                        file: import('element-plus').UploadFile;
+                        index: number;
+                    }) => any;
+                };
+            })>;
+            ElButton: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').ButtonProps> & Readonly<{
+                    onClick?: ((evt: MouseEvent) => any) | undefined;
+                }>, {
+                    ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                    disabled: import('vue').ComputedRef<boolean>;
+                    shouldAddSpace: import('vue').ComputedRef<boolean>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    click: (evt: MouseEvent) => void;
+                }, import('vue').PublicProps, {
+                    type: import('element-plus').ButtonType;
+                    text: boolean;
+                    disabled: boolean;
+                    round: boolean;
+                    dashed: boolean;
+                    nativeType: import('element-plus').ButtonNativeType;
+                    loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                    plain: boolean;
+                    autoInsertSpace: boolean;
+                    tag: string | import('vue').Component;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').ButtonProps> & Readonly<{
+                    onClick?: ((evt: MouseEvent) => any) | undefined;
+                }>, {
+                    ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                    disabled: import('vue').ComputedRef<boolean>;
+                    shouldAddSpace: import('vue').ComputedRef<boolean>;
+                }, {}, {}, {}, {
+                    type: import('element-plus').ButtonType;
+                    text: boolean;
+                    disabled: boolean;
+                    round: boolean;
+                    dashed: boolean;
+                    nativeType: import('element-plus').ButtonNativeType;
+                    loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                    plain: boolean;
+                    autoInsertSpace: boolean;
+                    tag: string | import('vue').Component;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').ButtonProps> & Readonly<{
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+            }>, {
+                ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                disabled: import('vue').ComputedRef<boolean>;
+                shouldAddSpace: import('vue').ComputedRef<boolean>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                click: (evt: MouseEvent) => void;
+            }, string, {
+                type: import('element-plus').ButtonType;
+                text: boolean;
+                disabled: boolean;
+                round: boolean;
+                dashed: boolean;
+                nativeType: import('element-plus').ButtonNativeType;
+                loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                plain: boolean;
+                autoInsertSpace: boolean;
+                tag: string | import('vue').Component;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    loading?: (props: {}) => any;
+                } & {
+                    icon?: (props: {}) => any;
+                } & {
+                    default?: (props: {}) => any;
+                };
+            }) & import('vue').ObjectPlugin & {
+                setPropsDefaults: (defaults: {
+                    readonly size?: "" | "default" | "small" | "large" | (() => "" | "default" | "small" | "large") | undefined;
+                    readonly disabled?: boolean | (() => boolean) | undefined;
+                    readonly type?: "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger" | (() => "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger") | undefined;
+                    readonly icon?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                        new (...args: any[]): any;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } | (() => (import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined) & {}) | undefined;
+                    readonly nativeType?: "button" | "submit" | "reset" | (() => "button" | "submit" | "reset") | undefined;
+                    readonly loading?: boolean | (() => boolean) | undefined;
+                    readonly loadingIcon?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                        new (...args: any[]): any;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } | (() => (import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined) & {}) | undefined;
+                    readonly plain?: boolean | (() => boolean) | undefined;
+                    readonly text?: boolean | (() => boolean) | undefined;
+                    readonly link?: boolean | (() => boolean) | undefined;
+                    readonly bg?: boolean | (() => boolean) | undefined;
+                    readonly autofocus?: boolean | (() => boolean) | undefined;
+                    readonly round?: boolean | (() => boolean) | undefined;
+                    readonly circle?: boolean | (() => boolean) | undefined;
+                    readonly dashed?: boolean | (() => boolean) | undefined;
+                    readonly color?: string | (() => string) | undefined;
+                    readonly dark?: boolean | (() => boolean) | undefined;
+                    readonly autoInsertSpace?: boolean | (() => boolean) | undefined;
+                    readonly tag?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                        new (...args: any[]): any;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } | (() => (string | import('vue').Component | undefined) & {}) | undefined;
+                }) => void;
+            } & {
+                ButtonGroup: {
+                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                        direction: "horizontal" | "vertical";
+                        type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
+                        direction: "horizontal" | "vertical";
+                        type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                    }>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & import('vue').ComponentOptionsBase<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                    direction: "horizontal" | "vertical";
+                    type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                    $slots: {
+                        default?: (props: {}) => any;
+                    };
+                });
+            };
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        treeSelect: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            modelValue: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: string;
+            };
+            data: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            pid: {
+                type: StringConstructor;
+                default: string;
+            };
+            nodeKey: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: string;
+            };
+            treeProps: {
+                type: ObjectConstructor;
+                default: () => {
+                    label: string;
+                    children: string;
+                    disabled: string;
+                };
+            };
+        }>, {
+            init: (val: any) => void;
+            clear: () => void;
+            focus: (val: any) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:modelValue": (...args: any[]) => void;
+            changeTree: (...args: any[]) => void;
+        }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            modelValue: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: string;
+            };
+            data: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            pid: {
+                type: StringConstructor;
+                default: string;
+            };
+            nodeKey: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: string;
+            };
+            treeProps: {
+                type: ObjectConstructor;
+                default: () => {
+                    label: string;
+                    children: string;
+                    disabled: string;
+                };
+            };
+        }>> & Readonly<{
+            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+            onChangeTree?: ((...args: any[]) => any) | undefined;
+        }>, {
+            modelValue: string | number;
+            data: unknown[];
+            pid: string;
+            nodeKey: string | number;
+            treeProps: Record<string, any>;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+            selectRef: unknown;
+            optionRef: unknown;
+            treeRef: unknown;
+        }, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    OfficeBuilding: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    UserFilled: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    pageDesc: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        title: {
+            type: StringConstructor;
+            default: string;
+        };
+        docUrl: {
+            type: StringConstructor;
+            default: string;
+        };
+        showDoc: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        desc: {
+            type: StringConstructor;
+            default: string;
+        };
+        img: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, {}, {
+        showDesc: boolean;
+    }, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        title: {
+            type: StringConstructor;
+            default: string;
+        };
+        docUrl: {
+            type: StringConstructor;
+            default: string;
+        };
+        showDoc: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        desc: {
+            type: StringConstructor;
+            default: string;
+        };
+        img: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        title: string;
+        img: string;
+        desc: string;
+        docUrl: string;
+        showDoc: boolean;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;