lew-ui 2.7.67 → 2.7.69

package/dist/components/form/tree-select/src/LewTreeSelect.vue.d.ts

@@ -230,173 +230,717 @@ declare function __VLS_template(): {
                 }): any;
             };
         }) | null;
-        lewSelectRef: HTMLDivElement;
-        inputRef: HTMLInputElement;
-        lewTreeRef: ({
-            $: import('vue').ComponentInternalInstance;
-            $data: {};
-            $props: Partial<{
-                checkable: boolean;
-                height: string;
-                multiple: boolean;
-                searchable: boolean;
-                expandAll: boolean;
-                free: boolean;
-                showLine: boolean;
-                keyField: string;
-                labelField: string;
-                disabledField: string;
-                isSelect: boolean;
-                onlyLeafSelectable: boolean;
-            }> & Omit<{
-                readonly checkable: boolean;
-                readonly height: string;
-                readonly multiple: boolean;
-                readonly searchable: boolean;
-                readonly expandAll: boolean;
-                readonly free: boolean;
-                readonly showLine: boolean;
-                readonly keyField: string;
-                readonly labelField: string;
-                readonly disabledField: string;
-                readonly isSelect: boolean;
-                readonly onlyLeafSelectable: boolean;
-                readonly expandKeys?: never[] | undefined;
-                readonly modelValue?: any;
-                readonly dataSource?: import('../../../..').LewTreeDataSource[] | undefined;
-                readonly initMethod?: (() => void) | undefined;
-                readonly loadMethod?: ((item: import('../../../..').LewTreeDataSource) => void) | undefined;
-                readonly onChange?: ((data: any) => any) | undefined;
-                readonly "onUpdate:modelValue"?: ((value: any) => any) | undefined;
-                readonly onExpand?: ((data: any) => any) | undefined;
-                readonly onLoadStart?: (() => any) | undefined;
-                readonly onLoadEnd?: ((text: string) => any) | undefined;
-                readonly "onUpdate:expandKeys"?: ((value: never[]) => any) | undefined;
-            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "checkable" | "height" | "multiple" | "searchable" | "expandAll" | "free" | "showLine" | "keyField" | "labelField" | "disabledField" | "isSelect" | "onlyLeafSelectable">;
-            $attrs: {
-                [x: string]: unknown;
+        lewSelectRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
+            size: {
+                type: StringConstructor;
+                default: string;
             };
-            $refs: {
-                [x: string]: unknown;
+            readonly: {
+                type: BooleanConstructor;
+                default: boolean;
             };
-            $slots: Readonly<{
-                [name: string]: import('vue').Slot<any> | undefined;
-            }>;
-            $root: ComponentPublicInstance | null;
-            $parent: ComponentPublicInstance | null;
-            $host: Element | null;
-            $emit: ((event: "change", data: any) => void) & ((event: "update:modelValue", value: any) => void) & ((event: "expand", data: any) => void) & ((event: "loadStart") => void) & ((event: "loadEnd", text: string) => void) & ((event: "update:expandKeys", value: never[]) => void);
-            $el: HTMLDivElement;
-            $options: import('vue').ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
-                dataSource: {
-                    type: PropType<import('../../../..').LewTreeDataSource[]>;
-                    typePopKeys: string[];
-                    validator: (value: any[] | undefined) => boolean;
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            clearable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            placeholder: {
+                type: StringConstructor;
+                default: string;
+            };
+            width: {
+                type: StringConstructor;
+                default: string;
+            };
+            formatItems: {
+                type: null;
+            };
+            focus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            popoverVisible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            multiple: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            searchable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            selectedLabel: {
+                type: StringConstructor;
+                default: string;
+            };
+            modelValue: {
+                type: globalThis.PropType<any>;
+            };
+            keyword: {
+                type: globalThis.PropType<any>;
+            };
+        }>> & Readonly<{
+            onInput?: ((...args: any[]) => any) | undefined;
+            onClear?: ((...args: any[]) => any) | undefined;
+            onDelete?: ((...args: any[]) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+            "onUpdate:keyword"?: ((value: any) => any) | undefined;
+        }>, {
+            clearHandle: () => void;
+            getInputRefStyle: () => {
+                fontSize: string;
+                padding: string;
+                fontFamily: string;
+                marginLeft: string;
+            };
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            input: (...args: any[]) => void;
+            clear: (...args: any[]) => void;
+            delete: (...args: any[]) => void;
+            "update:modelValue": (value: any) => void;
+            "update:keyword": (value: any) => void;
+        }, import('vue').PublicProps, {
+            loading: boolean;
+            size: string;
+            disabled: boolean;
+            focus: boolean;
+            width: string;
+            placeholder: string;
+            readonly: boolean;
+            clearable: boolean;
+            multiple: boolean;
+            searchable: boolean;
+            popoverVisible: boolean;
+            selectedLabel: string;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            lewSelectRef: HTMLDivElement;
+            inputRef: HTMLInputElement;
+            searchInputRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
+                type: {
+                    type: PropType<import('../../../..').LewInputType>;
+                    default: string;
+                    typeValues: import('../../../..').LewInputType[];
+                    validator: (value: any) => boolean;
                 };
-                height: {
-                    type: StringConstructor;
+                size: {
+                    type: PropType<import('../../../..').LewSize>;
+                    default: string;
+                    typeValues: import('../../../..').LewSize[];
+                    validator: (value: any) => boolean;
+                };
+                width: {
+                    type: PropType<import("csstype").Property.Width>;
                     default: string;
                     validator: (value: string | number | undefined) => boolean;
                 };
-                multiple: {
+                placeholder: {
+                    type: StringConstructor;
+                    defaultLocale: boolean;
+                    validator: (value: any) => boolean;
+                };
+                disabled: {
                     type: BooleanConstructor;
                     default: boolean;
                     validator: (value: any) => boolean;
                 };
-                checkable: {
+                readonly: {
                     type: BooleanConstructor;
                     default: boolean;
                     validator: (value: any) => boolean;
                 };
-                searchable: {
+                clearable: {
                     type: BooleanConstructor;
                     default: boolean;
                     validator: (value: any) => boolean;
                 };
-                expandAll: {
+                showPassword: {
                     type: BooleanConstructor;
                     default: boolean;
                     validator: (value: any) => boolean;
                 };
-                free: {
+                maxLength: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: undefined;
+                    validator: (value: number | undefined) => boolean;
+                };
+                showCount: {
                     type: BooleanConstructor;
                     default: boolean;
                     validator: (value: any) => boolean;
                 };
-                showLine: {
+                align: {
+                    type: PropType<import('../../../..').LewXAlignment>;
+                    default: string;
+                    typeValues: import('../../../..').LewXAlignment[];
+                    validator: (value: any) => boolean;
+                };
+                minWidth: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: string;
+                    validator: (value: string | number | undefined) => boolean;
+                };
+                autoWidth: {
                     type: BooleanConstructor;
                     default: boolean;
                     validator: (value: any) => boolean;
                 };
-                keyField: {
+                selectByFocus: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                    validator: (value: any) => boolean;
+                };
+                copyable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                    validator: (value: any) => boolean;
+                };
+                prefixes: {
+                    type: PropType<import('../../../..').LewInputPrefixesType>;
+                    default: string;
+                    typeValues: import('../../../..').LewInputPrefixesType[];
+                    validator: (value: any) => boolean;
+                };
+                prefixesOptions: {
+                    type: PropType<import('../../../..').LewContextMenusOption[]>;
+                    default: () => never[];
+                    validator: (value: any[] | undefined) => boolean;
+                };
+                prefixesTooltip: {
                     type: StringConstructor;
                     default: string;
                     validator: (value: any) => boolean;
                 };
-                labelField: {
+                suffix: {
+                    type: PropType<import('../../../..').LewInputSuffixType>;
+                    default: string;
+                    typeValues: import('../../../..').LewInputSuffixType[];
+                    validator: (value: any) => boolean;
+                };
+                suffixOptions: {
+                    type: PropType<import('../../../..').LewContextMenusOption[]>;
+                    default: () => never[];
+                    validator: (value: any[] | undefined) => boolean;
+                };
+                suffixTooltip: {
                     type: StringConstructor;
                     default: string;
                     validator: (value: any) => boolean;
                 };
-                disabledField: {
+                okByEnter: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                    validator: (value: any) => boolean;
+                };
+                modelValue: {
+                    type: globalThis.PropType<string | undefined>;
+                    required: true;
+                };
+                prefixValue: {
+                    type: globalThis.PropType<string>;
+                };
+                suffixValue: {
+                    type: globalThis.PropType<string>;
+                };
+            }>> & Readonly<{
+                onInput?: ((value?: string | undefined) => any) | undefined;
+                onBlur?: ((e: FocusEvent) => any) | undefined;
+                onChange?: ((value?: string | undefined) => any) | undefined;
+                onFocus?: ((e: FocusEvent) => any) | undefined;
+                onClear?: (() => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+                "onUpdate:prefixValue"?: ((value: string | undefined) => any) | undefined;
+                "onUpdate:suffixValue"?: ((value: string | undefined) => any) | undefined;
+                onOk?: ((value?: string | undefined) => any) | undefined;
+            }>, {
+                focus: () => any;
+                blur: () => any;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                input: (value?: string | undefined) => void;
+                blur: (e: FocusEvent) => void;
+                change: (value?: string | undefined) => void;
+                focus: (e: FocusEvent) => void;
+                clear: () => void;
+                ok: (value?: string | undefined) => void;
+                "update:modelValue": (value: string | undefined) => void;
+                "update:prefixValue": (value: string | undefined) => void;
+                "update:suffixValue": (value: string | undefined) => void;
+            }, import('vue').PublicProps, {
+                maxLength: string | number;
+                type: import('../../../..').LewInputType;
+                size: import('../../../..').LewSize;
+                disabled: boolean;
+                width: import("csstype").Property.Width<0 | (string & {})>;
+                minWidth: string | number;
+                readonly: boolean;
+                clearable: boolean;
+                showPassword: boolean;
+                showCount: boolean;
+                align: import('../../../..').LewXAlignment;
+                autoWidth: boolean;
+                selectByFocus: boolean;
+                copyable: boolean;
+                prefixes: import('../../../..').LewInputPrefixesType;
+                prefixesOptions: import('../../../..').LewContextMenusOption[];
+                prefixesTooltip: string;
+                suffix: import('../../../..').LewInputSuffixType;
+                suffixOptions: import('../../../..').LewContextMenusOption[];
+                suffixTooltip: string;
+                okByEnter: boolean;
+            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+                lewInputRef: HTMLInputElement;
+                lewInputCountRef: HTMLDivElement;
+            }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<globalThis.ExtractPropTypes<{
+                type: {
+                    type: PropType<import('../../../..').LewInputType>;
+                    default: string;
+                    typeValues: import('../../../..').LewInputType[];
+                    validator: (value: any) => boolean;
+                };
+                size: {
+                    type: PropType<import('../../../..').LewSize>;
+                    default: string;
+                    typeValues: import('../../../..').LewSize[];
+                    validator: (value: any) => boolean;
+                };
+                width: {
+                    type: PropType<import("csstype").Property.Width>;
+                    default: string;
+                    validator: (value: string | number | undefined) => boolean;
+                };
+                placeholder: {
                     type: StringConstructor;
+                    defaultLocale: boolean;
+                    validator: (value: any) => boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                    validator: (value: any) => boolean;
+                };
+                readonly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                    validator: (value: any) => boolean;
+                };
+                clearable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                    validator: (value: any) => boolean;
+                };
+                showPassword: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                    validator: (value: any) => boolean;
+                };
+                maxLength: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: undefined;
+                    validator: (value: number | undefined) => boolean;
+                };
+                showCount: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                    validator: (value: any) => boolean;
+                };
+                align: {
+                    type: PropType<import('../../../..').LewXAlignment>;
                     default: string;
+                    typeValues: import('../../../..').LewXAlignment[];
                     validator: (value: any) => boolean;
                 };
-                initMethod: {
-                    type: PropType<() => void>;
+                minWidth: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: string;
+                    validator: (value: string | number | undefined) => boolean;
+                };
+                autoWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
                     validator: (value: any) => boolean;
                 };
-                loadMethod: {
-                    type: PropType<(item: import('../../../..').LewTreeDataSource) => void>;
+                selectByFocus: {
+                    type: BooleanConstructor;
+                    default: boolean;
                     validator: (value: any) => boolean;
                 };
-                isSelect: {
+                copyable: {
                     type: BooleanConstructor;
                     default: boolean;
-                    hidden: boolean;
                     validator: (value: any) => boolean;
                 };
-                onlyLeafSelectable: {
+                prefixes: {
+                    type: PropType<import('../../../..').LewInputPrefixesType>;
+                    default: string;
+                    typeValues: import('../../../..').LewInputPrefixesType[];
+                    validator: (value: any) => boolean;
+                };
+                prefixesOptions: {
+                    type: PropType<import('../../../..').LewContextMenusOption[]>;
+                    default: () => never[];
+                    validator: (value: any[] | undefined) => boolean;
+                };
+                prefixesTooltip: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                suffix: {
+                    type: PropType<import('../../../..').LewInputSuffixType>;
+                    default: string;
+                    typeValues: import('../../../..').LewInputSuffixType[];
+                    validator: (value: any) => boolean;
+                };
+                suffixOptions: {
+                    type: PropType<import('../../../..').LewContextMenusOption[]>;
+                    default: () => never[];
+                    validator: (value: any[] | undefined) => boolean;
+                };
+                suffixTooltip: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                okByEnter: {
                     type: BooleanConstructor;
                     default: boolean;
                     validator: (value: any) => boolean;
                 };
                 modelValue: {
-                    type: globalThis.PropType<any>;
+                    type: globalThis.PropType<string | undefined>;
+                    required: true;
                 };
-                expandKeys: {
-                    type: globalThis.PropType<never[]>;
+                prefixValue: {
+                    type: globalThis.PropType<string>;
+                };
+                suffixValue: {
+                    type: globalThis.PropType<string>;
                 };
             }>> & Readonly<{
-                onChange?: ((data: any) => any) | undefined;
-                "onUpdate:modelValue"?: ((value: any) => any) | undefined;
-                onExpand?: ((data: any) => any) | undefined;
-                onLoadStart?: (() => any) | undefined;
-                onLoadEnd?: ((text: string) => any) | undefined;
-                "onUpdate:expandKeys"?: ((value: never[]) => any) | undefined;
+                onInput?: ((value?: string | undefined) => any) | undefined;
+                onBlur?: ((e: FocusEvent) => any) | undefined;
+                onChange?: ((value?: string | undefined) => any) | undefined;
+                onFocus?: ((e: FocusEvent) => any) | undefined;
+                onClear?: (() => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+                "onUpdate:prefixValue"?: ((value: string | undefined) => any) | undefined;
+                "onUpdate:suffixValue"?: ((value: string | undefined) => any) | undefined;
+                onOk?: ((value?: string | undefined) => any) | undefined;
             }>, {
-                search: (keyword: string) => void;
-                reset: () => void;
-                getTree: () => any;
-            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-                change: (data: any) => void;
-                expand: (data: any) => void;
-                loadStart: () => void;
-                loadEnd: (text: string) => void;
-                "update:modelValue": (value: any) => void;
-                "update:expandKeys": (value: never[]) => void;
-            }, string, {
-                checkable: boolean;
-                height: string;
-                multiple: boolean;
-                searchable: boolean;
-                expandAll: boolean;
-                free: boolean;
-                showLine: boolean;
-                keyField: string;
-                labelField: string;
-                disabledField: string;
+                focus: () => any;
+                blur: () => any;
+            }, {}, {}, {}, {
+                maxLength: string | number;
+                type: import('../../../..').LewInputType;
+                size: import('../../../..').LewSize;
+                disabled: boolean;
+                width: import("csstype").Property.Width<0 | (string & {})>;
+                minWidth: string | number;
+                readonly: boolean;
+                clearable: boolean;
+                showPassword: boolean;
+                showCount: boolean;
+                align: import('../../../..').LewXAlignment;
+                autoWidth: boolean;
+                selectByFocus: boolean;
+                copyable: boolean;
+                prefixes: import('../../../..').LewInputPrefixesType;
+                prefixesOptions: import('../../../..').LewContextMenusOption[];
+                prefixesTooltip: string;
+                suffix: import('../../../..').LewInputSuffixType;
+                suffixOptions: import('../../../..').LewContextMenusOption[];
+                suffixTooltip: string;
+                okByEnter: boolean;
+            }> | null;
+        }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<globalThis.ExtractPropTypes<{
+            size: {
+                type: StringConstructor;
+                default: string;
+            };
+            readonly: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            clearable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            placeholder: {
+                type: StringConstructor;
+                default: string;
+            };
+            width: {
+                type: StringConstructor;
+                default: string;
+            };
+            formatItems: {
+                type: null;
+            };
+            focus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            popoverVisible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            multiple: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            searchable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            selectedLabel: {
+                type: StringConstructor;
+                default: string;
+            };
+            modelValue: {
+                type: globalThis.PropType<any>;
+            };
+            keyword: {
+                type: globalThis.PropType<any>;
+            };
+        }>> & Readonly<{
+            onInput?: ((...args: any[]) => any) | undefined;
+            onClear?: ((...args: any[]) => any) | undefined;
+            onDelete?: ((...args: any[]) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+            "onUpdate:keyword"?: ((value: any) => any) | undefined;
+        }>, {
+            clearHandle: () => void;
+            getInputRefStyle: () => {
+                fontSize: string;
+                padding: string;
+                fontFamily: string;
+                marginLeft: string;
+            };
+        }, {}, {}, {}, {
+            loading: boolean;
+            size: string;
+            disabled: boolean;
+            focus: boolean;
+            width: string;
+            placeholder: string;
+            readonly: boolean;
+            clearable: boolean;
+            multiple: boolean;
+            searchable: boolean;
+            popoverVisible: boolean;
+            selectedLabel: string;
+        }> | null;
+        lewTreeRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                checkable: boolean;
+                height: string;
+                multiple: boolean;
+                searchable: boolean;
+                expandAll: boolean;
+                free: boolean;
+                showLine: boolean;
+                keyField: string;
+                labelField: string;
+                disabledField: string;
+                isSelect: boolean;
+                onlyLeafSelectable: boolean;
+            }> & Omit<{
+                readonly checkable: boolean;
+                readonly height: string;
+                readonly multiple: boolean;
+                readonly searchable: boolean;
+                readonly expandAll: boolean;
+                readonly free: boolean;
+                readonly showLine: boolean;
+                readonly keyField: string;
+                readonly labelField: string;
+                readonly disabledField: string;
+                readonly isSelect: boolean;
+                readonly onlyLeafSelectable: boolean;
+                readonly expandKeys?: string[] | undefined;
+                readonly modelValue?: string | string[] | undefined;
+                readonly dataSource?: import('../../../..').LewTreeDataSource[] | undefined;
+                readonly initMethod?: (() => void) | undefined;
+                readonly loadMethod?: ((item: import('../../../..').LewTreeDataSource) => void) | undefined;
+                readonly onChange?: ((data: any) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((value: string | string[]) => any) | undefined;
+                readonly onExpand?: ((data: any) => any) | undefined;
+                readonly onLoadStart?: (() => any) | undefined;
+                readonly onLoadEnd?: ((text: string) => any) | undefined;
+                readonly "onUpdate:expandKeys"?: ((value: string[]) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "checkable" | "height" | "multiple" | "searchable" | "expandAll" | "free" | "showLine" | "keyField" | "labelField" | "disabledField" | "isSelect" | "onlyLeafSelectable">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "change", data: any) => void) & ((event: "update:modelValue", value: string | string[]) => void) & ((event: "expand", data: any) => void) & ((event: "loadStart") => void) & ((event: "loadEnd", text: string) => void) & ((event: "update:expandKeys", value: string[]) => void);
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+                dataSource: {
+                    type: PropType<import('../../../..').LewTreeDataSource[]>;
+                    typePopKeys: string[];
+                    validator: (value: any[] | undefined) => boolean;
+                };
+                height: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: string | number | undefined) => boolean;
+                };
+                multiple: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                    validator: (value: any) => boolean;
+                };
+                checkable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                    validator: (value: any) => boolean;
+                };
+                searchable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                    validator: (value: any) => boolean;
+                };
+                expandAll: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                    validator: (value: any) => boolean;
+                };
+                free: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                    validator: (value: any) => boolean;
+                };
+                showLine: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                    validator: (value: any) => boolean;
+                };
+                keyField: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                labelField: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                disabledField: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                initMethod: {
+                    type: PropType<() => void>;
+                    validator: (value: any) => boolean;
+                };
+                loadMethod: {
+                    type: PropType<(item: import('../../../..').LewTreeDataSource) => void>;
+                    validator: (value: any) => boolean;
+                };
+                isSelect: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                    hidden: boolean;
+                    validator: (value: any) => boolean;
+                };
+                onlyLeafSelectable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                    validator: (value: any) => boolean;
+                };
+                modelValue: {
+                    type: globalThis.PropType<string | string[]>;
+                };
+                expandKeys: {
+                    type: globalThis.PropType<string[]>;
+                };
+            }>> & Readonly<{
+                onChange?: ((data: any) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string | string[]) => any) | undefined;
+                onExpand?: ((data: any) => any) | undefined;
+                onLoadStart?: (() => any) | undefined;
+                onLoadEnd?: ((text: string) => any) | undefined;
+                "onUpdate:expandKeys"?: ((value: string[]) => any) | undefined;
+            }>, {
+                search: any;
+                reset: () => void;
+                getTree: () => {
+                    label: string;
+                    key: string;
+                    level: number;
+                    isLeaf?: boolean | undefined;
+                    loading?: boolean | undefined;
+                    disabled?: boolean | undefined;
+                    parentKey?: string | undefined;
+                    treeIndex?: number | undefined;
+                    labelPaths?: string[] | undefined;
+                    valueKeys?: string[] | undefined;
+                    parentKeyPaths?: string[] | undefined;
+                    parentLabelPaths?: string[] | undefined;
+                    allNodeValues: string[];
+                    leafNodeValues: string[];
+                    children?: /*elided*/ any[] | undefined;
+                }[];
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                change: (data: any) => void;
+                expand: (data: any) => void;
+                loadStart: () => void;
+                loadEnd: (text: string) => void;
+                "update:modelValue": (value: string | string[]) => void;
+                "update:expandKeys": (value: string[]) => void;
+            }, string, {
+                checkable: boolean;
+                height: string;
+                multiple: boolean;
+                searchable: boolean;
+                expandAll: boolean;
+                free: boolean;
+                showLine: boolean;
+                keyField: string;
+                labelField: string;
+                disabledField: string;
                 isSelect: boolean;
                 onlyLeafSelectable: boolean;
             }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
