npm - lew-ui - Versions diffs - 2.7.57 → 2.7.60 - Mend

lew-ui 2.7.57 → 2.7.60

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

Files changed (38) hide show

package/dist/components/form/select/src/LewSelect.vue.d.ts CHANGED Viewed

@@ -245,272 +245,800 @@ declare function __VLS_template(): {
                 }): any;
             };
         }) | null;
-        lewSelectRef: HTMLDivElement;
-        inputRef: HTMLInputElement;
-        virtListRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
-            list: {
-                type: {
-                    (arrayLength: number): any[];
-                    (...items: any[]): any[];
-                    new (arrayLength: number): any[];
-                    new (...items: any[]): any[];
-                    isArray(arg: any): arg is any[];
-                    readonly prototype: any[];
-                    from<T>(arrayLike: ArrayLike<T>): T[];
-                    from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
-                    from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
-                    from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
-                    of<T_4>(...items: T_4[]): T_4[];
-                    readonly [Symbol.species]: ArrayConstructor;
-                };
-                default: () => never[];
-            };
-            itemKey: {
-                type: (StringConstructor | NumberConstructor)[];
-                required: true;
-            };
-            minSize: {
-                type: NumberConstructor;
-                default: number;
-                required: true;
-            };
-            itemGap: {
-                type: NumberConstructor;
-                default: number;
-            };
-            renderControl: {
-                type: FunctionConstructor;
-                default: undefined;
+        lewSelectInputRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
+            size: {
+                type: StringConstructor;
+                default: string;
             };
-            fixed: {
+            readonly: {
                 type: BooleanConstructor;
                 default: boolean;
             };
-            buffer: {
-                type: NumberConstructor;
-                default: number;
-            };
-            bufferTop: {
-                type: NumberConstructor;
-                default: number;
-            };
-            bufferBottom: {
-                type: NumberConstructor;
-                default: number;
-            };
-            scrollDistance: {
-                type: NumberConstructor;
-                default: number;
-            };
-            horizontal: {
+            disabled: {
                 type: BooleanConstructor;
                 default: boolean;
             };
-            start: {
-                type: NumberConstructor;
-                default: number;
-            };
-            offset: {
-                type: NumberConstructor;
-                default: number;
-            };
-            listStyle: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
-            };
-            listClass: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
-            };
-            itemStyle: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor | FunctionConstructor)[];
-                default: string;
-            };
-            itemClass: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor | FunctionConstructor)[];
-                default: string;
-            };
-            headerClass: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
-            };
-            headerStyle: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
-            };
-            footerClass: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
-            };
-            footerStyle: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
-            };
-            stickyHeaderClass: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
-            };
-            stickyHeaderStyle: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
-            };
-            stickyFooterClass: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
-            };
-            stickyFooterStyle: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
-            };
-        }>> & Readonly<{}>, import('vue-virt-list').VirtListReturn<any>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
-            fixed: boolean;
-            renderControl: Function;
-            buffer: number;
-            bufferTop: number;
-            bufferBottom: number;
-            horizontal: boolean;
-            start: number;
-            offset: number;
-            listStyle: string | Record<string, any> | unknown[];
-            listClass: string | Record<string, any> | unknown[];
-            itemStyle: string | Function | Record<string, any> | unknown[];
-            itemClass: string | Function | Record<string, any> | unknown[];
-            list: any[];
-            minSize: number;
-            itemGap: number;
-            scrollDistance: number;
-            headerClass: string | Record<string, any> | unknown[];
-            headerStyle: string | Record<string, any> | unknown[];
-            footerClass: string | Record<string, any> | unknown[];
-            footerStyle: string | Record<string, any> | unknown[];
-            stickyHeaderClass: string | Record<string, any> | unknown[];
-            stickyHeaderStyle: string | Record<string, any> | unknown[];
-            stickyFooterClass: string | Record<string, any> | unknown[];
-            stickyFooterStyle: string | Record<string, any> | unknown[];
-        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-            P: {};
-            B: {};
-            D: {};
-            C: {};
-            M: {};
-            Defaults: {};
-        }, Readonly<globalThis.ExtractPropTypes<{
-            list: {
-                type: {
-                    (arrayLength: number): any[];
-                    (...items: any[]): any[];
-                    new (arrayLength: number): any[];
-                    new (...items: any[]): any[];
-                    isArray(arg: any): arg is any[];
-                    readonly prototype: any[];
-                    from<T>(arrayLike: ArrayLike<T>): T[];
-                    from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
-                    from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
-                    from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
-                    of<T_4>(...items: T_4[]): T_4[];
-                    readonly [Symbol.species]: ArrayConstructor;
-                };
-                default: () => never[];
-            };
-            itemKey: {
-                type: (StringConstructor | NumberConstructor)[];
-                required: true;
-            };
-            minSize: {
-                type: NumberConstructor;
-                default: number;
-                required: true;
-            };
-            itemGap: {
-                type: NumberConstructor;
-                default: number;
-            };
-            renderControl: {
-                type: FunctionConstructor;
-                default: undefined;
-            };
-            fixed: {
+            loading: {
                 type: BooleanConstructor;
                 default: boolean;
             };
-            buffer: {
-                type: NumberConstructor;
-                default: number;
-            };
-            bufferTop: {
-                type: NumberConstructor;
-                default: number;
-            };
-            bufferBottom: {
-                type: NumberConstructor;
-                default: number;
-            };
-            scrollDistance: {
-                type: NumberConstructor;
-                default: number;
-            };
-            horizontal: {
+            clearable: {
                 type: BooleanConstructor;
                 default: boolean;
             };
-            start: {
-                type: NumberConstructor;
-                default: number;
-            };
-            offset: {
-                type: NumberConstructor;
-                default: number;
-            };
-            listStyle: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
-            };
-            listClass: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+            placeholder: {
+                type: StringConstructor;
                 default: string;
             };
-            itemStyle: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor | FunctionConstructor)[];
+            width: {
+                type: StringConstructor;
                 default: string;
             };
-            itemClass: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor | FunctionConstructor)[];
-                default: string;
+            formatItems: {
+                type: null;
             };
