@zjhc/ui 0.0.0-stage → 0.1.0

package/dist/components/autocomplete/src/autoComplete.vue.d.ts

@@ -0,0 +1,511 @@
+import { AutocompleteData } from './autocomplete';
+import { StyleValue } from 'vue';
+import { TooltipInstance, InputInstance } from 'element-plus';
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly ariaLabel: StringConstructor;
+    readonly valueKey: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "value", boolean>;
+    readonly modelValue: import('element-plus/es/utils/index.mjs').EpPropFinalized<{
+        (arrayLength: number): (string | number)[];
+        (...items: (string | number)[]): (string | number)[];
+        new (arrayLength: number): (string | number)[];
+        new (...items: (string | number)[]): (string | number)[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, readonly [], boolean>;
+    readonly debounce: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
+    readonly placement: import('element-plus/es/utils/index.mjs').EpPropFinalized<import('vue').PropType<import('element-plus').Placement>, "bottom" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end", unknown, "bottom-start", boolean>;
+    readonly fetchSuggestions: import('element-plus/es/utils/index.mjs').EpPropFinalized<import('vue').PropType<import('./autocomplete').AutocompleteFetchSuggestion>, unknown, unknown, () => void, boolean>;
+    readonly multiple: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly popperClass: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly triggerOnFocus: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly selectWhenUnmatched: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly hideLoading: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly teleported: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly highlightFirstItem: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly fitInputWidth: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly clearable: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly name: StringConstructor;
+}>, {
+    highlightedIndex: import('vue').Ref<number, number>;
+    activated: import('vue').Ref<boolean, boolean>;
+    loading: import('vue').Ref<boolean, boolean>;
+    inputRef: import('vue').Ref<InputInstance, InputInstance>;
+    popperRef: import('vue').Ref<TooltipInstance, TooltipInstance>;
+    suggestions: import('vue').Ref<Record<string, any>[], AutocompleteData | Record<string, any>[]>;
+    handleSelect: (item: any) => Promise<void>;
+    focus: () => void;
+    blur: () => void;
+    close: () => void;
+    highlight: (index: number) => void;
+    getData: (queryString: string) => Promise<void>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: (string | number)[]) => void;
+    change: (value: string) => void;
+    input: (value: string) => void;
+    clear: () => void;
+    select: (item: Record<string, any>, selected: boolean) => void;
+    blur: (evt: FocusEvent) => void;
+    focus: (evt: FocusEvent) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly ariaLabel: StringConstructor;
+    readonly valueKey: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "value", boolean>;
+    readonly modelValue: import('element-plus/es/utils/index.mjs').EpPropFinalized<{
+        (arrayLength: number): (string | number)[];
+        (...items: (string | number)[]): (string | number)[];
+        new (arrayLength: number): (string | number)[];
+        new (...items: (string | number)[]): (string | number)[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, readonly [], boolean>;
+    readonly debounce: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
+    readonly placement: import('element-plus/es/utils/index.mjs').EpPropFinalized<import('vue').PropType<import('element-plus').Placement>, "bottom" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end", unknown, "bottom-start", boolean>;
+    readonly fetchSuggestions: import('element-plus/es/utils/index.mjs').EpPropFinalized<import('vue').PropType<import('./autocomplete').AutocompleteFetchSuggestion>, unknown, unknown, () => void, boolean>;
+    readonly multiple: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly popperClass: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly triggerOnFocus: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly selectWhenUnmatched: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly hideLoading: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly teleported: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly highlightFirstItem: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly fitInputWidth: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly clearable: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly name: StringConstructor;
+}>> & Readonly<{
+    "onUpdate:modelValue"?: (value: (string | number)[]) => any;
+    onChange?: (value: string) => any;
+    onInput?: (value: string) => any;
+    onClear?: () => any;
+    onSelect?: (item: Record<string, any>, selected: boolean) => any;
+    onBlur?: (evt: FocusEvent) => any;
+    onFocus?: (evt: FocusEvent) => any;
+}>, {
+    readonly popperClass: string;
+    readonly teleported: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly placement: import('element-plus/es/utils/index.mjs').EpPropMergeType<import('vue').PropType<import('element-plus').Placement>, "bottom" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end", unknown>;
+    readonly modelValue: (string | number)[];
+    readonly multiple: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly valueKey: string;
+    readonly debounce: number;
+    readonly fetchSuggestions: import('./autocomplete').AutocompleteFetchSuggestion;
+    readonly triggerOnFocus: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly selectWhenUnmatched: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly hideLoading: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly highlightFirstItem: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly fitInputWidth: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly clearable: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    popperRef: {
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly showArrow?: boolean;
+            readonly "onUpdate:visible"?: ((value: boolean) => void) & ((...args: any[]) => any);
+            readonly role?: "grid" | "dialog" | "menu" | "listbox" | "tooltip" | "group" | "navigation" | "tree";
+            readonly appendTo?: string | HTMLElement;
+            readonly content?: string;
+            readonly rawContent?: boolean;
+            readonly persistent?: boolean;
+            readonly visible?: boolean | null;
+            readonly transition?: string;
+            readonly teleported?: boolean;
+            readonly disabled?: boolean;
+            readonly ariaLabel?: import('element-plus').AriaProps["ariaLabel"];
+            readonly showAfter?: number;
+            readonly hideAfter?: number;
+            readonly autoClose?: number;
+            readonly className?: import('element-plus/es/utils/typescript.mjs').ClassValue;
+            readonly zIndex?: number;
+            readonly offset?: number;
+            readonly style?: StyleValue;
+            readonly popperClass?: import('element-plus/es/utils/typescript.mjs').ClassValue;
+            readonly popperStyle?: StyleValue;
+            readonly virtualTriggering?: boolean;
+            readonly effect?: import('element-plus').PopperEffect;
+            readonly placement?: import('element-plus').Placement;
+            readonly popperOptions?: Partial<import('element-plus').Options>;
+            readonly id?: string;
+            readonly loop?: boolean;
+            readonly strategy?: "fixed" | "absolute";
+            readonly referenceEl?: HTMLElement;
+            readonly triggerTargetEl?: HTMLElement;
+            readonly enterable?: boolean;
+            readonly pure?: boolean;
+            readonly focusOnShow?: boolean;
+            readonly trapping?: boolean;
+            readonly stopPopperMouseEvent?: boolean;
+            readonly boundariesPadding?: number;
+            readonly fallbackPlacements?: import('element-plus').Placement[];
+            readonly gpuAcceleration?: boolean;
+            readonly arrowOffset?: number;
+            readonly trigger?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
+            readonly triggerKeys?: string[];
+            readonly focusOnTarget?: boolean;
+            readonly virtualRef?: import('element-plus').Measurable;
+            readonly onMouseenter?: (e: MouseEvent) => void;
+            readonly onMouseleave?: (e: MouseEvent) => void;
+            readonly onClick?: (e: PointerEvent) => void;
+            readonly onKeydown?: (e: KeyboardEvent) => void;
+            readonly onFocus?: (e: FocusEvent) => void;
+            readonly onBlur?: (e: FocusEvent) => void;
+            readonly onContextmenu?: (e: PointerEvent) => void;
+            readonly open?: boolean;
+            readonly onHide?: ((...args: any[]) => any) | undefined;
+            readonly onShow?: ((...args: any[]) => any) | undefined;
+            readonly onOpen?: ((...args: any[]) => any) | undefined;
+            readonly onClose?: ((...args: any[]) => any) | undefined;
+            readonly "onBefore-show"?: ((...args: any[]) => any) | undefined;
+            readonly "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any>;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "show", ...args: any[]) => void) & ((event: "close", ...args: any[]) => void) & ((event: "open", ...args: any[]) => void) & ((event: "hide", ...args: any[]) => void) & ((event: "update:visible", ...args: any[]) => void) & ((event: "before-show", ...args: any[]) => void) & ((event: "before-hide", ...args: any[]) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('element-plus').UseTooltipProps> & Readonly<{
+            onHide?: ((...args: any[]) => any) | undefined;
+            onShow?: ((...args: any[]) => any) | undefined;
+            onOpen?: ((...args: any[]) => any) | undefined;
+            onClose?: ((...args: any[]) => any) | undefined;
+            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+            "onBefore-show"?: ((...args: any[]) => any) | undefined;
+            "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined, import('element-plus').PopperInstance | undefined>;
+            contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined, import('element-plus').TooltipContentInstance | undefined>;
+            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+            updatePopper: () => void;
+            onOpen: (event?: Event, delay?: number) => void;
+            onClose: (event?: Event, delay?: number) => void;
+            hide: (event?: Event) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            hide: (...args: any[]) => void;
+            show: (...args: any[]) => void;
+            open: (...args: any[]) => void;
+            close: (...args: any[]) => void;
+            "update:visible": (...args: any[]) => void;
+            "before-show": (...args: any[]) => void;
+            "before-hide": (...args: any[]) => void;
+        }, string, {
+            visible: boolean | null;
+            style: string | false | import('vue').CSSProperties | StyleValue[] | null;
+            content: string;
+            role: "grid" | "dialog" | "menu" | "listbox" | "tooltip" | "group" | "navigation" | "tree";
+            offset: number;
+            teleported: boolean;
+            effect: import('element-plus').PopperEffect;
+            enterable: boolean;
+            pure: boolean;
+            focusOnShow: boolean;
+            trapping: boolean;
+            popperClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+            popperStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+            stopPopperMouseEvent: boolean;
+            virtualTriggering: boolean;
+            loop: boolean;
+            boundariesPadding: number;
+            gpuAcceleration: boolean;
+            placement: import('element-plus').Placement;
+            popperOptions: Partial<import('element-plus').Options>;
+            strategy: "absolute" | "fixed";
+            arrowOffset: number;
+            showArrow: boolean;
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            trigger: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
+            triggerKeys: string[];
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').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: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        visible: boolean | null;
+        style: string | false | import('vue').CSSProperties | StyleValue[] | null;
+        content: string;
+        role: "grid" | "dialog" | "menu" | "listbox" | "tooltip" | "group" | "navigation" | "tree";
+        offset: number;
+        teleported: boolean;
+        effect: import('element-plus').PopperEffect;
+        enterable: boolean;
+        pure: boolean;
+        focusOnShow: boolean;
+        trapping: boolean;
+        popperClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+        popperStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+        stopPopperMouseEvent: boolean;
+        virtualTriggering: boolean;
+        loop: boolean;
+        boundariesPadding: number;
+        gpuAcceleration: boolean;
+        placement: import('element-plus').Placement;
+        popperOptions: Partial<import('element-plus').Options>;
+        strategy: "absolute" | "fixed";
+        arrowOffset: number;
+        showArrow: boolean;
+        showAfter: number;
+        hideAfter: number;
+        autoClose: number;
+        trigger: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
+        triggerKeys: string[];
+    }> & Omit<Readonly<import('element-plus').UseTooltipProps> & Readonly<{
+        onHide?: ((...args: any[]) => any) | undefined;
+        onShow?: ((...args: any[]) => any) | undefined;
+        onOpen?: ((...args: any[]) => any) | undefined;
+        onClose?: ((...args: any[]) => any) | undefined;
+        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+        "onBefore-show"?: ((...args: any[]) => any) | undefined;
+        "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+    }>, "content" | "offset" | "style" | "popperClass" | "popperStyle" | "teleported" | "trigger" | "triggerKeys" | "virtualTriggering" | "effect" | "placement" | "popperOptions" | "loop" | "showArrow" | "role" | "strategy" | "popperRef" | "contentRef" | "visible" | "autoClose" | "enterable" | "pure" | "focusOnShow" | "trapping" | "stopPopperMouseEvent" | "boundariesPadding" | "gpuAcceleration" | "arrowOffset" | "showAfter" | "hideAfter" | "onClose" | "onOpen" | "hide" | "isFocusInsideContent" | "updatePopper"> & {
+        popperRef: import('element-plus').PopperInstance;
+        contentRef: import('element-plus').TooltipContentInstance;
+        isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+        updatePopper: () => void;
+        onOpen: (event?: Event, delay?: number) => void;
+        onClose: (event?: Event, delay?: number) => void;
+        hide: (event?: Event) => void;
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?: (props: {}) => any;
+        } & {
+            content?: (props: {}) => any;
+        };
+    };
+    listboxRef: HTMLDivElement;
+    inputRef: {
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly id?: string;
+            readonly size?: import('element-plus').ComponentSize;
+            readonly disabled?: boolean;
+            readonly modelValue?: string | number | null | undefined;
+            readonly modelModifiers?: import('element-plus').InputModelModifiers;
+            readonly maxlength?: string | number;
+            readonly minlength?: string | number;
+            readonly type?: import('element-plus').InputType;
+            readonly resize?: "none" | "both" | "horizontal" | "vertical";
+            readonly autosize?: import('element-plus').InputAutoSize;
+            readonly autocomplete?: string;
+            readonly formatter?: (value: string) => string;
+            readonly parser?: (value: string) => string;
+            readonly placeholder?: string;
+            readonly form?: string;
+            readonly readonly?: boolean;
+            readonly clearable?: boolean;
+            readonly clearIcon?: import('element-plus/es/utils/index.mjs').IconPropType;
+            readonly showPassword?: boolean;
+            readonly showWordLimit?: boolean;
+            readonly wordLimitPosition?: "inside" | "outside";
+            readonly suffixIcon?: import('element-plus/es/utils/index.mjs').IconPropType;
+            readonly prefixIcon?: import('element-plus/es/utils/index.mjs').IconPropType;
+            readonly containerRole?: string;
+            readonly tabindex?: string | number;
+            readonly validateEvent?: boolean;
+            readonly inputStyle?: StyleValue;
+            readonly autofocus?: boolean;
+            readonly rows?: number;
+            readonly ariaLabel?: string;
+            readonly inputmode?: import('vue').HTMLAttributes["inputmode"];
+            readonly name?: string;
+            readonly countGraphemes?: (value: string) => number;
+            readonly onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+            readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            readonly onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+            readonly onInput?: ((value: string) => any) | undefined;
+            readonly onBlur?: ((evt: FocusEvent) => any) | undefined;
+            readonly onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+            readonly onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+            readonly onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+            readonly onFocus?: ((evt: FocusEvent) => any) | undefined;
+            readonly onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+            readonly onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+            readonly onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any>;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "update:modelValue", value: string) => void) & ((event: "change", value: string, evt?: Event) => void) & ((event: "input", value: string) => void) & ((event: "clear", evt: MouseEvent) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "compositionend", evt: CompositionEvent) => void) & ((event: "compositionstart", evt: CompositionEvent) => void) & ((event: "compositionupdate", evt: CompositionEvent) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "keydown", evt: Event | KeyboardEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void) & ((event: "mouseleave", evt: MouseEvent) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('element-plus').InputProps> & Readonly<{
+            onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+            onInput?: ((value: string) => any) | undefined;
+            onBlur?: ((evt: FocusEvent) => any) | undefined;
+            onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+            onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+            onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+            onFocus?: ((evt: FocusEvent) => any) | undefined;
+            onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+            onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+            onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+        }>, {
+            input: import('vue').ShallowRef<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+            textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined, HTMLTextAreaElement | undefined>;
+            ref: import('vue').ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+            textareaStyle: import('vue').ComputedRef<StyleValue>;
+            autosize: import('vue').Ref<import('element-plus').InputAutoSize | undefined, import('element-plus').InputAutoSize | undefined>;
+            isComposing: import('vue').Ref<boolean, boolean>;
+            passwordVisible: import('vue').Ref<boolean, boolean>;
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+            select: () => void;
+            clear: (evt?: MouseEvent) => void;
+            resizeTextarea: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            clear: (evt: MouseEvent | undefined) => void;
+            "update:modelValue": (value: string) => void;
+            change: (value: string, evt?: Event | undefined) => void;
+            input: (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, {
+            type: import('element-plus').InputType;
+            disabled: boolean;
+            modelValue: string | number | null;
+            validateEvent: boolean;
+            modelModifiers: import('element-plus').InputModelModifiers;
+            autocomplete: string;
+            clearIcon: import('element-plus/es/utils/index.mjs').IconPropType;
+            wordLimitPosition: "inside" | "outside";
+            tabindex: string | number;
+            inputStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+            rows: number;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').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: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        type: import('element-plus').InputType;
+        disabled: boolean;
+        modelValue: string | number | null;
+        validateEvent: boolean;
+        modelModifiers: import('element-plus').InputModelModifiers;
+        autocomplete: string;
+        clearIcon: import('element-plus/es/utils/index.mjs').IconPropType;
+        wordLimitPosition: "inside" | "outside";
+        tabindex: string | number;
+        inputStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+        rows: number;
+    }> & Omit<Readonly<import('element-plus').InputProps> & Readonly<{
+        onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+        onInput?: ((value: string) => any) | undefined;
+        onBlur?: ((evt: FocusEvent) => any) | undefined;
+        onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+        onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+        onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+        onFocus?: ((evt: FocusEvent) => any) | undefined;
+        onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+        onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+        onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+    }>, "input" | "type" | "clear" | "select" | "textarea" | "blur" | "focus" | "disabled" | "rows" | "ref" | "tabindex" | "modelValue" | "modelModifiers" | "autosize" | "autocomplete" | "clearIcon" | "wordLimitPosition" | "validateEvent" | "inputStyle" | "textareaStyle" | "isComposing" | "passwordVisible" | "resizeTextarea"> & {
+        input: HTMLInputElement;
+        textarea: HTMLTextAreaElement;
+        ref: HTMLInputElement | HTMLTextAreaElement;
+        textareaStyle: StyleValue;
+        autosize: import('element-plus').InputAutoSize;
+        isComposing: boolean;
+        passwordVisible: boolean;
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        select: () => void;
+        clear: (evt?: MouseEvent) => void;
+        resizeTextarea: () => void;
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            prepend?: (props: {}) => any;
+        } & {
+            prefix?: (props: {}) => any;
+        } & {
+            suffix?: (props: {}) => any;
+        } & {
+            'password-icon'?: (props: {
+                visible: boolean;
+            }) => any;
+        } & {
+            append?: (props: {}) => any;
+        };
+    };
+    regionRef: HTMLDivElement;
+}, any>, {
+    prepend?(_: {}): any;
+    append?(_: {}): any;
+    prefix?(_: {}): any;
+    suffix?(_: {}): any;
+    loading?(_: {}): any;
+    default?(_: {
+        item: Record<string, any>;
+    }): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/autocomplete/src/autocomplete.d.ts

@@ -0,0 +1,50 @@
+import { Awaitable } from 'element-plus/es/utils/index';
+import { ExtractPropTypes } from 'vue';
+import { default as Autocomplete } from './autoComplete.vue';
+import { Placement } from 'element-plus/es/components/popper/index';
+export type AutocompleteData = Record<string, any>[];
+export type AutocompleteFetchSuggestionCallback = (data: AutocompleteData) => void;
+export type AutocompleteFetchSuggestion = ((queryString: string, cb: AutocompleteFetchSuggestionCallback) => Awaitable<AutocompleteData> | void) | AutocompleteData;
+export declare const autocompleteProps: {
+    readonly ariaLabel: StringConstructor;
+    readonly valueKey: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "value", boolean>;
+    readonly modelValue: import('element-plus/es/utils/index').EpPropFinalized<{
+        (arrayLength: number): (string | number)[];
+        (...items: (string | number)[]): (string | number)[];
+        new (arrayLength: number): (string | number)[];
+        new (...items: (string | number)[]): (string | number)[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, readonly [], boolean>;
+    readonly debounce: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
+    readonly placement: import('element-plus/es/utils/index').EpPropFinalized<import('vue').PropType<Placement>, "bottom" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end", unknown, "bottom-start", boolean>;
+    readonly fetchSuggestions: import('element-plus/es/utils/index').EpPropFinalized<import('vue').PropType<AutocompleteFetchSuggestion>, unknown, unknown, () => void, boolean>;
+    readonly multiple: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly popperClass: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly triggerOnFocus: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly selectWhenUnmatched: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly hideLoading: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly teleported: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly highlightFirstItem: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly fitInputWidth: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly clearable: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly name: StringConstructor;
+};
+export type AutocompleteProps = ExtractPropTypes<typeof autocompleteProps>;
+export declare const autocompleteEmits: {
+    "update:modelValue": (value: Array<string | number>) => boolean;
+    input: (value: string) => boolean;
+    change: (value: string) => boolean;
+    focus: (evt: FocusEvent) => boolean;
+    blur: (evt: FocusEvent) => boolean;
+    clear: () => boolean;
+    select: (item: Record<string, any>, selected: boolean) => boolean;
+};
+export type AutocompleteEmits = typeof autocompleteEmits;
+export type AutocompleteInstance = InstanceType<typeof Autocomplete>;

package/dist/components/collapse-container/index.d.ts

@@ -0,0 +1,6 @@
+import { default as CollapseContainer } from './src/collapseContainer.vue';
+import { SFCWithInstall } from '../../utils';
+export declare const ZjhcCollapseContainer: SFCWithInstall<typeof CollapseContainer>;
+export default CollapseContainer;
+export * from './src/collapseContainer.vue';
+export type { ZjhcCollapseContainerInstance } from './src/instance';

package/dist/components/collapse-container/src/collapseContainer.vue.d.ts

@@ -0,0 +1,47 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        title?(_: {}): any;
+        content?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    collapse: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    toggleEnd: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    collapse: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+}>> & Readonly<{
+    onToggleEnd?: (...args: any[]) => any;
+}>, {
+    title: string;
+    collapse: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/collapse-container/src/instance.d.ts

@@ -0,0 +1,2 @@
+import { default as CollapseContainer } from './collapseContainer.vue';
+export type ZjhcCollapseContainerInstance = InstanceType<typeof CollapseContainer>;

package/dist/components/collapse-panel/index.d.ts

@@ -0,0 +1,6 @@
+import { default as CollapsePanel } from './src/collapsePanel.vue';
+import { SFCWithInstall } from '../../utils';
+export declare const ZjhcCollapsePanel: SFCWithInstall<typeof CollapsePanel>;
+export default ZjhcCollapsePanel;
+export * from './src/collapsePanel.vue';
+export type { ZjhcCollapsePanelInstance } from './src/instance';