@@ -508,22 +1052,38 @@ declare function __VLS_template(): {
                 validator: (value: any) => boolean;
             };
             modelValue: {
-                type: globalThis.PropType<any>;
+                type: globalThis.PropType<string | string[]>;
             };
             expandKeys: {
-                type: globalThis.PropType<never[]>;
+                type: globalThis.PropType<string[]>;
             };
         }>> & Readonly<{
             onChange?: ((data: any) => any) | undefined;
-            "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string | string[]) => any) | undefined;
             onExpand?: ((data: any) => any) | undefined;
             onLoadStart?: (() => any) | undefined;
             onLoadEnd?: ((text: string) => any) | undefined;
-            "onUpdate:expandKeys"?: ((value: never[]) => any) | undefined;
+            "onUpdate:expandKeys"?: ((value: string[]) => any) | undefined;
         }>, "search" | "reset" | "getTree" | ("checkable" | "height" | "multiple" | "searchable" | "expandAll" | "free" | "showLine" | "keyField" | "labelField" | "disabledField" | "isSelect" | "onlyLeafSelectable")> & import('vue').ShallowUnwrapRef<{
-            search: (keyword: string) => void;
+            search: any;
             reset: () => void;
-            getTree: () => any;
+            getTree: () => {
+                label: string;
+                key: string;
+                level: number;
+                isLeaf?: boolean | undefined;
+                loading?: boolean | undefined;
+                disabled?: boolean | undefined;
+                parentKey?: string | undefined;
+                treeIndex?: number | undefined;
+                labelPaths?: string[] | undefined;
+                valueKeys?: string[] | undefined;
+                parentKeyPaths?: string[] | undefined;
+                parentLabelPaths?: string[] | undefined;
+                allNodeValues: string[];
+                leafNodeValues: string[];
+                children?: /*elided*/ any[] | undefined;
+            }[];
         }> & {} & import('vue').ComponentCustomProperties & {} & {
             $slots: {
                 empty?(_: {}): any;
@@ -569,11 +1129,21 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
         default: boolean;
         validator: (value: any) => boolean;
     };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
     checkable: {
         type: BooleanConstructor;
         default: boolean;
         validator: (value: any) => boolean;
     };
+    onlyLeafSelectable: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
     showAllLevels: {
         type: BooleanConstructor;
         default: boolean;
@@ -645,15 +1215,15 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
         validator: (value: any) => boolean;
     };
     modelValue: {
-        type: globalThis.PropType<any>;
+        type: globalThis.PropType<string | string[]>;
     };
 }>, {
     show: typeof show;
     hide: typeof hide;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    change: (value?: string | undefined) => void;
+    change: (value?: string | string[] | undefined) => void;
     clear: () => void;
-    "update:modelValue": (value: any) => void;
+    "update:modelValue": (value: string | string[]) => void;
 }, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
     dataSource: {
         type: PropType<import('../../../..').LewTreeDataSource[]>;
@@ -690,11 +1260,21 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
         default: boolean;
         validator: (value: any) => boolean;
     };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
     checkable: {
         type: BooleanConstructor;
         default: boolean;
         validator: (value: any) => boolean;
     };
