ra-element 0.1.6 → 0.1.7

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 (24) hide show
  1. package/docs/ra-table.md +1 -0
  2. package/lib/components/index.d.ts +1 -20
  3. package/lib/components/ra-auto-scroll/index.vue.d.ts +76 -100
  4. package/lib/components/ra-button/index.vue.d.ts +599 -772
  5. package/lib/components/ra-checkbox-group/index.vue.d.ts +329 -442
  6. package/lib/components/ra-date-picker/index.vue.d.ts +1062 -1261
  7. package/lib/components/ra-dialog/index.vue.d.ts +931 -1130
  8. package/lib/components/ra-dialog-select/index.vue.d.ts +57 -81
  9. package/lib/components/ra-help-tip/index.vue.d.ts +41 -65
  10. package/lib/components/ra-input/index.vue.d.ts +1042 -1256
  11. package/lib/components/ra-pagination/index.vue.d.ts +528 -643
  12. package/lib/components/ra-radio-group/index.vue.d.ts +425 -538
  13. package/lib/components/ra-select/index.vue.d.ts +1656 -1759
  14. package/lib/components/ra-svg/index.vue.d.ts +11 -35
  15. package/lib/components/ra-table/component/pagination-group.vue.d.ts +80 -104
  16. package/lib/components/ra-textarea/index.vue.d.ts +31 -55
  17. package/lib/components/ra-tool-tip/index.vue.d.ts +14 -38
  18. package/lib/components/ra-tree-select/index.vue.d.ts +35 -59
  19. package/lib/components/ra-upload/index.vue.d.ts +149 -173
  20. package/lib/index.d.ts +6 -6
  21. package/lib/ra-element.css +1 -1
  22. package/lib/ra-element.es.js +980 -958
  23. package/lib/ra-element.umd.js +11 -11
  24. package/package.json +1 -1
package/lib/components/ra-select/index.vue.d.ts CHANGED
@@ -15,1782 +15,1679 @@ declare function __VLS_template(): {
15
15
  rootEl: any;
16
16
  };
17
17
  type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