-            headerClass: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
+            focus: {
+                type: BooleanConstructor;
+                default: boolean;
             };
-            headerStyle: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
+            popoverVisible: {
+                type: BooleanConstructor;
+                default: boolean;
             };
-            footerClass: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
+            multiple: {
+                type: BooleanConstructor;
+                default: boolean;
             };
-            footerStyle: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
+            searchable: {
+                type: BooleanConstructor;
+                default: boolean;
             };
-            stickyHeaderClass: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+            selectedLabel: {
+                type: StringConstructor;
                 default: string;
             };
-            stickyHeaderStyle: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
+            modelValue: {
+                type: globalThis.PropType<any>;
             };
-            stickyFooterClass: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
+            keyword: {
+                type: globalThis.PropType<any>;
             };
-            stickyFooterStyle: {
-                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
-                default: string;
+        }>> & 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;
             };
-        }>> & Readonly<{}>, import('vue-virt-list').VirtListReturn<any>, {}, {}, {}, {
-            fixed: boolean;
+        }, {}, {}, {}, 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('../../../..').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;
+            }, {}, {}, {}, {
+                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;
+        virtListRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
+            list: {
+                type: {
+                    (arrayLength: number): any[];
+                    (...items: any[]): any[];
+                    new (arrayLength: number): any[];
+                    new (...items: any[]): any[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+                    from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+                    from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+                    of<T_4>(...items: T_4[]): T_4[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: () => never[];
+            };
+            itemKey: {
+                type: (StringConstructor | NumberConstructor)[];
+                required: true;
+            };
+            minSize: {
+                type: NumberConstructor;
+                default: number;
+                required: true;
+            };
+            itemGap: {
+                type: NumberConstructor;
+                default: number;
+            };
+            renderControl: {
+                type: FunctionConstructor;
+                default: undefined;
+            };
+            fixed: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            buffer: {
+                type: NumberConstructor;
+                default: number;
+            };
+            bufferTop: {
+                type: NumberConstructor;
+                default: number;
+            };
+            bufferBottom: {
+                type: NumberConstructor;
+                default: number;
+            };
+            scrollDistance: {
+                type: NumberConstructor;
+                default: number;
+            };
+            horizontal: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            start: {
+                type: NumberConstructor;
+                default: number;
+            };
+            offset: {
+                type: NumberConstructor;
+                default: number;
+            };
+            listStyle: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            listClass: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            itemStyle: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor | FunctionConstructor)[];
+                default: string;
+            };
+            itemClass: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor | FunctionConstructor)[];
+                default: string;
+            };
+            headerClass: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            headerStyle: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            footerClass: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            footerStyle: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            stickyHeaderClass: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            stickyHeaderStyle: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            stickyFooterClass: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            stickyFooterStyle: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+        }>> & Readonly<{}>, import('vue-virt-list').VirtListReturn<any>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+            fixed: boolean;
+            renderControl: Function;
+            buffer: number;
+            bufferTop: number;
+            bufferBottom: number;
+            horizontal: boolean;
+            start: number;
+            offset: number;
+            listStyle: string | Record<string, any> | unknown[];
+            listClass: string | Record<string, any> | unknown[];
+            itemStyle: string | Function | Record<string, any> | unknown[];
+            itemClass: string | Function | Record<string, any> | unknown[];
+            list: any[];
+            minSize: number;
+            itemGap: number;
+            scrollDistance: number;
+            headerClass: string | Record<string, any> | unknown[];
+            headerStyle: string | Record<string, any> | unknown[];
+            footerClass: string | Record<string, any> | unknown[];
+            footerStyle: string | Record<string, any> | unknown[];
+            stickyHeaderClass: string | Record<string, any> | unknown[];
+            stickyHeaderStyle: string | Record<string, any> | unknown[];
+            stickyFooterClass: string | Record<string, any> | unknown[];
+            stickyFooterStyle: string | Record<string, any> | unknown[];
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<globalThis.ExtractPropTypes<{
+            list: {
+                type: {
+                    (arrayLength: number): any[];
+                    (...items: any[]): any[];
+                    new (arrayLength: number): any[];
+                    new (...items: any[]): any[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+                    from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+                    from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+                    of<T_4>(...items: T_4[]): T_4[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: () => never[];
+            };
+            itemKey: {
+                type: (StringConstructor | NumberConstructor)[];
+                required: true;
+            };
+            minSize: {
+                type: NumberConstructor;
+                default: number;
+                required: true;
+            };
+            itemGap: {
+                type: NumberConstructor;
+                default: number;
+            };
+            renderControl: {
+                type: FunctionConstructor;
+                default: undefined;
+            };
+            fixed: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            buffer: {
+                type: NumberConstructor;
+                default: number;
+            };
+            bufferTop: {
+                type: NumberConstructor;
+                default: number;
+            };
+            bufferBottom: {
+                type: NumberConstructor;
+                default: number;
+            };
+            scrollDistance: {
+                type: NumberConstructor;
+                default: number;
+            };
+            horizontal: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            start: {
+                type: NumberConstructor;
+                default: number;
+            };
+            offset: {
+                type: NumberConstructor;
+                default: number;
+            };
+            listStyle: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            listClass: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            itemStyle: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor | FunctionConstructor)[];
+                default: string;
+            };
+            itemClass: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor | FunctionConstructor)[];
+                default: string;
+            };
+            headerClass: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            headerStyle: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            footerClass: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            footerStyle: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            stickyHeaderClass: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            stickyHeaderStyle: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            stickyFooterClass: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+            stickyFooterStyle: {
+                type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+                default: string;
+            };
+        }>> & Readonly<{}>, import('vue-virt-list').VirtListReturn<any>, {}, {}, {}, {
+            fixed: boolean;
             renderControl: Function;
             buffer: number;
             bufferTop: number;
@@ -541,7 +1069,7 @@ declare function __VLS_template(): {
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
     defaultValue: {
-        type: StringConstructor;
+        type: PropType<string | (string | number)[]>;
         default: string;
         validator: (value: any) => boolean;
     };
@@ -582,6 +1110,11 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
         typeValues: import('../../../..').LewSize[];
         validator: (value: any) => boolean;
     };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
     itemHeight: {
         type: NumberConstructor;
         default: number;
@@ -651,13 +1184,14 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
     clearSearchCache: () => void;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     blur: () => void;
-    change: (value?: string | undefined) => void;
+    change: (value?: string | number | (string | number)[] | undefined) => void;
     focus: () => void;
     clear: () => void;
+    delete: (value: (string | number)[], item: string | number) => void;
     "update:modelValue": (value: any) => void;
 }, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
     defaultValue: {
-        type: StringConstructor;
+        type: PropType<string | (string | number)[]>;
         default: string;
         validator: (value: any) => boolean;
     };
@@ -698,6 +1232,11 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
         typeValues: import('../../../..').LewSize[];
         validator: (value: any) => boolean;
     };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
     itemHeight: {
         type: NumberConstructor;
         default: number;
@@ -763,9 +1302,10 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
     };
 }>> & Readonly<{
     onBlur?: (() => any) | undefined;
-    onChange?: ((value?: string | undefined) => any) | undefined;
+    onChange?: ((value?: string | number | (string | number)[] | undefined) => any) | undefined;
     onFocus?: (() => any) | undefined;
     onClear?: (() => any) | undefined;
+    onDelete?: ((value: (string | number)[], item: string | number) => any) | undefined;
     "onUpdate:modelValue"?: ((value: any) => any) | undefined;
 }>, {
     size: import('../../../..').LewSize;
@@ -775,8 +1315,9 @@ declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractP
     trigger: import('../../../..').LewTrigger;
     clearable: boolean;
     autoWidth: boolean;
-    defaultValue: string;
+    defaultValue: string | (string | number)[];
     popoverWidth: import("csstype").Property.Width<0 | (string & {})>;
+    multiple: boolean;
     itemHeight: number;
     searchable: boolean;
     searchMethod: (params: import('../../../..').LewSelectSearchMethodParams) => LewSelectOption[];
@@ -792,63 +1333,529 @@ 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;
-            triggerTarget: Element;
-        }> & 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 triggerTarget: Element;
-            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" | "triggerTarget">;
-        $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;
+            triggerTarget: Element;
+        }> & 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 triggerTarget: Element;
+            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" | "triggerTarget">;
+        $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;
+            };
+            triggerTarget: {
+                type: PropType<Element>;
+                default: null;
+                validator: (value: unknown) => 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;
+            triggerTarget: Element;
+        }, {}, 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;
+        triggerTarget: Element;
+    }> & 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;
+        };
+        triggerTarget: {
+            type: PropType<Element>;
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+    }>> & Readonly<{
+        onShow?: (() => any) | undefined;
+        onHide?: (() => any) | undefined;
+    }>, "show" | "hide" | "refresh" | ("loading" | "disabled" | "offset" | "placement" | "delay" | "trigger" | "triggerWidth" | "hideOnClick" | "clickOutsideToHide" | "popoverBodyClassName" | "triggerTarget")> & import('vue').ShallowUnwrapRef<{
+        show: () => void;
+        hide: () => void;
+        refresh: () => void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            trigger?(_: {}): any;
+            'popover-body'?(_: {
+                show: () => void;
+                hide: () => void;
+            }): any;
+        };
+    }) | null;
+    lewSelectInputRef: 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: {
@@ -856,171 +1863,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;
             };