+    onlyLeafSelectable: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
     showAllLevels: {
         type: BooleanConstructor;
         default: boolean;
@@ -766,12 +1346,12 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
         validator: (value: any) => boolean;
     };
     modelValue: {
-        type: globalThis.PropType<any>;
+        type: globalThis.PropType<string | string[]>;
     };
 }>> & Readonly<{
-    onChange?: ((value?: string | undefined) => any) | undefined;
+    onChange?: ((value?: string | string[] | undefined) => any) | undefined;
     onClear?: (() => any) | undefined;
-    "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | string[]) => any) | undefined;
 }>, {
     size: import('../../../..').LewSize;
     disabled: boolean;
@@ -780,6 +1360,7 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
     readonly: boolean;
     trigger: import('../../../..').LewTrigger;
     clearable: boolean;
+    multiple: boolean;
     searchable: boolean;
     initMethod: () => void;
     searchDelay: number;
@@ -790,6 +1371,7 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
     labelField: string;
     disabledField: string;
     loadMethod: () => void;
+    onlyLeafSelectable: boolean;
     showAllLevels: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     lewPopoverRef: ({
@@ -798,61 +1380,515 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
         $props: Partial<{
             loading: boolean;
             disabled: boolean;
-            offset: import('../../../..').LewOffset;
-            placement: import('../../../..').LewPlacement;
-            delay: [number, number];
-            trigger: import('../../../..').LewTrigger;
-            triggerWidth: import("csstype").Property.Width<0 | (string & {})>;
-            hideOnClick: boolean;
-            clickOutsideToHide: boolean;
-            popoverBodyClassName: string;
-        }> & Omit<{
-            readonly loading: boolean;
-            readonly disabled: boolean;
-            readonly offset: import('../../../..').LewOffset;
-            readonly placement: import('../../../..').LewPlacement;
-            readonly delay: [number, number];
-            readonly trigger: import('../../../..').LewTrigger;
-            readonly triggerWidth: import("csstype").Property.Width<0 | (string & {})>;
-            readonly hideOnClick: boolean;
-            readonly clickOutsideToHide: boolean;
-            readonly popoverBodyClassName: string;
-            readonly onShow?: (() => any) | undefined;
-            readonly onHide?: (() => any) | undefined;
-        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "loading" | "disabled" | "offset" | "placement" | "delay" | "trigger" | "triggerWidth" | "hideOnClick" | "clickOutsideToHide" | "popoverBodyClassName">;
-        $attrs: {
-            [x: string]: unknown;
-        };
-        $refs: {
-            [x: string]: unknown;
-        } & {
-            triggerRef: HTMLDivElement;
-            bodyRef: HTMLDivElement;
-        };
-        $slots: Readonly<{
-            [name: string]: import('vue').Slot<any> | undefined;
-        }>;
-        $root: ComponentPublicInstance | null;
-        $parent: ComponentPublicInstance | null;
-        $host: Element | null;
-        $emit: ((event: "show") => void) & ((event: "hide") => void);
-        $el: HTMLDivElement;
-        $options: import('vue').ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
-            trigger: {
-                type: PropType<import('../../../..').LewTrigger>;
+            offset: import('../../../..').LewOffset;
+            placement: import('../../../..').LewPlacement;
+            delay: [number, number];
+            trigger: import('../../../..').LewTrigger;
+            triggerWidth: import("csstype").Property.Width<0 | (string & {})>;
+            hideOnClick: boolean;
+            clickOutsideToHide: boolean;
+            popoverBodyClassName: string;
+        }> & Omit<{
+            readonly loading: boolean;
+            readonly disabled: boolean;
+            readonly offset: import('../../../..').LewOffset;
+            readonly placement: import('../../../..').LewPlacement;
+            readonly delay: [number, number];
+            readonly trigger: import('../../../..').LewTrigger;
+            readonly triggerWidth: import("csstype").Property.Width<0 | (string & {})>;
+            readonly hideOnClick: boolean;
+            readonly clickOutsideToHide: boolean;
+            readonly popoverBodyClassName: string;
+            readonly onShow?: (() => any) | undefined;
+            readonly onHide?: (() => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "loading" | "disabled" | "offset" | "placement" | "delay" | "trigger" | "triggerWidth" | "hideOnClick" | "clickOutsideToHide" | "popoverBodyClassName">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            triggerRef: HTMLDivElement;
+            bodyRef: HTMLDivElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "show") => void) & ((event: "hide") => void);
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+            trigger: {
+                type: PropType<import('../../../..').LewTrigger>;
+                default: string;
+                typeValues: import('../../../..').LewTrigger[];
+                validator: (value: any) => boolean;
+            };
+            triggerWidth: {
+                type: PropType<import("csstype").Property.Width>;
+                default: string;
+                validator: (value: any) => boolean;
+            };
+            placement: {
+                type: PropType<import('../../../..').LewPlacement>;
+                default: string;
+                typeValues: import('../../../..').LewPlacement[];
+                validator: (value: any) => boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            hideOnClick: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            clickOutsideToHide: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            offset: {
+                type: PropType<import('../../../..').LewOffset>;
+                default: number[];
+                validator: (value: any[] | undefined) => boolean;
+            };
+            delay: {
+                type: PropType<[number, number]>;
+                default: number[];
+                validator: (value: any[] | undefined) => boolean;
+            };
+            popoverBodyClassName: {
+                type: StringConstructor;
+                default: string;
+                validator: (value: any) => boolean;
+            };
+        }>> & Readonly<{
+            onShow?: (() => any) | undefined;
+            onHide?: (() => any) | undefined;
+        }>, {
+            show: () => void;
+            hide: () => void;
+            refresh: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            show: () => void;
+            hide: () => void;
+        }, string, {
+            loading: boolean;
+            disabled: boolean;
+            offset: import('../../../..').LewOffset;
+            placement: import('../../../..').LewPlacement;
+            delay: [number, number];
+            trigger: import('../../../..').LewTrigger;
+            triggerWidth: import("csstype").Property.Width<0 | (string & {})>;
+            hideOnClick: boolean;
+            clickOutsideToHide: boolean;
+            popoverBodyClassName: 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: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: 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<{
+        loading: boolean;
+        disabled: boolean;
+        offset: import('../../../..').LewOffset;
+        placement: import('../../../..').LewPlacement;
+        delay: [number, number];
+        trigger: import('../../../..').LewTrigger;
+        triggerWidth: import("csstype").Property.Width<0 | (string & {})>;
+        hideOnClick: boolean;
+        clickOutsideToHide: boolean;
+        popoverBodyClassName: string;
+    }> & Omit<Readonly<globalThis.ExtractPropTypes<{
+        trigger: {
+            type: PropType<import('../../../..').LewTrigger>;
+            default: string;
+            typeValues: import('../../../..').LewTrigger[];
+            validator: (value: any) => boolean;
+        };
+        triggerWidth: {
+            type: PropType<import("csstype").Property.Width>;
+            default: string;
+            validator: (value: any) => boolean;
+        };
+        placement: {
+            type: PropType<import('../../../..').LewPlacement>;
+            default: string;
+            typeValues: import('../../../..').LewPlacement[];
+            validator: (value: any) => boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+            validator: (value: any) => boolean;
+        };
+        loading: {
+            type: BooleanConstructor;
+            default: boolean;
+            validator: (value: any) => boolean;
+        };
+        hideOnClick: {
+            type: BooleanConstructor;
+            default: boolean;
+            validator: (value: any) => boolean;
+        };
+        clickOutsideToHide: {
+            type: BooleanConstructor;
+            default: boolean;
+            validator: (value: any) => boolean;
+        };
+        offset: {
+            type: PropType<import('../../../..').LewOffset>;
+            default: number[];
+            validator: (value: any[] | undefined) => boolean;
+        };
+        delay: {
+            type: PropType<[number, number]>;
+            default: number[];
+            validator: (value: any[] | undefined) => boolean;
+        };
+        popoverBodyClassName: {
+            type: StringConstructor;
+            default: string;
+            validator: (value: any) => boolean;
+        };
+    }>> & Readonly<{
+        onShow?: (() => any) | undefined;
+        onHide?: (() => any) | undefined;
+    }>, "show" | "hide" | "refresh" | ("loading" | "disabled" | "offset" | "placement" | "delay" | "trigger" | "triggerWidth" | "hideOnClick" | "clickOutsideToHide" | "popoverBodyClassName")> & import('vue').ShallowUnwrapRef<{
+        show: () => void;
+        hide: () => void;
+        refresh: () => void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            trigger?(_: {}): any;
+            'popover-body'?(_: {
+                show: () => void;
+                hide: () => void;
+            }): any;
+        };
+    }) | null;
+    lewSelectRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
+        size: {
+            type: StringConstructor;
+            default: string;
+        };
+        readonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        loading: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        clearable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        placeholder: {
+            type: StringConstructor;
+            default: string;
+        };
+        width: {
+            type: StringConstructor;
+            default: string;
+        };
+        formatItems: {
+            type: null;
+        };
+        focus: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        popoverVisible: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        searchable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        selectedLabel: {
+            type: StringConstructor;
+            default: string;
+        };
+        modelValue: {
+            type: globalThis.PropType<any>;
+        };
+        keyword: {
+            type: globalThis.PropType<any>;
+        };
+    }>> & Readonly<{
+        onInput?: ((...args: any[]) => any) | undefined;
+        onClear?: ((...args: any[]) => any) | undefined;
+        onDelete?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+        "onUpdate:keyword"?: ((value: any) => any) | undefined;
+    }>, {
+        clearHandle: () => void;
+        getInputRefStyle: () => {
+            fontSize: string;
+            padding: string;
+            fontFamily: string;
+            marginLeft: string;
+        };
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        input: (...args: any[]) => void;
+        clear: (...args: any[]) => void;
+        delete: (...args: any[]) => void;
+        "update:modelValue": (value: any) => void;
+        "update:keyword": (value: any) => void;
+    }, import('vue').PublicProps, {
+        loading: boolean;
+        size: string;
+        disabled: boolean;
+        focus: boolean;
+        width: string;
+        placeholder: string;
+        readonly: boolean;
+        clearable: boolean;
+        multiple: boolean;
+        searchable: boolean;
+        popoverVisible: boolean;
+        selectedLabel: string;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        lewSelectRef: HTMLDivElement;
+        inputRef: HTMLInputElement;
+        searchInputRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
+            type: {
+                type: PropType<import('../../../..').LewInputType>;
+                default: string;
+                typeValues: import('../../../..').LewInputType[];
+                validator: (value: any) => boolean;
+            };
+            size: {
+                type: PropType<import('../../../..').LewSize>;
+                default: string;
+                typeValues: import('../../../..').LewSize[];
+                validator: (value: any) => boolean;
+            };
+            width: {
+                type: PropType<import("csstype").Property.Width>;
+                default: string;
+                validator: (value: string | number | undefined) => boolean;
+            };
+            placeholder: {
+                type: StringConstructor;
+                defaultLocale: boolean;
+                validator: (value: any) => boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            readonly: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            clearable: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            showPassword: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            maxLength: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: undefined;
+                validator: (value: number | undefined) => boolean;
+            };
+            showCount: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            align: {
+                type: PropType<import('../../../..').LewXAlignment>;
+                default: string;
+                typeValues: import('../../../..').LewXAlignment[];
+                validator: (value: any) => boolean;
+            };
+            minWidth: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: string;
+                validator: (value: string | number | undefined) => boolean;
+            };
+            autoWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            selectByFocus: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            copyable: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            prefixes: {
+                type: PropType<import('../../../..').LewInputPrefixesType>;
+                default: string;
+                typeValues: import('../../../..').LewInputPrefixesType[];
+                validator: (value: any) => boolean;
+            };
+            prefixesOptions: {
+                type: PropType<import('../../../..').LewContextMenusOption[]>;
+                default: () => never[];
+                validator: (value: any[] | undefined) => boolean;
+            };
+            prefixesTooltip: {
+                type: StringConstructor;
+                default: string;
+                validator: (value: any) => boolean;
+            };
+            suffix: {
+                type: PropType<import('../../../..').LewInputSuffixType>;
+                default: string;
+                typeValues: import('../../../..').LewInputSuffixType[];
+                validator: (value: any) => boolean;
+            };
+            suffixOptions: {
+                type: PropType<import('../../../..').LewContextMenusOption[]>;
+                default: () => never[];
+                validator: (value: any[] | undefined) => boolean;
+            };
+            suffixTooltip: {
+                type: StringConstructor;
+                default: string;
+                validator: (value: any) => boolean;
+            };
+            okByEnter: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            modelValue: {
+                type: globalThis.PropType<string | undefined>;
+                required: true;
+            };
+            prefixValue: {
+                type: globalThis.PropType<string>;
+            };
+            suffixValue: {
+                type: globalThis.PropType<string>;
+            };
+        }>> & Readonly<{
+            onInput?: ((value?: string | undefined) => any) | undefined;
+            onBlur?: ((e: FocusEvent) => any) | undefined;
+            onChange?: ((value?: string | undefined) => any) | undefined;
+            onFocus?: ((e: FocusEvent) => any) | undefined;
+            onClear?: (() => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+            "onUpdate:prefixValue"?: ((value: string | undefined) => any) | undefined;
+            "onUpdate:suffixValue"?: ((value: string | undefined) => any) | undefined;
+            onOk?: ((value?: string | undefined) => any) | undefined;
+        }>, {
+            focus: () => any;
+            blur: () => any;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            input: (value?: string | undefined) => void;
+            blur: (e: FocusEvent) => void;
+            change: (value?: string | undefined) => void;
+            focus: (e: FocusEvent) => void;
+            clear: () => void;
+            ok: (value?: string | undefined) => void;
+            "update:modelValue": (value: string | undefined) => void;
+            "update:prefixValue": (value: string | undefined) => void;
+            "update:suffixValue": (value: string | undefined) => void;
+        }, import('vue').PublicProps, {
+            maxLength: string | number;
+            type: import('../../../..').LewInputType;
+            size: import('../../../..').LewSize;
+            disabled: boolean;
+            width: import("csstype").Property.Width<0 | (string & {})>;
+            minWidth: string | number;
+            readonly: boolean;
+            clearable: boolean;
+            showPassword: boolean;
+            showCount: boolean;
+            align: import('../../../..').LewXAlignment;
+            autoWidth: boolean;
+            selectByFocus: boolean;
+            copyable: boolean;
+            prefixes: import('../../../..').LewInputPrefixesType;
+            prefixesOptions: import('../../../..').LewContextMenusOption[];
+            prefixesTooltip: string;
+            suffix: import('../../../..').LewInputSuffixType;
+            suffixOptions: import('../../../..').LewContextMenusOption[];
+            suffixTooltip: string;
+            okByEnter: boolean;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            lewInputRef: HTMLInputElement;
+            lewInputCountRef: HTMLDivElement;
+        }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<globalThis.ExtractPropTypes<{
+            type: {
+                type: PropType<import('../../../..').LewInputType>;
                 default: string;
-                typeValues: import('../../../..').LewTrigger[];
+                typeValues: import('../../../..').LewInputType[];
                 validator: (value: any) => boolean;
             };
-            triggerWidth: {
-                type: PropType<import("csstype").Property.Width>;
+            size: {
+                type: PropType<import('../../../..').LewSize>;
                 default: string;
+                typeValues: import('../../../..').LewSize[];
                 validator: (value: any) => boolean;
             };
-            placement: {
-                type: PropType<import('../../../..').LewPlacement>;
+            width: {
+                type: PropType<import("csstype").Property.Width>;
                 default: string;
-                typeValues: import('../../../..').LewPlacement[];
+                validator: (value: string | number | undefined) => boolean;
+            };
+            placeholder: {
+                type: StringConstructor;
+                defaultLocale: boolean;
                 validator: (value: any) => boolean;
             };
             disabled: {
@@ -860,159 +1896,233 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
                 default: boolean;
                 validator: (value: any) => boolean;
             };
-            loading: {
+            readonly: {
                 type: BooleanConstructor;
                 default: boolean;
                 validator: (value: any) => boolean;
             };
-            hideOnClick: {
+            clearable: {
                 type: BooleanConstructor;
                 default: boolean;
                 validator: (value: any) => boolean;
             };
-            clickOutsideToHide: {
+            showPassword: {
                 type: BooleanConstructor;
                 default: boolean;
                 validator: (value: any) => boolean;
             };
-            offset: {
-                type: PropType<import('../../../..').LewOffset>;
-                default: number[];
+            maxLength: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: undefined;
+                validator: (value: number | undefined) => boolean;
+            };
+            showCount: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            align: {
+                type: PropType<import('../../../..').LewXAlignment>;
+                default: string;
+                typeValues: import('../../../..').LewXAlignment[];
+                validator: (value: any) => boolean;
+            };
+            minWidth: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: string;
+                validator: (value: string | number | undefined) => boolean;
+            };
+            autoWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            selectByFocus: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            copyable: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            prefixes: {
+                type: PropType<import('../../../..').LewInputPrefixesType>;
+                default: string;
+                typeValues: import('../../../..').LewInputPrefixesType[];
+                validator: (value: any) => boolean;
+            };
+            prefixesOptions: {
+                type: PropType<import('../../../..').LewContextMenusOption[]>;
+                default: () => never[];
                 validator: (value: any[] | undefined) => boolean;
             };
-            delay: {
-                type: PropType<[number, number]>;
-                default: number[];
+            prefixesTooltip: {
+                type: StringConstructor;
+                default: string;
+                validator: (value: any) => boolean;
+            };
+            suffix: {
+                type: PropType<import('../../../..').LewInputSuffixType>;
+                default: string;
+                typeValues: import('../../../..').LewInputSuffixType[];
+                validator: (value: any) => boolean;
+            };
+            suffixOptions: {
+                type: PropType<import('../../../..').LewContextMenusOption[]>;
+                default: () => never[];
                 validator: (value: any[] | undefined) => boolean;
             };
-            popoverBodyClassName: {
+            suffixTooltip: {
                 type: StringConstructor;
                 default: string;
                 validator: (value: any) => boolean;
             };
+            okByEnter: {
+                type: BooleanConstructor;
+                default: boolean;
+                validator: (value: any) => boolean;
+            };
+            modelValue: {
+                type: globalThis.PropType<string | undefined>;
+                required: true;
+            };
+            prefixValue: {
+                type: globalThis.PropType<string>;
+            };
+            suffixValue: {
+                type: globalThis.PropType<string>;
+            };
         }>> & Readonly<{
-            onShow?: (() => any) | undefined;
-            onHide?: (() => any) | undefined;
+            onInput?: ((value?: string | undefined) => any) | undefined;
+            onBlur?: ((e: FocusEvent) => any) | undefined;
+            onChange?: ((value?: string | undefined) => any) | undefined;
+            onFocus?: ((e: FocusEvent) => any) | undefined;
+            onClear?: (() => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+            "onUpdate:prefixValue"?: ((value: string | undefined) => any) | undefined;
+            "onUpdate:suffixValue"?: ((value: string | undefined) => any) | undefined;
+            onOk?: ((value?: string | undefined) => any) | undefined;
         }>, {
-            show: () => void;
-            hide: () => void;
-            refresh: () => void;
-        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-            show: () => void;
-            hide: () => void;
-        }, string, {
-            loading: boolean;
+            focus: () => any;
+            blur: () => any;
+        }, {}, {}, {}, {
+            maxLength: string | number;
+            type: import('../../../..').LewInputType;
+            size: import('../../../..').LewSize;
             disabled: boolean;
-            offset: import('../../../..').LewOffset;
-            placement: import('../../../..').LewPlacement;
-            delay: [number, number];
-            trigger: import('../../../..').LewTrigger;
-            triggerWidth: import("csstype").Property.Width<0 | (string & {})>;
-            hideOnClick: boolean;
-            clickOutsideToHide: boolean;
-            popoverBodyClassName: 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: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: 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<{
-        loading: boolean;
-        disabled: boolean;
-        offset: import('../../../..').LewOffset;
-        placement: import('../../../..').LewPlacement;
-        delay: [number, number];
-        trigger: import('../../../..').LewTrigger;
-        triggerWidth: import("csstype").Property.Width<0 | (string & {})>;
-        hideOnClick: boolean;
-        clickOutsideToHide: boolean;
-        popoverBodyClassName: string;
-    }> & Omit<Readonly<globalThis.ExtractPropTypes<{
-        trigger: {
-            type: PropType<import('../../../..').LewTrigger>;
-            default: string;
-            typeValues: import('../../../..').LewTrigger[];
-            validator: (value: any) => boolean;
-        };
-        triggerWidth: {
-            type: PropType<import("csstype").Property.Width>;
+            width: import("csstype").Property.Width<0 | (string & {})>;
+            minWidth: string | number;
+            readonly: boolean;
+            clearable: boolean;
+            showPassword: boolean;
+            showCount: boolean;
+            align: import('../../../..').LewXAlignment;
+            autoWidth: boolean;
+            selectByFocus: boolean;
+            copyable: boolean;
+            prefixes: import('../../../..').LewInputPrefixesType;
+            prefixesOptions: import('../../../..').LewContextMenusOption[];
+            prefixesTooltip: string;
+            suffix: import('../../../..').LewInputSuffixType;
+            suffixOptions: import('../../../..').LewContextMenusOption[];
+            suffixTooltip: string;
+            okByEnter: boolean;
+        }> | null;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<globalThis.ExtractPropTypes<{
+        size: {
+            type: StringConstructor;
             default: string;
-            validator: (value: any) => boolean;
         };
-        placement: {
-            type: PropType<import('../../../..').LewPlacement>;
-            default: string;
-            typeValues: import('../../../..').LewPlacement[];
-            validator: (value: any) => boolean;
+        readonly: {
+            type: BooleanConstructor;
+            default: boolean;
         };
         disabled: {
             type: BooleanConstructor;
             default: boolean;
-            validator: (value: any) => boolean;
         };
         loading: {
             type: BooleanConstructor;
             default: boolean;
-            validator: (value: any) => boolean;
         };
-        hideOnClick: {
+        clearable: {
             type: BooleanConstructor;
             default: boolean;
-            validator: (value: any) => boolean;
         };
-        clickOutsideToHide: {
+        placeholder: {
+            type: StringConstructor;
+            default: string;
+        };
+        width: {
+            type: StringConstructor;
+            default: string;
+        };
+        formatItems: {
+            type: null;
+        };
+        focus: {
             type: BooleanConstructor;
             default: boolean;
-            validator: (value: any) => boolean;
         };
-        offset: {
-            type: PropType<import('../../../..').LewOffset>;
-            default: number[];
-            validator: (value: any[] | undefined) => boolean;
+        popoverVisible: {
+            type: BooleanConstructor;
+            default: boolean;
         };
-        delay: {
-            type: PropType<[number, number]>;
-            default: number[];
-            validator: (value: any[] | undefined) => boolean;
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
         };
-        popoverBodyClassName: {
+        searchable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        selectedLabel: {
             type: StringConstructor;
             default: string;
-            validator: (value: any) => boolean;
+        };
+        modelValue: {
+            type: globalThis.PropType<any>;
+        };
+        keyword: {
+            type: globalThis.PropType<any>;
         };
     }>> & Readonly<{
-        onShow?: (() => any) | undefined;
-        onHide?: (() => any) | undefined;
-    }>, "show" | "hide" | "refresh" | ("loading" | "disabled" | "offset" | "placement" | "delay" | "trigger" | "triggerWidth" | "hideOnClick" | "clickOutsideToHide" | "popoverBodyClassName")> & import('vue').ShallowUnwrapRef<{
-        show: () => void;
-        hide: () => void;
-        refresh: () => void;
-    }> & {} & import('vue').ComponentCustomProperties & {} & {
-        $slots: {
-            trigger?(_: {}): any;
-            'popover-body'?(_: {
-                show: () => void;
-                hide: () => void;
-            }): any;
+        onInput?: ((...args: any[]) => any) | undefined;
+        onClear?: ((...args: any[]) => any) | undefined;
+        onDelete?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+        "onUpdate:keyword"?: ((value: any) => any) | undefined;
+    }>, {
+        clearHandle: () => void;
+        getInputRefStyle: () => {
+            fontSize: string;
+            padding: string;
+            fontFamily: string;
+            marginLeft: string;
         };
-    }) | null;
-    lewSelectRef: HTMLDivElement;
-    inputRef: HTMLInputElement;
+    }, {}, {}, {}, {
+        loading: boolean;
+        size: string;
+        disabled: boolean;
+        focus: boolean;
+        width: string;
+        placeholder: string;
+        readonly: boolean;
+        clearable: boolean;
+        multiple: boolean;
+        searchable: boolean;
+        popoverVisible: boolean;
+        selectedLabel: string;
+    }> | null;
     lewTreeRef: ({
         $: import('vue').ComponentInternalInstance;
         $data: {};
@@ -1042,17 +2152,17 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
             readonly disabledField: string;
             readonly isSelect: boolean;
             readonly onlyLeafSelectable: boolean;
-            readonly expandKeys?: never[] | undefined;
-            readonly modelValue?: any;
+            readonly expandKeys?: string[] | undefined;
+            readonly modelValue?: string | string[] | undefined;
             readonly dataSource?: import('../../../..').LewTreeDataSource[] | undefined;
             readonly initMethod?: (() => void) | undefined;
             readonly loadMethod?: ((item: import('../../../..').LewTreeDataSource) => void) | undefined;
             readonly onChange?: ((data: any) => any) | undefined;
-            readonly "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+            readonly "onUpdate:modelValue"?: ((value: string | string[]) => any) | undefined;
             readonly onExpand?: ((data: any) => any) | undefined;
             readonly onLoadStart?: (() => any) | undefined;
             readonly onLoadEnd?: ((text: string) => any) | undefined;
-            readonly "onUpdate:expandKeys"?: ((value: never[]) => any) | undefined;
+            readonly "onUpdate:expandKeys"?: ((value: string[]) => any) | undefined;
         } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "checkable" | "height" | "multiple" | "searchable" | "expandAll" | "free" | "showLine" | "keyField" | "labelField" | "disabledField" | "isSelect" | "onlyLeafSelectable">;
         $attrs: {
             [x: string]: unknown;
@@ -1066,7 +2176,7 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
         $root: ComponentPublicInstance | null;
         $parent: ComponentPublicInstance | null;
         $host: Element | null;
-        $emit: ((event: "change", data: any) => void) & ((event: "update:modelValue", value: any) => void) & ((event: "expand", data: any) => void) & ((event: "loadStart") => void) & ((event: "loadEnd", text: string) => void) & ((event: "update:expandKeys", value: never[]) => void);
+        $emit: ((event: "change", data: any) => void) & ((event: "update:modelValue", value: string | string[]) => void) & ((event: "expand", data: any) => void) & ((event: "loadStart") => void) & ((event: "loadEnd", text: string) => void) & ((event: "update:expandKeys", value: string[]) => void);
         $el: HTMLDivElement;
         $options: import('vue').ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
             dataSource: {
@@ -1144,29 +2254,45 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
                 validator: (value: any) => boolean;
             };
             modelValue: {
-                type: globalThis.PropType<any>;
+                type: globalThis.PropType<string | string[]>;
             };
             expandKeys: {
-                type: globalThis.PropType<never[]>;
+                type: globalThis.PropType<string[]>;
             };
         }>> & Readonly<{
             onChange?: ((data: any) => any) | undefined;
-            "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string | string[]) => any) | undefined;
             onExpand?: ((data: any) => any) | undefined;
             onLoadStart?: (() => any) | undefined;
             onLoadEnd?: ((text: string) => any) | undefined;
-            "onUpdate:expandKeys"?: ((value: never[]) => any) | undefined;
+            "onUpdate:expandKeys"?: ((value: string[]) => any) | undefined;
         }>, {
-            search: (keyword: string) => void;
+            search: any;
             reset: () => void;
-            getTree: () => any;
+            getTree: () => {
+                label: string;
+                key: string;
+                level: number;
+                isLeaf?: boolean | undefined;
+                loading?: boolean | undefined;
+                disabled?: boolean | undefined;
+                parentKey?: string | undefined;
+                treeIndex?: number | undefined;
+                labelPaths?: string[] | undefined;
+                valueKeys?: string[] | undefined;
+                parentKeyPaths?: string[] | undefined;
+                parentLabelPaths?: string[] | undefined;
+                allNodeValues: string[];
+                leafNodeValues: string[];
+                children?: /*elided*/ any[] | undefined;
+            }[];
         }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
             change: (data: any) => void;
             expand: (data: any) => void;
             loadStart: () => void;
             loadEnd: (text: string) => void;
-            "update:modelValue": (value: any) => void;
-            "update:expandKeys": (value: never[]) => void;
+            "update:modelValue": (value: string | string[]) => void;
+            "update:expandKeys": (value: string[]) => void;
         }, string, {
             checkable: boolean;
             height: string;
@@ -1289,22 +2415,38 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
             validator: (value: any) => boolean;
         };
         modelValue: {
-            type: globalThis.PropType<any>;
+            type: globalThis.PropType<string | string[]>;
         };
         expandKeys: {
-            type: globalThis.PropType<never[]>;
+            type: globalThis.PropType<string[]>;
         };
     }>> & Readonly<{
         onChange?: ((data: any) => any) | undefined;
-        "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | string[]) => any) | undefined;
         onExpand?: ((data: any) => any) | undefined;
         onLoadStart?: (() => any) | undefined;
         onLoadEnd?: ((text: string) => any) | undefined;
-        "onUpdate:expandKeys"?: ((value: never[]) => any) | undefined;
+        "onUpdate:expandKeys"?: ((value: string[]) => any) | undefined;
     }>, "search" | "reset" | "getTree" | ("checkable" | "height" | "multiple" | "searchable" | "expandAll" | "free" | "showLine" | "keyField" | "labelField" | "disabledField" | "isSelect" | "onlyLeafSelectable")> & import('vue').ShallowUnwrapRef<{
-        search: (keyword: string) => void;
+        search: any;
         reset: () => void;
-        getTree: () => any;
+        getTree: () => {
+            label: string;
+            key: string;
+            level: number;
+            isLeaf?: boolean | undefined;
+            loading?: boolean | undefined;
+            disabled?: boolean | undefined;
+            parentKey?: string | undefined;
+            treeIndex?: number | undefined;
+            labelPaths?: string[] | undefined;
+            valueKeys?: string[] | undefined;
+            parentKeyPaths?: string[] | undefined;
+            parentLabelPaths?: string[] | undefined;
+            allNodeValues: string[];
+            leafNodeValues: string[];
+            children?: /*elided*/ any[] | undefined;
+        }[];
     }> & {} & import('vue').ComponentCustomProperties & {} & {
         $slots: {
             empty?(_: {}): any;