18
- declare const __VLS_component: import('vue').DefineComponent<
19
- import('vue').ExtractPropTypes<{
18
+ declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
19
+ modelValue: {
20
+ type: (NumberConstructor | StringConstructor | ArrayConstructor)[];
21
+ default: string;
22
+ };
23
+ options: {
24
+ type: PropType<SelectOptions[]>;
25
+ default: () => never[];
26
+ };
27
+ collapseTags: {
28
+ type: BooleanConstructor;
29
+ default: boolean;
30
+ };
31
+ clearable: {
32
+ type: BooleanConstructor;
33
+ default: boolean;
34
+ };
35
+ multiple: {
36
+ type: BooleanConstructor;
37
+ default: boolean;
38
+ };
39
+ cssStyle: {
40
+ type: StringConstructor;
41
+ default: string;
42
+ };
43
+ }>, {
44
+ component: import('vue').Ref<import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
45
+ ariaLabel: StringConstructor;
46
+ emptyValues: ArrayConstructor;
47
+ valueOnClear: {
48
+ readonly type: PropType<string | number | boolean | Function>;
49
+ readonly required: false;
50
+ readonly validator: ((val: unknown) => boolean) | undefined;
51
+ __epPropKey: true;
52
+ } & {
53
+ readonly default: undefined;
54
+ };
55
+ name: StringConstructor;
56
+ id: StringConstructor;
20
57
  modelValue: {
21
- type: (NumberConstructor | StringConstructor | ArrayConstructor)[];
22
- default: string;
58
+ readonly type: PropType<(string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[]>;
59
+ readonly required: false;
60
+ readonly validator: ((val: unknown) => boolean) | undefined;
61
+ __epPropKey: true;
62
+ } & {
63
+ readonly default: undefined;
64
+ };
65
+ autocomplete: {
66
+ readonly type: PropType<string>;
67
+ readonly required: false;
68
+ readonly validator: ((val: unknown) => boolean) | undefined;
69
+ __epPropKey: true;
70
+ } & {
71
+ readonly default: string;
72
+ };
73
+ automaticDropdown: BooleanConstructor;
74
+ size: {
75
+ readonly type: PropType<"" | "default" | "small" | "large">;
76
+ readonly required: false;
77
+ readonly validator: ((val: unknown) => boolean) | undefined;
78
+ __epPropKey: true;
79
+ };
80
+ effect: {
81
+ readonly type: PropType<import('element-plus').PopperEffect>;
82
+ readonly required: false;
83
+ readonly validator: ((val: unknown) => boolean) | undefined;
84
+ __epPropKey: true;
85
+ } & {
86
+ readonly default: string;
87
+ };
88
+ disabled: BooleanConstructor;
89
+ clearable: BooleanConstructor;
90
+ filterable: BooleanConstructor;
91
+ allowCreate: BooleanConstructor;
92
+ loading: BooleanConstructor;
93
+ popperClass: {
94
+ readonly type: PropType<string>;
95
+ readonly required: false;
96
+ readonly validator: ((val: unknown) => boolean) | undefined;
97
+ __epPropKey: true;
98
+ } & {
99
+ readonly default: string;
100
+ };
101
+ popperOptions: {
102
+ readonly type: PropType<any>;
103
+ readonly required: false;
104
+ readonly validator: ((val: unknown) => boolean) | undefined;
105
+ __epPropKey: true;
106
+ } & {
107
+ readonly default: () => Partial<Options>;
108
+ };
109
+ remote: BooleanConstructor;
110
+ loadingText: StringConstructor;
111
+ noMatchText: StringConstructor;
112
+ noDataText: StringConstructor;
113
+ remoteMethod: FunctionConstructor;
114
+ filterMethod: FunctionConstructor;
115
+ multiple: BooleanConstructor;
116
+ multipleLimit: {
117
+ readonly type: PropType<number>;
118
+ readonly required: false;
119
+ readonly validator: ((val: unknown) => boolean) | undefined;
120
+ __epPropKey: true;
121
+ } & {
122
+ readonly default: number;
123
+ };
124
+ placeholder: {
125
+ readonly type: PropType<string>;
126
+ readonly required: false;
127
+ readonly validator: ((val: unknown) => boolean) | undefined;
128
+ __epPropKey: true;
129
+ };
130
+ defaultFirstOption: BooleanConstructor;
131
+ reserveKeyword: {
132
+ readonly type: PropType<boolean>;
133
+ readonly required: false;
134
+ readonly validator: ((val: unknown) => boolean) | undefined;
135
+ __epPropKey: true;
136
+ } & {
137
+ readonly default: boolean;
138
+ };
139
+ valueKey: {
140
+ readonly type: PropType<string>;
141
+ readonly required: false;
142
+ readonly validator: ((val: unknown) => boolean) | undefined;
143
+ __epPropKey: true;
144
+ } & {
145
+ readonly default: string;
146
+ };
147
+ collapseTags: BooleanConstructor;
148
+ collapseTagsTooltip: BooleanConstructor;
149
+ maxCollapseTags: {
150
+ readonly type: PropType<number>;
151
+ readonly required: false;
152
+ readonly validator: ((val: unknown) => boolean) | undefined;
153
+ __epPropKey: true;
154
+ } & {
155
+ readonly default: number;
23
156
  };
24
- options: {
25
- type: PropType<SelectOptions[]>;
26
- default: () => never[];
157
+ teleported: {
158
+ readonly type: PropType<boolean>;
159
+ readonly required: false;
160
+ readonly validator: ((val: unknown) => boolean) | undefined;
161
+ __epPropKey: true;
162
+ } & {
163
+ readonly default: true;
27
164
  };
28
- collapseTags: {
29
- type: BooleanConstructor;
30
- default: boolean;
165
+ persistent: {
166
+ readonly type: PropType<boolean>;
167
+ readonly required: false;
168
+ readonly validator: ((val: unknown) => boolean) | undefined;
169
+ __epPropKey: true;
170
+ } & {
171
+ readonly default: boolean;
31
172
  };
32
- clearable: {
33
- type: BooleanConstructor;
34
- default: boolean;
173
+ clearIcon: {
174
+ readonly type: PropType<string | import('vue').Component>;
175
+ readonly required: false;
176
+ readonly validator: ((val: unknown) => boolean) | undefined;
177
+ __epPropKey: true;
35
178
  };
36
- multiple: {
37
- type: BooleanConstructor;
38
- default: boolean;
179
+ fitInputWidth: BooleanConstructor;
180
+ suffixIcon: {
181
+ readonly type: PropType<string | import('vue').Component>;
182
+ readonly required: false;
183
+ readonly validator: ((val: unknown) => boolean) | undefined;
184
+ __epPropKey: true;
39
185
  };
40
- cssStyle: {
41
- type: StringConstructor;
186
+ tagType: {
42
187
  default: string;
188
+ type: PropType<"primary" | "success" | "warning" | "info" | "danger">;
189
+ required: false;
190
+ validator: ((val: unknown) => boolean) | undefined;
191
+ __epPropKey: true;
43
192
  };
44
- }>,
45
- {
46
- component: import('vue').Ref<
47
- | import('vue').CreateComponentPublicInstanceWithMixins<
48
- Readonly<
49
- import('vue').ExtractPropTypes<{
50
- ariaLabel: StringConstructor;
51
- emptyValues: ArrayConstructor;
52
- valueOnClear: {
53
- readonly type: PropType<string | number | boolean | Function>;
54
- readonly required: false;
55
- readonly validator: ((val: unknown) => boolean) | undefined;
56
- __epPropKey: true;
57
- } & {
58
- readonly default: undefined;
59
- };
60
- name: StringConstructor;
61
- id: StringConstructor;
62
- modelValue: {
63
- readonly type: PropType<(string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[]>;
64
- readonly required: false;
65
- readonly validator: ((val: unknown) => boolean) | undefined;
66
- __epPropKey: true;
67
- } & {
68
- readonly default: undefined;
69
- };
70
- autocomplete: {
71
- readonly type: PropType<string>;
72
- readonly required: false;
73
- readonly validator: ((val: unknown) => boolean) | undefined;
74
- __epPropKey: true;
75
- } & {
76
- readonly default: string;
77
- };
78
- automaticDropdown: BooleanConstructor;
79
- size: {
80
- readonly type: PropType<'' | 'default' | 'small' | 'large'>;
81
- readonly required: false;
82
- readonly validator: ((val: unknown) => boolean) | undefined;
83
- __epPropKey: true;
84
- };
85
- effect: {
86
- readonly type: PropType<import('element-plus').PopperEffect>;
87
- readonly required: false;
88
- readonly validator: ((val: unknown) => boolean) | undefined;
89
- __epPropKey: true;
90
- } & {
91
- readonly default: string;
92
- };
93
- disabled: BooleanConstructor;
94
- clearable: BooleanConstructor;
95
- filterable: BooleanConstructor;
96
- allowCreate: BooleanConstructor;
97
- loading: BooleanConstructor;
98
- popperClass: {
99
- readonly type: PropType<string>;
100
- readonly required: false;
101
- readonly validator: ((val: unknown) => boolean) | undefined;
102
- __epPropKey: true;
103
- } & {
104
- readonly default: string;
105
- };
106
- popperOptions: {
107
- readonly type: PropType<any>;
108
- readonly required: false;
109
- readonly validator: ((val: unknown) => boolean) | undefined;
110
- __epPropKey: true;
111
- } & {
112
- readonly default: () => Partial<Options>;
113
- };
114
- remote: BooleanConstructor;
115
- loadingText: StringConstructor;
116
- noMatchText: StringConstructor;
117
- noDataText: StringConstructor;
118
- remoteMethod: FunctionConstructor;
119
- filterMethod: FunctionConstructor;
120
- multiple: BooleanConstructor;
121
- multipleLimit: {
122
- readonly type: PropType<number>;
123
- readonly required: false;
124
- readonly validator: ((val: unknown) => boolean) | undefined;
125
- __epPropKey: true;
126
- } & {
127
- readonly default: number;
128
- };
129
- placeholder: {
130
- readonly type: PropType<string>;
131
- readonly required: false;
132
- readonly validator: ((val: unknown) => boolean) | undefined;
133
- __epPropKey: true;
134
- };
135
- defaultFirstOption: BooleanConstructor;
136
- reserveKeyword: {
137
- readonly type: PropType<boolean>;
138
- readonly required: false;
139
- readonly validator: ((val: unknown) => boolean) | undefined;
140
- __epPropKey: true;
141
- } & {
142
- readonly default: boolean;
143
- };
144
- valueKey: {
145
- readonly type: PropType<string>;
146
- readonly required: false;
147
- readonly validator: ((val: unknown) => boolean) | undefined;
148
- __epPropKey: true;
149
- } & {
150
- readonly default: string;
151
- };
152
- collapseTags: BooleanConstructor;
153
- collapseTagsTooltip: BooleanConstructor;
154
- maxCollapseTags: {
155
- readonly type: PropType<number>;
156
- readonly required: false;
157
- readonly validator: ((val: unknown) => boolean) | undefined;
158
- __epPropKey: true;
159
- } & {
160
- readonly default: number;
161
- };
162
- teleported: {
163
- readonly type: PropType<boolean>;
164
- readonly required: false;
165
- readonly validator: ((val: unknown) => boolean) | undefined;
166
- __epPropKey: true;
167
- } & {
168
- readonly default: true;
169
- };
170
- persistent: {
171
- readonly type: PropType<boolean>;
172
- readonly required: false;
173
- readonly validator: ((val: unknown) => boolean) | undefined;
174
- __epPropKey: true;
175
- } & {
176
- readonly default: boolean;
177
- };
178
- clearIcon: {
179
- readonly type: PropType<string | import('vue').Component>;
180
- readonly required: false;
181
- readonly validator: ((val: unknown) => boolean) | undefined;
182
- __epPropKey: true;
183
- };
184
- fitInputWidth: BooleanConstructor;
185
- suffixIcon: {
186
- readonly type: PropType<string | import('vue').Component>;
187
- readonly required: false;
188
- readonly validator: ((val: unknown) => boolean) | undefined;
189
- __epPropKey: true;
190
- };
191
- tagType: {
192
- default: string;
193
- type: PropType<'primary' | 'success' | 'warning' | 'info' | 'danger'>;
194
- required: false;
195
- validator: ((val: unknown) => boolean) | undefined;
196
- __epPropKey: true;
197
- };
198
- tagEffect: {
199
- default: string;
200
- type: PropType<'plain' | 'dark' | 'light'>;
201
- required: false;
202
- validator: ((val: unknown) => boolean) | undefined;
203
- __epPropKey: true;
204
- };
205
- validateEvent: {
206
- readonly type: PropType<boolean>;
207
- readonly required: false;
208
- readonly validator: ((val: unknown) => boolean) | undefined;
209
- __epPropKey: true;
210
- } & {
211
- readonly default: boolean;
212
- };
213
- remoteShowSuffix: BooleanConstructor;
214
- showArrow: {
215
- readonly type: PropType<boolean>;
216
- readonly required: false;
217
- readonly validator: ((val: unknown) => boolean) | undefined;
218
- __epPropKey: true;
219
- } & {
220
- readonly default: boolean;
221
- };
222
- offset: {
223
- readonly type: PropType<number>;
224
- readonly required: false;
225
- readonly validator: ((val: unknown) => boolean) | undefined;
226
- __epPropKey: true;
227
- } & {
228
- readonly default: number;
229
- };
230
- placement: {
231
- readonly type: PropType<any>;
232
- readonly required: false;
233
- readonly validator: ((val: unknown) => boolean) | undefined;
234
- __epPropKey: true;
235
- } & {
236
- readonly default: string;
237
- };
238
- fallbackPlacements: {
239
- readonly type: PropType<Placement[]>;
240
- readonly required: false;
241
- readonly validator: ((val: unknown) => boolean) | undefined;
242
- __epPropKey: true;
243
- } & {
244
- readonly default: string[];
245
- };
246
- tabindex: {
247
- readonly type: PropType<string | number>;
248
- readonly required: false;
249
- readonly validator: ((val: unknown) => boolean) | undefined;
250
- __epPropKey: true;
251
- } & {
252
- readonly default: number;
253
- };
254
- appendTo: {
255
- readonly type: PropType<string | HTMLElement>;
256
- readonly required: false;
257
- readonly validator: ((val: unknown) => boolean) | undefined;
258
- __epPropKey: true;
259
- };
260
- }>
261
- > & {
262
- 'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
263
- onChange?: ((...args: any[]) => any) | undefined;
264
- onFocus?: ((...args: any[]) => any) | undefined;
265
- onBlur?: ((...args: any[]) => any) | undefined;
266
- onClear?: ((...args: any[]) => any) | undefined;
267
- 'onVisible-change'?: ((...args: any[]) => any) | undefined;
268
- 'onRemove-tag'?: ((...args: any[]) => any) | undefined;
269
- 'onPopup-scroll'?: ((...args: any[]) => any) | undefined;
270
- },
271
- {
272
- modelValue: import('vue').ComputedRef<string | number | boolean | any[] | Record<string, any> | undefined>;
273
- selectedLabel: import('vue').ComputedRef<string | string[]>;
274
- calculatorRef: import('vue').ShallowRef<HTMLElement | undefined>;
275
- inputStyle: import('vue').ComputedRef<{
276
- minWidth: string;
277
- }>;
278
- inputId: import('vue').Ref<string | undefined>;
279
- contentId: import('vue').Ref<string>;
280
- nsSelect: {
281
- namespace: import('vue').ComputedRef<string>;
282
- b: (blockSuffix?: string) => string;
283
- e: (element?: string) => string;
284
- m: (modifier?: string) => string;
285
- be: (blockSuffix?: string, element?: string) => string;
286
- em: (element?: string, modifier?: string) => string;
287
- bm: (blockSuffix?: string, modifier?: string) => string;
288
- bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
289
- is: {
290
- (name: string, state: boolean | undefined): string;
291
- (name: string): string;
292
- };
293
- cssVar: (object: Record<string, string>) => Record<string, string>;
294
- cssVarName: (name: string) => string;
295
- cssVarBlock: (object: Record<string, string>) => Record<string, string>;
296
- cssVarBlockName: (name: string) => string;
297
- };
298
- nsInput: {
299
- namespace: import('vue').ComputedRef<string>;
300
- b: (blockSuffix?: string) => string;
301
- e: (element?: string) => string;
302
- m: (modifier?: string) => string;
303
- be: (blockSuffix?: string, element?: string) => string;
304
- em: (element?: string, modifier?: string) => string;
305
- bm: (blockSuffix?: string, modifier?: string) => string;
306
- bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
307
- is: {
308
- (name: string, state: boolean | undefined): string;
309
- (name: string): string;
310
- };
311
- cssVar: (object: Record<string, string>) => Record<string, string>;
312
- cssVarName: (name: string) => string;
313
- cssVarBlock: (object: Record<string, string>) => Record<string, string>;
314
- cssVarBlockName: (name: string) => string;
315
- };
316
- states: {
317
- inputValue: string;
318
- options: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
319
- cachedOptions: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
320
- optionValues: (string | number | boolean | Record<string, any>)[];
321
- selected: {
322
- value: string | number | boolean | Record<string, any>;
323
- currentLabel: import('element-plus').SelectOptionProxy['currentLabel'];
324
- isDisabled?: import('element-plus').SelectOptionProxy['isDisabled'] | undefined;
325
- }[];
326
- hoveringIndex: number;
327
- inputHovering: boolean;
328
- selectionWidth: number;
329
- collapseItemWidth: number;
330
- previousQuery: string | null;
331
- selectedLabel: string;
332
- menuVisibleOnFocus: boolean;
333
- isBeforeHide: boolean;
334
- };
335
- isFocused: import('vue').Ref<boolean>;
336
- expanded: import('vue').Ref<boolean>;
337
- optionsArray: import('vue').ComputedRef<import('element-plus').SelectOptionProxy[]>;
338
- hoverOption: import('vue').Ref<any>;
339
- selectSize: import('vue').ComputedRef<'' | 'small' | 'default' | 'large'>;
340
- filteredOptionsCount: import('vue').ComputedRef<number>;
341
- updateTooltip: () => void;
342
- updateTagTooltip: () => void;
343
- debouncedOnInputChange: import('lodash-es').DebouncedFunc<() => void>;
344
- onInput: (event: Event) => void;
345
- deletePrevTag: (e: KeyboardEvent) => void;
346
- deleteTag: (event: MouseEvent, tag: import('element-plus').SelectOptionProxy | import('element-plus').OptionBasic) => void;
347
- deleteSelected: (event: Event) => void;
348
- handleOptionSelect: (option: import('element-plus').SelectOptionProxy) => void;
349
- scrollToOption: (
350
- option: import('element-plus').SelectOptionProxy | import('element-plus').SelectOptionProxy[] | import('element-plus').OptionBasic[],
351
- ) => void;
352
- hasModelValue: import('vue').ComputedRef<boolean>;
353
- shouldShowPlaceholder: import('vue').ComputedRef<boolean>;
354
- currentPlaceholder: import('vue').ComputedRef<string>;
355
- mouseEnterEventName: import('vue').ComputedRef<'mouseenter' | null>;
356
- needStatusIcon: import('vue').ComputedRef<boolean>;
357
- showClose: import('vue').ComputedRef<boolean>;
358
- iconComponent: import('vue').ComputedRef<(string | import('vue').Component) | undefined>;
359
- iconReverse: import('vue').ComputedRef<string>;
360
- validateState: import('vue').ComputedRef<'' | 'error' | 'success' | 'validating'>;
361
- validateIcon: import('vue').ComputedRef<'' | import('vue').Component>;
362
- showNewOption: import('vue').ComputedRef<boolean>;
363
- updateOptions: () => void;
364
- collapseTagSize: import('vue').ComputedRef<'default' | 'small'>;
365
- setSelected: () => void;
366
- selectDisabled: import('vue').ComputedRef<boolean>;
367
- emptyText: import('vue').ComputedRef<string | null>;
368
- handleCompositionStart: (event: CompositionEvent) => void;
369
- handleCompositionUpdate: (event: CompositionEvent) => void;
370
- handleCompositionEnd: (event: CompositionEvent) => void;
371
- onOptionCreate: (vm: import('element-plus').SelectOptionProxy) => void;
372
- onOptionDestroy: (key: string | number | boolean | Record<string, any>, vm: import('element-plus').SelectOptionProxy) => void;
373
- handleMenuEnter: () => void;
374
- focus: () => void;
375
- blur: () => void;
376
- handleClearClick: (event: Event) => void;
377
- handleClickOutside: (event: Event) => void;
378
- handleEsc: () => void;
379
- toggleMenu: () => void;
380
- selectOption: () => void;
381
- getValueKey: (item: import('element-plus').SelectOptionProxy | import('element-plus').OptionBasic) => any;
382
- navigateOptions: (direction: 'prev' | 'next') => void;
383
- dropdownMenuVisible: import('vue').WritableComputedRef<boolean>;
384
- showTagList: import('vue').ComputedRef<
385
- {
386
- value: string | number | boolean | Record<string, any>;
387
- currentLabel: import('element-plus').SelectOptionProxy['currentLabel'];
388
- isDisabled?: import('element-plus').SelectOptionProxy['isDisabled'] | undefined;
389
- }[]
390
- >;
391
- collapseTagList: import('vue').ComputedRef<
392
- {
393
- value: string | number | boolean | Record<string, any>;
394
- currentLabel: import('element-plus').SelectOptionProxy['currentLabel'];
395
- isDisabled?: import('element-plus').SelectOptionProxy['isDisabled'] | undefined;
396
- }[]
397
- >;
398
- popupScroll: (data: { scrollTop: number; scrollLeft: number }) => void;
399
- tagStyle: import('vue').ComputedRef<{
400
- maxWidth: string;
401
- }>;
402
- collapseTagStyle: import('vue').ComputedRef<{
403
- maxWidth: string;
404
- }>;
405
- popperRef: import('vue').ComputedRef<HTMLElement | undefined>;
406
- inputRef: import('vue').Ref<HTMLInputElement | undefined>;
407
- tooltipRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
408
- tagTooltipRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
409
- prefixRef: import('vue').Ref<HTMLElement | undefined>;
410
- suffixRef: import('vue').Ref<HTMLElement | undefined>;
411
- selectRef: import('vue').Ref<HTMLElement | undefined>;
412
- wrapperRef: import('vue').ShallowRef<HTMLElement | undefined>;
413
- selectionRef: import('vue').Ref<HTMLElement | undefined>;
414
- scrollbarRef: import('vue').Ref<import('element-plus').ScrollbarInstance | undefined>;
415
- menuRef: import('vue').Ref<HTMLElement | undefined>;
416
- tagMenuRef: import('vue').Ref<HTMLElement | undefined>;
417
- collapseItemRef: import('vue').Ref<HTMLElement | undefined>;
418
- },
419
- unknown,
420
- {},
421
- {},
422
- import('vue').ComponentOptionsMixin,
423
- import('vue').ComponentOptionsMixin,
424
- ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'visible-change' | 'remove-tag' | 'popup-scroll')[],
425
- import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps,
426
- {
427
- disabled: boolean;
428
- offset: number;
429
- multiple: boolean;
430
- loading: boolean;
431
- modelValue: (string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[];
432
- placement: any;
433
- effect: import('element-plus').PopperEffect;
434
- tabindex: string | number;
435
- valueOnClear: string | number | boolean | Function;
436
- autocomplete: string;
437
- validateEvent: boolean;
438
- clearable: boolean;
439
- fallbackPlacements: Placement[];
440
- popperOptions: Partial<Options>;
441
- popperClass: string;
442
- teleported: boolean;
443
- persistent: boolean;
444
- showArrow: boolean;
445
- valueKey: string;
446
- fitInputWidth: boolean;
447
- filterable: boolean;
448
- collapseTags: boolean;
449
- maxCollapseTags: number;
450
- collapseTagsTooltip: boolean;
451
- tagType: 'primary' | 'success' | 'warning' | 'info' | 'danger';
452
- tagEffect: 'plain' | 'dark' | 'light';
453
- automaticDropdown: boolean;
454
- allowCreate: boolean;
455
- remote: boolean;
456
- multipleLimit: number;
457
- defaultFirstOption: boolean;
458
- reserveKeyword: boolean;
459
- remoteShowSuffix: boolean;
460
- },
461
- true,
462
- {},
463
- {},
464
- import('vue').GlobalComponents,
465
- import('vue').GlobalDirectives,
466
- string,
467
- {},
468
- any,
469
- import('vue').ComponentProvideOptions,
470
- {
471
- P: {};
472
- B: {};
473
- D: {};
474
- C: {};
475
- M: {};
476
- Defaults: {};
477
- },
478
- Readonly<
479
- import('vue').ExtractPropTypes<{
480
- ariaLabel: StringConstructor;
481
- emptyValues: ArrayConstructor;
482
- valueOnClear: {
483
- readonly type: PropType<string | number | boolean | Function>;
484
- readonly required: false;
485
- readonly validator: ((val: unknown) => boolean) | undefined;
486
- __epPropKey: true;
487
- } & {
488
- readonly default: undefined;
489
- };
490
- name: StringConstructor;
491
- id: StringConstructor;
492
- modelValue: {
493
- readonly type: PropType<(string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[]>;
494
- readonly required: false;
495
- readonly validator: ((val: unknown) => boolean) | undefined;
496
- __epPropKey: true;
497
- } & {
498
- readonly default: undefined;
499
- };
500
- autocomplete: {
501
- readonly type: PropType<string>;
502
- readonly required: false;
503
- readonly validator: ((val: unknown) => boolean) | undefined;
504
- __epPropKey: true;
505
- } & {
506
- readonly default: string;
507
- };
508
- automaticDropdown: BooleanConstructor;
509
- size: {
510
- readonly type: PropType<'' | 'default' | 'small' | 'large'>;
511
- readonly required: false;
512
- readonly validator: ((val: unknown) => boolean) | undefined;
513
- __epPropKey: true;
514
- };
515
- effect: {
516
- readonly type: PropType<import('element-plus').PopperEffect>;
517
- readonly required: false;
518
- readonly validator: ((val: unknown) => boolean) | undefined;
519
- __epPropKey: true;
520
- } & {
521
- readonly default: string;
522
- };
523
- disabled: BooleanConstructor;
524
- clearable: BooleanConstructor;
525
- filterable: BooleanConstructor;
526
- allowCreate: BooleanConstructor;
527
- loading: BooleanConstructor;
528
- popperClass: {
529
- readonly type: PropType<string>;
530
- readonly required: false;
531
- readonly validator: ((val: unknown) => boolean) | undefined;
532
- __epPropKey: true;
533
- } & {
534
- readonly default: string;
535
- };
536
- popperOptions: {
537
- readonly type: PropType<any>;
538
- readonly required: false;
539
- readonly validator: ((val: unknown) => boolean) | undefined;
540
- __epPropKey: true;
541
- } & {
542
- readonly default: () => Partial<Options>;
543
- };
544
- remote: BooleanConstructor;
545
- loadingText: StringConstructor;
546
- noMatchText: StringConstructor;
547
- noDataText: StringConstructor;
548
- remoteMethod: FunctionConstructor;
549
- filterMethod: FunctionConstructor;
550
- multiple: BooleanConstructor;
551
- multipleLimit: {
552
- readonly type: PropType<number>;
553
- readonly required: false;
554
- readonly validator: ((val: unknown) => boolean) | undefined;
555
- __epPropKey: true;
556
- } & {
557
- readonly default: number;
558
- };
559
- placeholder: {
560
- readonly type: PropType<string>;
561
- readonly required: false;
562
- readonly validator: ((val: unknown) => boolean) | undefined;
563
- __epPropKey: true;
564
- };
565
- defaultFirstOption: BooleanConstructor;
566
- reserveKeyword: {
567
- readonly type: PropType<boolean>;
568
- readonly required: false;
569
- readonly validator: ((val: unknown) => boolean) | undefined;
570
- __epPropKey: true;
571
- } & {
572
- readonly default: boolean;
573
- };
574
- valueKey: {
575
- readonly type: PropType<string>;
576
- readonly required: false;
577
- readonly validator: ((val: unknown) => boolean) | undefined;
578
- __epPropKey: true;
579
- } & {
580
- readonly default: string;
581
- };
582
- collapseTags: BooleanConstructor;
583
- collapseTagsTooltip: BooleanConstructor;
584
- maxCollapseTags: {
585
- readonly type: PropType<number>;
586
- readonly required: false;
587
- readonly validator: ((val: unknown) => boolean) | undefined;
588
- __epPropKey: true;
589
- } & {
590
- readonly default: number;
591
- };
592
- teleported: {
593
- readonly type: PropType<boolean>;
594
- readonly required: false;
595
- readonly validator: ((val: unknown) => boolean) | undefined;
596
- __epPropKey: true;
597
- } & {
598
- readonly default: true;
599
- };
600
- persistent: {
601
- readonly type: PropType<boolean>;
602
- readonly required: false;
603
- readonly validator: ((val: unknown) => boolean) | undefined;
604
- __epPropKey: true;
605
- } & {
606
- readonly default: boolean;
607
- };
608
- clearIcon: {
609
- readonly type: PropType<string | import('vue').Component>;
610
- readonly required: false;
611
- readonly validator: ((val: unknown) => boolean) | undefined;
612
- __epPropKey: true;
613
- };
614
- fitInputWidth: BooleanConstructor;
615
- suffixIcon: {
616
- readonly type: PropType<string | import('vue').Component>;
617
- readonly required: false;
618
- readonly validator: ((val: unknown) => boolean) | undefined;
619
- __epPropKey: true;
620
- };
621
- tagType: {
622
- default: string;
623
- type: PropType<'primary' | 'success' | 'warning' | 'info' | 'danger'>;
624
- required: false;
625
- validator: ((val: unknown) => boolean) | undefined;
626
- __epPropKey: true;
627
- };
628
- tagEffect: {
629
- default: string;
630
- type: PropType<'plain' | 'dark' | 'light'>;
631
- required: false;
632
- validator: ((val: unknown) => boolean) | undefined;
633
- __epPropKey: true;
634
- };
635
- validateEvent: {
636
- readonly type: PropType<boolean>;
637
- readonly required: false;
638
- readonly validator: ((val: unknown) => boolean) | undefined;
639
- __epPropKey: true;
640
- } & {
641
- readonly default: boolean;
642
- };
643
- remoteShowSuffix: BooleanConstructor;
644
- showArrow: {
645
- readonly type: PropType<boolean>;
646
- readonly required: false;
647
- readonly validator: ((val: unknown) => boolean) | undefined;
648
- __epPropKey: true;
649
- } & {
650
- readonly default: boolean;
651
- };
652
- offset: {
653
- readonly type: PropType<number>;
654
- readonly required: false;
655
- readonly validator: ((val: unknown) => boolean) | undefined;
656
- __epPropKey: true;
657
- } & {
658
- readonly default: number;
659
- };
660
- placement: {
661
- readonly type: PropType<any>;
662
- readonly required: false;
663
- readonly validator: ((val: unknown) => boolean) | undefined;
664
- __epPropKey: true;
665
- } & {
666
- readonly default: string;
667
- };
668
- fallbackPlacements: {
669
- readonly type: PropType<Placement[]>;
670
- readonly required: false;
671
- readonly validator: ((val: unknown) => boolean) | undefined;
672
- __epPropKey: true;
673
- } & {
674
- readonly default: string[];
675
- };
676
- tabindex: {
677
- readonly type: PropType<string | number>;
678
- readonly required: false;
679
- readonly validator: ((val: unknown) => boolean) | undefined;
680
- __epPropKey: true;
681
- } & {
682
- readonly default: number;
683
- };
684
- appendTo: {
685
- readonly type: PropType<string | HTMLElement>;
686
- readonly required: false;
687
- readonly validator: ((val: unknown) => boolean) | undefined;
688
- __epPropKey: true;
689
- };
690
- }>
691
- > & {
692
- 'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
693
- onChange?: ((...args: any[]) => any) | undefined;
694
- onFocus?: ((...args: any[]) => any) | undefined;
695
- onBlur?: ((...args: any[]) => any) | undefined;
696
- onClear?: ((...args: any[]) => any) | undefined;
697
- 'onVisible-change'?: ((...args: any[]) => any) | undefined;
698
- 'onRemove-tag'?: ((...args: any[]) => any) | undefined;
699
- 'onPopup-scroll'?: ((...args: any[]) => any) | undefined;
700
- },
701
- {
702
- modelValue: import('vue').ComputedRef<string | number | boolean | any[] | Record<string, any> | undefined>;
703
- selectedLabel: import('vue').ComputedRef<string | string[]>;
704
- calculatorRef: import('vue').ShallowRef<HTMLElement | undefined>;
705
- inputStyle: import('vue').ComputedRef<{
706
- minWidth: string;
707
- }>;
708
- inputId: import('vue').Ref<string | undefined>;
709
- contentId: import('vue').Ref<string>;
710
- nsSelect: {
711
- namespace: import('vue').ComputedRef<string>;
712
- b: (blockSuffix?: string) => string;
713
- e: (element?: string) => string;
714
- m: (modifier?: string) => string;
715
- be: (blockSuffix?: string, element?: string) => string;
716
- em: (element?: string, modifier?: string) => string;
717
- bm: (blockSuffix?: string, modifier?: string) => string;
718
- bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
719
- is: {
720
- (name: string, state: boolean | undefined): string;
721
- (name: string): string;
722
- };
723
- cssVar: (object: Record<string, string>) => Record<string, string>;
724
- cssVarName: (name: string) => string;
725
- cssVarBlock: (object: Record<string, string>) => Record<string, string>;
726
- cssVarBlockName: (name: string) => string;
727
- };
728
- nsInput: {
729
- namespace: import('vue').ComputedRef<string>;
730
- b: (blockSuffix?: string) => string;
731
- e: (element?: string) => string;
732
- m: (modifier?: string) => string;
733
- be: (blockSuffix?: string, element?: string) => string;
734
- em: (element?: string, modifier?: string) => string;
735
- bm: (blockSuffix?: string, modifier?: string) => string;
736
- bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
737
- is: {
738
- (name: string, state: boolean | undefined): string;
739
- (name: string): string;
740
- };
741
- cssVar: (object: Record<string, string>) => Record<string, string>;
742
- cssVarName: (name: string) => string;
743
- cssVarBlock: (object: Record<string, string>) => Record<string, string>;
744
- cssVarBlockName: (name: string) => string;
745
- };
746
- states: {
747
- inputValue: string;
748
- options: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
749
- cachedOptions: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
750
- optionValues: (string | number | boolean | Record<string, any>)[];
751
- selected: {
752
- value: string | number | boolean | Record<string, any>;
753
- currentLabel: import('element-plus').SelectOptionProxy['currentLabel'];
754
- isDisabled?: import('element-plus').SelectOptionProxy['isDisabled'] | undefined;
755
- }[];
756
- hoveringIndex: number;
757
- inputHovering: boolean;
758
- selectionWidth: number;
759
- collapseItemWidth: number;
760
- previousQuery: string | null;
761
- selectedLabel: string;
762
- menuVisibleOnFocus: boolean;
763
- isBeforeHide: boolean;
764
- };
765
- isFocused: import('vue').Ref<boolean>;
766
- expanded: import('vue').Ref<boolean>;
767
- optionsArray: import('vue').ComputedRef<import('element-plus').SelectOptionProxy[]>;
768
- hoverOption: import('vue').Ref<any>;
769
- selectSize: import('vue').ComputedRef<'' | 'small' | 'default' | 'large'>;
770
- filteredOptionsCount: import('vue').ComputedRef<number>;
771
- updateTooltip: () => void;
772
- updateTagTooltip: () => void;
773
- debouncedOnInputChange: import('lodash-es').DebouncedFunc<() => void>;
774
- onInput: (event: Event) => void;
775
- deletePrevTag: (e: KeyboardEvent) => void;
776
- deleteTag: (event: MouseEvent, tag: import('element-plus').SelectOptionProxy | import('element-plus').OptionBasic) => void;
777
- deleteSelected: (event: Event) => void;
778
- handleOptionSelect: (option: import('element-plus').SelectOptionProxy) => void;
779
- scrollToOption: (
780
- option: import('element-plus').SelectOptionProxy | import('element-plus').SelectOptionProxy[] | import('element-plus').OptionBasic[],
781
- ) => void;
782
- hasModelValue: import('vue').ComputedRef<boolean>;
783
- shouldShowPlaceholder: import('vue').ComputedRef<boolean>;
784
- currentPlaceholder: import('vue').ComputedRef<string>;
785
- mouseEnterEventName: import('vue').ComputedRef<'mouseenter' | null>;
786
- needStatusIcon: import('vue').ComputedRef<boolean>;
787
- showClose: import('vue').ComputedRef<boolean>;
788
- iconComponent: import('vue').ComputedRef<(string | import('vue').Component) | undefined>;
789
- iconReverse: import('vue').ComputedRef<string>;
790
- validateState: import('vue').ComputedRef<'' | 'error' | 'success' | 'validating'>;
791
- validateIcon: import('vue').ComputedRef<'' | import('vue').Component>;
792
- showNewOption: import('vue').ComputedRef<boolean>;
793
- updateOptions: () => void;
794
- collapseTagSize: import('vue').ComputedRef<'default' | 'small'>;
795
- setSelected: () => void;
796
- selectDisabled: import('vue').ComputedRef<boolean>;
797
- emptyText: import('vue').ComputedRef<string | null>;
798
- handleCompositionStart: (event: CompositionEvent) => void;
799
- handleCompositionUpdate: (event: CompositionEvent) => void;
800
- handleCompositionEnd: (event: CompositionEvent) => void;
801
- onOptionCreate: (vm: import('element-plus').SelectOptionProxy) => void;
802
- onOptionDestroy: (key: string | number | boolean | Record<string, any>, vm: import('element-plus').SelectOptionProxy) => void;
803
- handleMenuEnter: () => void;
804
- focus: () => void;
805
- blur: () => void;
806
- handleClearClick: (event: Event) => void;
807
- handleClickOutside: (event: Event) => void;
808
- handleEsc: () => void;
809
- toggleMenu: () => void;
810
- selectOption: () => void;
811
- getValueKey: (item: import('element-plus').SelectOptionProxy | import('element-plus').OptionBasic) => any;
812
- navigateOptions: (direction: 'prev' | 'next') => void;
813
- dropdownMenuVisible: import('vue').WritableComputedRef<boolean>;
814
- showTagList: import('vue').ComputedRef<
815
- {
816
- value: string | number | boolean | Record<string, any>;
817
- currentLabel: import('element-plus').SelectOptionProxy['currentLabel'];
818
- isDisabled?: import('element-plus').SelectOptionProxy['isDisabled'] | undefined;
819
- }[]
820
- >;
821
- collapseTagList: import('vue').ComputedRef<
822
- {
823
- value: string | number | boolean | Record<string, any>;
824
- currentLabel: import('element-plus').SelectOptionProxy['currentLabel'];
825
- isDisabled?: import('element-plus').SelectOptionProxy['isDisabled'] | undefined;
826
- }[]
827
- >;
828
- popupScroll: (data: { scrollTop: number; scrollLeft: number }) => void;
829
- tagStyle: import('vue').ComputedRef<{
830
- maxWidth: string;
831
- }>;
832
- collapseTagStyle: import('vue').ComputedRef<{
833
- maxWidth: string;
834
- }>;
835
- popperRef: import('vue').ComputedRef<HTMLElement | undefined>;
836
- inputRef: import('vue').Ref<HTMLInputElement | undefined>;
837
- tooltipRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
838
- tagTooltipRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
839
- prefixRef: import('vue').Ref<HTMLElement | undefined>;
840
- suffixRef: import('vue').Ref<HTMLElement | undefined>;
841
- selectRef: import('vue').Ref<HTMLElement | undefined>;
842
- wrapperRef: import('vue').ShallowRef<HTMLElement | undefined>;
843
- selectionRef: import('vue').Ref<HTMLElement | undefined>;
844
- scrollbarRef: import('vue').Ref<import('element-plus').ScrollbarInstance | undefined>;
845
- menuRef: import('vue').Ref<HTMLElement | undefined>;
846
- tagMenuRef: import('vue').Ref<HTMLElement | undefined>;
847
- collapseItemRef: import('vue').Ref<HTMLElement | undefined>;
848
- },
849
- {},
850
- {},
851
- {},
852
- {
853
- disabled: boolean;
854
- offset: number;
855
- multiple: boolean;
856
- loading: boolean;
857
- modelValue: (string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[];
858
- placement: any;
859
- effect: import('element-plus').PopperEffect;
860
- tabindex: string | number;
861
- valueOnClear: string | number | boolean | Function;
862
- autocomplete: string;
863
- validateEvent: boolean;
864
- clearable: boolean;
865
- fallbackPlacements: Placement[];
866
- popperOptions: Partial<Options>;
867
- popperClass: string;
868
- teleported: boolean;
869
- persistent: boolean;
870
- showArrow: boolean;
871
- valueKey: string;
872
- fitInputWidth: boolean;
873
- filterable: boolean;
874
- collapseTags: boolean;
875
- maxCollapseTags: number;
876
- collapseTagsTooltip: boolean;
877
- tagType: 'primary' | 'success' | 'warning' | 'info' | 'danger';
878
- tagEffect: 'plain' | 'dark' | 'light';
879
- automaticDropdown: boolean;
880
- allowCreate: boolean;
881
- remote: boolean;
882
- multipleLimit: number;
883
- defaultFirstOption: boolean;
884
- reserveKeyword: boolean;
885
- remoteShowSuffix: boolean;
886
- }
887
- >
888
- | null,
889
- | import('vue').CreateComponentPublicInstanceWithMixins<
890
- Readonly<
891
- import('vue').ExtractPropTypes<{
892
- ariaLabel: StringConstructor;
893
- emptyValues: ArrayConstructor;
894
- valueOnClear: {
895
- readonly type: PropType<string | number | boolean | Function>;
896
- readonly required: false;
897
- readonly validator: ((val: unknown) => boolean) | undefined;
898
- __epPropKey: true;
899
- } & {
900
- readonly default: undefined;
901
- };
902
- name: StringConstructor;
903
- id: StringConstructor;
904
- modelValue: {
905
- readonly type: PropType<(string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[]>;
906
- readonly required: false;
907
- readonly validator: ((val: unknown) => boolean) | undefined;
908
- __epPropKey: true;
909
- } & {
910
- readonly default: undefined;
911
- };
912
- autocomplete: {
913
- readonly type: PropType<string>;
914
- readonly required: false;
915
- readonly validator: ((val: unknown) => boolean) | undefined;
916
- __epPropKey: true;
917
- } & {
918
- readonly default: string;
919
- };
920
- automaticDropdown: BooleanConstructor;
921
- size: {
922
- readonly type: PropType<'' | 'default' | 'small' | 'large'>;
923
- readonly required: false;
924
- readonly validator: ((val: unknown) => boolean) | undefined;
925
- __epPropKey: true;
926
- };
927
- effect: {
928
- readonly type: PropType<import('element-plus').PopperEffect>;
929
- readonly required: false;
930
- readonly validator: ((val: unknown) => boolean) | undefined;
931
- __epPropKey: true;
932
- } & {
933
- readonly default: string;
934
- };
935
- disabled: BooleanConstructor;
936
- clearable: BooleanConstructor;
937
- filterable: BooleanConstructor;
938
- allowCreate: BooleanConstructor;
939
- loading: BooleanConstructor;
940
- popperClass: {
941
- readonly type: PropType<string>;
942
- readonly required: false;
943
- readonly validator: ((val: unknown) => boolean) | undefined;
944
- __epPropKey: true;
945
- } & {
946
- readonly default: string;
947
- };
948
- popperOptions: {
949
- readonly type: PropType<any>;
950
- readonly required: false;
951
- readonly validator: ((val: unknown) => boolean) | undefined;
952
- __epPropKey: true;
953
- } & {
954
- readonly default: () => Partial<Options>;
955
- };
956
- remote: BooleanConstructor;
957
- loadingText: StringConstructor;
958
- noMatchText: StringConstructor;
959
- noDataText: StringConstructor;
960
- remoteMethod: FunctionConstructor;
961
- filterMethod: FunctionConstructor;
962
- multiple: BooleanConstructor;
963
- multipleLimit: {
964
- readonly type: PropType<number>;
965
- readonly required: false;
966
- readonly validator: ((val: unknown) => boolean) | undefined;
967
- __epPropKey: true;
968
- } & {
969
- readonly default: number;
970
- };
971
- placeholder: {
972
- readonly type: PropType<string>;
973
- readonly required: false;
974
- readonly validator: ((val: unknown) => boolean) | undefined;
975
- __epPropKey: true;
976
- };
977
- defaultFirstOption: BooleanConstructor;
978
- reserveKeyword: {
979
- readonly type: PropType<boolean>;
980
- readonly required: false;
981
- readonly validator: ((val: unknown) => boolean) | undefined;
982
- __epPropKey: true;
983
- } & {
984
- readonly default: boolean;
985
- };
986
- valueKey: {
987
- readonly type: PropType<string>;
988
- readonly required: false;
989
- readonly validator: ((val: unknown) => boolean) | undefined;
990
- __epPropKey: true;
991
- } & {
992
- readonly default: string;
993
- };
994
- collapseTags: BooleanConstructor;
995
- collapseTagsTooltip: BooleanConstructor;
996
- maxCollapseTags: {
997
- readonly type: PropType<number>;
998
- readonly required: false;
999
- readonly validator: ((val: unknown) => boolean) | undefined;
1000
- __epPropKey: true;
1001
- } & {
1002
- readonly default: number;
1003
- };
1004
- teleported: {
1005
- readonly type: PropType<boolean>;
1006
- readonly required: false;
1007
- readonly validator: ((val: unknown) => boolean) | undefined;
1008
- __epPropKey: true;
1009
- } & {
1010
- readonly default: true;
1011
- };
1012
- persistent: {
1013
- readonly type: PropType<boolean>;
1014
- readonly required: false;
1015
- readonly validator: ((val: unknown) => boolean) | undefined;
1016
- __epPropKey: true;
1017
- } & {
1018
- readonly default: boolean;
1019
- };
1020
- clearIcon: {
1021
- readonly type: PropType<string | import('vue').Component>;
1022
- readonly required: false;
1023
- readonly validator: ((val: unknown) => boolean) | undefined;
1024
- __epPropKey: true;
1025
- };
1026
- fitInputWidth: BooleanConstructor;
1027
- suffixIcon: {
1028
- readonly type: PropType<string | import('vue').Component>;
1029
- readonly required: false;
1030
- readonly validator: ((val: unknown) => boolean) | undefined;
1031
- __epPropKey: true;
1032
- };
1033
- tagType: {
1034
- default: string;
1035
- type: PropType<'primary' | 'success' | 'warning' | 'info' | 'danger'>;
1036
- required: false;
1037
- validator: ((val: unknown) => boolean) | undefined;
1038
- __epPropKey: true;
1039
- };
1040
- tagEffect: {
1041
- default: string;
1042
- type: PropType<'plain' | 'dark' | 'light'>;
1043
- required: false;
1044
- validator: ((val: unknown) => boolean) | undefined;
1045
- __epPropKey: true;
1046
- };
1047
- validateEvent: {
1048
- readonly type: PropType<boolean>;
1049
- readonly required: false;
1050
- readonly validator: ((val: unknown) => boolean) | undefined;
1051
- __epPropKey: true;
1052
- } & {
1053
- readonly default: boolean;
1054
- };
1055
- remoteShowSuffix: BooleanConstructor;
1056
- showArrow: {
1057
- readonly type: PropType<boolean>;
1058
- readonly required: false;
1059
- readonly validator: ((val: unknown) => boolean) | undefined;
1060
- __epPropKey: true;
1061
- } & {
1062
- readonly default: boolean;
1063
- };
1064
- offset: {
1065
- readonly type: PropType<number>;
1066
- readonly required: false;
1067
- readonly validator: ((val: unknown) => boolean) | undefined;
1068
- __epPropKey: true;
1069
- } & {
1070
- readonly default: number;
1071
- };
1072
- placement: {
1073
- readonly type: PropType<any>;
1074
- readonly required: false;
1075
- readonly validator: ((val: unknown) => boolean) | undefined;
1076
- __epPropKey: true;
1077
- } & {
1078
- readonly default: string;
1079
- };
1080
- fallbackPlacements: {
1081
- readonly type: PropType<Placement[]>;
1082
- readonly required: false;
1083
- readonly validator: ((val: unknown) => boolean) | undefined;
1084
- __epPropKey: true;
1085
- } & {
1086
- readonly default: string[];
1087
- };
1088
- tabindex: {
1089
- readonly type: PropType<string | number>;
1090
- readonly required: false;
1091
- readonly validator: ((val: unknown) => boolean) | undefined;
1092
- __epPropKey: true;
1093
- } & {
1094
- readonly default: number;
1095
- };
1096
- appendTo: {
1097
- readonly type: PropType<string | HTMLElement>;
1098
- readonly required: false;
1099
- readonly validator: ((val: unknown) => boolean) | undefined;
1100
- __epPropKey: true;
1101
- };
1102
- }>
1103
- > & {
1104
- 'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
1105
- onChange?: ((...args: any[]) => any) | undefined;
1106
- onFocus?: ((...args: any[]) => any) | undefined;
1107
- onBlur?: ((...args: any[]) => any) | undefined;
1108
- onClear?: ((...args: any[]) => any) | undefined;
1109
- 'onVisible-change'?: ((...args: any[]) => any) | undefined;
1110
- 'onRemove-tag'?: ((...args: any[]) => any) | undefined;
1111
- 'onPopup-scroll'?: ((...args: any[]) => any) | undefined;
1112
- },
1113
- {
1114
- modelValue: import('vue').ComputedRef<string | number | boolean | any[] | Record<string, any> | undefined>;
1115
- selectedLabel: import('vue').ComputedRef<string | string[]>;
1116
- calculatorRef: import('vue').ShallowRef<HTMLElement | undefined>;
1117
- inputStyle: import('vue').ComputedRef<{
1118
- minWidth: string;
1119
- }>;
1120
- inputId: import('vue').Ref<string | undefined>;
1121
- contentId: import('vue').Ref<string>;
1122
- nsSelect: {
1123
- namespace: import('vue').ComputedRef<string>;
1124
- b: (blockSuffix?: string) => string;
1125
- e: (element?: string) => string;
1126
- m: (modifier?: string) => string;
1127
- be: (blockSuffix?: string, element?: string) => string;
1128
- em: (element?: string, modifier?: string) => string;
1129
- bm: (blockSuffix?: string, modifier?: string) => string;
1130
- bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
1131
- is: {
1132
- (name: string, state: boolean | undefined): string;
1133
- (name: string): string;
1134
- };
1135
- cssVar: (object: Record<string, string>) => Record<string, string>;
1136
- cssVarName: (name: string) => string;
1137
- cssVarBlock: (object: Record<string, string>) => Record<string, string>;
1138
- cssVarBlockName: (name: string) => string;
1139
- };
1140
- nsInput: {
1141
- namespace: import('vue').ComputedRef<string>;
1142
- b: (blockSuffix?: string) => string;
1143
- e: (element?: string) => string;
1144
- m: (modifier?: string) => string;
1145
- be: (blockSuffix?: string, element?: string) => string;
1146
- em: (element?: string, modifier?: string) => string;
1147
- bm: (blockSuffix?: string, modifier?: string) => string;
1148
- bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
1149
- is: {
1150
- (name: string, state: boolean | undefined): string;
1151
- (name: string): string;
1152
- };
1153
- cssVar: (object: Record<string, string>) => Record<string, string>;
1154
- cssVarName: (name: string) => string;
1155
- cssVarBlock: (object: Record<string, string>) => Record<string, string>;
1156
- cssVarBlockName: (name: string) => string;
1157
- };
1158
- states: {
1159
- inputValue: string;
1160
- options: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
1161
- cachedOptions: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
1162
- optionValues: (string | number | boolean | Record<string, any>)[];
1163
- selected: {
1164
- value: string | number | boolean | Record<string, any>;
1165
- currentLabel: import('element-plus').SelectOptionProxy['currentLabel'];
1166
- isDisabled?: import('element-plus').SelectOptionProxy['isDisabled'] | undefined;
1167
- }[];
1168
- hoveringIndex: number;
1169
- inputHovering: boolean;
1170
- selectionWidth: number;
1171
- collapseItemWidth: number;
1172
- previousQuery: string | null;
1173
- selectedLabel: string;
1174
- menuVisibleOnFocus: boolean;
1175
- isBeforeHide: boolean;
1176
- };
1177
- isFocused: import('vue').Ref<boolean>;
1178
- expanded: import('vue').Ref<boolean>;
1179
- optionsArray: import('vue').ComputedRef<import('element-plus').SelectOptionProxy[]>;
1180
- hoverOption: import('vue').Ref<any>;
1181
- selectSize: import('vue').ComputedRef<'' | 'small' | 'default' | 'large'>;
1182
- filteredOptionsCount: import('vue').ComputedRef<number>;
1183
- updateTooltip: () => void;
1184
- updateTagTooltip: () => void;
1185
- debouncedOnInputChange: import('lodash-es').DebouncedFunc<() => void>;
1186
- onInput: (event: Event) => void;
1187
- deletePrevTag: (e: KeyboardEvent) => void;
1188
- deleteTag: (event: MouseEvent, tag: import('element-plus').SelectOptionProxy | import('element-plus').OptionBasic) => void;
1189
- deleteSelected: (event: Event) => void;
1190
- handleOptionSelect: (option: import('element-plus').SelectOptionProxy) => void;
1191
- scrollToOption: (
1192
- option: import('element-plus').SelectOptionProxy | import('element-plus').SelectOptionProxy[] | import('element-plus').OptionBasic[],
1193
- ) => void;
1194
- hasModelValue: import('vue').ComputedRef<boolean>;
1195
- shouldShowPlaceholder: import('vue').ComputedRef<boolean>;
1196
- currentPlaceholder: import('vue').ComputedRef<string>;
1197
- mouseEnterEventName: import('vue').ComputedRef<'mouseenter' | null>;
1198
- needStatusIcon: import('vue').ComputedRef<boolean>;
1199
- showClose: import('vue').ComputedRef<boolean>;
1200
- iconComponent: import('vue').ComputedRef<(string | import('vue').Component) | undefined>;
1201
- iconReverse: import('vue').ComputedRef<string>;
1202
- validateState: import('vue').ComputedRef<'' | 'error' | 'success' | 'validating'>;
1203
- validateIcon: import('vue').ComputedRef<'' | import('vue').Component>;
1204
- showNewOption: import('vue').ComputedRef<boolean>;
1205
- updateOptions: () => void;
1206
- collapseTagSize: import('vue').ComputedRef<'default' | 'small'>;
1207
- setSelected: () => void;
1208
- selectDisabled: import('vue').ComputedRef<boolean>;
1209
- emptyText: import('vue').ComputedRef<string | null>;
1210
- handleCompositionStart: (event: CompositionEvent) => void;
1211
- handleCompositionUpdate: (event: CompositionEvent) => void;
1212
- handleCompositionEnd: (event: CompositionEvent) => void;
1213
- onOptionCreate: (vm: import('element-plus').SelectOptionProxy) => void;
1214
- onOptionDestroy: (key: string | number | boolean | Record<string, any>, vm: import('element-plus').SelectOptionProxy) => void;
1215
- handleMenuEnter: () => void;
1216
- focus: () => void;
1217
- blur: () => void;
1218
- handleClearClick: (event: Event) => void;
1219
- handleClickOutside: (event: Event) => void;
1220
- handleEsc: () => void;
1221
- toggleMenu: () => void;
1222
- selectOption: () => void;
1223
- getValueKey: (item: import('element-plus').SelectOptionProxy | import('element-plus').OptionBasic) => any;
1224
- navigateOptions: (direction: 'prev' | 'next') => void;
1225
- dropdownMenuVisible: import('vue').WritableComputedRef<boolean>;
1226
- showTagList: import('vue').ComputedRef<
1227
- {
1228
- value: string | number | boolean | Record<string, any>;
1229
- currentLabel: import('element-plus').SelectOptionProxy['currentLabel'];
1230
- isDisabled?: import('element-plus').SelectOptionProxy['isDisabled'] | undefined;
1231
- }[]
1232
- >;
1233
- collapseTagList: import('vue').ComputedRef<
1234
- {
1235
- value: string | number | boolean | Record<string, any>;
1236
- currentLabel: import('element-plus').SelectOptionProxy['currentLabel'];
1237
- isDisabled?: import('element-plus').SelectOptionProxy['isDisabled'] | undefined;
1238
- }[]
1239
- >;
1240
- popupScroll: (data: { scrollTop: number; scrollLeft: number }) => void;
1241
- tagStyle: import('vue').ComputedRef<{
1242
- maxWidth: string;
1243
- }>;
1244
- collapseTagStyle: import('vue').ComputedRef<{
1245
- maxWidth: string;
1246
- }>;
1247
- popperRef: import('vue').ComputedRef<HTMLElement | undefined>;
1248
- inputRef: import('vue').Ref<HTMLInputElement | undefined>;
1249
- tooltipRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
1250
- tagTooltipRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
1251
- prefixRef: import('vue').Ref<HTMLElement | undefined>;
1252
- suffixRef: import('vue').Ref<HTMLElement | undefined>;
1253
- selectRef: import('vue').Ref<HTMLElement | undefined>;
1254
- wrapperRef: import('vue').ShallowRef<HTMLElement | undefined>;
1255
- selectionRef: import('vue').Ref<HTMLElement | undefined>;
1256
- scrollbarRef: import('vue').Ref<import('element-plus').ScrollbarInstance | undefined>;
1257
- menuRef: import('vue').Ref<HTMLElement | undefined>;
1258
- tagMenuRef: import('vue').Ref<HTMLElement | undefined>;
1259
- collapseItemRef: import('vue').Ref<HTMLElement | undefined>;
1260
- },
1261
- unknown,
1262
- {},
1263
- {},
1264
- import('vue').ComponentOptionsMixin,
1265
- import('vue').ComponentOptionsMixin,
1266
- ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'visible-change' | 'remove-tag' | 'popup-scroll')[],
1267
- import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps,
1268
- {
1269
- disabled: boolean;
1270
- offset: number;
1271
- multiple: boolean;
1272
- loading: boolean;
1273
- modelValue: (string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[];
1274
- placement: any;
1275
- effect: import('element-plus').PopperEffect;
1276
- tabindex: string | number;
1277
- valueOnClear: string | number | boolean | Function;
1278
- autocomplete: string;
1279
- validateEvent: boolean;
1280
- clearable: boolean;
1281
- fallbackPlacements: Placement[];
1282
- popperOptions: Partial<Options>;
1283
- popperClass: string;
1284
- teleported: boolean;
1285
- persistent: boolean;
1286
- showArrow: boolean;
1287
- valueKey: string;
1288
- fitInputWidth: boolean;
1289
- filterable: boolean;
1290
- collapseTags: boolean;
1291
- maxCollapseTags: number;
1292
- collapseTagsTooltip: boolean;
1293
- tagType: 'primary' | 'success' | 'warning' | 'info' | 'danger';
1294
- tagEffect: 'plain' | 'dark' | 'light';
1295
- automaticDropdown: boolean;
1296
- allowCreate: boolean;
1297
- remote: boolean;
1298
- multipleLimit: number;
1299
- defaultFirstOption: boolean;
1300
- reserveKeyword: boolean;
1301
- remoteShowSuffix: boolean;
1302
- },
1303
- true,
1304
- {},
1305
- {},
1306
- import('vue').GlobalComponents,
1307
- import('vue').GlobalDirectives,
1308
- string,
1309
- {},
1310
- any,
1311
- import('vue').ComponentProvideOptions,
1312
- {
1313
- P: {};
1314
- B: {};
1315
- D: {};
1316
- C: {};
1317
- M: {};
1318
- Defaults: {};
1319
- },
1320
- Readonly<
1321
- import('vue').ExtractPropTypes<{
1322
- ariaLabel: StringConstructor;
1323
- emptyValues: ArrayConstructor;
1324
- valueOnClear: {
1325
- readonly type: PropType<string | number | boolean | Function>;
1326
- readonly required: false;
1327
- readonly validator: ((val: unknown) => boolean) | undefined;
1328
- __epPropKey: true;
1329
- } & {
1330
- readonly default: undefined;
1331
- };
1332
- name: StringConstructor;
1333
- id: StringConstructor;
1334
- modelValue: {
1335
- readonly type: PropType<(string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[]>;
1336
- readonly required: false;
1337
- readonly validator: ((val: unknown) => boolean) | undefined;
1338
- __epPropKey: true;
1339
- } & {
1340
- readonly default: undefined;
1341
- };
1342
- autocomplete: {
1343
- readonly type: PropType<string>;
1344
- readonly required: false;
1345
- readonly validator: ((val: unknown) => boolean) | undefined;
1346
- __epPropKey: true;
1347
- } & {
1348
- readonly default: string;
1349
- };
1350
- automaticDropdown: BooleanConstructor;
1351
- size: {
1352
- readonly type: PropType<'' | 'default' | 'small' | 'large'>;
1353
- readonly required: false;
1354
- readonly validator: ((val: unknown) => boolean) | undefined;
1355
- __epPropKey: true;
1356
- };
1357
- effect: {
1358
- readonly type: PropType<import('element-plus').PopperEffect>;
1359
- readonly required: false;
1360
- readonly validator: ((val: unknown) => boolean) | undefined;
1361
- __epPropKey: true;
1362
- } & {
1363
- readonly default: string;
1364
- };
1365
- disabled: BooleanConstructor;
1366
- clearable: BooleanConstructor;
1367
- filterable: BooleanConstructor;
1368
- allowCreate: BooleanConstructor;
1369
- loading: BooleanConstructor;
1370
- popperClass: {
1371
- readonly type: PropType<string>;
1372
- readonly required: false;
1373
- readonly validator: ((val: unknown) => boolean) | undefined;
1374
- __epPropKey: true;
1375
- } & {
1376
- readonly default: string;
1377
- };
1378
- popperOptions: {
1379
- readonly type: PropType<any>;
1380
- readonly required: false;
1381
- readonly validator: ((val: unknown) => boolean) | undefined;
1382
- __epPropKey: true;
1383
- } & {
1384
- readonly default: () => Partial<Options>;
1385
- };
1386
- remote: BooleanConstructor;
1387
- loadingText: StringConstructor;
1388
- noMatchText: StringConstructor;
1389
- noDataText: StringConstructor;
1390
- remoteMethod: FunctionConstructor;
1391
- filterMethod: FunctionConstructor;
1392
- multiple: BooleanConstructor;
1393
- multipleLimit: {
1394
- readonly type: PropType<number>;
1395
- readonly required: false;
1396
- readonly validator: ((val: unknown) => boolean) | undefined;
1397
- __epPropKey: true;
1398
- } & {
1399
- readonly default: number;
1400
- };
1401
- placeholder: {
1402
- readonly type: PropType<string>;
1403
- readonly required: false;
1404
- readonly validator: ((val: unknown) => boolean) | undefined;
1405
- __epPropKey: true;
1406
- };
1407
- defaultFirstOption: BooleanConstructor;
1408
- reserveKeyword: {
1409
- readonly type: PropType<boolean>;
1410
- readonly required: false;
1411
- readonly validator: ((val: unknown) => boolean) | undefined;
1412
- __epPropKey: true;
1413
- } & {
1414
- readonly default: boolean;
1415
- };
1416
- valueKey: {
1417
- readonly type: PropType<string>;
1418
- readonly required: false;
1419
- readonly validator: ((val: unknown) => boolean) | undefined;
1420
- __epPropKey: true;
1421
- } & {
1422
- readonly default: string;
1423
- };
1424
- collapseTags: BooleanConstructor;
1425
- collapseTagsTooltip: BooleanConstructor;
1426
- maxCollapseTags: {
1427
- readonly type: PropType<number>;
1428
- readonly required: false;
1429
- readonly validator: ((val: unknown) => boolean) | undefined;
1430
- __epPropKey: true;
1431
- } & {
1432
- readonly default: number;
1433
- };
1434
- teleported: {
1435
- readonly type: PropType<boolean>;
1436
- readonly required: false;
1437
- readonly validator: ((val: unknown) => boolean) | undefined;
1438
- __epPropKey: true;
1439
- } & {
1440
- readonly default: true;
1441
- };
1442
- persistent: {
1443
- readonly type: PropType<boolean>;
1444
- readonly required: false;
1445
- readonly validator: ((val: unknown) => boolean) | undefined;
1446
- __epPropKey: true;
1447
- } & {
1448
- readonly default: boolean;
1449
- };
1450
- clearIcon: {
1451
- readonly type: PropType<string | import('vue').Component>;
1452
- readonly required: false;
1453
- readonly validator: ((val: unknown) => boolean) | undefined;
1454
- __epPropKey: true;
1455
- };
1456
- fitInputWidth: BooleanConstructor;
1457
- suffixIcon: {
1458
- readonly type: PropType<string | import('vue').Component>;
1459
- readonly required: false;
1460
- readonly validator: ((val: unknown) => boolean) | undefined;
1461
- __epPropKey: true;
1462
- };
1463
- tagType: {
1464
- default: string;
1465
- type: PropType<'primary' | 'success' | 'warning' | 'info' | 'danger'>;
1466
- required: false;
1467
- validator: ((val: unknown) => boolean) | undefined;
1468
- __epPropKey: true;
1469
- };
1470
- tagEffect: {
1471
- default: string;
1472
- type: PropType<'plain' | 'dark' | 'light'>;
1473
- required: false;
1474
- validator: ((val: unknown) => boolean) | undefined;
1475
- __epPropKey: true;
1476
- };
1477
- validateEvent: {
1478
- readonly type: PropType<boolean>;
1479
- readonly required: false;
1480
- readonly validator: ((val: unknown) => boolean) | undefined;
1481
- __epPropKey: true;
1482
- } & {
1483
- readonly default: boolean;
1484
- };
1485
- remoteShowSuffix: BooleanConstructor;
1486
- showArrow: {
1487
- readonly type: PropType<boolean>;
1488
- readonly required: false;
1489
- readonly validator: ((val: unknown) => boolean) | undefined;
1490
- __epPropKey: true;
1491
- } & {
1492
- readonly default: boolean;
1493
- };
1494
- offset: {
1495
- readonly type: PropType<number>;
1496
- readonly required: false;
1497
- readonly validator: ((val: unknown) => boolean) | undefined;
1498
- __epPropKey: true;
1499
- } & {
1500
- readonly default: number;
1501
- };
1502
- placement: {
1503
- readonly type: PropType<any>;
1504
- readonly required: false;
1505
- readonly validator: ((val: unknown) => boolean) | undefined;
1506
- __epPropKey: true;
1507
- } & {
1508
- readonly default: string;
1509
- };
1510
- fallbackPlacements: {
1511
- readonly type: PropType<Placement[]>;
1512
- readonly required: false;
1513
- readonly validator: ((val: unknown) => boolean) | undefined;
1514
- __epPropKey: true;
1515
- } & {
1516
- readonly default: string[];
1517
- };
1518
- tabindex: {
1519
- readonly type: PropType<string | number>;
1520
- readonly required: false;
1521
- readonly validator: ((val: unknown) => boolean) | undefined;
1522
- __epPropKey: true;
1523
- } & {
1524
- readonly default: number;
1525
- };
1526
- appendTo: {
1527
- readonly type: PropType<string | HTMLElement>;
1528
- readonly required: false;
1529
- readonly validator: ((val: unknown) => boolean) | undefined;
1530
- __epPropKey: true;
1531
- };
1532
- }>
1533
- > & {
1534
- 'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
1535
- onChange?: ((...args: any[]) => any) | undefined;
1536
- onFocus?: ((...args: any[]) => any) | undefined;
1537
- onBlur?: ((...args: any[]) => any) | undefined;
1538
- onClear?: ((...args: any[]) => any) | undefined;
1539
- 'onVisible-change'?: ((...args: any[]) => any) | undefined;
1540
- 'onRemove-tag'?: ((...args: any[]) => any) | undefined;
1541
- 'onPopup-scroll'?: ((...args: any[]) => any) | undefined;
1542
- },
1543
- {
1544
- modelValue: import('vue').ComputedRef<string | number | boolean | any[] | Record<string, any> | undefined>;
1545
- selectedLabel: import('vue').ComputedRef<string | string[]>;
1546
- calculatorRef: import('vue').ShallowRef<HTMLElement | undefined>;
1547
- inputStyle: import('vue').ComputedRef<{
1548
- minWidth: string;
1549
- }>;
1550
- inputId: import('vue').Ref<string | undefined>;
1551
- contentId: import('vue').Ref<string>;
1552
- nsSelect: {
1553
- namespace: import('vue').ComputedRef<string>;
1554
- b: (blockSuffix?: string) => string;
1555
- e: (element?: string) => string;
1556
- m: (modifier?: string) => string;
1557
- be: (blockSuffix?: string, element?: string) => string;
1558
- em: (element?: string, modifier?: string) => string;
1559
- bm: (blockSuffix?: string, modifier?: string) => string;
1560
- bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
1561
- is: {
1562
- (name: string, state: boolean | undefined): string;
1563
- (name: string): string;
1564
- };
1565
- cssVar: (object: Record<string, string>) => Record<string, string>;
1566
- cssVarName: (name: string) => string;
1567
- cssVarBlock: (object: Record<string, string>) => Record<string, string>;
1568
- cssVarBlockName: (name: string) => string;
1569
- };
1570
- nsInput: {
1571
- namespace: import('vue').ComputedRef<string>;
1572
- b: (blockSuffix?: string) => string;
1573
- e: (element?: string) => string;
1574
- m: (modifier?: string) => string;
1575
- be: (blockSuffix?: string, element?: string) => string;
1576
- em: (element?: string, modifier?: string) => string;
1577
- bm: (blockSuffix?: string, modifier?: string) => string;
1578
- bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
1579
- is: {
1580
- (name: string, state: boolean | undefined): string;
1581
- (name: string): string;
1582
- };
1583
- cssVar: (object: Record<string, string>) => Record<string, string>;
1584
- cssVarName: (name: string) => string;
1585
- cssVarBlock: (object: Record<string, string>) => Record<string, string>;
1586
- cssVarBlockName: (name: string) => string;
1587
- };
1588
- states: {
1589
- inputValue: string;
1590
- options: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
1591
- cachedOptions: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
1592
- optionValues: (string | number | boolean | Record<string, any>)[];
1593
- selected: {
1594
- value: string | number | boolean | Record<string, any>;
1595
- currentLabel: import('element-plus').SelectOptionProxy['currentLabel'];
1596
- isDisabled?: import('element-plus').SelectOptionProxy['isDisabled'] | undefined;
1597
- }[];
1598
- hoveringIndex: number;
1599
- inputHovering: boolean;
1600
- selectionWidth: number;
1601
- collapseItemWidth: number;
1602
- previousQuery: string | null;
1603
- selectedLabel: string;
1604
- menuVisibleOnFocus: boolean;
1605
- isBeforeHide: boolean;
1606
- };
1607
- isFocused: import('vue').Ref<boolean>;
1608
- expanded: import('vue').Ref<boolean>;
1609
- optionsArray: import('vue').ComputedRef<import('element-plus').SelectOptionProxy[]>;
1610
- hoverOption: import('vue').Ref<any>;
1611
- selectSize: import('vue').ComputedRef<'' | 'small' | 'default' | 'large'>;
1612
- filteredOptionsCount: import('vue').ComputedRef<number>;
1613
- updateTooltip: () => void;
1614
- updateTagTooltip: () => void;
1615
- debouncedOnInputChange: import('lodash-es').DebouncedFunc<() => void>;
1616
- onInput: (event: Event) => void;
1617
- deletePrevTag: (e: KeyboardEvent) => void;
1618
- deleteTag: (event: MouseEvent, tag: import('element-plus').SelectOptionProxy | import('element-plus').OptionBasic) => void;
1619
- deleteSelected: (event: Event) => void;
1620
- handleOptionSelect: (option: import('element-plus').SelectOptionProxy) => void;
1621
- scrollToOption: (
1622
- option: import('element-plus').SelectOptionProxy | import('element-plus').SelectOptionProxy[] | import('element-plus').OptionBasic[],
1623
- ) => void;
1624
- hasModelValue: import('vue').ComputedRef<boolean>;
1625
- shouldShowPlaceholder: import('vue').ComputedRef<boolean>;
1626
- currentPlaceholder: import('vue').ComputedRef<string>;
1627
- mouseEnterEventName: import('vue').ComputedRef<'mouseenter' | null>;
1628
- needStatusIcon: import('vue').ComputedRef<boolean>;
1629
- showClose: import('vue').ComputedRef<boolean>;
1630
- iconComponent: import('vue').ComputedRef<(string | import('vue').Component) | undefined>;
1631
- iconReverse: import('vue').ComputedRef<string>;
1632
- validateState: import('vue').ComputedRef<'' | 'error' | 'success' | 'validating'>;
1633
- validateIcon: import('vue').ComputedRef<'' | import('vue').Component>;
1634
- showNewOption: import('vue').ComputedRef<boolean>;
1635
- updateOptions: () => void;
1636
- collapseTagSize: import('vue').ComputedRef<'default' | 'small'>;
1637
- setSelected: () => void;
1638
- selectDisabled: import('vue').ComputedRef<boolean>;
1639
- emptyText: import('vue').ComputedRef<string | null>;
1640
- handleCompositionStart: (event: CompositionEvent) => void;
1641
- handleCompositionUpdate: (event: CompositionEvent) => void;
1642
- handleCompositionEnd: (event: CompositionEvent) => void;
1643
- onOptionCreate: (vm: import('element-plus').SelectOptionProxy) => void;
1644
- onOptionDestroy: (key: string | number | boolean | Record<string, any>, vm: import('element-plus').SelectOptionProxy) => void;
1645
- handleMenuEnter: () => void;
1646
- focus: () => void;
1647
- blur: () => void;
1648
- handleClearClick: (event: Event) => void;
1649
- handleClickOutside: (event: Event) => void;
1650
- handleEsc: () => void;
1651
- toggleMenu: () => void;
1652
- selectOption: () => void;
1653
- getValueKey: (item: import('element-plus').SelectOptionProxy | import('element-plus').OptionBasic) => any;
1654
- navigateOptions: (direction: 'prev' | 'next') => void;
1655
- dropdownMenuVisible: import('vue').WritableComputedRef<boolean>;
1656
- showTagList: import('vue').ComputedRef<
1657
- {
1658
- value: string | number | boolean | Record<string, any>;
1659
- currentLabel: import('element-plus').SelectOptionProxy['currentLabel'];
1660
- isDisabled?: import('element-plus').SelectOptionProxy['isDisabled'] | undefined;
1661
- }[]
1662
- >;
1663
- collapseTagList: import('vue').ComputedRef<
1664
- {
1665
- value: string | number | boolean | Record<string, any>;
1666
- currentLabel: import('element-plus').SelectOptionProxy['currentLabel'];
1667
- isDisabled?: import('element-plus').SelectOptionProxy['isDisabled'] | undefined;
1668
- }[]
1669
- >;
1670
- popupScroll: (data: { scrollTop: number; scrollLeft: number }) => void;
1671
- tagStyle: import('vue').ComputedRef<{
1672
- maxWidth: string;
1673
- }>;
1674
- collapseTagStyle: import('vue').ComputedRef<{
1675
- maxWidth: string;
1676
- }>;
1677
- popperRef: import('vue').ComputedRef<HTMLElement | undefined>;
1678
- inputRef: import('vue').Ref<HTMLInputElement | undefined>;
1679
- tooltipRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
1680
- tagTooltipRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
1681
- prefixRef: import('vue').Ref<HTMLElement | undefined>;
1682
- suffixRef: import('vue').Ref<HTMLElement | undefined>;
1683
- selectRef: import('vue').Ref<HTMLElement | undefined>;
1684
- wrapperRef: import('vue').ShallowRef<HTMLElement | undefined>;
1685
- selectionRef: import('vue').Ref<HTMLElement | undefined>;
1686
- scrollbarRef: import('vue').Ref<import('element-plus').ScrollbarInstance | undefined>;
1687
- menuRef: import('vue').Ref<HTMLElement | undefined>;
1688
- tagMenuRef: import('vue').Ref<HTMLElement | undefined>;
1689
- collapseItemRef: import('vue').Ref<HTMLElement | undefined>;
1690
- },
1691
- {},
1692
- {},
1693
- {},
1694
- {
1695
- disabled: boolean;
1696
- offset: number;
1697
- multiple: boolean;
1698
- loading: boolean;
1699
- modelValue: (string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[];
1700
- placement: any;
1701
- effect: import('element-plus').PopperEffect;
1702
- tabindex: string | number;
1703
- valueOnClear: string | number | boolean | Function;
1704
- autocomplete: string;
1705
- validateEvent: boolean;
1706
- clearable: boolean;
1707
- fallbackPlacements: Placement[];
1708
- popperOptions: Partial<Options>;
1709
- popperClass: string;
1710
- teleported: boolean;
1711
- persistent: boolean;
1712
- showArrow: boolean;
1713
- valueKey: string;
1714
- fitInputWidth: boolean;
1715
- filterable: boolean;
1716
- collapseTags: boolean;
1717
- maxCollapseTags: number;
1718
- collapseTagsTooltip: boolean;
1719
- tagType: 'primary' | 'success' | 'warning' | 'info' | 'danger';
1720
- tagEffect: 'plain' | 'dark' | 'light';
1721
- automaticDropdown: boolean;
1722
- allowCreate: boolean;
1723
- remote: boolean;
1724
- multipleLimit: number;
1725
- defaultFirstOption: boolean;
1726
- reserveKeyword: boolean;
1727
- remoteShowSuffix: boolean;
1728
- }
1729
- >
1730
- | null
1731
- >;
1732
- },
1733
- {},
1734
- {},
1735
- {},
1736
- import('vue').ComponentOptionsMixin,
1737
- import('vue').ComponentOptionsMixin,
1738
- {
1739
- 'update:modelValue': (value: any) => any;
1740
- },
1741
- string,
1742
- import('vue').PublicProps,
1743
- Readonly<
1744
- import('vue').ExtractPropTypes<{
1745
- modelValue: {
1746
- type: (NumberConstructor | StringConstructor | ArrayConstructor)[];
1747
- default: string;
193
+ tagEffect: {
194
+ default: string;
195
+ type: PropType<"plain" | "dark" | "light">;
196
+ required: false;
197
+ validator: ((val: unknown) => boolean) | undefined;
198
+ __epPropKey: true;
199
+ };
200
+ validateEvent: {
201
+ readonly type: PropType<boolean>;
202
+ readonly required: false;
203
+ readonly validator: ((val: unknown) => boolean) | undefined;
204
+ __epPropKey: true;
205
+ } & {
206
+ readonly default: boolean;
207
+ };
208
+ remoteShowSuffix: BooleanConstructor;
209
+ showArrow: {
210
+ readonly type: PropType<boolean>;
211
+ readonly required: false;
212
+ readonly validator: ((val: unknown) => boolean) | undefined;
213
+ __epPropKey: true;
214
+ } & {
215
+ readonly default: boolean;
216
+ };
217
+ offset: {
218
+ readonly type: PropType<number>;
219
+ readonly required: false;
220
+ readonly validator: ((val: unknown) => boolean) | undefined;
221
+ __epPropKey: true;
222
+ } & {
223
+ readonly default: number;
224
+ };
225
+ placement: {
226
+ readonly type: PropType<any>;
227
+ readonly required: false;
228
+ readonly validator: ((val: unknown) => boolean) | undefined;
229
+ __epPropKey: true;
230
+ } & {
231
+ readonly default: string;
232
+ };
233
+ fallbackPlacements: {
234
+ readonly type: PropType<Placement[]>;
235
+ readonly required: false;
236
+ readonly validator: ((val: unknown) => boolean) | undefined;
237
+ __epPropKey: true;
238
+ } & {
239
+ readonly default: string[];
240
+ };
241
+ tabindex: {
242
+ readonly type: PropType<string | number>;
243
+ readonly required: false;
244
+ readonly validator: ((val: unknown) => boolean) | undefined;
245
+ __epPropKey: true;
246
+ } & {
247
+ readonly default: number;
248
+ };
249
+ appendTo: {
250
+ readonly type: PropType<string | HTMLElement>;
251
+ readonly required: false;
252
+ readonly validator: ((val: unknown) => boolean) | undefined;
253
+ __epPropKey: true;
254
+ };
255
+ }>> & {
256
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
257
+ onChange?: ((...args: any[]) => any) | undefined;
258
+ onFocus?: ((...args: any[]) => any) | undefined;
259
+ onBlur?: ((...args: any[]) => any) | undefined;
260
+ onClear?: ((...args: any[]) => any) | undefined;
261
+ "onVisible-change"?: ((...args: any[]) => any) | undefined;
262
+ "onRemove-tag"?: ((...args: any[]) => any) | undefined;
263
+ "onPopup-scroll"?: ((...args: any[]) => any) | undefined;
264
+ }, {
265
+ modelValue: import('vue').ComputedRef<string | number | boolean | any[] | Record<string, any> | undefined>;
266
+ selectedLabel: import('vue').ComputedRef<string | string[]>;
267
+ calculatorRef: import('vue').ShallowRef<HTMLElement | undefined>;
268
+ inputStyle: import('vue').ComputedRef<{
269
+ minWidth: string;
270
+ }>;
271
+ inputId: import('vue').Ref<string | undefined>;
272
+ contentId: import('vue').Ref<string>;
273
+ nsSelect: {
274
+ namespace: import('vue').ComputedRef<string>;
275
+ b: (blockSuffix?: string) => string;
276
+ e: (element?: string) => string;
277
+ m: (modifier?: string) => string;
278
+ be: (blockSuffix?: string, element?: string) => string;
279
+ em: (element?: string, modifier?: string) => string;
280
+ bm: (blockSuffix?: string, modifier?: string) => string;
281
+ bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
282
+ is: {
283
+ (name: string, state: boolean | undefined): string;
284
+ (name: string): string;
1748
285
  };
1749
- options: {
1750
- type: PropType<SelectOptions[]>;
1751
- default: () => never[];
286
+ cssVar: (object: Record<string, string>) => Record<string, string>;
287
+ cssVarName: (name: string) => string;
288
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
289
+ cssVarBlockName: (name: string) => string;
290
+ };
291
+ nsInput: {
292
+ namespace: import('vue').ComputedRef<string>;
293
+ b: (blockSuffix?: string) => string;
294
+ e: (element?: string) => string;
295
+ m: (modifier?: string) => string;
296
+ be: (blockSuffix?: string, element?: string) => string;
297
+ em: (element?: string, modifier?: string) => string;
298
+ bm: (blockSuffix?: string, modifier?: string) => string;
299
+ bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
300
+ is: {
301
+ (name: string, state: boolean | undefined): string;
302
+ (name: string): string;
1752
303
  };
1753
- collapseTags: {
1754
- type: BooleanConstructor;
1755
- default: boolean;
304
+ cssVar: (object: Record<string, string>) => Record<string, string>;
305
+ cssVarName: (name: string) => string;
306
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
307
+ cssVarBlockName: (name: string) => string;
308
+ };
309
+ states: {
310
+ inputValue: string;
311
+ options: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
312
+ cachedOptions: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
313
+ optionValues: (string | number | boolean | Record<string, any>)[];
314
+ selected: {
315
+ value: string | number | boolean | Record<string, any>;
316
+ currentLabel: import('element-plus').SelectOptionProxy["currentLabel"];
317
+ isDisabled?: import('element-plus').SelectOptionProxy["isDisabled"] | undefined;
318
+ }[];
319
+ hoveringIndex: number;
320
+ inputHovering: boolean;
321
+ selectionWidth: number;
322
+ collapseItemWidth: number;
323
+ previousQuery: string | null;
324
+ selectedLabel: string;
325
+ menuVisibleOnFocus: boolean;
326
+ isBeforeHide: boolean;
327
+ };
328
+ isFocused: import('vue').Ref<boolean>;
329
+ expanded: import('vue').Ref<boolean>;
330
+ optionsArray: import('vue').ComputedRef<import('element-plus').SelectOptionProxy[]>;
331
+ hoverOption: import('vue').Ref<any>;
332
+ selectSize: import('vue').ComputedRef<"" | "small" | "default" | "large">;
333
+ filteredOptionsCount: import('vue').ComputedRef<number>;
334
+ updateTooltip: () => void;
335
+ updateTagTooltip: () => void;
336
+ debouncedOnInputChange: import('lodash-es').DebouncedFunc<() => void>;
337
+ onInput: (event: Event) => void;
338
+ deletePrevTag: (e: KeyboardEvent) => void;
339
+ deleteTag: (event: MouseEvent, tag: import('element-plus').SelectOptionProxy | import('element-plus').OptionBasic) => void;
340
+ deleteSelected: (event: Event) => void;
341
+ handleOptionSelect: (option: import('element-plus').SelectOptionProxy) => void;
342
+ scrollToOption: (option: import('element-plus').SelectOptionProxy | import('element-plus').SelectOptionProxy[] | import('element-plus').OptionBasic[]) => void;
343
+ hasModelValue: import('vue').ComputedRef<boolean>;
344
+ shouldShowPlaceholder: import('vue').ComputedRef<boolean>;
345
+ currentPlaceholder: import('vue').ComputedRef<string>;
346
+ mouseEnterEventName: import('vue').ComputedRef<"mouseenter" | null>;
347
+ needStatusIcon: import('vue').ComputedRef<boolean>;
348
+ showClose: import('vue').ComputedRef<boolean>;
349
+ iconComponent: import('vue').ComputedRef<(string | import('vue').Component) | undefined>;
350
+ iconReverse: import('vue').ComputedRef<string>;
351
+ validateState: import('vue').ComputedRef<"" | "error" | "success" | "validating">;
352
+ validateIcon: import('vue').ComputedRef<"" | import('vue').Component>;
353
+ showNewOption: import('vue').ComputedRef<boolean>;
354
+ updateOptions: () => void;
355
+ collapseTagSize: import('vue').ComputedRef<"default" | "small">;
356
+ setSelected: () => void;
357
+ selectDisabled: import('vue').ComputedRef<boolean>;
358
+ emptyText: import('vue').ComputedRef<string | null>;
359
+ handleCompositionStart: (event: CompositionEvent) => void;
360
+ handleCompositionUpdate: (event: CompositionEvent) => void;
361
+ handleCompositionEnd: (event: CompositionEvent) => void;
362
+ onOptionCreate: (vm: import('element-plus').SelectOptionProxy) => void;
363
+ onOptionDestroy: (key: string | number | boolean | Record<string, any>, vm: import('element-plus').SelectOptionProxy) => void;
364
+ handleMenuEnter: () => void;
365
+ focus: () => void;
366
+ blur: () => void;
367
+ handleClearClick: (event: Event) => void;
368
+ handleClickOutside: (event: Event) => void;
369
+ handleEsc: () => void;
370
+ toggleMenu: () => void;
371
+ selectOption: () => void;
372
+ getValueKey: (item: import('element-plus').SelectOptionProxy | import('element-plus').OptionBasic) => any;
373
+ navigateOptions: (direction: "prev" | "next") => void;
374
+ dropdownMenuVisible: import('vue').WritableComputedRef<boolean>;
375
+ showTagList: import('vue').ComputedRef<{
376
+ value: string | number | boolean | Record<string, any>;
377
+ currentLabel: import('element-plus').SelectOptionProxy["currentLabel"];
378
+ isDisabled?: import('element-plus').SelectOptionProxy["isDisabled"] | undefined;
379
+ }[]>;
380
+ collapseTagList: import('vue').ComputedRef<{
381
+ value: string | number | boolean | Record<string, any>;
382
+ currentLabel: import('element-plus').SelectOptionProxy["currentLabel"];
383
+ isDisabled?: import('element-plus').SelectOptionProxy["isDisabled"] | undefined;
384
+ }[]>;
385
+ popupScroll: (data: {
386
+ scrollTop: number;
387
+ scrollLeft: number;
388
+ }) => void;
389
+ tagStyle: import('vue').ComputedRef<{
390
+ maxWidth: string;
391
+ }>;
392
+ collapseTagStyle: import('vue').ComputedRef<{
393
+ maxWidth: string;
394
+ }>;
395
+ popperRef: import('vue').ComputedRef<HTMLElement | undefined>;
396
+ inputRef: import('vue').Ref<HTMLInputElement | undefined>;
397
+ tooltipRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
398
+ tagTooltipRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
399
+ prefixRef: import('vue').Ref<HTMLElement | undefined>;
400
+ suffixRef: import('vue').Ref<HTMLElement | undefined>;
401
+ selectRef: import('vue').Ref<HTMLElement | undefined>;
402
+ wrapperRef: import('vue').ShallowRef<HTMLElement | undefined>;
403
+ selectionRef: import('vue').Ref<HTMLElement | undefined>;
404
+ scrollbarRef: import('vue').Ref<import('element-plus').ScrollbarInstance | undefined>;
405
+ menuRef: import('vue').Ref<HTMLElement | undefined>;
406
+ tagMenuRef: import('vue').Ref<HTMLElement | undefined>;
407
+ collapseItemRef: import('vue').Ref<HTMLElement | undefined>;
408
+ }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("blur" | "change" | "focus" | "clear" | "update:modelValue" | "visible-change" | "remove-tag" | "popup-scroll")[], import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
409
+ disabled: boolean;
410
+ offset: number;
411
+ multiple: boolean;
412
+ loading: boolean;
413
+ modelValue: (string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[];
414
+ placement: any;
415
+ effect: import('element-plus').PopperEffect;
416
+ tabindex: string | number;
417
+ valueOnClear: string | number | boolean | Function;
418
+ autocomplete: string;
419
+ validateEvent: boolean;
420
+ clearable: boolean;
421
+ fallbackPlacements: Placement[];
422
+ popperOptions: Partial<Options>;
423
+ popperClass: string;
424
+ teleported: boolean;
425
+ persistent: boolean;
426
+ showArrow: boolean;
427
+ valueKey: string;
428
+ fitInputWidth: boolean;
429
+ filterable: boolean;
430
+ collapseTags: boolean;
431
+ maxCollapseTags: number;
432
+ collapseTagsTooltip: boolean;
433
+ tagType: "primary" | "success" | "warning" | "info" | "danger";
434
+ tagEffect: "plain" | "dark" | "light";
435
+ automaticDropdown: boolean;
436
+ allowCreate: boolean;
437
+ remote: boolean;
438
+ multipleLimit: number;
439
+ defaultFirstOption: boolean;
440
+ reserveKeyword: boolean;
441
+ remoteShowSuffix: boolean;
442
+ }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
443
+ P: {};
444
+ B: {};
445
+ D: {};
446
+ C: {};
447
+ M: {};
448
+ Defaults: {};
449
+ }, Readonly<import('vue').ExtractPropTypes<{
450
+ ariaLabel: StringConstructor;
451
+ emptyValues: ArrayConstructor;
452
+ valueOnClear: {
453
+ readonly type: PropType<string | number | boolean | Function>;
454
+ readonly required: false;
455
+ readonly validator: ((val: unknown) => boolean) | undefined;
456
+ __epPropKey: true;
457
+ } & {
458
+ readonly default: undefined;
459
+ };
460
+ name: StringConstructor;
461
+ id: StringConstructor;
462
+ modelValue: {
463
+ readonly type: PropType<(string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[]>;
464
+ readonly required: false;
465
+ readonly validator: ((val: unknown) => boolean) | undefined;
466
+ __epPropKey: true;
467
+ } & {
468
+ readonly default: undefined;
469
+ };
470
+ autocomplete: {
471
+ readonly type: PropType<string>;
472
+ readonly required: false;
473
+ readonly validator: ((val: unknown) => boolean) | undefined;
474
+ __epPropKey: true;
475
+ } & {
476
+ readonly default: string;
477
+ };
478
+ automaticDropdown: BooleanConstructor;
479
+ size: {
480
+ readonly type: PropType<"" | "default" | "small" | "large">;
481
+ readonly required: false;
482
+ readonly validator: ((val: unknown) => boolean) | undefined;
483
+ __epPropKey: true;
484
+ };
485
+ effect: {
486
+ readonly type: PropType<import('element-plus').PopperEffect>;
487
+ readonly required: false;
488
+ readonly validator: ((val: unknown) => boolean) | undefined;
489
+ __epPropKey: true;
490
+ } & {
491
+ readonly default: string;
492
+ };
493
+ disabled: BooleanConstructor;
494
+ clearable: BooleanConstructor;
495
+ filterable: BooleanConstructor;
496
+ allowCreate: BooleanConstructor;
497
+ loading: BooleanConstructor;
498
+ popperClass: {
499
+ readonly type: PropType<string>;
500
+ readonly required: false;
501
+ readonly validator: ((val: unknown) => boolean) | undefined;
502
+ __epPropKey: true;
503
+ } & {
504
+ readonly default: string;
505
+ };
506
+ popperOptions: {
507
+ readonly type: PropType<any>;
508
+ readonly required: false;
509
+ readonly validator: ((val: unknown) => boolean) | undefined;
510
+ __epPropKey: true;
511
+ } & {
512
+ readonly default: () => Partial<Options>;
513
+ };
514
+ remote: BooleanConstructor;
515
+ loadingText: StringConstructor;
516
+ noMatchText: StringConstructor;
517
+ noDataText: StringConstructor;
518
+ remoteMethod: FunctionConstructor;
519
+ filterMethod: FunctionConstructor;
520
+ multiple: BooleanConstructor;
521
+ multipleLimit: {
522
+ readonly type: PropType<number>;
523
+ readonly required: false;
524
+ readonly validator: ((val: unknown) => boolean) | undefined;
525
+ __epPropKey: true;
526
+ } & {
527
+ readonly default: number;
528
+ };
529
+ placeholder: {
530
+ readonly type: PropType<string>;
531
+ readonly required: false;
532
+ readonly validator: ((val: unknown) => boolean) | undefined;
533
+ __epPropKey: true;
534
+ };
535
+ defaultFirstOption: BooleanConstructor;
536
+ reserveKeyword: {
537
+ readonly type: PropType<boolean>;
538
+ readonly required: false;
539
+ readonly validator: ((val: unknown) => boolean) | undefined;
540
+ __epPropKey: true;
541
+ } & {
542
+ readonly default: boolean;
543
+ };
544
+ valueKey: {
545
+ readonly type: PropType<string>;
546
+ readonly required: false;
547
+ readonly validator: ((val: unknown) => boolean) | undefined;
548
+ __epPropKey: true;
549
+ } & {
550
+ readonly default: string;
551
+ };
552
+ collapseTags: BooleanConstructor;
553
+ collapseTagsTooltip: BooleanConstructor;
554
+ maxCollapseTags: {
555
+ readonly type: PropType<number>;
556
+ readonly required: false;
557
+ readonly validator: ((val: unknown) => boolean) | undefined;
558
+ __epPropKey: true;
559
+ } & {
560
+ readonly default: number;
561
+ };
562
+ teleported: {
563
+ readonly type: PropType<boolean>;
564
+ readonly required: false;
565
+ readonly validator: ((val: unknown) => boolean) | undefined;
566
+ __epPropKey: true;
567
+ } & {
568
+ readonly default: true;
569
+ };
570
+ persistent: {
571
+ readonly type: PropType<boolean>;
572
+ readonly required: false;
573
+ readonly validator: ((val: unknown) => boolean) | undefined;
574
+ __epPropKey: true;
575
+ } & {
576
+ readonly default: boolean;
577
+ };
578
+ clearIcon: {
579
+ readonly type: PropType<string | import('vue').Component>;
580
+ readonly required: false;
581
+ readonly validator: ((val: unknown) => boolean) | undefined;
582
+ __epPropKey: true;
583
+ };
584
+ fitInputWidth: BooleanConstructor;
585
+ suffixIcon: {
586
+ readonly type: PropType<string | import('vue').Component>;
587
+ readonly required: false;
588
+ readonly validator: ((val: unknown) => boolean) | undefined;
589
+ __epPropKey: true;
590
+ };
591
+ tagType: {
592
+ default: string;
593
+ type: PropType<"primary" | "success" | "warning" | "info" | "danger">;
594
+ required: false;
595
+ validator: ((val: unknown) => boolean) | undefined;
596
+ __epPropKey: true;
597
+ };
598
+ tagEffect: {
599
+ default: string;
600
+ type: PropType<"plain" | "dark" | "light">;
601
+ required: false;
602
+ validator: ((val: unknown) => boolean) | undefined;
603
+ __epPropKey: true;
604
+ };
605
+ validateEvent: {
606
+ readonly type: PropType<boolean>;
607
+ readonly required: false;
608
+ readonly validator: ((val: unknown) => boolean) | undefined;
609
+ __epPropKey: true;
610
+ } & {
611
+ readonly default: boolean;
612
+ };
613
+ remoteShowSuffix: BooleanConstructor;
614
+ showArrow: {
615
+ readonly type: PropType<boolean>;
616
+ readonly required: false;
617
+ readonly validator: ((val: unknown) => boolean) | undefined;
618
+ __epPropKey: true;
619
+ } & {
620
+ readonly default: boolean;
621
+ };
622
+ offset: {
623
+ readonly type: PropType<number>;
624
+ readonly required: false;
625
+ readonly validator: ((val: unknown) => boolean) | undefined;
626
+ __epPropKey: true;
627
+ } & {
628
+ readonly default: number;
629
+ };
630
+ placement: {
631
+ readonly type: PropType<any>;
632
+ readonly required: false;
633
+ readonly validator: ((val: unknown) => boolean) | undefined;
634
+ __epPropKey: true;
635
+ } & {
636
+ readonly default: string;
637
+ };
638
+ fallbackPlacements: {
639
+ readonly type: PropType<Placement[]>;
640
+ readonly required: false;
641
+ readonly validator: ((val: unknown) => boolean) | undefined;
642
+ __epPropKey: true;
643
+ } & {
644
+ readonly default: string[];
645
+ };
646
+ tabindex: {
647
+ readonly type: PropType<string | number>;
648
+ readonly required: false;
649
+ readonly validator: ((val: unknown) => boolean) | undefined;
650
+ __epPropKey: true;
651
+ } & {
652
+ readonly default: number;
653
+ };
654
+ appendTo: {
655
+ readonly type: PropType<string | HTMLElement>;
656
+ readonly required: false;
657
+ readonly validator: ((val: unknown) => boolean) | undefined;
658
+ __epPropKey: true;
659
+ };
660
+ }>> & {
661
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
662
+ onChange?: ((...args: any[]) => any) | undefined;
663
+ onFocus?: ((...args: any[]) => any) | undefined;
664
+ onBlur?: ((...args: any[]) => any) | undefined;
665
+ onClear?: ((...args: any[]) => any) | undefined;
666
+ "onVisible-change"?: ((...args: any[]) => any) | undefined;
667
+ "onRemove-tag"?: ((...args: any[]) => any) | undefined;
668
+ "onPopup-scroll"?: ((...args: any[]) => any) | undefined;
669
+ }, {
670
+ modelValue: import('vue').ComputedRef<string | number | boolean | any[] | Record<string, any> | undefined>;
671
+ selectedLabel: import('vue').ComputedRef<string | string[]>;
672
+ calculatorRef: import('vue').ShallowRef<HTMLElement | undefined>;
673
+ inputStyle: import('vue').ComputedRef<{
674
+ minWidth: string;
675
+ }>;
676
+ inputId: import('vue').Ref<string | undefined>;
677
+ contentId: import('vue').Ref<string>;
678
+ nsSelect: {
679
+ namespace: import('vue').ComputedRef<string>;
680
+ b: (blockSuffix?: string) => string;
681
+ e: (element?: string) => string;
682
+ m: (modifier?: string) => string;
683
+ be: (blockSuffix?: string, element?: string) => string;
684
+ em: (element?: string, modifier?: string) => string;
685
+ bm: (blockSuffix?: string, modifier?: string) => string;
686
+ bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
687
+ is: {
688
+ (name: string, state: boolean | undefined): string;
689
+ (name: string): string;
1756
690
  };
1757
- clearable: {
1758
- type: BooleanConstructor;
1759
- default: boolean;
691
+ cssVar: (object: Record<string, string>) => Record<string, string>;
692
+ cssVarName: (name: string) => string;
693
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
694
+ cssVarBlockName: (name: string) => string;
695
+ };
696
+ nsInput: {
697
+ namespace: import('vue').ComputedRef<string>;
698
+ b: (blockSuffix?: string) => string;
699
+ e: (element?: string) => string;
700
+ m: (modifier?: string) => string;
701
+ be: (blockSuffix?: string, element?: string) => string;
702
+ em: (element?: string, modifier?: string) => string;
703
+ bm: (blockSuffix?: string, modifier?: string) => string;
704
+ bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
705
+ is: {
706
+ (name: string, state: boolean | undefined): string;
707
+ (name: string): string;
1760
708
  };
1761
- multiple: {
1762
- type: BooleanConstructor;
1763
- default: boolean;
709
+ cssVar: (object: Record<string, string>) => Record<string, string>;
710
+ cssVarName: (name: string) => string;
711
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
712
+ cssVarBlockName: (name: string) => string;
713
+ };
714
+ states: {
715
+ inputValue: string;
716
+ options: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
717
+ cachedOptions: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
718
+ optionValues: (string | number | boolean | Record<string, any>)[];
719
+ selected: {
720
+ value: string | number | boolean | Record<string, any>;
721
+ currentLabel: import('element-plus').SelectOptionProxy["currentLabel"];
722
+ isDisabled?: import('element-plus').SelectOptionProxy["isDisabled"] | undefined;
723
+ }[];
724
+ hoveringIndex: number;
725
+ inputHovering: boolean;
726
+ selectionWidth: number;
727
+ collapseItemWidth: number;
728
+ previousQuery: string | null;
729
+ selectedLabel: string;
730
+ menuVisibleOnFocus: boolean;
731
+ isBeforeHide: boolean;
732
+ };
733
+ isFocused: import('vue').Ref<boolean>;
734
+ expanded: import('vue').Ref<boolean>;
735
+ optionsArray: import('vue').ComputedRef<import('element-plus').SelectOptionProxy[]>;
736
+ hoverOption: import('vue').Ref<any>;
737
+ selectSize: import('vue').ComputedRef<"" | "small" | "default" | "large">;
738
+ filteredOptionsCount: import('vue').ComputedRef<number>;
739
+ updateTooltip: () => void;
740
+ updateTagTooltip: () => void;
741
+ debouncedOnInputChange: import('lodash-es').DebouncedFunc<() => void>;
742
+ onInput: (event: Event) => void;
743
+ deletePrevTag: (e: KeyboardEvent) => void;
744
+ deleteTag: (event: MouseEvent, tag: import('element-plus').SelectOptionProxy | import('element-plus').OptionBasic) => void;
745
+ deleteSelected: (event: Event) => void;
746
+ handleOptionSelect: (option: import('element-plus').SelectOptionProxy) => void;
747
+ scrollToOption: (option: import('element-plus').SelectOptionProxy | import('element-plus').SelectOptionProxy[] | import('element-plus').OptionBasic[]) => void;
748
+ hasModelValue: import('vue').ComputedRef<boolean>;
749
+ shouldShowPlaceholder: import('vue').ComputedRef<boolean>;
750
+ currentPlaceholder: import('vue').ComputedRef<string>;
751
+ mouseEnterEventName: import('vue').ComputedRef<"mouseenter" | null>;
752
+ needStatusIcon: import('vue').ComputedRef<boolean>;
753
+ showClose: import('vue').ComputedRef<boolean>;
754
+ iconComponent: import('vue').ComputedRef<(string | import('vue').Component) | undefined>;
755
+ iconReverse: import('vue').ComputedRef<string>;
756
+ validateState: import('vue').ComputedRef<"" | "error" | "success" | "validating">;
757
+ validateIcon: import('vue').ComputedRef<"" | import('vue').Component>;
758
+ showNewOption: import('vue').ComputedRef<boolean>;
759
+ updateOptions: () => void;
760
+ collapseTagSize: import('vue').ComputedRef<"default" | "small">;
761
+ setSelected: () => void;
762
+ selectDisabled: import('vue').ComputedRef<boolean>;
763
+ emptyText: import('vue').ComputedRef<string | null>;
764
+ handleCompositionStart: (event: CompositionEvent) => void;
765
+ handleCompositionUpdate: (event: CompositionEvent) => void;
766
+ handleCompositionEnd: (event: CompositionEvent) => void;
767
+ onOptionCreate: (vm: import('element-plus').SelectOptionProxy) => void;
768
+ onOptionDestroy: (key: string | number | boolean | Record<string, any>, vm: import('element-plus').SelectOptionProxy) => void;
769
+ handleMenuEnter: () => void;
770
+ focus: () => void;
771
+ blur: () => void;
772
+ handleClearClick: (event: Event) => void;
773
+ handleClickOutside: (event: Event) => void;
774
+ handleEsc: () => void;
775
+ toggleMenu: () => void;
776
+ selectOption: () => void;
777
+ getValueKey: (item: import('element-plus').SelectOptionProxy | import('element-plus').OptionBasic) => any;
778
+ navigateOptions: (direction: "prev" | "next") => void;
779
+ dropdownMenuVisible: import('vue').WritableComputedRef<boolean>;
780
+ showTagList: import('vue').ComputedRef<{
781
+ value: string | number | boolean | Record<string, any>;
782
+ currentLabel: import('element-plus').SelectOptionProxy["currentLabel"];
783
+ isDisabled?: import('element-plus').SelectOptionProxy["isDisabled"] | undefined;
784
+ }[]>;
785
+ collapseTagList: import('vue').ComputedRef<{
786
+ value: string | number | boolean | Record<string, any>;
787
+ currentLabel: import('element-plus').SelectOptionProxy["currentLabel"];
788
+ isDisabled?: import('element-plus').SelectOptionProxy["isDisabled"] | undefined;
789
+ }[]>;
790
+ popupScroll: (data: {
791
+ scrollTop: number;
792
+ scrollLeft: number;
793
+ }) => void;
794
+ tagStyle: import('vue').ComputedRef<{
795
+ maxWidth: string;
796
+ }>;
797
+ collapseTagStyle: import('vue').ComputedRef<{
798
+ maxWidth: string;
799
+ }>;
800
+ popperRef: import('vue').ComputedRef<HTMLElement | undefined>;
801
+ inputRef: import('vue').Ref<HTMLInputElement | undefined>;
802
+ tooltipRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
803
+ tagTooltipRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
804
+ prefixRef: import('vue').Ref<HTMLElement | undefined>;
805
+ suffixRef: import('vue').Ref<HTMLElement | undefined>;
806
+ selectRef: import('vue').Ref<HTMLElement | undefined>;
807
+ wrapperRef: import('vue').ShallowRef<HTMLElement | undefined>;
808
+ selectionRef: import('vue').Ref<HTMLElement | undefined>;
809
+ scrollbarRef: import('vue').Ref<import('element-plus').ScrollbarInstance | undefined>;
810
+ menuRef: import('vue').Ref<HTMLElement | undefined>;
811
+ tagMenuRef: import('vue').Ref<HTMLElement | undefined>;
812
+ collapseItemRef: import('vue').Ref<HTMLElement | undefined>;
813
+ }, {}, {}, {}, {
814
+ disabled: boolean;
815
+ offset: number;
816
+ multiple: boolean;
817
+ loading: boolean;
818
+ modelValue: (string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[];
819
+ placement: any;
820
+ effect: import('element-plus').PopperEffect;
821
+ tabindex: string | number;
822
+ valueOnClear: string | number | boolean | Function;
823
+ autocomplete: string;
824
+ validateEvent: boolean;
825
+ clearable: boolean;
826
+ fallbackPlacements: Placement[];
827
+ popperOptions: Partial<Options>;
828
+ popperClass: string;
829
+ teleported: boolean;
830
+ persistent: boolean;
831
+ showArrow: boolean;
832
+ valueKey: string;
833
+ fitInputWidth: boolean;
834
+ filterable: boolean;
835
+ collapseTags: boolean;
836
+ maxCollapseTags: number;
837
+ collapseTagsTooltip: boolean;
838
+ tagType: "primary" | "success" | "warning" | "info" | "danger";
839
+ tagEffect: "plain" | "dark" | "light";
840
+ automaticDropdown: boolean;
841
+ allowCreate: boolean;
842
+ remote: boolean;
843
+ multipleLimit: number;
844
+ defaultFirstOption: boolean;
845
+ reserveKeyword: boolean;
846
+ remoteShowSuffix: boolean;
847
+ }> | null, import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
848
+ ariaLabel: StringConstructor;
849
+ emptyValues: ArrayConstructor;
850
+ valueOnClear: {
851
+ readonly type: PropType<string | number | boolean | Function>;
852
+ readonly required: false;
853
+ readonly validator: ((val: unknown) => boolean) | undefined;
854
+ __epPropKey: true;
855
+ } & {
856
+ readonly default: undefined;
857
+ };
858
+ name: StringConstructor;
859
+ id: StringConstructor;
860
+ modelValue: {
861
+ readonly type: PropType<(string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[]>;
862
+ readonly required: false;
863
+ readonly validator: ((val: unknown) => boolean) | undefined;
864
+ __epPropKey: true;
865
+ } & {
866
+ readonly default: undefined;
867
+ };
868
+ autocomplete: {
869
+ readonly type: PropType<string>;
870
+ readonly required: false;
871
+ readonly validator: ((val: unknown) => boolean) | undefined;
872
+ __epPropKey: true;
873
+ } & {
874
+ readonly default: string;
875
+ };
876
+ automaticDropdown: BooleanConstructor;
877
+ size: {
878
+ readonly type: PropType<"" | "default" | "small" | "large">;
879
+ readonly required: false;
880
+ readonly validator: ((val: unknown) => boolean) | undefined;
881
+ __epPropKey: true;
882
+ };
883
+ effect: {
884
+ readonly type: PropType<import('element-plus').PopperEffect>;
885
+ readonly required: false;
886
+ readonly validator: ((val: unknown) => boolean) | undefined;
887
+ __epPropKey: true;
888
+ } & {
889
+ readonly default: string;
890
+ };
891
+ disabled: BooleanConstructor;
892
+ clearable: BooleanConstructor;
893
+ filterable: BooleanConstructor;
894
+ allowCreate: BooleanConstructor;
895
+ loading: BooleanConstructor;
896
+ popperClass: {
897
+ readonly type: PropType<string>;
898
+ readonly required: false;
899
+ readonly validator: ((val: unknown) => boolean) | undefined;
900
+ __epPropKey: true;
901
+ } & {
902
+ readonly default: string;
903
+ };
904
+ popperOptions: {
905
+ readonly type: PropType<any>;
906
+ readonly required: false;
907
+ readonly validator: ((val: unknown) => boolean) | undefined;
908
+ __epPropKey: true;
909
+ } & {
910
+ readonly default: () => Partial<Options>;
911
+ };
912
+ remote: BooleanConstructor;
913
+ loadingText: StringConstructor;
914
+ noMatchText: StringConstructor;
915
+ noDataText: StringConstructor;
916
+ remoteMethod: FunctionConstructor;
917
+ filterMethod: FunctionConstructor;
918
+ multiple: BooleanConstructor;
919
+ multipleLimit: {
920
+ readonly type: PropType<number>;
921
+ readonly required: false;
922
+ readonly validator: ((val: unknown) => boolean) | undefined;
923
+ __epPropKey: true;
924
+ } & {
925
+ readonly default: number;
926
+ };
927
+ placeholder: {
928
+ readonly type: PropType<string>;
929
+ readonly required: false;
930
+ readonly validator: ((val: unknown) => boolean) | undefined;
931
+ __epPropKey: true;
932
+ };
933
+ defaultFirstOption: BooleanConstructor;
934
+ reserveKeyword: {
935
+ readonly type: PropType<boolean>;
936
+ readonly required: false;
937
+ readonly validator: ((val: unknown) => boolean) | undefined;
938
+ __epPropKey: true;
939
+ } & {
940
+ readonly default: boolean;
941
+ };
942
+ valueKey: {
943
+ readonly type: PropType<string>;
944
+ readonly required: false;
945
+ readonly validator: ((val: unknown) => boolean) | undefined;
946
+ __epPropKey: true;
947
+ } & {
948
+ readonly default: string;
949
+ };
950
+ collapseTags: BooleanConstructor;
951
+ collapseTagsTooltip: BooleanConstructor;
952
+ maxCollapseTags: {
953
+ readonly type: PropType<number>;
954
+ readonly required: false;
955
+ readonly validator: ((val: unknown) => boolean) | undefined;
956
+ __epPropKey: true;
957
+ } & {
958
+ readonly default: number;
959
+ };
960
+ teleported: {
961
+ readonly type: PropType<boolean>;
962
+ readonly required: false;
963
+ readonly validator: ((val: unknown) => boolean) | undefined;
964
+ __epPropKey: true;
965
+ } & {
966
+ readonly default: true;
967
+ };
968
+ persistent: {
969
+ readonly type: PropType<boolean>;
970
+ readonly required: false;
971
+ readonly validator: ((val: unknown) => boolean) | undefined;
972
+ __epPropKey: true;
973
+ } & {
974
+ readonly default: boolean;
975
+ };
976
+ clearIcon: {
977
+ readonly type: PropType<string | import('vue').Component>;
978
+ readonly required: false;
979
+ readonly validator: ((val: unknown) => boolean) | undefined;
980
+ __epPropKey: true;
981
+ };
982
+ fitInputWidth: BooleanConstructor;
983
+ suffixIcon: {
984
+ readonly type: PropType<string | import('vue').Component>;
985
+ readonly required: false;
986
+ readonly validator: ((val: unknown) => boolean) | undefined;
987
+ __epPropKey: true;
988
+ };
989
+ tagType: {
990
+ default: string;
991
+ type: PropType<"primary" | "success" | "warning" | "info" | "danger">;
992
+ required: false;
993
+ validator: ((val: unknown) => boolean) | undefined;
994
+ __epPropKey: true;
995
+ };
996
+ tagEffect: {
997
+ default: string;
998
+ type: PropType<"plain" | "dark" | "light">;
999
+ required: false;
1000
+ validator: ((val: unknown) => boolean) | undefined;
1001
+ __epPropKey: true;
1002
+ };
1003
+ validateEvent: {
1004
+ readonly type: PropType<boolean>;
1005
+ readonly required: false;
1006
+ readonly validator: ((val: unknown) => boolean) | undefined;
1007
+ __epPropKey: true;
1008
+ } & {
1009
+ readonly default: boolean;
1010
+ };
1011
+ remoteShowSuffix: BooleanConstructor;
1012
+ showArrow: {
1013
+ readonly type: PropType<boolean>;
1014
+ readonly required: false;
1015
+ readonly validator: ((val: unknown) => boolean) | undefined;
1016
+ __epPropKey: true;
1017
+ } & {
1018
+ readonly default: boolean;
1019
+ };
1020
+ offset: {
1021
+ readonly type: PropType<number>;
1022
+ readonly required: false;
1023
+ readonly validator: ((val: unknown) => boolean) | undefined;
1024
+ __epPropKey: true;
1025
+ } & {
1026
+ readonly default: number;
1027
+ };
1028
+ placement: {
1029
+ readonly type: PropType<any>;
1030
+ readonly required: false;
1031
+ readonly validator: ((val: unknown) => boolean) | undefined;
1032
+ __epPropKey: true;
1033
+ } & {
1034
+ readonly default: string;
1035
+ };
1036
+ fallbackPlacements: {
1037
+ readonly type: PropType<Placement[]>;
1038
+ readonly required: false;
1039
+ readonly validator: ((val: unknown) => boolean) | undefined;
1040
+ __epPropKey: true;
1041
+ } & {
1042
+ readonly default: string[];
1043
+ };
1044
+ tabindex: {
1045
+ readonly type: PropType<string | number>;
1046
+ readonly required: false;
1047
+ readonly validator: ((val: unknown) => boolean) | undefined;
1048
+ __epPropKey: true;
1049
+ } & {
1050
+ readonly default: number;
1051
+ };
1052
+ appendTo: {
1053
+ readonly type: PropType<string | HTMLElement>;
1054
+ readonly required: false;
1055
+ readonly validator: ((val: unknown) => boolean) | undefined;
1056
+ __epPropKey: true;
1057
+ };
1058
+ }>> & {
1059
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
1060
+ onChange?: ((...args: any[]) => any) | undefined;
1061
+ onFocus?: ((...args: any[]) => any) | undefined;
1062
+ onBlur?: ((...args: any[]) => any) | undefined;
1063
+ onClear?: ((...args: any[]) => any) | undefined;
1064
+ "onVisible-change"?: ((...args: any[]) => any) | undefined;
1065
+ "onRemove-tag"?: ((...args: any[]) => any) | undefined;
1066
+ "onPopup-scroll"?: ((...args: any[]) => any) | undefined;
1067
+ }, {
1068
+ modelValue: import('vue').ComputedRef<string | number | boolean | any[] | Record<string, any> | undefined>;
1069
+ selectedLabel: import('vue').ComputedRef<string | string[]>;
1070
+ calculatorRef: import('vue').ShallowRef<HTMLElement | undefined>;
1071
+ inputStyle: import('vue').ComputedRef<{
1072
+ minWidth: string;
1073
+ }>;
1074
+ inputId: import('vue').Ref<string | undefined>;
1075
+ contentId: import('vue').Ref<string>;
1076
+ nsSelect: {
1077
+ namespace: import('vue').ComputedRef<string>;
1078
+ b: (blockSuffix?: string) => string;
1079
+ e: (element?: string) => string;
1080
+ m: (modifier?: string) => string;
1081
+ be: (blockSuffix?: string, element?: string) => string;
1082
+ em: (element?: string, modifier?: string) => string;
1083
+ bm: (blockSuffix?: string, modifier?: string) => string;
1084
+ bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
1085
+ is: {
1086
+ (name: string, state: boolean | undefined): string;
1087
+ (name: string): string;
1764
1088
  };
1765
- cssStyle: {
1766
- type: StringConstructor;
1767
- default: string;
1089
+ cssVar: (object: Record<string, string>) => Record<string, string>;
1090
+ cssVarName: (name: string) => string;
1091
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
1092
+ cssVarBlockName: (name: string) => string;
1093
+ };
1094
+ nsInput: {
1095
+ namespace: import('vue').ComputedRef<string>;
1096
+ b: (blockSuffix?: string) => string;
1097
+ e: (element?: string) => string;
1098
+ m: (modifier?: string) => string;
1099
+ be: (blockSuffix?: string, element?: string) => string;
1100
+ em: (element?: string, modifier?: string) => string;
1101
+ bm: (blockSuffix?: string, modifier?: string) => string;
1102
+ bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
1103
+ is: {
1104
+ (name: string, state: boolean | undefined): string;
1105
+ (name: string): string;
1768
1106
  };
1769
- }>
1770
- > &
1771
- Readonly<{
1772
- 'onUpdate:modelValue'?: ((value: any) => any) | undefined;
1773
- }>,
1774
- {
1775
- cssStyle: string;
1776
- modelValue: string | number | unknown[];
1777
- options: SelectOptions[];
1107
+ cssVar: (object: Record<string, string>) => Record<string, string>;
1108
+ cssVarName: (name: string) => string;
1109
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
1110
+ cssVarBlockName: (name: string) => string;
1111
+ };
1112
+ states: {
1113
+ inputValue: string;
1114
+ options: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
1115
+ cachedOptions: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
1116
+ optionValues: (string | number | boolean | Record<string, any>)[];
1117
+ selected: {
1118
+ value: string | number | boolean | Record<string, any>;
1119
+ currentLabel: import('element-plus').SelectOptionProxy["currentLabel"];
1120
+ isDisabled?: import('element-plus').SelectOptionProxy["isDisabled"] | undefined;
1121
+ }[];
1122
+ hoveringIndex: number;
1123
+ inputHovering: boolean;
1124
+ selectionWidth: number;
1125
+ collapseItemWidth: number;
1126
+ previousQuery: string | null;
1127
+ selectedLabel: string;
1128
+ menuVisibleOnFocus: boolean;
1129
+ isBeforeHide: boolean;
1130
+ };
1131
+ isFocused: import('vue').Ref<boolean>;
1132
+ expanded: import('vue').Ref<boolean>;
1133
+ optionsArray: import('vue').ComputedRef<import('element-plus').SelectOptionProxy[]>;
1134
+ hoverOption: import('vue').Ref<any>;
1135
+ selectSize: import('vue').ComputedRef<"" | "small" | "default" | "large">;
1136
+ filteredOptionsCount: import('vue').ComputedRef<number>;
1137
+ updateTooltip: () => void;
1138
+ updateTagTooltip: () => void;
1139
+ debouncedOnInputChange: import('lodash-es').DebouncedFunc<() => void>;
1140
+ onInput: (event: Event) => void;
1141
+ deletePrevTag: (e: KeyboardEvent) => void;
1142
+ deleteTag: (event: MouseEvent, tag: import('element-plus').SelectOptionProxy | import('element-plus').OptionBasic) => void;
1143
+ deleteSelected: (event: Event) => void;
1144
+ handleOptionSelect: (option: import('element-plus').SelectOptionProxy) => void;
1145
+ scrollToOption: (option: import('element-plus').SelectOptionProxy | import('element-plus').SelectOptionProxy[] | import('element-plus').OptionBasic[]) => void;
1146
+ hasModelValue: import('vue').ComputedRef<boolean>;
1147
+ shouldShowPlaceholder: import('vue').ComputedRef<boolean>;
1148
+ currentPlaceholder: import('vue').ComputedRef<string>;
1149
+ mouseEnterEventName: import('vue').ComputedRef<"mouseenter" | null>;
1150
+ needStatusIcon: import('vue').ComputedRef<boolean>;
1151
+ showClose: import('vue').ComputedRef<boolean>;
1152
+ iconComponent: import('vue').ComputedRef<(string | import('vue').Component) | undefined>;
1153
+ iconReverse: import('vue').ComputedRef<string>;
1154
+ validateState: import('vue').ComputedRef<"" | "error" | "success" | "validating">;
1155
+ validateIcon: import('vue').ComputedRef<"" | import('vue').Component>;
1156
+ showNewOption: import('vue').ComputedRef<boolean>;
1157
+ updateOptions: () => void;
1158
+ collapseTagSize: import('vue').ComputedRef<"default" | "small">;
1159
+ setSelected: () => void;
1160
+ selectDisabled: import('vue').ComputedRef<boolean>;
1161
+ emptyText: import('vue').ComputedRef<string | null>;
1162
+ handleCompositionStart: (event: CompositionEvent) => void;
1163
+ handleCompositionUpdate: (event: CompositionEvent) => void;
1164
+ handleCompositionEnd: (event: CompositionEvent) => void;
1165
+ onOptionCreate: (vm: import('element-plus').SelectOptionProxy) => void;
1166
+ onOptionDestroy: (key: string | number | boolean | Record<string, any>, vm: import('element-plus').SelectOptionProxy) => void;
1167
+ handleMenuEnter: () => void;
1168
+ focus: () => void;
1169
+ blur: () => void;
1170
+ handleClearClick: (event: Event) => void;
1171
+ handleClickOutside: (event: Event) => void;
1172
+ handleEsc: () => void;
1173
+ toggleMenu: () => void;
1174
+ selectOption: () => void;
1175
+ getValueKey: (item: import('element-plus').SelectOptionProxy | import('element-plus').OptionBasic) => any;
1176
+ navigateOptions: (direction: "prev" | "next") => void;
1177
+ dropdownMenuVisible: import('vue').WritableComputedRef<boolean>;
1178
+ showTagList: import('vue').ComputedRef<{
1179
+ value: string | number | boolean | Record<string, any>;
1180
+ currentLabel: import('element-plus').SelectOptionProxy["currentLabel"];
1181
+ isDisabled?: import('element-plus').SelectOptionProxy["isDisabled"] | undefined;
1182
+ }[]>;
1183
+ collapseTagList: import('vue').ComputedRef<{
1184
+ value: string | number | boolean | Record<string, any>;
1185
+ currentLabel: import('element-plus').SelectOptionProxy["currentLabel"];
1186
+ isDisabled?: import('element-plus').SelectOptionProxy["isDisabled"] | undefined;
1187
+ }[]>;
1188
+ popupScroll: (data: {
1189
+ scrollTop: number;
1190
+ scrollLeft: number;
1191
+ }) => void;
1192
+ tagStyle: import('vue').ComputedRef<{
1193
+ maxWidth: string;
1194
+ }>;
1195
+ collapseTagStyle: import('vue').ComputedRef<{
1196
+ maxWidth: string;
1197
+ }>;
1198
+ popperRef: import('vue').ComputedRef<HTMLElement | undefined>;
1199
+ inputRef: import('vue').Ref<HTMLInputElement | undefined>;
1200
+ tooltipRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
1201
+ tagTooltipRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
1202
+ prefixRef: import('vue').Ref<HTMLElement | undefined>;
1203
+ suffixRef: import('vue').Ref<HTMLElement | undefined>;
1204
+ selectRef: import('vue').Ref<HTMLElement | undefined>;
1205
+ wrapperRef: import('vue').ShallowRef<HTMLElement | undefined>;
1206
+ selectionRef: import('vue').Ref<HTMLElement | undefined>;
1207
+ scrollbarRef: import('vue').Ref<import('element-plus').ScrollbarInstance | undefined>;
1208
+ menuRef: import('vue').Ref<HTMLElement | undefined>;
1209
+ tagMenuRef: import('vue').Ref<HTMLElement | undefined>;
1210
+ collapseItemRef: import('vue').Ref<HTMLElement | undefined>;
1211
+ }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("blur" | "change" | "focus" | "clear" | "update:modelValue" | "visible-change" | "remove-tag" | "popup-scroll")[], import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
1212
+ disabled: boolean;
1213
+ offset: number;
1214
+ multiple: boolean;
1215
+ loading: boolean;
1216
+ modelValue: (string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[];
1217
+ placement: any;
1218
+ effect: import('element-plus').PopperEffect;
1219
+ tabindex: string | number;
1220
+ valueOnClear: string | number | boolean | Function;
1221
+ autocomplete: string;
1222
+ validateEvent: boolean;
1778
1223
  clearable: boolean;
1224
+ fallbackPlacements: Placement[];
1225
+ popperOptions: Partial<Options>;
1226
+ popperClass: string;
1227
+ teleported: boolean;
1228
+ persistent: boolean;
1229
+ showArrow: boolean;
1230
+ valueKey: string;
1231
+ fitInputWidth: boolean;
1232
+ filterable: boolean;
1779
1233
  collapseTags: boolean;
1234
+ maxCollapseTags: number;
1235
+ collapseTagsTooltip: boolean;
1236
+ tagType: "primary" | "success" | "warning" | "info" | "danger";
1237
+ tagEffect: "plain" | "dark" | "light";
1238
+ automaticDropdown: boolean;
1239
+ allowCreate: boolean;
1240
+ remote: boolean;
1241
+ multipleLimit: number;
1242
+ defaultFirstOption: boolean;
1243
+ reserveKeyword: boolean;
1244
+ remoteShowSuffix: boolean;
1245
+ }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
1246
+ P: {};
1247
+ B: {};
1248
+ D: {};
1249
+ C: {};
1250
+ M: {};
1251
+ Defaults: {};
1252
+ }, Readonly<import('vue').ExtractPropTypes<{
1253
+ ariaLabel: StringConstructor;
1254
+ emptyValues: ArrayConstructor;
1255
+ valueOnClear: {
1256
+ readonly type: PropType<string | number | boolean | Function>;
1257
+ readonly required: false;
1258
+ readonly validator: ((val: unknown) => boolean) | undefined;
1259
+ __epPropKey: true;
1260
+ } & {
1261
+ readonly default: undefined;
1262
+ };
1263
+ name: StringConstructor;
1264
+ id: StringConstructor;
1265
+ modelValue: {
1266
+ readonly type: PropType<(string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[]>;
1267
+ readonly required: false;
1268
+ readonly validator: ((val: unknown) => boolean) | undefined;
1269
+ __epPropKey: true;
1270
+ } & {
1271
+ readonly default: undefined;
1272
+ };
1273
+ autocomplete: {
1274
+ readonly type: PropType<string>;
1275
+ readonly required: false;
1276
+ readonly validator: ((val: unknown) => boolean) | undefined;
1277
+ __epPropKey: true;
1278
+ } & {
1279
+ readonly default: string;
1280
+ };
1281
+ automaticDropdown: BooleanConstructor;
1282
+ size: {
1283
+ readonly type: PropType<"" | "default" | "small" | "large">;
1284
+ readonly required: false;
1285
+ readonly validator: ((val: unknown) => boolean) | undefined;
1286
+ __epPropKey: true;
1287
+ };
1288
+ effect: {
1289
+ readonly type: PropType<import('element-plus').PopperEffect>;
1290
+ readonly required: false;
1291
+ readonly validator: ((val: unknown) => boolean) | undefined;
1292
+ __epPropKey: true;
1293
+ } & {
1294
+ readonly default: string;
1295
+ };
1296
+ disabled: BooleanConstructor;
1297
+ clearable: BooleanConstructor;
1298
+ filterable: BooleanConstructor;
1299
+ allowCreate: BooleanConstructor;
1300
+ loading: BooleanConstructor;
1301
+ popperClass: {
1302
+ readonly type: PropType<string>;
1303
+ readonly required: false;
1304
+ readonly validator: ((val: unknown) => boolean) | undefined;
1305
+ __epPropKey: true;
1306
+ } & {
1307
+ readonly default: string;
1308
+ };
1309
+ popperOptions: {
1310
+ readonly type: PropType<any>;
1311
+ readonly required: false;
1312
+ readonly validator: ((val: unknown) => boolean) | undefined;
1313
+ __epPropKey: true;
1314
+ } & {
1315
+ readonly default: () => Partial<Options>;
1316
+ };
1317
+ remote: BooleanConstructor;
1318
+ loadingText: StringConstructor;
1319
+ noMatchText: StringConstructor;
1320
+ noDataText: StringConstructor;
1321
+ remoteMethod: FunctionConstructor;
1322
+ filterMethod: FunctionConstructor;
1323
+ multiple: BooleanConstructor;
1324
+ multipleLimit: {
1325
+ readonly type: PropType<number>;
1326
+ readonly required: false;
1327
+ readonly validator: ((val: unknown) => boolean) | undefined;
1328
+ __epPropKey: true;
1329
+ } & {
1330
+ readonly default: number;
1331
+ };
1332
+ placeholder: {
1333
+ readonly type: PropType<string>;
1334
+ readonly required: false;
1335
+ readonly validator: ((val: unknown) => boolean) | undefined;
1336
+ __epPropKey: true;
1337
+ };
1338
+ defaultFirstOption: BooleanConstructor;
1339
+ reserveKeyword: {
1340
+ readonly type: PropType<boolean>;
1341
+ readonly required: false;
1342
+ readonly validator: ((val: unknown) => boolean) | undefined;
1343
+ __epPropKey: true;
1344
+ } & {
1345
+ readonly default: boolean;
1346
+ };
1347
+ valueKey: {
1348
+ readonly type: PropType<string>;
1349
+ readonly required: false;
1350
+ readonly validator: ((val: unknown) => boolean) | undefined;
1351
+ __epPropKey: true;
1352
+ } & {
1353
+ readonly default: string;
1354
+ };
1355
+ collapseTags: BooleanConstructor;
1356
+ collapseTagsTooltip: BooleanConstructor;
1357
+ maxCollapseTags: {
1358
+ readonly type: PropType<number>;
1359
+ readonly required: false;
1360
+ readonly validator: ((val: unknown) => boolean) | undefined;
1361
+ __epPropKey: true;
1362
+ } & {
1363
+ readonly default: number;
1364
+ };
1365
+ teleported: {
1366
+ readonly type: PropType<boolean>;
1367
+ readonly required: false;
1368
+ readonly validator: ((val: unknown) => boolean) | undefined;
1369
+ __epPropKey: true;
1370
+ } & {
1371
+ readonly default: true;
1372
+ };
1373
+ persistent: {
1374
+ readonly type: PropType<boolean>;
1375
+ readonly required: false;
1376
+ readonly validator: ((val: unknown) => boolean) | undefined;
1377
+ __epPropKey: true;
1378
+ } & {
1379
+ readonly default: boolean;
1380
+ };
1381
+ clearIcon: {
1382
+ readonly type: PropType<string | import('vue').Component>;
1383
+ readonly required: false;
1384
+ readonly validator: ((val: unknown) => boolean) | undefined;
1385
+ __epPropKey: true;
1386
+ };
1387
+ fitInputWidth: BooleanConstructor;
1388
+ suffixIcon: {
1389
+ readonly type: PropType<string | import('vue').Component>;
1390
+ readonly required: false;
1391
+ readonly validator: ((val: unknown) => boolean) | undefined;
1392
+ __epPropKey: true;
1393
+ };
1394
+ tagType: {
1395
+ default: string;
1396
+ type: PropType<"primary" | "success" | "warning" | "info" | "danger">;
1397
+ required: false;
1398
+ validator: ((val: unknown) => boolean) | undefined;
1399
+ __epPropKey: true;
1400
+ };
1401
+ tagEffect: {
1402
+ default: string;
1403
+ type: PropType<"plain" | "dark" | "light">;
1404
+ required: false;
1405
+ validator: ((val: unknown) => boolean) | undefined;
1406
+ __epPropKey: true;
1407
+ };
1408
+ validateEvent: {
1409
+ readonly type: PropType<boolean>;
1410
+ readonly required: false;
1411
+ readonly validator: ((val: unknown) => boolean) | undefined;
1412
+ __epPropKey: true;
1413
+ } & {
1414
+ readonly default: boolean;
1415
+ };
1416
+ remoteShowSuffix: BooleanConstructor;
1417
+ showArrow: {
1418
+ readonly type: PropType<boolean>;
1419
+ readonly required: false;
1420
+ readonly validator: ((val: unknown) => boolean) | undefined;
1421
+ __epPropKey: true;
1422
+ } & {
1423
+ readonly default: boolean;
1424
+ };
1425
+ offset: {
1426
+ readonly type: PropType<number>;
1427
+ readonly required: false;
1428
+ readonly validator: ((val: unknown) => boolean) | undefined;
1429
+ __epPropKey: true;
1430
+ } & {
1431
+ readonly default: number;
1432
+ };
1433
+ placement: {
1434
+ readonly type: PropType<any>;
1435
+ readonly required: false;
1436
+ readonly validator: ((val: unknown) => boolean) | undefined;
1437
+ __epPropKey: true;
1438
+ } & {
1439
+ readonly default: string;
1440
+ };
1441
+ fallbackPlacements: {
1442
+ readonly type: PropType<Placement[]>;
1443
+ readonly required: false;
1444
+ readonly validator: ((val: unknown) => boolean) | undefined;
1445
+ __epPropKey: true;
1446
+ } & {
1447
+ readonly default: string[];
1448
+ };
1449
+ tabindex: {
1450
+ readonly type: PropType<string | number>;
1451
+ readonly required: false;
1452
+ readonly validator: ((val: unknown) => boolean) | undefined;
1453
+ __epPropKey: true;
1454
+ } & {
1455
+ readonly default: number;
1456
+ };
1457
+ appendTo: {
1458
+ readonly type: PropType<string | HTMLElement>;
1459
+ readonly required: false;
1460
+ readonly validator: ((val: unknown) => boolean) | undefined;
1461
+ __epPropKey: true;
1462
+ };
1463
+ }>> & {
1464
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
1465
+ onChange?: ((...args: any[]) => any) | undefined;
1466
+ onFocus?: ((...args: any[]) => any) | undefined;
1467
+ onBlur?: ((...args: any[]) => any) | undefined;
1468
+ onClear?: ((...args: any[]) => any) | undefined;
1469
+ "onVisible-change"?: ((...args: any[]) => any) | undefined;
1470
+ "onRemove-tag"?: ((...args: any[]) => any) | undefined;
1471
+ "onPopup-scroll"?: ((...args: any[]) => any) | undefined;
1472
+ }, {
1473
+ modelValue: import('vue').ComputedRef<string | number | boolean | any[] | Record<string, any> | undefined>;
1474
+ selectedLabel: import('vue').ComputedRef<string | string[]>;
1475
+ calculatorRef: import('vue').ShallowRef<HTMLElement | undefined>;
1476
+ inputStyle: import('vue').ComputedRef<{
1477
+ minWidth: string;
1478
+ }>;
1479
+ inputId: import('vue').Ref<string | undefined>;
1480
+ contentId: import('vue').Ref<string>;
1481
+ nsSelect: {
1482
+ namespace: import('vue').ComputedRef<string>;
1483
+ b: (blockSuffix?: string) => string;
1484
+ e: (element?: string) => string;
1485
+ m: (modifier?: string) => string;
1486
+ be: (blockSuffix?: string, element?: string) => string;
1487
+ em: (element?: string, modifier?: string) => string;
1488
+ bm: (blockSuffix?: string, modifier?: string) => string;
1489
+ bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
1490
+ is: {
1491
+ (name: string, state: boolean | undefined): string;
1492
+ (name: string): string;
1493
+ };
1494
+ cssVar: (object: Record<string, string>) => Record<string, string>;
1495
+ cssVarName: (name: string) => string;
1496
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
1497
+ cssVarBlockName: (name: string) => string;
1498
+ };
1499
+ nsInput: {
1500
+ namespace: import('vue').ComputedRef<string>;
1501
+ b: (blockSuffix?: string) => string;
1502
+ e: (element?: string) => string;
1503
+ m: (modifier?: string) => string;
1504
+ be: (blockSuffix?: string, element?: string) => string;
1505
+ em: (element?: string, modifier?: string) => string;
1506
+ bm: (blockSuffix?: string, modifier?: string) => string;
1507
+ bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
1508
+ is: {
1509
+ (name: string, state: boolean | undefined): string;
1510
+ (name: string): string;
1511
+ };
1512
+ cssVar: (object: Record<string, string>) => Record<string, string>;
1513
+ cssVarName: (name: string) => string;
1514
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
1515
+ cssVarBlockName: (name: string) => string;
1516
+ };
1517
+ states: {
1518
+ inputValue: string;
1519
+ options: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
1520
+ cachedOptions: Map<string | number | boolean | Record<string, any>, import('element-plus').SelectOptionProxy>;
1521
+ optionValues: (string | number | boolean | Record<string, any>)[];
1522
+ selected: {
1523
+ value: string | number | boolean | Record<string, any>;
1524
+ currentLabel: import('element-plus').SelectOptionProxy["currentLabel"];
1525
+ isDisabled?: import('element-plus').SelectOptionProxy["isDisabled"] | undefined;
1526
+ }[];
1527
+ hoveringIndex: number;
1528
+ inputHovering: boolean;
1529
+ selectionWidth: number;
1530
+ collapseItemWidth: number;
1531
+ previousQuery: string | null;
1532
+ selectedLabel: string;
1533
+ menuVisibleOnFocus: boolean;
1534
+ isBeforeHide: boolean;
1535
+ };
1536
+ isFocused: import('vue').Ref<boolean>;
1537
+ expanded: import('vue').Ref<boolean>;
1538
+ optionsArray: import('vue').ComputedRef<import('element-plus').SelectOptionProxy[]>;
1539
+ hoverOption: import('vue').Ref<any>;
1540
+ selectSize: import('vue').ComputedRef<"" | "small" | "default" | "large">;
1541
+ filteredOptionsCount: import('vue').ComputedRef<number>;
1542
+ updateTooltip: () => void;
1543
+ updateTagTooltip: () => void;
1544
+ debouncedOnInputChange: import('lodash-es').DebouncedFunc<() => void>;
1545
+ onInput: (event: Event) => void;
1546
+ deletePrevTag: (e: KeyboardEvent) => void;
1547
+ deleteTag: (event: MouseEvent, tag: import('element-plus').SelectOptionProxy | import('element-plus').OptionBasic) => void;
1548
+ deleteSelected: (event: Event) => void;
1549
+ handleOptionSelect: (option: import('element-plus').SelectOptionProxy) => void;
1550
+ scrollToOption: (option: import('element-plus').SelectOptionProxy | import('element-plus').SelectOptionProxy[] | import('element-plus').OptionBasic[]) => void;
1551
+ hasModelValue: import('vue').ComputedRef<boolean>;
1552
+ shouldShowPlaceholder: import('vue').ComputedRef<boolean>;
1553
+ currentPlaceholder: import('vue').ComputedRef<string>;
1554
+ mouseEnterEventName: import('vue').ComputedRef<"mouseenter" | null>;
1555
+ needStatusIcon: import('vue').ComputedRef<boolean>;
1556
+ showClose: import('vue').ComputedRef<boolean>;
1557
+ iconComponent: import('vue').ComputedRef<(string | import('vue').Component) | undefined>;
1558
+ iconReverse: import('vue').ComputedRef<string>;
1559
+ validateState: import('vue').ComputedRef<"" | "error" | "success" | "validating">;
1560
+ validateIcon: import('vue').ComputedRef<"" | import('vue').Component>;
1561
+ showNewOption: import('vue').ComputedRef<boolean>;
1562
+ updateOptions: () => void;
1563
+ collapseTagSize: import('vue').ComputedRef<"default" | "small">;
1564
+ setSelected: () => void;
1565
+ selectDisabled: import('vue').ComputedRef<boolean>;
1566
+ emptyText: import('vue').ComputedRef<string | null>;
1567
+ handleCompositionStart: (event: CompositionEvent) => void;
1568
+ handleCompositionUpdate: (event: CompositionEvent) => void;
1569
+ handleCompositionEnd: (event: CompositionEvent) => void;
1570
+ onOptionCreate: (vm: import('element-plus').SelectOptionProxy) => void;
1571
+ onOptionDestroy: (key: string | number | boolean | Record<string, any>, vm: import('element-plus').SelectOptionProxy) => void;
1572
+ handleMenuEnter: () => void;
1573
+ focus: () => void;
1574
+ blur: () => void;
1575
+ handleClearClick: (event: Event) => void;
1576
+ handleClickOutside: (event: Event) => void;
1577
+ handleEsc: () => void;
1578
+ toggleMenu: () => void;
1579
+ selectOption: () => void;
1580
+ getValueKey: (item: import('element-plus').SelectOptionProxy | import('element-plus').OptionBasic) => any;
1581
+ navigateOptions: (direction: "prev" | "next") => void;
1582
+ dropdownMenuVisible: import('vue').WritableComputedRef<boolean>;
1583
+ showTagList: import('vue').ComputedRef<{
1584
+ value: string | number | boolean | Record<string, any>;
1585
+ currentLabel: import('element-plus').SelectOptionProxy["currentLabel"];
1586
+ isDisabled?: import('element-plus').SelectOptionProxy["isDisabled"] | undefined;
1587
+ }[]>;
1588
+ collapseTagList: import('vue').ComputedRef<{
1589
+ value: string | number | boolean | Record<string, any>;
1590
+ currentLabel: import('element-plus').SelectOptionProxy["currentLabel"];
1591
+ isDisabled?: import('element-plus').SelectOptionProxy["isDisabled"] | undefined;
1592
+ }[]>;
1593
+ popupScroll: (data: {
1594
+ scrollTop: number;
1595
+ scrollLeft: number;
1596
+ }) => void;
1597
+ tagStyle: import('vue').ComputedRef<{
1598
+ maxWidth: string;
1599
+ }>;
1600
+ collapseTagStyle: import('vue').ComputedRef<{
1601
+ maxWidth: string;
1602
+ }>;
1603
+ popperRef: import('vue').ComputedRef<HTMLElement | undefined>;
1604
+ inputRef: import('vue').Ref<HTMLInputElement | undefined>;
1605
+ tooltipRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
1606
+ tagTooltipRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
1607
+ prefixRef: import('vue').Ref<HTMLElement | undefined>;
1608
+ suffixRef: import('vue').Ref<HTMLElement | undefined>;
1609
+ selectRef: import('vue').Ref<HTMLElement | undefined>;
1610
+ wrapperRef: import('vue').ShallowRef<HTMLElement | undefined>;
1611
+ selectionRef: import('vue').Ref<HTMLElement | undefined>;
1612
+ scrollbarRef: import('vue').Ref<import('element-plus').ScrollbarInstance | undefined>;
1613
+ menuRef: import('vue').Ref<HTMLElement | undefined>;
1614
+ tagMenuRef: import('vue').Ref<HTMLElement | undefined>;
1615
+ collapseItemRef: import('vue').Ref<HTMLElement | undefined>;
1616
+ }, {}, {}, {}, {
1617
+ disabled: boolean;
1618
+ offset: number;
1780
1619
  multiple: boolean;
1781
- },
1782
- {},
1783
- {},
1784
- {},
1785
- string,
1786
- import('vue').ComponentProvideOptions,
1787
- true,
1788
- {
1789
- componentRef: unknown;
1790
- },
1791
- any
1792
- >;
1793
- declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult['slots']>;
1620
+ loading: boolean;
1621
+ modelValue: (string | number | boolean | Record<string, any>) | (string | number | boolean | Record<string, any>)[];
1622
+ placement: any;
1623
+ effect: import('element-plus').PopperEffect;
1624
+ tabindex: string | number;
1625
+ valueOnClear: string | number | boolean | Function;
1626
+ autocomplete: string;
1627
+ validateEvent: boolean;
1628
+ clearable: boolean;
1629
+ fallbackPlacements: Placement[];
1630
+ popperOptions: Partial<Options>;
1631
+ popperClass: string;
1632
+ teleported: boolean;
1633
+ persistent: boolean;
1634
+ showArrow: boolean;
1635
+ valueKey: string;
1636
+ fitInputWidth: boolean;
1637
+ filterable: boolean;
1638
+ collapseTags: boolean;
1639
+ maxCollapseTags: number;
1640
+ collapseTagsTooltip: boolean;
1641
+ tagType: "primary" | "success" | "warning" | "info" | "danger";
1642
+ tagEffect: "plain" | "dark" | "light";
1643
+ automaticDropdown: boolean;
1644
+ allowCreate: boolean;
1645
+ remote: boolean;
1646
+ multipleLimit: number;
1647
+ defaultFirstOption: boolean;
1648
+ reserveKeyword: boolean;
1649
+ remoteShowSuffix: boolean;
1650
+ }> | null>;
1651
+ }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
1652
+ "update:modelValue": (value: any) => any;
1653
+ }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
1654
+ modelValue: {
1655
+ type: (NumberConstructor | StringConstructor | ArrayConstructor)[];
1656
+ default: string;
1657
+ };
1658
+ options: {
1659
+ type: PropType<SelectOptions[]>;
1660
+ default: () => never[];
1661
+ };
1662
+ collapseTags: {
1663
+ type: BooleanConstructor;
1664
+ default: boolean;
1665
+ };
1666
+ clearable: {
1667
+ type: BooleanConstructor;
1668
+ default: boolean;
1669
+ };
1670
+ multiple: {
1671
+ type: BooleanConstructor;
1672
+ default: boolean;
1673
+ };
1674
+ cssStyle: {
1675
+ type: StringConstructor;
1676
+ default: string;
1677
+ };
1678
+ }>> & Readonly<{
1679
+ "onUpdate:modelValue"?: ((value: any) => any) | undefined;
1680
+ }>, {
1681
+ cssStyle: string;
1682
+ modelValue: string | number | unknown[];
1683
+ options: SelectOptions[];
1684
+ clearable: boolean;
1685
+ collapseTags: boolean;
1686
+ multiple: boolean;
1687
+ }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
1688
+ componentRef: unknown;
1689
+ }, any>;
1690
+ declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
1794
1691
  export default _default;
1795
1692
  type __VLS_WithTemplateSlots<T, S> = T & {
1796
1693
  new (): {