npm - yahee-components - Versions diffs - 0.0.68 → 0.0.70 - Mend

yahee-components 0.0.68 → 0.0.70

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/types/src/installs.d.ts ADDED Viewed

@@ -0,0 +1,2251 @@
+import { SFCWithInstall } from './utils/typescript';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions, ComponentInternalInstance, StyleValue, VNodeProps, AllowedComponentProps, ComponentCustomProps, Slot, ComponentPublicInstance, ComponentOptionsBase, ExtractPropTypes, PropType, ShallowRef, ComputedRef, Ref, GlobalComponents, GlobalDirectives, DebuggerEvent, nextTick, WatchOptions, WatchStopHandle, ShallowUnwrapRef, ComponentCustomProperties, CreateComponentPublicInstanceWithMixins, CSSProperties } from 'vue';
+import { InputProps } from './input';
+import { InputAutoSize, ScrollbarDirection, UploadFile, UploadFiles, UploadProgressEvent, UploadUserFile, UploadRequestHandler, UploadRawFile, UploadStatus, TooltipTriggerType, PopperEffect, Placement, Options, ButtonProps, Translator, TooltipInstance } from 'element-plus';
+import { OnCleanup } from '@vue/reactivity';
+import { CopyProps } from './copy';
+import { ImageUploadProps } from './image-upload';
+import { OperationLogProps } from './operation-log';
+import { AnnexUploadProps } from './annex-upload';
+import { Option } from './static/CommonObject';
+import { DropdownEntity } from './drop-down-condition/drop-down-condition';
+import { data } from './country-platform-shop-condition/country-platform-shop-condition';
+declare const _default: (( SFCWithInstall<DefineComponent<InputProps, {
+    focus: () => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, PublicProps, Readonly< InputProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: string) => any;
+}>, {
+    modelValue: string;
+    disabled: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    inputRef: {
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            readonly disabled: boolean;
+            readonly id: string;
+            readonly type: string;
+            readonly modelValue: string | number;
+            readonly tabindex: string | number;
+            readonly readonly: boolean;
+            readonly autosize: InputAutoSize;
+            readonly autocomplete: string;
+            readonly containerRole: string;
+            readonly validateEvent: boolean;
+            readonly inputStyle: StyleValue;
+            readonly rows: number;
+            readonly clearable: boolean;
+            readonly showPassword: boolean;
+            readonly showWordLimit: boolean;
+            readonly autofocus: boolean;
+        }> & Omit<{
+            readonly modelValue: string | number;
+            readonly disabled: boolean;
+            readonly type: string;
+            readonly autosize: false;
+            readonly autocomplete: string;
+            readonly readonly: boolean;
+            readonly clearable: boolean;
+            readonly showPassword: boolean;
+            readonly showWordLimit: boolean;
+            readonly tabindex: string | number;
+            readonly validateEvent: boolean;
+            readonly inputStyle: StyleValue;
+            readonly autofocus: boolean;
+            readonly rows: number;
+            readonly resize?: "none" | "both" | "horizontal" | "vertical";
+            readonly ariaLabel?: string;
+            readonly id?: string;
+            readonly size?: "" | "default" | "small" | "large";
+            readonly maxlength?: string | number;
+            readonly minlength?: string | number;
+            readonly formatter?: Function;
+            readonly parser?: Function;
+            readonly placeholder?: string;
+            readonly form?: string;
+            readonly suffixIcon?: unknown;
+            readonly prefixIcon?: unknown;
+            readonly containerRole?: string;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onChange?: ((value: string) => any) | undefined;
+            onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+            onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+            onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+            onFocus?: ((evt: FocusEvent) => any) | undefined;
+            onBlur?: ((evt: FocusEvent) => any) | undefined;
+            onInput?: ((value: string) => any) | undefined;
+            onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+            onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+            onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+            onClear?: (() => any) | undefined;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "modelValue" | "disabled" | "type" | "id" | "autosize" | "autocomplete" | "readonly" | "clearable" | "showPassword" | "showWordLimit" | "containerRole" | "tabindex" | "validateEvent" | "inputStyle" | "autofocus" | "rows">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot<any>;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "blur", evt: FocusEvent) => void) & ((event: "change", value: string) => void) & ((event: "compositionend", evt: CompositionEvent) => void) & ((event: "compositionstart", evt: CompositionEvent) => void) & ((event: "compositionupdate", evt: CompositionEvent) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "input", value: string) => void) & ((event: "keydown", evt: Event | KeyboardEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "clear") => void);
+        $el: any;
+        $options: ComponentOptionsBase<Readonly< ExtractPropTypes<{
+            readonly ariaLabel: StringConstructor;
+            readonly id: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly size: {
+                readonly type: PropType<"" | "default" | "small" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly modelValue: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly maxlength: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly minlength: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly type: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "text";
+            };
+            readonly resize: {
+                readonly type: PropType<"none" | "both" | "horizontal" | "vertical">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly autosize: {
+                readonly type: PropType<unknown>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: false;
+            };
+            readonly autocomplete: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "off";
+            };
+            readonly formatter: {
+                readonly type: PropType<Function>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly parser: {
+                readonly type: PropType<Function>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly placeholder: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly form: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly readonly: BooleanConstructor;
+            readonly clearable: BooleanConstructor;
+            readonly showPassword: BooleanConstructor;
+            readonly showWordLimit: BooleanConstructor;
+            readonly suffixIcon: {
+                readonly type: PropType<unknown>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly prefixIcon: {
+                readonly type: PropType<unknown>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly containerRole: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly tabindex: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly validateEvent: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly inputStyle: {
+                readonly type: PropType<StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => {};
+            };
+            readonly autofocus: BooleanConstructor;
+            readonly rows: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 2;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onChange?: ((value: string) => any) | undefined;
+            onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+            onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+            onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+            onFocus?: ((evt: FocusEvent) => any) | undefined;
+            onBlur?: ((evt: FocusEvent) => any) | undefined;
+            onInput?: ((value: string) => any) | undefined;
+            onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+            onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+            onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+            onClear?: (() => any) | undefined;
+        }, {
+            input: ShallowRef<HTMLInputElement | undefined>;
+            textarea: ShallowRef<HTMLTextAreaElement | undefined>;
+            ref: ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+            textareaStyle: ComputedRef<StyleValue>;
+            autosize: Ref<InputAutoSize>;
+            isComposing: Ref<boolean>;
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+            select: () => void;
+            clear: () => void;
+            resizeTextarea: () => void;
+        }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+            input: (value: string) => void;
+            clear: () => void;
+            "update:modelValue": (value: string) => void;
+            change: (value: string) => void;
+            blur: (evt: FocusEvent) => void;
+            compositionend: (evt: CompositionEvent) => void;
+            compositionstart: (evt: CompositionEvent) => void;
+            compositionupdate: (evt: CompositionEvent) => void;
+            focus: (evt: FocusEvent) => void;
+            keydown: (evt: Event | KeyboardEvent) => void;
+            mouseenter: (evt: MouseEvent) => void;
+            mouseleave: (evt: MouseEvent) => void;
+        }, string, {
+            readonly disabled: boolean;
+            readonly id: string;
+            readonly type: string;
+            readonly modelValue: string | number;
+            readonly tabindex: string | number;
+            readonly readonly: boolean;
+            readonly autosize: InputAutoSize;
+            readonly autocomplete: string;
+            readonly containerRole: string;
+            readonly validateEvent: boolean;
+            readonly inputStyle: StyleValue;
+            readonly rows: number;
+            readonly clearable: boolean;
+            readonly showPassword: boolean;
+            readonly showWordLimit: boolean;
+            readonly autofocus: boolean;
+        }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+    } & Readonly<{
+        readonly disabled: boolean;
+        readonly id: string;
+        readonly type: string;
+        readonly modelValue: string | number;
+        readonly tabindex: string | number;
+        readonly readonly: boolean;
+        readonly autosize: InputAutoSize;
+        readonly autocomplete: string;
+        readonly containerRole: string;
+        readonly validateEvent: boolean;
+        readonly inputStyle: StyleValue;
+        readonly rows: number;
+        readonly clearable: boolean;
+        readonly showPassword: boolean;
+        readonly showWordLimit: boolean;
+        readonly autofocus: boolean;
+    }> & Omit<Readonly< ExtractPropTypes<{
+        readonly ariaLabel: StringConstructor;
+        readonly id: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: undefined;
+        };
+        readonly size: {
+            readonly type: PropType<"" | "default" | "small" | "large">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly modelValue: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly maxlength: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly minlength: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly type: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "text";
+        };
+        readonly resize: {
+            readonly type: PropType<"none" | "both" | "horizontal" | "vertical">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly autosize: {
+            readonly type: PropType<unknown>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: false;
+        };
+        readonly autocomplete: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "off";
+        };
+        readonly formatter: {
+            readonly type: PropType<Function>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly parser: {
+            readonly type: PropType<Function>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly placeholder: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly form: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly readonly: BooleanConstructor;
+        readonly clearable: BooleanConstructor;
+        readonly showPassword: BooleanConstructor;
+        readonly showWordLimit: BooleanConstructor;
+        readonly suffixIcon: {
+            readonly type: PropType<unknown>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly prefixIcon: {
+            readonly type: PropType<unknown>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly containerRole: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: undefined;
+        };
+        readonly tabindex: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        readonly validateEvent: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        readonly inputStyle: {
+            readonly type: PropType<StyleValue>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => {};
+        };
+        readonly autofocus: BooleanConstructor;
+        readonly rows: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 2;
+        };
+    }>> & {
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onChange?: ((value: string) => any) | undefined;
+        onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+        onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+        onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+        onFocus?: ((evt: FocusEvent) => any) | undefined;
+        onBlur?: ((evt: FocusEvent) => any) | undefined;
+        onInput?: ((value: string) => any) | undefined;
+        onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+        onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+        onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+        onClear?: (() => any) | undefined;
+    }, "blur" | "focus" | "input" | "select" | "modelValue" | "disabled" | "type" | "id" | "autosize" | "autocomplete" | "readonly" | "clearable" | "showPassword" | "showWordLimit" | "containerRole" | "tabindex" | "validateEvent" | "inputStyle" | "autofocus" | "rows" | "clear" | "textarea" | "ref" | "textareaStyle" | "isComposing" | "resizeTextarea"> & ShallowUnwrapRef<{
+        input: ShallowRef<HTMLInputElement | undefined>;
+        textarea: ShallowRef<HTMLTextAreaElement | undefined>;
+        ref: ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+        textareaStyle: ComputedRef<StyleValue>;
+        autosize: Ref<InputAutoSize>;
+        isComposing: Ref<boolean>;
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        select: () => void;
+        clear: () => void;
+        resizeTextarea: () => void;
+    }> & {} & ComponentCustomProperties & {} & {
+        $slots: {
+            prepend?(_: {}): any;
+            prefix?(_: {}): any;
+            suffix?(_: {}): any;
+            append?(_: {}): any;
+        };
+    };
+}, HTMLDivElement>> & Record<string, any>) | ( SFCWithInstall<DefineComponent> & Record<string, any>) | ( SFCWithInstall<{
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< CopyProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
+        message: string;
+        content: string;
+    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLDivElement, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< CopyProps> & Readonly<{}>, {}, {}, {}, {}, {
+        message: string;
+        content: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly< CopyProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+    message: string;
+    content: string;
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+})> & Record<string, any>) | ( SFCWithInstall<{
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ImageUploadProps> & Readonly<{
+        onChange?: (...args: any[]) => any;
+        "onUpdate:modelValue"?: (...args: any[]) => any;
+    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+        change: (...args: any[]) => void;
+        "update:modelValue": (...args: any[]) => void;
+    }, PublicProps, {
+        modelValue: {
+            index: number;
+            fileId: string;
+            fileName: string;
+        };
+        fileType: string;
+        showDelete: boolean;
+        zoom: number;
+        imgSize: {
+            width: number;
+            height: number;
+        };
+        limitImgSize: boolean;
+        limitFileSize: boolean;
+        fileSize: number;
+        fileSizeUnit: "kb" | "KB" | "mb" | "MB";
+    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< ImageUploadProps> & Readonly<{
+        onChange?: (...args: any[]) => any;
+        "onUpdate:modelValue"?: (...args: any[]) => any;
+    }>, {}, {}, {}, {}, {
+        modelValue: {
+            index: number;
+            fileId: string;
+            fileName: string;
+        };
+        fileType: string;
+        showDelete: boolean;
+        zoom: number;
+        imgSize: {
+            width: number;
+            height: number;
+        };
+        limitImgSize: boolean;
+        limitFileSize: boolean;
+        fileSize: number;
+        fileSizeUnit: "kb" | "KB" | "mb" | "MB";
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly< ImageUploadProps> & Readonly<{
+    onChange?: (...args: any[]) => any;
+    "onUpdate:modelValue"?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+    "update:modelValue": (...args: any[]) => void;
+}, string, {
+    modelValue: {
+        index: number;
+        fileId: string;
+        fileName: string;
+    };
+    fileType: string;
+    showDelete: boolean;
+    zoom: number;
+    imgSize: {
+        width: number;
+        height: number;
+    };
+    limitImgSize: boolean;
+    limitFileSize: boolean;
+    fileSize: number;
+    fileSizeUnit: "kb" | "KB" | "mb" | "MB";
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {
+            value: string;
+        }): any;
+    };
+})> & Record<string, any>) | ( SFCWithInstall<DefineComponent<OperationLogProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< OperationLogProps> & Readonly<{}>, {
+    businessKey: string;
+    businessName: string;
+    ifShowDocument: boolean;
+    topHeight: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    logForm: CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+        businessKey: {
+            type: StringConstructor;
+            default: string;
+        };
+        businessName: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{
+        onFilterChange?: (...args: any[]) => any;
+    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+        filterChange: (...args: any[]) => void;
+    }, PublicProps, {
+        businessKey: string;
+        businessName: string;
+    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< ExtractPropTypes<{
+        businessKey: {
+            type: StringConstructor;
+            default: string;
+        };
+        businessName: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{
+        onFilterChange?: (...args: any[]) => any;
+    }>, {}, {}, {}, {}, {
+        businessKey: string;
+        businessName: string;
+    }>;
+    infiniteList: {
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            readonly height: string | number;
+            readonly maxHeight: string | number;
+            readonly always: boolean;
+            readonly tabindex: string | number;
+            readonly minSize: number;
+            readonly native: boolean;
+            readonly wrapStyle: StyleValue;
+            readonly wrapClass: string | unknown[];
+            readonly viewClass: string | unknown[];
+            readonly viewStyle: string | unknown[] | Record<string, any>;
+            readonly tag: string;
+            readonly noresize: boolean;
+        }> & Omit<{
+            readonly tag: string;
+            readonly always: boolean;
+            readonly height: string | number;
+            readonly maxHeight: string | number;
+            readonly native: boolean;
+            readonly wrapStyle: StyleValue;
+            readonly wrapClass: string | unknown[];
+            readonly viewClass: string | unknown[];
+            readonly viewStyle: string | unknown[] | Record<string, any>;
+            readonly noresize: boolean;
+            readonly minSize: number;
+            readonly ariaLabel?: string;
+            readonly id?: string;
+            readonly tabindex?: string | number;
+            readonly role?: string;
+            readonly ariaOrientation?: string;
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            "onEnd-reached"?: ((direction: ScrollbarDirection) => any) | undefined;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "tabindex" | "tag" | "always" | "height" | "maxHeight" | "native" | "wrapStyle" | "wrapClass" | "viewClass" | "viewStyle" | "noresize" | "minSize">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot<any>;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "scroll", args_0: {
+            scrollTop: number;
+            scrollLeft: number;
+        }) => void) & ((event: "end-reached", direction: ScrollbarDirection) => void);
+        $el: any;
+        $options: ComponentOptionsBase<Readonly< ExtractPropTypes<{
+            readonly ariaLabel: StringConstructor;
+            readonly ariaOrientation: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly height: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly maxHeight: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly native: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: false;
+            };
+            readonly wrapStyle: {
+                readonly type: PropType<StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly wrapClass: {
+                readonly type: PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly viewClass: {
+                readonly type: PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly viewStyle: {
+                readonly type: PropType<string | unknown[] | Record<string, any>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly noresize: BooleanConstructor;
+            readonly tag: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "div";
+            };
+            readonly always: BooleanConstructor;
+            readonly minSize: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 20;
+            };
+            readonly tabindex: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly id: StringConstructor;
+            readonly role: StringConstructor;
+        }>> & {
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            "onEnd-reached"?: ((direction: ScrollbarDirection) => any) | undefined;
+        }, {
+            wrapRef: Ref<HTMLDivElement | undefined>;
+            update: () => void;
+            scrollTo: {
+                (xCord: number, yCord?: number): void;
+                (options: ScrollToOptions): void;
+            };
+            setScrollTop: (value: number) => void;
+            setScrollLeft: (value: number) => void;
+            handleScroll: () => void;
+        }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+            scroll: (args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => void;
+            "end-reached": (direction: ScrollbarDirection) => void;
+        }, string, {
+            readonly height: string | number;
+            readonly maxHeight: string | number;
+            readonly always: boolean;
+            readonly tabindex: string | number;
+            readonly minSize: number;
+            readonly native: boolean;
+            readonly wrapStyle: StyleValue;
+            readonly wrapClass: string | unknown[];
+            readonly viewClass: string | unknown[];
+            readonly viewStyle: string | unknown[] | Record<string, any>;
+            readonly tag: string;
+            readonly noresize: boolean;
+        }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+    } & Readonly<{
+        readonly height: string | number;
+        readonly maxHeight: string | number;
+        readonly always: boolean;
+        readonly tabindex: string | number;
+        readonly minSize: number;
+        readonly native: boolean;
+        readonly wrapStyle: StyleValue;
+        readonly wrapClass: string | unknown[];
+        readonly viewClass: string | unknown[];
+        readonly viewStyle: string | unknown[] | Record<string, any>;
+        readonly tag: string;
+        readonly noresize: boolean;
+    }> & Omit<Readonly< ExtractPropTypes<{
+        readonly ariaLabel: StringConstructor;
+        readonly ariaOrientation: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly height: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly maxHeight: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly native: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: false;
+        };
+        readonly wrapStyle: {
+            readonly type: PropType<StyleValue>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly wrapClass: {
+            readonly type: PropType<string | unknown[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly viewClass: {
+            readonly type: PropType<string | unknown[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly viewStyle: {
+            readonly type: PropType<string | unknown[] | Record<string, any>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly noresize: BooleanConstructor;
+        readonly tag: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "div";
+        };
+        readonly always: BooleanConstructor;
+        readonly minSize: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 20;
+        };
+        readonly tabindex: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: undefined;
+        };
+        readonly id: StringConstructor;
+        readonly role: StringConstructor;
+    }>> & {
+        onScroll?: ((args_0: {
+            scrollTop: number;
+            scrollLeft: number;
+        }) => any) | undefined;
+        "onEnd-reached"?: ((direction: ScrollbarDirection) => any) | undefined;
+    }, "tabindex" | "tag" | "always" | "height" | "maxHeight" | "native" | "wrapStyle" | "wrapClass" | "viewClass" | "viewStyle" | "noresize" | "minSize" | "wrapRef" | "update" | "scrollTo" | "setScrollTop" | "setScrollLeft" | "handleScroll"> & ShallowUnwrapRef<{
+        wrapRef: Ref<HTMLDivElement | undefined>;
+        update: () => void;
+        scrollTo: {
+            (xCord: number, yCord?: number): void;
+            (options: ScrollToOptions): void;
+        };
+        setScrollTop: (value: number) => void;
+        setScrollLeft: (value: number) => void;
+        handleScroll: () => void;
+    }> & {} & ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {}): any;
+        };
+    };
+    logText: HTMLTextAreaElement;
+}, HTMLDivElement>> & Record<string, any>) | ( SFCWithInstall<{
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< AnnexUploadProps> & Readonly<{
+        onChange?: (...args: any[]) => any;
+        "onUpdate:modelValue"?: (...args: any[]) => any;
+        onSuccess?: (...args: any[]) => any;
+        onRemove?: (...args: any[]) => any;
+    }>, {
+        clearFiles: () => Promise<void>;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+        change: (...args: any[]) => void;
+        "update:modelValue": (...args: any[]) => void;
+        success: (...args: any[]) => void;
+        remove: (...args: any[]) => void;
+    }, PublicProps, {
+        modelValue: {
+            index: number;
+            fileId: string;
+            fileName: string;
+        }[];
+        validateEvent: boolean;
+        fileType: string;
+        limitFileSize: boolean;
+        fileSize: number;
+        fileSizeUnit: "kb" | "KB" | "mb" | "MB";
+        accept: string;
+        fileList: {
+            name: string;
+            url: string;
+        }[];
+        limit: number;
+        showList: boolean;
+        checkRealType: boolean;
+        uploadType: "upload" | "import";
+        showTips: boolean;
+    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        uploadRef: {
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                readonly data: unknown;
+                readonly disabled: boolean;
+                readonly drag: boolean;
+                readonly multiple: boolean;
+                readonly name: string;
+                readonly onChange: (uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+                readonly onError: (error: Error, uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+                readonly onProgress: (evt: UploadProgressEvent, uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+                readonly method: string;
+                readonly action: string;
+                readonly withCredentials: boolean;
+                readonly showFileList: boolean;
+                readonly accept: string;
+                readonly fileList: UploadUserFile[];
+                readonly autoUpload: boolean;
+                readonly listType: "text" | "picture" | "picture-card";
+                readonly httpRequest: UploadRequestHandler;
+                readonly beforeUpload: (rawFile: UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob>;
+                readonly onRemove: (uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+                readonly onPreview: (uploadFile: UploadFile) => void;
+                readonly onSuccess: (response: any, uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+                readonly onExceed: (files: File[], uploadFiles: UploadUserFile[]) => void;
+            }> & Omit<{
+                readonly drag: boolean;
+                readonly disabled: boolean;
+                readonly name: string;
+                readonly data: {};
+                readonly onChange: (uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+                readonly onError: (error: Error, uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+                readonly onProgress: (evt: UploadProgressEvent, uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+                readonly multiple: boolean;
+                readonly method: string;
+                readonly withCredentials: boolean;
+                readonly beforeUpload: (rawFile: UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob>;
+                readonly onRemove: (uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+                readonly onPreview: (uploadFile: UploadFile) => void;
+                readonly onSuccess: (response: any, uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+                readonly onExceed: (files: File[], uploadFiles: UploadUserFile[]) => void;
+                readonly action: string;
+                readonly showFileList: boolean;
+                readonly accept: string;
+                readonly fileList: UploadUserFile[];
+                readonly autoUpload: boolean;
+                readonly listType: "text" | "picture" | "picture-card";
+                readonly httpRequest: UploadRequestHandler;
+                readonly headers?: Record<string, any> | Headers;
+                readonly beforeRemove?: (uploadFile: UploadFile, uploadFiles: UploadFiles) => boolean | Promise<boolean>;
+                readonly crossorigin?: "" | "anonymous" | "use-credentials";
+                readonly limit?: number;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "drag" | "disabled" | "name" | "data" | "onChange" | "onError" | "onProgress" | "multiple" | "method" | "withCredentials" | "beforeUpload" | "onRemove" | "onPreview" | "onSuccess" | "onExceed" | "action" | "showFileList" | "accept" | "fileList" | "autoUpload" | "listType" | "httpRequest">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any>;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: ComponentOptionsBase<Readonly< ExtractPropTypes<{
+                readonly beforeUpload: {
+                    readonly type: PropType<(rawFile: UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly beforeRemove: {
+                    readonly type: PropType<(uploadFile: UploadFile, uploadFiles: UploadFiles) => boolean | Promise<boolean>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onRemove: {
+                    readonly type: PropType<(uploadFile: UploadFile, uploadFiles: UploadFiles) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onChange: {
+                    readonly type: PropType<(uploadFile: UploadFile, uploadFiles: UploadFiles) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onPreview: {
+                    readonly type: PropType<(uploadFile: UploadFile) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onSuccess: {
+                    readonly type: PropType<(response: any, uploadFile: UploadFile, uploadFiles: UploadFiles) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onProgress: {
+                    readonly type: PropType<(evt: UploadProgressEvent, uploadFile: UploadFile, uploadFiles: UploadFiles) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onError: {
+                    readonly type: PropType<(error: Error, uploadFile: UploadFile, uploadFiles: UploadFiles) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onExceed: {
+                    readonly type: PropType<(files: File[], uploadFiles: UploadUserFile[]) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly crossorigin: {
+                    readonly type: PropType<"" | "anonymous" | "use-credentials">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly action: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "#";
+                };
+                readonly headers: {
+                    readonly type: PropType<Record<string, any> | Headers>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly method: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "post";
+                };
+                readonly data: {
+                    readonly type: PropType<unknown>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => {};
+                };
+                readonly multiple: BooleanConstructor;
+                readonly name: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "file";
+                };
+                readonly drag: BooleanConstructor;
+                readonly withCredentials: BooleanConstructor;
+                readonly showFileList: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                readonly accept: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly fileList: {
+                    readonly type: PropType< UploadUserFile[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => [];
+                };
+                readonly autoUpload: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                readonly listType: {
+                    readonly type: PropType<"text" | "picture" | "picture-card">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "text";
+                };
+                readonly httpRequest: {
+                    readonly type: PropType<UploadRequestHandler>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: UploadRequestHandler;
+                };
+                readonly disabled: BooleanConstructor;
+                readonly limit: NumberConstructor;
+            }>>, {
+                abort: (file: UploadFile) => void;
+                submit: () => void;
+                clearFiles: (states?: UploadStatus[]) => void;
+                handleStart: (rawFile: UploadRawFile) => void;
+                handleRemove: (file: UploadFile | UploadRawFile, rawFile?: UploadRawFile) => void;
+            }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, Record<string, any>, string, {
+                readonly data: unknown;
+                readonly disabled: boolean;
+                readonly drag: boolean;
+                readonly multiple: boolean;
+                readonly name: string;
+                readonly onChange: (uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+                readonly onError: (error: Error, uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+                readonly onProgress: (evt: UploadProgressEvent, uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+                readonly method: string;
+                readonly action: string;
+                readonly withCredentials: boolean;
+                readonly showFileList: boolean;
+                readonly accept: string;
+                readonly fileList: UploadUserFile[];
+                readonly autoUpload: boolean;
+                readonly listType: "text" | "picture" | "picture-card";
+                readonly httpRequest: UploadRequestHandler;
+                readonly beforeUpload: (rawFile: UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob>;
+                readonly onRemove: (uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+                readonly onPreview: (uploadFile: UploadFile) => void;
+                readonly onSuccess: (response: any, uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+                readonly onExceed: (files: File[], uploadFiles: UploadUserFile[]) => void;
+            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+        } & Readonly<{
+            readonly data: unknown;
+            readonly disabled: boolean;
+            readonly drag: boolean;
+            readonly multiple: boolean;
+            readonly name: string;
+            readonly onChange: (uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+            readonly onError: (error: Error, uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+            readonly onProgress: (evt: UploadProgressEvent, uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+            readonly method: string;
+            readonly action: string;
+            readonly withCredentials: boolean;
+            readonly showFileList: boolean;
+            readonly accept: string;
+            readonly fileList: UploadUserFile[];
+            readonly autoUpload: boolean;
+            readonly listType: "text" | "picture" | "picture-card";
+            readonly httpRequest: UploadRequestHandler;
+            readonly beforeUpload: (rawFile: UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob>;
+            readonly onRemove: (uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+            readonly onPreview: (uploadFile: UploadFile) => void;
+            readonly onSuccess: (response: any, uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+            readonly onExceed: (files: File[], uploadFiles: UploadUserFile[]) => void;
+        }> & Omit<Readonly< ExtractPropTypes<{
+            readonly beforeUpload: {
+                readonly type: PropType<(rawFile: UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => void;
+            };
+            readonly beforeRemove: {
+                readonly type: PropType<(uploadFile: UploadFile, uploadFiles: UploadFiles) => boolean | Promise<boolean>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onRemove: {
+                readonly type: PropType<(uploadFile: UploadFile, uploadFiles: UploadFiles) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => void;
+            };
+            readonly onChange: {
+                readonly type: PropType<(uploadFile: UploadFile, uploadFiles: UploadFiles) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => void;
+            };
+            readonly onPreview: {
+                readonly type: PropType<(uploadFile: UploadFile) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => void;
+            };
+            readonly onSuccess: {
+                readonly type: PropType<(response: any, uploadFile: UploadFile, uploadFiles: UploadFiles) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => void;
+            };
+            readonly onProgress: {
+                readonly type: PropType<(evt: UploadProgressEvent, uploadFile: UploadFile, uploadFiles: UploadFiles) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => void;
+            };
+            readonly onError: {
+                readonly type: PropType<(error: Error, uploadFile: UploadFile, uploadFiles: UploadFiles) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => void;
+            };
+            readonly onExceed: {
+                readonly type: PropType<(files: File[], uploadFiles: UploadUserFile[]) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => void;
+            };
+            readonly crossorigin: {
+                readonly type: PropType<"" | "anonymous" | "use-credentials">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly action: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "#";
+            };
+            readonly headers: {
+                readonly type: PropType<Record<string, any> | Headers>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly method: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "post";
+            };
+            readonly data: {
+                readonly type: PropType<unknown>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => {};
+            };
+            readonly multiple: BooleanConstructor;
+            readonly name: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "file";
+            };
+            readonly drag: BooleanConstructor;
+            readonly withCredentials: BooleanConstructor;
+            readonly showFileList: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly accept: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly fileList: {
+                readonly type: PropType< UploadUserFile[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => [];
+            };
+            readonly autoUpload: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly listType: {
+                readonly type: PropType<"text" | "picture" | "picture-card">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "text";
+            };
+            readonly httpRequest: {
+                readonly type: PropType<UploadRequestHandler>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: UploadRequestHandler;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly limit: NumberConstructor;
+        }>>, "abort" | "drag" | "submit" | "disabled" | "name" | "data" | "onChange" | "onError" | "onProgress" | "multiple" | "method" | "withCredentials" | "beforeUpload" | "onRemove" | "onPreview" | "onSuccess" | "onExceed" | "action" | "showFileList" | "accept" | "fileList" | "autoUpload" | "listType" | "httpRequest" | "clearFiles" | "handleStart" | "handleRemove"> & ShallowUnwrapRef<{
+            abort: (file: UploadFile) => void;
+            submit: () => void;
+            clearFiles: (states?: UploadStatus[]) => void;
+            handleStart: (rawFile: UploadRawFile) => void;
+            handleRemove: (file: UploadFile | UploadRawFile, rawFile?: UploadRawFile) => void;
+        }> & {} & ComponentCustomProperties & {} & {
+            $slots: {
+                file?(_: {
+                    file: UploadFile;
+                    index: number;
+                }): any;
+                file?(_: {
+                    file: UploadFile;
+                    index: number;
+                }): any;
+                trigger?(_: {}): any;
+                trigger?(_: {}): any;
+                default?(_: {}): any;
+                default?(_: {}): any;
+                default?(_: {}): any;
+                tip?(_: {}): any;
+            };
+        };
+    }, HTMLDivElement, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< AnnexUploadProps> & Readonly<{
+        onChange?: (...args: any[]) => any;
+        "onUpdate:modelValue"?: (...args: any[]) => any;
+        onSuccess?: (...args: any[]) => any;
+        onRemove?: (...args: any[]) => any;
+    }>, {
+        clearFiles: () => Promise<void>;
+    }, {}, {}, {}, {
+        modelValue: {
+            index: number;
+            fileId: string;
+            fileName: string;
+        }[];
+        validateEvent: boolean;
+        fileType: string;
+        limitFileSize: boolean;
+        fileSize: number;
+        fileSizeUnit: "kb" | "KB" | "mb" | "MB";
+        accept: string;
+        fileList: {
+            name: string;
+            url: string;
+        }[];
+        limit: number;
+        showList: boolean;
+        checkRealType: boolean;
+        uploadType: "upload" | "import";
+        showTips: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly< AnnexUploadProps> & Readonly<{
+    onChange?: (...args: any[]) => any;
+    "onUpdate:modelValue"?: (...args: any[]) => any;
+    onSuccess?: (...args: any[]) => any;
+    onRemove?: (...args: any[]) => any;
+}>, {
+    clearFiles: () => Promise<void>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+    "update:modelValue": (...args: any[]) => void;
+    success: (...args: any[]) => void;
+    remove: (...args: any[]) => void;
+}, string, {
+    modelValue: {
+        index: number;
+        fileId: string;
+        fileName: string;
+    }[];
+    validateEvent: boolean;
+    fileType: string;
+    limitFileSize: boolean;
+    fileSize: number;
+    fileSizeUnit: "kb" | "KB" | "mb" | "MB";
+    accept: string;
+    fileList: {
+        name: string;
+        url: string;
+    }[];
+    limit: number;
+    showList: boolean;
+    checkRealType: boolean;
+    uploadType: "upload" | "import";
+    showTips: boolean;
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+        tip?(_: {}): any;
+    };
+})> & Record<string, any>) | ( SFCWithInstall<DefineComponent<{
+    multiSelectList?: Array<any>;
+    selectList: Array< Option>;
+    countList?: Array<any>;
+    totalCount?: number;
+    hasNum?: boolean;
+    displayRangeInput?: boolean;
+    rangeLabel?: string;
+    rangeStartKey?: string;
+    rangeEndKey?: string;
+    rangeDelimiter?: string;
+    allIsCheckbox?: boolean;
+    allIsEmpty?: boolean;
+    translateUserId?: boolean;
+    staticSearch?: boolean;
+    label?: string;
+    noNeedRefreshNumFilterName?: string;
+    filterKey: string;
+    defaultValues?: Array<string | number | boolean>;
+    showTotal?: boolean;
+}, {
+    clickAllSelected: () => void;
+    resetAllCheckedValueAndSelectAll: () => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    filterChange: (...args: any[]) => void;
+    setNoNeedRefreshNumFilterName: (...args: any[]) => void;
+}, string, PublicProps, Readonly<{
+    multiSelectList?: Array<any>;
+    selectList: Array< Option>;
+    countList?: Array<any>;
+    totalCount?: number;
+    hasNum?: boolean;
+    displayRangeInput?: boolean;
+    rangeLabel?: string;
+    rangeStartKey?: string;
+    rangeEndKey?: string;
+    rangeDelimiter?: string;
+    allIsCheckbox?: boolean;
+    allIsEmpty?: boolean;
+    translateUserId?: boolean;
+    staticSearch?: boolean;
+    label?: string;
+    noNeedRefreshNumFilterName?: string;
+    filterKey: string;
+    defaultValues?: Array<string | number | boolean>;
+    showTotal?: boolean;
+}> & Readonly<{
+    onFilterChange?: (...args: any[]) => any;
+    onSetNoNeedRefreshNumFilterName?: (...args: any[]) => any;
+}>, {
+    label: string;
+    filterKey: string;
+    multiSelectList: Array<any>;
+    countList: Array<any>;
+    hasNum: boolean;
+    selectList: Array< Option>;
+    totalCount: number;
+    displayRangeInput: boolean;
+    rangeLabel: string;
+    rangeStartKey: string;
+    rangeEndKey: string;
+    rangeDelimiter: string;
+    allIsEmpty: boolean;
+    staticSearch: boolean;
+    noNeedRefreshNumFilterName: string;
+    defaultValues: Array<string | number | boolean>;
+    showTotal: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    itemRefs: CreateComponentPublicInstanceWithMixins<Readonly<{
+        multiSelectList: Array<any>;
+        countList?: Array<any>;
+        item: Option;
+        hasNum: boolean;
+        allIsCheckbox?: boolean;
+        translateUserId: boolean;
+    }> & Readonly<{
+        onResetAllCheckedValue?: (...args: any[]) => any;
+        onSetSelectedStatusMap?: (...args: any[]) => any;
+        onResetRange?: (...args: any[]) => any;
+        onResetIsSelectAll?: (...args: any[]) => any;
+        onNotifyParent?: (...args: any[]) => any;
+        onSetNoNeedRefreshNumFilterName?: (...args: any[]) => any;
+    }>, {
+        resetValue: () => void;
+        getValue: () => Option;
+        setCurrentValue: (val: boolean) => void;
+        setCheckboxValue: (val: boolean) => void;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+        resetAllCheckedValue: (...args: any[]) => void;
+        setSelectedStatusMap: (...args: any[]) => void;
+        resetRange: (...args: any[]) => void;
+        resetIsSelectAll: (...args: any[]) => void;
+        notifyParent: (...args: any[]) => void;
+        setNoNeedRefreshNumFilterName: (...args: any[]) => void;
+    }, PublicProps, {
+        item: Option;
+        multiSelectList: Array<any>;
+        hasNum: boolean;
+        allIsCheckbox: boolean;
+        translateUserId: boolean;
+    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        multiSelectList: Array<any>;
+        countList?: Array<any>;
+        item: Option;
+        hasNum: boolean;
+        allIsCheckbox?: boolean;
+        translateUserId: boolean;
+    }> & Readonly<{
+        onResetAllCheckedValue?: (...args: any[]) => any;
+        onSetSelectedStatusMap?: (...args: any[]) => any;
+        onResetRange?: (...args: any[]) => any;
+        onResetIsSelectAll?: (...args: any[]) => any;
+        onNotifyParent?: (...args: any[]) => any;
+        onSetNoNeedRefreshNumFilterName?: (...args: any[]) => any;
+    }>, {
+        resetValue: () => void;
+        getValue: () => Option;
+        setCurrentValue: (val: boolean) => void;
+        setCheckboxValue: (val: boolean) => void;
+    }, {}, {}, {}, {
+        item: Option;
+        multiSelectList: Array<any>;
+        hasNum: boolean;
+        allIsCheckbox: boolean;
+        translateUserId: boolean;
+    }>[];
+}, HTMLDivElement>> & Record<string, any>) | ( SFCWithInstall<DefineComponent<{
+    selectList: Option[];
+    countList?: any[];
+    enumEntity: string;
+    filterKey: string;
+    totalCount?: number;
+    noNeedRefreshNumFilterName?: string;
+    allIsCheckbox?: boolean;
+    allIsEmpty?: boolean;
+    translateUserId?: boolean;
+    initFilters: (...args: any[]) => any;
+    defaultValues?: (string | boolean | number)[];
+}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    filterChange: (...args: any[]) => void;
+    setNoNeedRefreshNumFilterName: (...args: any[]) => void;
+}, string, PublicProps, Readonly<{
+    selectList: Option[];
+    countList?: any[];
+    enumEntity: string;
+    filterKey: string;
+    totalCount?: number;
+    noNeedRefreshNumFilterName?: string;
+    allIsCheckbox?: boolean;
+    allIsEmpty?: boolean;
+    translateUserId?: boolean;
+    initFilters: (...args: any[]) => any;
+    defaultValues?: (string | boolean | number)[];
+}> & Readonly<{
+    onFilterChange?: (...args: any[]) => any;
+    onSetNoNeedRefreshNumFilterName?: (...args: any[]) => any;
+}>, {
+    filterKey: string;
+    countList: any[];
+    selectList: Option[];
+    totalCount: number;
+    noNeedRefreshNumFilterName: string;
+    defaultValues: (string | boolean | number)[];
+    enumEntity: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>> & Record<string, any>) | ( SFCWithInstall<DefineComponent<{
+    filterList?: Array< DropdownEntity>;
+    totalCount?: number;
+    level1Count?: Array<{
+        value: string;
+        count: number;
+    }>;
+    level2Count?: Array<{
+        value: string;
+        count: number;
+    }>;
+    filterKey: string;
+    enumEntity: string;
+    noNeedRefreshNumFilterName?: string;
+    initFilters?: Function;
+}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    filterChange: (...args: any[]) => void;
+    setNoNeedRefreshNumFilterName: (...args: any[]) => void;
+}, string, PublicProps, Readonly<{
+    filterList?: Array< DropdownEntity>;
+    totalCount?: number;
+    level1Count?: Array<{
+        value: string;
+        count: number;
+    }>;
+    level2Count?: Array<{
+        value: string;
+        count: number;
+    }>;
+    filterKey: string;
+    enumEntity: string;
+    noNeedRefreshNumFilterName?: string;
+    initFilters?: Function;
+}> & Readonly<{
+    onFilterChange?: (...args: any[]) => any;
+    onSetNoNeedRefreshNumFilterName?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    dropdown1: CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+        readonly trigger: {
+            readonly type: PropType< TooltipTriggerType | TooltipTriggerType[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "hover";
+        };
+        readonly triggerKeys: {
+            readonly type: PropType<string[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => string[];
+        };
+        readonly effect: {
+            readonly default: "light";
+            readonly type: PropType<PopperEffect>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            readonly __epPropKey: true;
+        };
+        readonly type: {
+            readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly placement: {
+            readonly type: PropType<Placement>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "bottom";
+        };
+        readonly popperOptions: {
+            readonly type: PropType<Partial< Options>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => {};
+        };
+        readonly id: StringConstructor;
+        readonly size: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly splitButton: BooleanConstructor;
+        readonly hideOnClick: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        readonly loop: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        readonly showTimeout: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 150;
+        };
+        readonly hideTimeout: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 150;
+        };
+        readonly tabindex: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        readonly maxHeight: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly popperClass: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly disabled: BooleanConstructor;
+        readonly role: {
+            readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "menu";
+        };
+        readonly buttonProps: {
+            readonly type: PropType<Partial< ButtonProps>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly teleported: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        readonly persistent: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+    }>> & {
+        onClick?: ((...args: any[]) => any) | undefined;
+        "onVisible-change"?: ((...args: any[]) => any) | undefined;
+        onCommand?: ((...args: any[]) => any) | undefined;
+    }, {
+        t: Translator;
+        ns: {
+            namespace: ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        scrollbar: Ref<null>;
+        wrapStyle: ComputedRef<CSSProperties>;
+        dropdownTriggerKls: ComputedRef<string[]>;
+        dropdownSize: ComputedRef<"" | "small" | "default" | "large">;
+        triggerId: ComputedRef<string>;
+        currentTabId: Ref<string | null>;
+        handleCurrentTabIdChange: (id: string) => void;
+        handlerMainButtonClick: (event: MouseEvent) => void;
+        handleEntryFocus: (e: Event) => void;
+        handleClose: () => void;
+        handleOpen: () => void;
+        handleBeforeShowTooltip: () => void;
+        handleShowTooltip: (event?: Event) => void;
+        handleBeforeHideTooltip: () => void;
+        onFocusAfterTrapped: (e: Event) => void;
+        popperRef: Ref< TooltipInstance | undefined>;
+        contentRef: Ref<HTMLElement | undefined>;
+        triggeringElementRef: Ref<any>;
+        referenceElementRef: Ref<any>;
+    }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("click" | "visible-change" | "command")[], VNodeProps & AllowedComponentProps & ComponentCustomProps, {
+        readonly disabled: boolean;
+        readonly maxHeight: string | number;
+        readonly size: string;
+        readonly placement: Placement;
+        readonly effect: PopperEffect;
+        readonly trigger: TooltipTriggerType | TooltipTriggerType[];
+        readonly tabindex: string | number;
+        readonly role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+        readonly loop: boolean;
+        readonly popperOptions: Partial< Options>;
+        readonly popperClass: string;
+        readonly triggerKeys: string[];
+        readonly teleported: boolean;
+        readonly persistent: boolean;
+        readonly hideOnClick: boolean;
+        readonly showTimeout: number;
+        readonly hideTimeout: number;
+        readonly splitButton: boolean;
+    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< ExtractPropTypes<{
+        readonly trigger: {
+            readonly type: PropType< TooltipTriggerType | TooltipTriggerType[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "hover";
+        };
+        readonly triggerKeys: {
+            readonly type: PropType<string[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => string[];
+        };
+        readonly effect: {
+            readonly default: "light";
+            readonly type: PropType<PopperEffect>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            readonly __epPropKey: true;
+        };
+        readonly type: {
+            readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly placement: {
+            readonly type: PropType<Placement>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "bottom";
+        };
+        readonly popperOptions: {
+            readonly type: PropType<Partial< Options>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => {};
+        };
+        readonly id: StringConstructor;
+        readonly size: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly splitButton: BooleanConstructor;
+        readonly hideOnClick: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        readonly loop: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        readonly showTimeout: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 150;
+        };
+        readonly hideTimeout: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 150;
+        };
+        readonly tabindex: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        readonly maxHeight: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly popperClass: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly disabled: BooleanConstructor;
+        readonly role: {
+            readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "menu";
+        };
+        readonly buttonProps: {
+            readonly type: PropType<Partial< ButtonProps>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly teleported: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        readonly persistent: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+    }>> & {
+        onClick?: ((...args: any[]) => any) | undefined;
+        "onVisible-change"?: ((...args: any[]) => any) | undefined;
+        onCommand?: ((...args: any[]) => any) | undefined;
+    }, {
+        t: Translator;
+        ns: {
+            namespace: ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        scrollbar: Ref<null>;
+        wrapStyle: ComputedRef<CSSProperties>;
+        dropdownTriggerKls: ComputedRef<string[]>;
+        dropdownSize: ComputedRef<"" | "small" | "default" | "large">;
+        triggerId: ComputedRef<string>;
+        currentTabId: Ref<string | null>;
+        handleCurrentTabIdChange: (id: string) => void;
+        handlerMainButtonClick: (event: MouseEvent) => void;
+        handleEntryFocus: (e: Event) => void;
+        handleClose: () => void;
+        handleOpen: () => void;
+        handleBeforeShowTooltip: () => void;
+        handleShowTooltip: (event?: Event) => void;
+        handleBeforeHideTooltip: () => void;
+        onFocusAfterTrapped: (e: Event) => void;
+        popperRef: Ref< TooltipInstance | undefined>;
+        contentRef: Ref<HTMLElement | undefined>;
+        triggeringElementRef: Ref<any>;
+        referenceElementRef: Ref<any>;
+    }, {}, {}, {}, {
+        readonly disabled: boolean;
+        readonly maxHeight: string | number;
+        readonly size: string;
+        readonly placement: Placement;
+        readonly effect: PopperEffect;
+        readonly trigger: TooltipTriggerType | TooltipTriggerType[];
+        readonly tabindex: string | number;
+        readonly role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+        readonly loop: boolean;
+        readonly popperOptions: Partial< Options>;
+        readonly popperClass: string;
+        readonly triggerKeys: string[];
+        readonly teleported: boolean;
+        readonly persistent: boolean;
+        readonly hideOnClick: boolean;
+        readonly showTimeout: number;
+        readonly hideTimeout: number;
+        readonly splitButton: boolean;
+    }>;
+}, HTMLDivElement>> & Record<string, any>) | ( SFCWithInstall<DefineComponent<{
+    xyFilters?: data;
+    filterKey: string;
+}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    filterChange: (...args: any[]) => void;
+}, string, PublicProps, Readonly<{
+    xyFilters?: data;
+    filterKey: string;
+}> & Readonly<{
+    onFilterChange?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>> & Record<string, any>))[];
+export default _default;