-            triggerTarget: {
-                type: PropType<Element>;
-                default: null;
-                validator: (value: unknown) => 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;
-            triggerTarget: Element;
-        }, {}, 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;
-        triggerTarget: Element;
-    }> & 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;
         };
-        triggerTarget: {
-            type: PropType<Element>;
-            default: null;
-            validator: (value: unknown) => boolean;
+        modelValue: {
+            type: globalThis.PropType<any>;
         };
-    }>> & Readonly<{
-        onShow?: (() => any) | undefined;
-        onHide?: (() => any) | undefined;
-    }>, "show" | "hide" | "refresh" | ("loading" | "disabled" | "offset" | "placement" | "delay" | "trigger" | "triggerWidth" | "hideOnClick" | "clickOutsideToHide" | "popoverBodyClassName" | "triggerTarget")> & import('vue').ShallowUnwrapRef<{
-        show: () => void;
-        hide: () => void;
-        refresh: () => void;
-    }> & {} & import('vue').ComponentCustomProperties & {} & {
-        $slots: {
-            trigger?(_: {}): any;
-            'popover-body'?(_: {
-                show: () => void;
-                hide: () => void;
-            }): any;
+        keyword: {
+            type: globalThis.PropType<any>;
         };
-    }) | null;
-    lewSelectRef: HTMLDivElement;
-    inputRef: HTMLInputElement;
+    }>> & 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;
     virtListRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
         list: {
             type: {