ra-element 0.1.56 → 0.1.63

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 (19) hide show
  1. package/docs/ra-form.md +2 -1
  2. package/lib/components/ra-button/index.vue.d.ts +105 -195
  3. package/lib/components/ra-checkbox-group/index.vue.d.ts +92 -148
  4. package/lib/components/ra-date-picker/index.vue.d.ts +282 -264
  5. package/lib/components/ra-dialog/index.vue.d.ts +163 -321
  6. package/lib/components/ra-input/index.vue.d.ts +173 -329
  7. package/lib/components/ra-pagination/index.vue.d.ts +107 -119
  8. package/lib/components/ra-radio-group/index.vue.d.ts +82 -154
  9. package/lib/components/ra-table/component/table-column-item.vue.d.ts +1 -6
  10. package/lib/components/ra-textarea/index.vue.d.ts +912 -2
  11. package/lib/components/ra-tool-tip/index.vue.d.ts +2426 -3
  12. package/lib/components/ra-tree-select/index.vue.d.ts +98 -96
  13. package/lib/components/ra-upload/index.vue.d.ts +385 -15
  14. package/lib/ra-element.css +1 -1
  15. package/lib/ra-element.es.js +1712 -1655
  16. package/lib/ra-element.es.js.map +1 -1
  17. package/lib/ra-element.umd.js +1 -1
  18. package/lib/ra-element.umd.js.map +1 -1
  19. package/package.json +1 -1
package/lib/components/ra-tool-tip/index.vue.d.ts CHANGED
@@ -4,7 +4,902 @@ declare function __VLS_template(): {
4
4
  default?(_: {}): any;
5
5
  content?(_: {}): any;
6
6
  };
7
- refs: {};
7
+ refs: {
8
+ componentRef: ({
9
+ $: import('vue').ComponentInternalInstance;
10
+ $data: {};
11
+ $props: Partial<{
12
+ disabled: boolean;
13
+ content: string;
14
+ offset: number;
15
+ visible: boolean | null;
16
+ open: boolean;
17
+ placement: string;
18
+ strategy: "fixed" | "absolute";
19
+ effect: import('element-plus').PopperEffect;
20
+ showAfter: number;
21
+ hideAfter: number;
22
+ autoClose: number;
23
+ role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
24
+ trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
25
+ virtualTriggering: boolean;
26
+ arrowOffset: number;
27
+ boundariesPadding: number;
28
+ fallbackPlacements: Placement[];
29
+ gpuAcceleration: boolean;
30
+ popperOptions: Partial<Options>;
31
+ enterable: boolean;
32
+ stopPopperMouseEvent: boolean;
33
+ pure: boolean;
34
+ focusOnShow: boolean;
35
+ trapping: boolean;
36
+ triggerKeys: string[];
37
+ focusOnTarget: boolean;
38
+ teleported: boolean;
39
+ rawContent: boolean;
40
+ persistent: boolean;
41
+ showArrow: boolean;
42
+ }> & Omit<{
43
+ readonly disabled: boolean;
44
+ readonly visible: boolean | null;
45
+ readonly placement: string;
46
+ readonly popperOptions: any;
47
+ readonly open: boolean;
48
+ readonly effect: import('element-plus').PopperEffect;
49
+ readonly teleported: boolean;
50
+ readonly persistent: boolean;
51
+ readonly showArrow: boolean;
52
+ readonly offset: number;
53
+ readonly arrowOffset: number;
54
+ readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
55
+ readonly triggerKeys: string[];
56
+ readonly focusOnTarget: boolean;
57
+ readonly virtualTriggering: boolean;
58
+ readonly content: string;
59
+ readonly rawContent: boolean;
60
+ readonly enterable: boolean;
61
+ readonly pure: boolean;
62
+ readonly focusOnShow: boolean;
63
+ readonly trapping: boolean;
64
+ readonly stopPopperMouseEvent: boolean;
65
+ readonly boundariesPadding: number;
66
+ readonly gpuAcceleration: boolean;
67
+ readonly strategy: "fixed" | "absolute";
68
+ readonly showAfter: number;
69
+ readonly hideAfter: number;
70
+ readonly autoClose: number;
71
+ readonly role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
72
+ readonly style?: import('vue').StyleValue;
73
+ readonly onFocus?: ((e: Event) => void) | undefined;
74
+ readonly onBlur?: ((e: Event) => void) | undefined;
75
+ readonly onKeydown?: ((e: Event) => void) | undefined;
76
+ readonly onMouseenter?: ((e: Event) => void) | undefined;
77
+ readonly onMouseleave?: ((e: Event) => void) | undefined;
78
+ readonly onClick?: ((e: Event) => void) | undefined;
79
+ readonly onContextmenu?: ((e: Event) => void) | undefined;
80
+ readonly transition?: string | undefined;
81
+ readonly className?: (string | {
82
+ [x: string]: boolean;
83
+ } | (string | {
84
+ [x: string]: boolean;
85
+ } | (string | {
86
+ [x: string]: boolean;
87
+ } | (string | {
88
+ [x: string]: boolean;
89
+ } | (string | {
90
+ [x: string]: boolean;
91
+ } | (string | {
92
+ [x: string]: boolean;
93
+ } | (string | {
94
+ [x: string]: boolean;
95
+ } | (string | {
96
+ [x: string]: boolean;
97
+ } | (string | {
98
+ [x: string]: boolean;
99
+ } | (string | {
100
+ [x: string]: boolean;
101
+ } | (string | any[] | {
102
+ [x: string]: boolean;
103
+ })[])[])[])[])[])[])[])[])[])[]) | undefined;
104
+ readonly id?: string | undefined;
105
+ readonly ariaLabel?: string | undefined;
106
+ readonly fallbackPlacements?: Placement[] | undefined;
107
+ readonly popperClass?: (string | {
108
+ [x: string]: boolean;
109
+ } | (string | {
110
+ [x: string]: boolean;
111
+ } | (string | {
112
+ [x: string]: boolean;
113
+ } | (string | {
114
+ [x: string]: boolean;
115
+ } | (string | {
116
+ [x: string]: boolean;
117
+ } | (string | {
118
+ [x: string]: boolean;
119
+ } | (string | {
120
+ [x: string]: boolean;
121
+ } | (string | {
122
+ [x: string]: boolean;
123
+ } | (string | {
124
+ [x: string]: boolean;
125
+ } | (string | {
126
+ [x: string]: boolean;
127
+ } | (string | any[] | {
128
+ [x: string]: boolean;
129
+ })[])[])[])[])[])[])[])[])[])[]) | undefined;
130
+ readonly popperStyle?: import('vue').StyleValue;
131
+ readonly appendTo?: (string | HTMLElement) | undefined;
132
+ readonly zIndex?: number | undefined;
133
+ readonly virtualRef?: import('element-plus').Measurable | undefined;
134
+ readonly referenceEl?: HTMLElement | undefined;
135
+ readonly triggerTargetEl?: HTMLElement | undefined;
136
+ readonly "onUpdate:visible"?: ((val: boolean) => void) | undefined;
137
+ } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "visible" | "placement" | "fallbackPlacements" | "popperOptions" | "open" | "effect" | "teleported" | "persistent" | "showArrow" | "offset" | "arrowOffset" | "trigger" | "triggerKeys" | "focusOnTarget" | "virtualTriggering" | "content" | "rawContent" | "enterable" | "pure" | "focusOnShow" | "trapping" | "stopPopperMouseEvent" | "boundariesPadding" | "gpuAcceleration" | "strategy" | "showAfter" | "hideAfter" | "autoClose" | "role">;
138
+ $attrs: {
139
+ [x: string]: unknown;
140
+ };
141
+ $refs: {
142
+ [x: string]: unknown;
143
+ };
144
+ $slots: Readonly<{
145
+ [name: string]: import('vue').Slot<any> | undefined;
146
+ }>;
147
+ $root: import('vue').ComponentPublicInstance | null;
148
+ $parent: import('vue').ComponentPublicInstance | null;
149
+ $host: Element | null;
150
+ $emit: (event: string, ...args: any[]) => void;
151
+ $el: any;
152
+ $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
153
+ showArrow: {
154
+ readonly type: import('vue').PropType<boolean>;
155
+ readonly required: false;
156
+ readonly validator: ((val: unknown) => boolean) | undefined;
157
+ __epPropKey: true;
158
+ } & {
159
+ readonly default: boolean;
160
+ };
161
+ arrowOffset: {
162
+ readonly type: import('vue').PropType<number>;
163
+ readonly required: false;
164
+ readonly validator: ((val: unknown) => boolean) | undefined;
165
+ __epPropKey: true;
166
+ } & {
167
+ readonly default: 5;
168
+ };
169
+ disabled: BooleanConstructor;
170
+ trigger: {
171
+ readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
172
+ readonly required: false;
173
+ readonly validator: ((val: unknown) => boolean) | undefined;
174
+ __epPropKey: true;
175
+ } & {
176
+ readonly default: "hover";
177
+ };
178
+ triggerKeys: {
179
+ readonly type: import('vue').PropType<string[]>;
180
+ readonly required: false;
181
+ readonly validator: ((val: unknown) => boolean) | undefined;
182
+ __epPropKey: true;
183
+ } & {
184
+ readonly default: () => string[];
185
+ };
186
+ focusOnTarget: BooleanConstructor;
187
+ virtualRef: {
188
+ readonly type: import('vue').PropType<import('element-plus').Measurable>;
189
+ readonly required: false;
190
+ readonly validator: ((val: unknown) => boolean) | undefined;
191
+ __epPropKey: true;
192
+ };
193
+ virtualTriggering: BooleanConstructor;
194
+ onMouseenter: {
195
+ readonly type: import('vue').PropType<(e: Event) => void>;
196
+ readonly required: false;
197
+ readonly validator: ((val: unknown) => boolean) | undefined;
198
+ __epPropKey: true;
199
+ };
200
+ onMouseleave: {
201
+ readonly type: import('vue').PropType<(e: Event) => void>;
202
+ readonly required: false;
203
+ readonly validator: ((val: unknown) => boolean) | undefined;
204
+ __epPropKey: true;
205
+ };
206
+ onClick: {
207
+ readonly type: import('vue').PropType<(e: Event) => void>;
208
+ readonly required: false;
209
+ readonly validator: ((val: unknown) => boolean) | undefined;
210
+ __epPropKey: true;
211
+ };
212
+ onKeydown: {
213
+ readonly type: import('vue').PropType<(e: Event) => void>;
214
+ readonly required: false;
215
+ readonly validator: ((val: unknown) => boolean) | undefined;
216
+ __epPropKey: true;
217
+ };
218
+ onFocus: {
219
+ readonly type: import('vue').PropType<(e: Event) => void>;
220
+ readonly required: false;
221
+ readonly validator: ((val: unknown) => boolean) | undefined;
222
+ __epPropKey: true;
223
+ };
224
+ onBlur: {
225
+ readonly type: import('vue').PropType<(e: Event) => void>;
226
+ readonly required: false;
227
+ readonly validator: ((val: unknown) => boolean) | undefined;
228
+ __epPropKey: true;
229
+ };
230
+ onContextmenu: {
231
+ readonly type: import('vue').PropType<(e: Event) => void>;
232
+ readonly required: false;
233
+ readonly validator: ((val: unknown) => boolean) | undefined;
234
+ __epPropKey: true;
235
+ };
236
+ id: StringConstructor;
237
+ open: BooleanConstructor;
238
+ ariaLabel: StringConstructor;
239
+ appendTo: {
240
+ readonly type: import('vue').PropType<string | HTMLElement>;
241
+ readonly required: false;
242
+ readonly validator: ((val: unknown) => boolean) | undefined;
243
+ __epPropKey: true;
244
+ };
245
+ content: {
246
+ readonly type: import('vue').PropType<string>;
247
+ readonly required: false;
248
+ readonly validator: ((val: unknown) => boolean) | undefined;
249
+ __epPropKey: true;
250
+ } & {
251
+ readonly default: "";
252
+ };
253
+ rawContent: BooleanConstructor;
254
+ persistent: BooleanConstructor;
255
+ visible: {
256
+ readonly type: import('vue').PropType<boolean | null>;
257
+ readonly required: false;
258
+ readonly validator: ((val: unknown) => boolean) | undefined;
259
+ __epPropKey: true;
260
+ } & {
261
+ readonly default: null;
262
+ };
263
+ transition: StringConstructor;
264
+ teleported: {
265
+ readonly type: import('vue').PropType<boolean>;
266
+ readonly required: false;
267
+ readonly validator: ((val: unknown) => boolean) | undefined;
268
+ __epPropKey: true;
269
+ } & {
270
+ readonly default: true;
271
+ };
272
+ style: {
273
+ readonly type: import('vue').PropType<import('vue').StyleValue>;
274
+ readonly required: false;
275
+ readonly validator: ((val: unknown) => boolean) | undefined;
276
+ __epPropKey: true;
277
+ };
278
+ className: {
279
+ readonly type: import('vue').PropType<string | {
280
+ [x: string]: boolean;
281
+ } | (string | {
282
+ [x: string]: boolean;
283
+ } | (string | {
284
+ [x: string]: boolean;
285
+ } | (string | {
286
+ [x: string]: boolean;
287
+ } | (string | {
288
+ [x: string]: boolean;
289
+ } | (string | {
290
+ [x: string]: boolean;
291
+ } | (string | {
292
+ [x: string]: boolean;
293
+ } | (string | {
294
+ [x: string]: boolean;
295
+ } | (string | {
296
+ [x: string]: boolean;
297
+ } | (string | {
298
+ [x: string]: boolean;
299
+ } | (string | any[] | {
300
+ [x: string]: boolean;
301
+ })[])[])[])[])[])[])[])[])[])[]>;
302
+ readonly required: false;
303
+ readonly validator: ((val: unknown) => boolean) | undefined;
304
+ __epPropKey: true;
305
+ };
306
+ effect: {
307
+ readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
308
+ readonly required: false;
309
+ readonly validator: ((val: unknown) => boolean) | undefined;
310
+ __epPropKey: true;
311
+ } & {
312
+ readonly default: "dark";
313
+ };
314
+ enterable: {
315
+ readonly type: import('vue').PropType<boolean>;
316
+ readonly required: false;
317
+ readonly validator: ((val: unknown) => boolean) | undefined;
318
+ __epPropKey: true;
319
+ } & {
320
+ readonly default: true;
321
+ };
322
+ pure: BooleanConstructor;
323
+ focusOnShow: BooleanConstructor;
324
+ trapping: BooleanConstructor;
325
+ popperClass: {
326
+ readonly type: import('vue').PropType<string | {
327
+ [x: string]: boolean;
328
+ } | (string | {
329
+ [x: string]: boolean;
330
+ } | (string | {
331
+ [x: string]: boolean;
332
+ } | (string | {
333
+ [x: string]: boolean;
334
+ } | (string | {
335
+ [x: string]: boolean;
336
+ } | (string | {
337
+ [x: string]: boolean;
338
+ } | (string | {
339
+ [x: string]: boolean;
340
+ } | (string | {
341
+ [x: string]: boolean;
342
+ } | (string | {
343
+ [x: string]: boolean;
344
+ } | (string | {
345
+ [x: string]: boolean;
346
+ } | (string | any[] | {
347
+ [x: string]: boolean;
348
+ })[])[])[])[])[])[])[])[])[])[]>;
349
+ readonly required: false;
350
+ readonly validator: ((val: unknown) => boolean) | undefined;
351
+ __epPropKey: true;
352
+ };
353
+ popperStyle: {
354
+ readonly type: import('vue').PropType<import('vue').StyleValue>;
355
+ readonly required: false;
356
+ readonly validator: ((val: unknown) => boolean) | undefined;
357
+ __epPropKey: true;
358
+ };
359
+ referenceEl: {
360
+ readonly type: import('vue').PropType<HTMLElement>;
361
+ readonly required: false;
362
+ readonly validator: ((val: unknown) => boolean) | undefined;
363
+ __epPropKey: true;
364
+ };
365
+ triggerTargetEl: {
366
+ readonly type: import('vue').PropType<HTMLElement>;
367
+ readonly required: false;
368
+ readonly validator: ((val: unknown) => boolean) | undefined;
369
+ __epPropKey: true;
370
+ };
371
+ stopPopperMouseEvent: {
372
+ readonly type: import('vue').PropType<boolean>;
373
+ readonly required: false;
374
+ readonly validator: ((val: unknown) => boolean) | undefined;
375
+ __epPropKey: true;
376
+ } & {
377
+ readonly default: true;
378
+ };
379
+ zIndex: NumberConstructor;
380
+ boundariesPadding: {
381
+ readonly type: import('vue').PropType<number>;
382
+ readonly required: false;
383
+ readonly validator: ((val: unknown) => boolean) | undefined;
384
+ __epPropKey: true;
385
+ } & {
386
+ readonly default: 0;
387
+ };
388
+ fallbackPlacements: {
389
+ readonly type: import('vue').PropType<Placement[]>;
390
+ readonly required: false;
391
+ readonly validator: ((val: unknown) => boolean) | undefined;
392
+ __epPropKey: true;
393
+ } & {
394
+ readonly default: undefined;
395
+ };
396
+ gpuAcceleration: {
397
+ readonly type: import('vue').PropType<boolean>;
398
+ readonly required: false;
399
+ readonly validator: ((val: unknown) => boolean) | undefined;
400
+ __epPropKey: true;
401
+ } & {
402
+ readonly default: true;
403
+ };
404
+ offset: {
405
+ readonly type: import('vue').PropType<number>;
406
+ readonly required: false;
407
+ readonly validator: ((val: unknown) => boolean) | undefined;
408
+ __epPropKey: true;
409
+ } & {
410
+ readonly default: 12;
411
+ };
412
+ placement: {
413
+ readonly type: import('vue').PropType<string>;
414
+ readonly required: false;
415
+ readonly validator: ((val: unknown) => boolean) | undefined;
416
+ __epPropKey: true;
417
+ } & {
418
+ readonly default: "bottom";
419
+ };
420
+ popperOptions: {
421
+ readonly type: import('vue').PropType<any>;
422
+ readonly required: false;
423
+ readonly validator: ((val: unknown) => boolean) | undefined;
424
+ __epPropKey: true;
425
+ } & {
426
+ readonly default: () => {};
427
+ };
428
+ strategy: {
429
+ readonly type: import('vue').PropType<"fixed" | "absolute">;
430
+ readonly required: false;
431
+ readonly validator: ((val: unknown) => boolean) | undefined;
432
+ __epPropKey: true;
433
+ } & {
434
+ readonly default: "absolute";
435
+ };
436
+ showAfter: {
437
+ readonly type: import('vue').PropType<number>;
438
+ readonly required: false;
439
+ readonly validator: ((val: unknown) => boolean) | undefined;
440
+ __epPropKey: true;
441
+ } & {
442
+ readonly default: 0;
443
+ };
444
+ hideAfter: {
445
+ readonly type: import('vue').PropType<number>;
446
+ readonly required: false;
447
+ readonly validator: ((val: unknown) => boolean) | undefined;
448
+ __epPropKey: true;
449
+ } & {
450
+ readonly default: 200;
451
+ };
452
+ autoClose: {
453
+ readonly type: import('vue').PropType<number>;
454
+ readonly required: false;
455
+ readonly validator: ((val: unknown) => boolean) | undefined;
456
+ __epPropKey: true;
457
+ } & {
458
+ readonly default: 0;
459
+ };
460
+ "onUpdate:visible": {
461
+ readonly type: import('vue').PropType<(val: boolean) => void>;
462
+ readonly required: false;
463
+ readonly validator: ((val: unknown) => boolean) | undefined;
464
+ __epPropKey: true;
465
+ };
466
+ role: {
467
+ readonly type: import('vue').PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
468
+ readonly required: false;
469
+ readonly validator: ((val: unknown) => boolean) | undefined;
470
+ __epPropKey: true;
471
+ } & {
472
+ readonly default: "tooltip";
473
+ };
474
+ }>>, {
475
+ popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
476
+ contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
477
+ isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
478
+ updatePopper: () => void;
479
+ onOpen: (event?: Event, delay?: number) => void;
480
+ onClose: (event?: Event, delay?: number) => void;
481
+ hide: (event?: Event) => void;
482
+ }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
483
+ [x: string]: (...args: any[]) => void;
484
+ }, string, {
485
+ disabled: boolean;
486
+ content: string;
487
+ offset: number;
488
+ visible: boolean | null;
489
+ open: boolean;
490
+ placement: string;
491
+ strategy: "fixed" | "absolute";
492
+ effect: import('element-plus').PopperEffect;
493
+ showAfter: number;
494
+ hideAfter: number;
495
+ autoClose: number;
496
+ role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
497
+ trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
498
+ virtualTriggering: boolean;
499
+ arrowOffset: number;
500
+ boundariesPadding: number;
501
+ fallbackPlacements: Placement[];
502
+ gpuAcceleration: boolean;
503
+ popperOptions: Partial<Options>;
504
+ enterable: boolean;
505
+ stopPopperMouseEvent: boolean;
506
+ pure: boolean;
507
+ focusOnShow: boolean;
508
+ trapping: boolean;
509
+ triggerKeys: string[];
510
+ focusOnTarget: boolean;
511
+ teleported: boolean;
512
+ rawContent: boolean;
513
+ persistent: boolean;
514
+ showArrow: boolean;
515
+ }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
516
+ beforeCreate?: (() => void) | (() => void)[];
517
+ created?: (() => void) | (() => void)[];
518
+ beforeMount?: (() => void) | (() => void)[];
519
+ mounted?: (() => void) | (() => void)[];
520
+ beforeUpdate?: (() => void) | (() => void)[];
521
+ updated?: (() => void) | (() => void)[];
522
+ activated?: (() => void) | (() => void)[];
523
+ deactivated?: (() => void) | (() => void)[];
524
+ beforeDestroy?: (() => void) | (() => void)[];
525
+ beforeUnmount?: (() => void) | (() => void)[];
526
+ destroyed?: (() => void) | (() => void)[];
527
+ unmounted?: (() => void) | (() => void)[];
528
+ renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
529
+ renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
530
+ errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
531
+ };
532
+ $forceUpdate: () => void;
533
+ $nextTick: typeof import('vue').nextTick;
534
+ $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
535
+ } & Readonly<{
536
+ disabled: boolean;
537
+ content: string;
538
+ offset: number;
539
+ visible: boolean | null;
540
+ open: boolean;
541
+ placement: string;
542
+ strategy: "fixed" | "absolute";
543
+ effect: import('element-plus').PopperEffect;
544
+ showAfter: number;
545
+ hideAfter: number;
546
+ autoClose: number;
547
+ role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
548
+ trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
549
+ virtualTriggering: boolean;
550
+ arrowOffset: number;
551
+ boundariesPadding: number;
552
+ fallbackPlacements: Placement[];
553
+ gpuAcceleration: boolean;
554
+ popperOptions: Partial<Options>;
555
+ enterable: boolean;
556
+ stopPopperMouseEvent: boolean;
557
+ pure: boolean;
558
+ focusOnShow: boolean;
559
+ trapping: boolean;
560
+ triggerKeys: string[];
561
+ focusOnTarget: boolean;
562
+ teleported: boolean;
563
+ rawContent: boolean;
564
+ persistent: boolean;
565
+ showArrow: boolean;
566
+ }> & Omit<Readonly<import('vue').ExtractPropTypes<{
567
+ showArrow: {
568
+ readonly type: import('vue').PropType<boolean>;
569
+ readonly required: false;
570
+ readonly validator: ((val: unknown) => boolean) | undefined;
571
+ __epPropKey: true;
572
+ } & {
573
+ readonly default: boolean;
574
+ };
575
+ arrowOffset: {
576
+ readonly type: import('vue').PropType<number>;
577
+ readonly required: false;
578
+ readonly validator: ((val: unknown) => boolean) | undefined;
579
+ __epPropKey: true;
580
+ } & {
581
+ readonly default: 5;
582
+ };
583
+ disabled: BooleanConstructor;
584
+ trigger: {
585
+ readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
586
+ readonly required: false;
587
+ readonly validator: ((val: unknown) => boolean) | undefined;
588
+ __epPropKey: true;
589
+ } & {
590
+ readonly default: "hover";
591
+ };
592
+ triggerKeys: {
593
+ readonly type: import('vue').PropType<string[]>;
594
+ readonly required: false;
595
+ readonly validator: ((val: unknown) => boolean) | undefined;
596
+ __epPropKey: true;
597
+ } & {
598
+ readonly default: () => string[];
599
+ };
600
+ focusOnTarget: BooleanConstructor;
601
+ virtualRef: {
602
+ readonly type: import('vue').PropType<import('element-plus').Measurable>;
603
+ readonly required: false;
604
+ readonly validator: ((val: unknown) => boolean) | undefined;
605
+ __epPropKey: true;
606
+ };
607
+ virtualTriggering: BooleanConstructor;
608
+ onMouseenter: {
609
+ readonly type: import('vue').PropType<(e: Event) => void>;
610
+ readonly required: false;
611
+ readonly validator: ((val: unknown) => boolean) | undefined;
612
+ __epPropKey: true;
613
+ };
614
+ onMouseleave: {
615
+ readonly type: import('vue').PropType<(e: Event) => void>;
616
+ readonly required: false;
617
+ readonly validator: ((val: unknown) => boolean) | undefined;
618
+ __epPropKey: true;
619
+ };
620
+ onClick: {
621
+ readonly type: import('vue').PropType<(e: Event) => void>;
622
+ readonly required: false;
623
+ readonly validator: ((val: unknown) => boolean) | undefined;
624
+ __epPropKey: true;
625
+ };
626
+ onKeydown: {
627
+ readonly type: import('vue').PropType<(e: Event) => void>;
628
+ readonly required: false;
629
+ readonly validator: ((val: unknown) => boolean) | undefined;
630
+ __epPropKey: true;
631
+ };
632
+ onFocus: {
633
+ readonly type: import('vue').PropType<(e: Event) => void>;
634
+ readonly required: false;
635
+ readonly validator: ((val: unknown) => boolean) | undefined;
636
+ __epPropKey: true;
637
+ };
638
+ onBlur: {
639
+ readonly type: import('vue').PropType<(e: Event) => void>;
640
+ readonly required: false;
641
+ readonly validator: ((val: unknown) => boolean) | undefined;
642
+ __epPropKey: true;
643
+ };
644
+ onContextmenu: {
645
+ readonly type: import('vue').PropType<(e: Event) => void>;
646
+ readonly required: false;
647
+ readonly validator: ((val: unknown) => boolean) | undefined;
648
+ __epPropKey: true;
649
+ };
650
+ id: StringConstructor;
651
+ open: BooleanConstructor;
652
+ ariaLabel: StringConstructor;
653
+ appendTo: {
654
+ readonly type: import('vue').PropType<string | HTMLElement>;
655
+ readonly required: false;
656
+ readonly validator: ((val: unknown) => boolean) | undefined;
657
+ __epPropKey: true;
658
+ };
659
+ content: {
660
+ readonly type: import('vue').PropType<string>;
661
+ readonly required: false;
662
+ readonly validator: ((val: unknown) => boolean) | undefined;
663
+ __epPropKey: true;
664
+ } & {
665
+ readonly default: "";
666
+ };
667
+ rawContent: BooleanConstructor;
668
+ persistent: BooleanConstructor;
669
+ visible: {
670
+ readonly type: import('vue').PropType<boolean | null>;
671
+ readonly required: false;
672
+ readonly validator: ((val: unknown) => boolean) | undefined;
673
+ __epPropKey: true;
674
+ } & {
675
+ readonly default: null;
676
+ };
677
+ transition: StringConstructor;
678
+ teleported: {
679
+ readonly type: import('vue').PropType<boolean>;
680
+ readonly required: false;
681
+ readonly validator: ((val: unknown) => boolean) | undefined;
682
+ __epPropKey: true;
683
+ } & {
684
+ readonly default: true;
685
+ };
686
+ style: {
687
+ readonly type: import('vue').PropType<import('vue').StyleValue>;
688
+ readonly required: false;
689
+ readonly validator: ((val: unknown) => boolean) | undefined;
690
+ __epPropKey: true;
691
+ };
692
+ className: {
693
+ readonly type: import('vue').PropType<string | {
694
+ [x: string]: boolean;
695
+ } | (string | {
696
+ [x: string]: boolean;
697
+ } | (string | {
698
+ [x: string]: boolean;
699
+ } | (string | {
700
+ [x: string]: boolean;
701
+ } | (string | {
702
+ [x: string]: boolean;
703
+ } | (string | {
704
+ [x: string]: boolean;
705
+ } | (string | {
706
+ [x: string]: boolean;
707
+ } | (string | {
708
+ [x: string]: boolean;
709
+ } | (string | {
710
+ [x: string]: boolean;
711
+ } | (string | {
712
+ [x: string]: boolean;
713
+ } | (string | any[] | {
714
+ [x: string]: boolean;
715
+ })[])[])[])[])[])[])[])[])[])[]>;
716
+ readonly required: false;
717
+ readonly validator: ((val: unknown) => boolean) | undefined;
718
+ __epPropKey: true;
719
+ };
720
+ effect: {
721
+ readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
722
+ readonly required: false;
723
+ readonly validator: ((val: unknown) => boolean) | undefined;
724
+ __epPropKey: true;
725
+ } & {
726
+ readonly default: "dark";
727
+ };
728
+ enterable: {
729
+ readonly type: import('vue').PropType<boolean>;
730
+ readonly required: false;
731
+ readonly validator: ((val: unknown) => boolean) | undefined;
732
+ __epPropKey: true;
733
+ } & {
734
+ readonly default: true;
735
+ };
736
+ pure: BooleanConstructor;
737
+ focusOnShow: BooleanConstructor;
738
+ trapping: BooleanConstructor;
739
+ popperClass: {
740
+ readonly type: import('vue').PropType<string | {
741
+ [x: string]: boolean;
742
+ } | (string | {
743
+ [x: string]: boolean;
744
+ } | (string | {
745
+ [x: string]: boolean;
746
+ } | (string | {
747
+ [x: string]: boolean;
748
+ } | (string | {
749
+ [x: string]: boolean;
750
+ } | (string | {
751
+ [x: string]: boolean;
752
+ } | (string | {
753
+ [x: string]: boolean;
754
+ } | (string | {
755
+ [x: string]: boolean;
756
+ } | (string | {
757
+ [x: string]: boolean;
758
+ } | (string | {
759
+ [x: string]: boolean;
760
+ } | (string | any[] | {
761
+ [x: string]: boolean;
762
+ })[])[])[])[])[])[])[])[])[])[]>;
763
+ readonly required: false;
764
+ readonly validator: ((val: unknown) => boolean) | undefined;
765
+ __epPropKey: true;
766
+ };
767
+ popperStyle: {
768
+ readonly type: import('vue').PropType<import('vue').StyleValue>;
769
+ readonly required: false;
770
+ readonly validator: ((val: unknown) => boolean) | undefined;
771
+ __epPropKey: true;
772
+ };
773
+ referenceEl: {
774
+ readonly type: import('vue').PropType<HTMLElement>;
775
+ readonly required: false;
776
+ readonly validator: ((val: unknown) => boolean) | undefined;
777
+ __epPropKey: true;
778
+ };
779
+ triggerTargetEl: {
780
+ readonly type: import('vue').PropType<HTMLElement>;
781
+ readonly required: false;
782
+ readonly validator: ((val: unknown) => boolean) | undefined;
783
+ __epPropKey: true;
784
+ };
785
+ stopPopperMouseEvent: {
786
+ readonly type: import('vue').PropType<boolean>;
787
+ readonly required: false;
788
+ readonly validator: ((val: unknown) => boolean) | undefined;
789
+ __epPropKey: true;
790
+ } & {
791
+ readonly default: true;
792
+ };
793
+ zIndex: NumberConstructor;
794
+ boundariesPadding: {
795
+ readonly type: import('vue').PropType<number>;
796
+ readonly required: false;
797
+ readonly validator: ((val: unknown) => boolean) | undefined;
798
+ __epPropKey: true;
799
+ } & {
800
+ readonly default: 0;
801
+ };
802
+ fallbackPlacements: {
803
+ readonly type: import('vue').PropType<Placement[]>;
804
+ readonly required: false;
805
+ readonly validator: ((val: unknown) => boolean) | undefined;
806
+ __epPropKey: true;
807
+ } & {
808
+ readonly default: undefined;
809
+ };
810
+ gpuAcceleration: {
811
+ readonly type: import('vue').PropType<boolean>;
812
+ readonly required: false;
813
+ readonly validator: ((val: unknown) => boolean) | undefined;
814
+ __epPropKey: true;
815
+ } & {
816
+ readonly default: true;
817
+ };
818
+ offset: {
819
+ readonly type: import('vue').PropType<number>;
820
+ readonly required: false;
821
+ readonly validator: ((val: unknown) => boolean) | undefined;
822
+ __epPropKey: true;
823
+ } & {
824
+ readonly default: 12;
825
+ };
826
+ placement: {
827
+ readonly type: import('vue').PropType<string>;
828
+ readonly required: false;
829
+ readonly validator: ((val: unknown) => boolean) | undefined;
830
+ __epPropKey: true;
831
+ } & {
832
+ readonly default: "bottom";
833
+ };
834
+ popperOptions: {
835
+ readonly type: import('vue').PropType<any>;
836
+ readonly required: false;
837
+ readonly validator: ((val: unknown) => boolean) | undefined;
838
+ __epPropKey: true;
839
+ } & {
840
+ readonly default: () => {};
841
+ };
842
+ strategy: {
843
+ readonly type: import('vue').PropType<"fixed" | "absolute">;
844
+ readonly required: false;
845
+ readonly validator: ((val: unknown) => boolean) | undefined;
846
+ __epPropKey: true;
847
+ } & {
848
+ readonly default: "absolute";
849
+ };
850
+ showAfter: {
851
+ readonly type: import('vue').PropType<number>;
852
+ readonly required: false;
853
+ readonly validator: ((val: unknown) => boolean) | undefined;
854
+ __epPropKey: true;
855
+ } & {
856
+ readonly default: 0;
857
+ };
858
+ hideAfter: {
859
+ readonly type: import('vue').PropType<number>;
860
+ readonly required: false;
861
+ readonly validator: ((val: unknown) => boolean) | undefined;
862
+ __epPropKey: true;
863
+ } & {
864
+ readonly default: 200;
865
+ };
866
+ autoClose: {
867
+ readonly type: import('vue').PropType<number>;
868
+ readonly required: false;
869
+ readonly validator: ((val: unknown) => boolean) | undefined;
870
+ __epPropKey: true;
871
+ } & {
872
+ readonly default: 0;
873
+ };
874
+ "onUpdate:visible": {
875
+ readonly type: import('vue').PropType<(val: boolean) => void>;
876
+ readonly required: false;
877
+ readonly validator: ((val: unknown) => boolean) | undefined;
878
+ __epPropKey: true;
879
+ };
880
+ role: {
881
+ readonly type: import('vue').PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
882
+ readonly required: false;
883
+ readonly validator: ((val: unknown) => boolean) | undefined;
884
+ __epPropKey: true;
885
+ } & {
886
+ readonly default: "tooltip";
887
+ };
888
+ }>>, "disabled" | "visible" | "placement" | "fallbackPlacements" | "popperOptions" | "onOpen" | "onClose" | "open" | "effect" | "teleported" | "persistent" | "showArrow" | "offset" | "popperRef" | "arrowOffset" | "trigger" | "triggerKeys" | "focusOnTarget" | "virtualTriggering" | "content" | "rawContent" | "enterable" | "pure" | "focusOnShow" | "trapping" | "stopPopperMouseEvent" | "boundariesPadding" | "gpuAcceleration" | "strategy" | "showAfter" | "hideAfter" | "autoClose" | "role" | "contentRef" | "isFocusInsideContent" | "updatePopper" | "hide"> & import('vue').ShallowUnwrapRef<{
889
+ popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
890
+ contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
891
+ isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
892
+ updatePopper: () => void;
893
+ onOpen: (event?: Event, delay?: number) => void;
894
+ onClose: (event?: Event, delay?: number) => void;
895
+ hide: (event?: Event) => void;
896
+ }> & {} & import('vue').ComponentCustomProperties & {} & {
897
+ $slots: {
898
+ default?(_: {}): any;
899
+ content?(_: {}): any;
900
+ };
901
+ }) | null;
902
+ };
8
903
  rootEl: any;
9
904
  };
10
905
  type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
@@ -13,14 +908,1542 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
13
908
  type: NumberConstructor;
14
909
  default: number;
15
910
  };
16
- }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
911
+ }>, {
912
+ $: import('vue').ComponentInternalInstance;
913
+ $data: {};
914
+ $props: Partial<{
915
+ disabled: boolean;
916
+ content: string;
917
+ offset: number;
918
+ visible: boolean | null;
919
+ open: boolean;
920
+ placement: string;
921
+ strategy: "fixed" | "absolute";
922
+ effect: import('element-plus').PopperEffect;
923
+ showAfter: number;
924
+ hideAfter: number;
925
+ autoClose: number;
926
+ role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
927
+ trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
928
+ virtualTriggering: boolean;
929
+ arrowOffset: number;
930
+ boundariesPadding: number;
931
+ fallbackPlacements: Placement[];
932
+ gpuAcceleration: boolean;
933
+ popperOptions: Partial<Options>;
934
+ enterable: boolean;
935
+ stopPopperMouseEvent: boolean;
936
+ pure: boolean;
937
+ focusOnShow: boolean;
938
+ trapping: boolean;
939
+ triggerKeys: string[];
940
+ focusOnTarget: boolean;
941
+ teleported: boolean;
942
+ rawContent: boolean;
943
+ persistent: boolean;
944
+ showArrow: boolean;
945
+ }> & Omit<{
946
+ readonly disabled: boolean;
947
+ readonly visible: boolean | null;
948
+ readonly placement: string;
949
+ readonly popperOptions: any;
950
+ readonly open: boolean;
951
+ readonly effect: import('element-plus').PopperEffect;
952
+ readonly teleported: boolean;
953
+ readonly persistent: boolean;
954
+ readonly showArrow: boolean;
955
+ readonly offset: number;
956
+ readonly arrowOffset: number;
957
+ readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
958
+ readonly triggerKeys: string[];
959
+ readonly focusOnTarget: boolean;
960
+ readonly virtualTriggering: boolean;
961
+ readonly content: string;
962
+ readonly rawContent: boolean;
963
+ readonly enterable: boolean;
964
+ readonly pure: boolean;
965
+ readonly focusOnShow: boolean;
966
+ readonly trapping: boolean;
967
+ readonly stopPopperMouseEvent: boolean;
968
+ readonly boundariesPadding: number;
969
+ readonly gpuAcceleration: boolean;
970
+ readonly strategy: "fixed" | "absolute";
971
+ readonly showAfter: number;
972
+ readonly hideAfter: number;
973
+ readonly autoClose: number;
974
+ readonly role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
975
+ readonly style?: import('vue').StyleValue;
976
+ readonly onFocus?: ((e: Event) => void) | undefined;
977
+ readonly onBlur?: ((e: Event) => void) | undefined;
978
+ readonly onKeydown?: ((e: Event) => void) | undefined;
979
+ readonly onMouseenter?: ((e: Event) => void) | undefined;
980
+ readonly onMouseleave?: ((e: Event) => void) | undefined;
981
+ readonly onClick?: ((e: Event) => void) | undefined;
982
+ readonly onContextmenu?: ((e: Event) => void) | undefined;
983
+ readonly transition?: string | undefined;
984
+ readonly className?: (string | {
985
+ [x: string]: boolean;
986
+ } | (string | {
987
+ [x: string]: boolean;
988
+ } | (string | {
989
+ [x: string]: boolean;
990
+ } | (string | {
991
+ [x: string]: boolean;
992
+ } | (string | {
993
+ [x: string]: boolean;
994
+ } | (string | {
995
+ [x: string]: boolean;
996
+ } | (string | {
997
+ [x: string]: boolean;
998
+ } | (string | {
999
+ [x: string]: boolean;
1000
+ } | (string | {
1001
+ [x: string]: boolean;
1002
+ } | (string | {
1003
+ [x: string]: boolean;
1004
+ } | (string | any[] | {
1005
+ [x: string]: boolean;
1006
+ })[])[])[])[])[])[])[])[])[])[]) | undefined;
1007
+ readonly id?: string | undefined;
1008
+ readonly ariaLabel?: string | undefined;
1009
+ readonly fallbackPlacements?: Placement[] | undefined;
1010
+ readonly popperClass?: (string | {
1011
+ [x: string]: boolean;
1012
+ } | (string | {
1013
+ [x: string]: boolean;
1014
+ } | (string | {
1015
+ [x: string]: boolean;
1016
+ } | (string | {
1017
+ [x: string]: boolean;
1018
+ } | (string | {
1019
+ [x: string]: boolean;
1020
+ } | (string | {
1021
+ [x: string]: boolean;
1022
+ } | (string | {
1023
+ [x: string]: boolean;
1024
+ } | (string | {
1025
+ [x: string]: boolean;
1026
+ } | (string | {
1027
+ [x: string]: boolean;
1028
+ } | (string | {
1029
+ [x: string]: boolean;
1030
+ } | (string | any[] | {
1031
+ [x: string]: boolean;
1032
+ })[])[])[])[])[])[])[])[])[])[]) | undefined;
1033
+ readonly popperStyle?: import('vue').StyleValue;
1034
+ readonly appendTo?: (string | HTMLElement) | undefined;
1035
+ readonly zIndex?: number | undefined;
1036
+ readonly virtualRef?: import('element-plus').Measurable | undefined;
1037
+ readonly referenceEl?: HTMLElement | undefined;
1038
+ readonly triggerTargetEl?: HTMLElement | undefined;
1039
+ readonly "onUpdate:visible"?: ((val: boolean) => void) | undefined;
1040
+ } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "visible" | "placement" | "fallbackPlacements" | "popperOptions" | "open" | "effect" | "teleported" | "persistent" | "showArrow" | "offset" | "arrowOffset" | "trigger" | "triggerKeys" | "focusOnTarget" | "virtualTriggering" | "content" | "rawContent" | "enterable" | "pure" | "focusOnShow" | "trapping" | "stopPopperMouseEvent" | "boundariesPadding" | "gpuAcceleration" | "strategy" | "showAfter" | "hideAfter" | "autoClose" | "role">;
1041
+ $attrs: {
1042
+ [x: string]: unknown;
1043
+ };
1044
+ $refs: {
1045
+ [x: string]: unknown;
1046
+ };
1047
+ $slots: Readonly<{
1048
+ [name: string]: import('vue').Slot<any> | undefined;
1049
+ }> & {
1050
+ default?(_: {}): any;
1051
+ content?(_: {}): any;
1052
+ };
1053
+ $root: import('vue').ComponentPublicInstance | null;
1054
+ $parent: import('vue').ComponentPublicInstance | null;
1055
+ $host: Element | null;
1056
+ $emit: (event: string, ...args: any[]) => void;
1057
+ $el: any;
1058
+ $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
1059
+ showArrow: {
1060
+ readonly type: import('vue').PropType<boolean>;
1061
+ readonly required: false;
1062
+ readonly validator: ((val: unknown) => boolean) | undefined;
1063
+ __epPropKey: true;
1064
+ } & {
1065
+ readonly default: boolean;
1066
+ };
1067
+ arrowOffset: {
1068
+ readonly type: import('vue').PropType<number>;
1069
+ readonly required: false;
1070
+ readonly validator: ((val: unknown) => boolean) | undefined;
1071
+ __epPropKey: true;
1072
+ } & {
1073
+ readonly default: 5;
1074
+ };
1075
+ disabled: BooleanConstructor;
1076
+ trigger: {
1077
+ readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
1078
+ readonly required: false;
1079
+ readonly validator: ((val: unknown) => boolean) | undefined;
1080
+ __epPropKey: true;
1081
+ } & {
1082
+ readonly default: "hover";
1083
+ };
1084
+ triggerKeys: {
1085
+ readonly type: import('vue').PropType<string[]>;
1086
+ readonly required: false;
1087
+ readonly validator: ((val: unknown) => boolean) | undefined;
1088
+ __epPropKey: true;
1089
+ } & {
1090
+ readonly default: () => string[];
1091
+ };
1092
+ focusOnTarget: BooleanConstructor;
1093
+ virtualRef: {
1094
+ readonly type: import('vue').PropType<import('element-plus').Measurable>;
1095
+ readonly required: false;
1096
+ readonly validator: ((val: unknown) => boolean) | undefined;
1097
+ __epPropKey: true;
1098
+ };
1099
+ virtualTriggering: BooleanConstructor;
1100
+ onMouseenter: {
1101
+ readonly type: import('vue').PropType<(e: Event) => void>;
1102
+ readonly required: false;
1103
+ readonly validator: ((val: unknown) => boolean) | undefined;
1104
+ __epPropKey: true;
1105
+ };
1106
+ onMouseleave: {
1107
+ readonly type: import('vue').PropType<(e: Event) => void>;
1108
+ readonly required: false;
1109
+ readonly validator: ((val: unknown) => boolean) | undefined;
1110
+ __epPropKey: true;
1111
+ };
1112
+ onClick: {
1113
+ readonly type: import('vue').PropType<(e: Event) => void>;
1114
+ readonly required: false;
1115
+ readonly validator: ((val: unknown) => boolean) | undefined;
1116
+ __epPropKey: true;
1117
+ };
1118
+ onKeydown: {
1119
+ readonly type: import('vue').PropType<(e: Event) => void>;
1120
+ readonly required: false;
1121
+ readonly validator: ((val: unknown) => boolean) | undefined;
1122
+ __epPropKey: true;
1123
+ };
1124
+ onFocus: {
1125
+ readonly type: import('vue').PropType<(e: Event) => void>;
1126
+ readonly required: false;
1127
+ readonly validator: ((val: unknown) => boolean) | undefined;
1128
+ __epPropKey: true;
1129
+ };
1130
+ onBlur: {
1131
+ readonly type: import('vue').PropType<(e: Event) => void>;
1132
+ readonly required: false;
1133
+ readonly validator: ((val: unknown) => boolean) | undefined;
1134
+ __epPropKey: true;
1135
+ };
1136
+ onContextmenu: {
1137
+ readonly type: import('vue').PropType<(e: Event) => void>;
1138
+ readonly required: false;
1139
+ readonly validator: ((val: unknown) => boolean) | undefined;
1140
+ __epPropKey: true;
1141
+ };
1142
+ id: StringConstructor;
1143
+ open: BooleanConstructor;
1144
+ ariaLabel: StringConstructor;
1145
+ appendTo: {
1146
+ readonly type: import('vue').PropType<string | HTMLElement>;
1147
+ readonly required: false;
1148
+ readonly validator: ((val: unknown) => boolean) | undefined;
1149
+ __epPropKey: true;
1150
+ };
1151
+ content: {
1152
+ readonly type: import('vue').PropType<string>;
1153
+ readonly required: false;
1154
+ readonly validator: ((val: unknown) => boolean) | undefined;
1155
+ __epPropKey: true;
1156
+ } & {
1157
+ readonly default: "";
1158
+ };
1159
+ rawContent: BooleanConstructor;
1160
+ persistent: BooleanConstructor;
1161
+ visible: {
1162
+ readonly type: import('vue').PropType<boolean | null>;
1163
+ readonly required: false;
1164
+ readonly validator: ((val: unknown) => boolean) | undefined;
1165
+ __epPropKey: true;
1166
+ } & {
1167
+ readonly default: null;
1168
+ };
1169
+ transition: StringConstructor;
1170
+ teleported: {
1171
+ readonly type: import('vue').PropType<boolean>;
1172
+ readonly required: false;
1173
+ readonly validator: ((val: unknown) => boolean) | undefined;
1174
+ __epPropKey: true;
1175
+ } & {
1176
+ readonly default: true;
1177
+ };
1178
+ style: {
1179
+ readonly type: import('vue').PropType<import('vue').StyleValue>;
1180
+ readonly required: false;
1181
+ readonly validator: ((val: unknown) => boolean) | undefined;
1182
+ __epPropKey: true;
1183
+ };
1184
+ className: {
1185
+ readonly type: import('vue').PropType<string | {
1186
+ [x: string]: boolean;
1187
+ } | (string | {
1188
+ [x: string]: boolean;
1189
+ } | (string | {
1190
+ [x: string]: boolean;
1191
+ } | (string | {
1192
+ [x: string]: boolean;
1193
+ } | (string | {
1194
+ [x: string]: boolean;
1195
+ } | (string | {
1196
+ [x: string]: boolean;
1197
+ } | (string | {
1198
+ [x: string]: boolean;
1199
+ } | (string | {
1200
+ [x: string]: boolean;
1201
+ } | (string | {
1202
+ [x: string]: boolean;
1203
+ } | (string | {
1204
+ [x: string]: boolean;
1205
+ } | (string | any[] | {
1206
+ [x: string]: boolean;
1207
+ })[])[])[])[])[])[])[])[])[])[]>;
1208
+ readonly required: false;
1209
+ readonly validator: ((val: unknown) => boolean) | undefined;
1210
+ __epPropKey: true;
1211
+ };
1212
+ effect: {
1213
+ readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
1214
+ readonly required: false;
1215
+ readonly validator: ((val: unknown) => boolean) | undefined;
1216
+ __epPropKey: true;
1217
+ } & {
1218
+ readonly default: "dark";
1219
+ };
1220
+ enterable: {
1221
+ readonly type: import('vue').PropType<boolean>;
1222
+ readonly required: false;
1223
+ readonly validator: ((val: unknown) => boolean) | undefined;
1224
+ __epPropKey: true;
1225
+ } & {
1226
+ readonly default: true;
1227
+ };
1228
+ pure: BooleanConstructor;
1229
+ focusOnShow: BooleanConstructor;
1230
+ trapping: BooleanConstructor;
1231
+ popperClass: {
1232
+ readonly type: import('vue').PropType<string | {
1233
+ [x: string]: boolean;
1234
+ } | (string | {
1235
+ [x: string]: boolean;
1236
+ } | (string | {
1237
+ [x: string]: boolean;
1238
+ } | (string | {
1239
+ [x: string]: boolean;
1240
+ } | (string | {
1241
+ [x: string]: boolean;
1242
+ } | (string | {
1243
+ [x: string]: boolean;
1244
+ } | (string | {
1245
+ [x: string]: boolean;
1246
+ } | (string | {
1247
+ [x: string]: boolean;
1248
+ } | (string | {
1249
+ [x: string]: boolean;
1250
+ } | (string | {
1251
+ [x: string]: boolean;
1252
+ } | (string | any[] | {
1253
+ [x: string]: boolean;
1254
+ })[])[])[])[])[])[])[])[])[])[]>;
1255
+ readonly required: false;
1256
+ readonly validator: ((val: unknown) => boolean) | undefined;
1257
+ __epPropKey: true;
1258
+ };
1259
+ popperStyle: {
1260
+ readonly type: import('vue').PropType<import('vue').StyleValue>;
1261
+ readonly required: false;
1262
+ readonly validator: ((val: unknown) => boolean) | undefined;
1263
+ __epPropKey: true;
1264
+ };
1265
+ referenceEl: {
1266
+ readonly type: import('vue').PropType<HTMLElement>;
1267
+ readonly required: false;
1268
+ readonly validator: ((val: unknown) => boolean) | undefined;
1269
+ __epPropKey: true;
1270
+ };
1271
+ triggerTargetEl: {
1272
+ readonly type: import('vue').PropType<HTMLElement>;
1273
+ readonly required: false;
1274
+ readonly validator: ((val: unknown) => boolean) | undefined;
1275
+ __epPropKey: true;
1276
+ };
1277
+ stopPopperMouseEvent: {
1278
+ readonly type: import('vue').PropType<boolean>;
1279
+ readonly required: false;
1280
+ readonly validator: ((val: unknown) => boolean) | undefined;
1281
+ __epPropKey: true;
1282
+ } & {
1283
+ readonly default: true;
1284
+ };
1285
+ zIndex: NumberConstructor;
1286
+ boundariesPadding: {
1287
+ readonly type: import('vue').PropType<number>;
1288
+ readonly required: false;
1289
+ readonly validator: ((val: unknown) => boolean) | undefined;
1290
+ __epPropKey: true;
1291
+ } & {
1292
+ readonly default: 0;
1293
+ };
1294
+ fallbackPlacements: {
1295
+ readonly type: import('vue').PropType<Placement[]>;
1296
+ readonly required: false;
1297
+ readonly validator: ((val: unknown) => boolean) | undefined;
1298
+ __epPropKey: true;
1299
+ } & {
1300
+ readonly default: undefined;
1301
+ };
1302
+ gpuAcceleration: {
1303
+ readonly type: import('vue').PropType<boolean>;
1304
+ readonly required: false;
1305
+ readonly validator: ((val: unknown) => boolean) | undefined;
1306
+ __epPropKey: true;
1307
+ } & {
1308
+ readonly default: true;
1309
+ };
1310
+ offset: {
1311
+ readonly type: import('vue').PropType<number>;
1312
+ readonly required: false;
1313
+ readonly validator: ((val: unknown) => boolean) | undefined;
1314
+ __epPropKey: true;
1315
+ } & {
1316
+ readonly default: 12;
1317
+ };
1318
+ placement: {
1319
+ readonly type: import('vue').PropType<string>;
1320
+ readonly required: false;
1321
+ readonly validator: ((val: unknown) => boolean) | undefined;
1322
+ __epPropKey: true;
1323
+ } & {
1324
+ readonly default: "bottom";
1325
+ };
1326
+ popperOptions: {
1327
+ readonly type: import('vue').PropType<any>;
1328
+ readonly required: false;
1329
+ readonly validator: ((val: unknown) => boolean) | undefined;
1330
+ __epPropKey: true;
1331
+ } & {
1332
+ readonly default: () => {};
1333
+ };
1334
+ strategy: {
1335
+ readonly type: import('vue').PropType<"fixed" | "absolute">;
1336
+ readonly required: false;
1337
+ readonly validator: ((val: unknown) => boolean) | undefined;
1338
+ __epPropKey: true;
1339
+ } & {
1340
+ readonly default: "absolute";
1341
+ };
1342
+ showAfter: {
1343
+ readonly type: import('vue').PropType<number>;
1344
+ readonly required: false;
1345
+ readonly validator: ((val: unknown) => boolean) | undefined;
1346
+ __epPropKey: true;
1347
+ } & {
1348
+ readonly default: 0;
1349
+ };
1350
+ hideAfter: {
1351
+ readonly type: import('vue').PropType<number>;
1352
+ readonly required: false;
1353
+ readonly validator: ((val: unknown) => boolean) | undefined;
1354
+ __epPropKey: true;
1355
+ } & {
1356
+ readonly default: 200;
1357
+ };
1358
+ autoClose: {
1359
+ readonly type: import('vue').PropType<number>;
1360
+ readonly required: false;
1361
+ readonly validator: ((val: unknown) => boolean) | undefined;
1362
+ __epPropKey: true;
1363
+ } & {
1364
+ readonly default: 0;
1365
+ };
1366
+ "onUpdate:visible": {
1367
+ readonly type: import('vue').PropType<(val: boolean) => void>;
1368
+ readonly required: false;
1369
+ readonly validator: ((val: unknown) => boolean) | undefined;
1370
+ __epPropKey: true;
1371
+ };
1372
+ role: {
1373
+ readonly type: import('vue').PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
1374
+ readonly required: false;
1375
+ readonly validator: ((val: unknown) => boolean) | undefined;
1376
+ __epPropKey: true;
1377
+ } & {
1378
+ readonly default: "tooltip";
1379
+ };
1380
+ }>>, {
1381
+ popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
1382
+ contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
1383
+ isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
1384
+ updatePopper: () => void;
1385
+ onOpen: (event?: Event, delay?: number) => void;
1386
+ onClose: (event?: Event, delay?: number) => void;
1387
+ hide: (event?: Event) => void;
1388
+ }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
1389
+ [x: string]: (...args: any[]) => void;
1390
+ }, string, {
1391
+ disabled: boolean;
1392
+ content: string;
1393
+ offset: number;
1394
+ visible: boolean | null;
1395
+ open: boolean;
1396
+ placement: string;
1397
+ strategy: "fixed" | "absolute";
1398
+ effect: import('element-plus').PopperEffect;
1399
+ showAfter: number;
1400
+ hideAfter: number;
1401
+ autoClose: number;
1402
+ role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
1403
+ trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
1404
+ virtualTriggering: boolean;
1405
+ arrowOffset: number;
1406
+ boundariesPadding: number;
1407
+ fallbackPlacements: Placement[];
1408
+ gpuAcceleration: boolean;
1409
+ popperOptions: Partial<Options>;
1410
+ enterable: boolean;
1411
+ stopPopperMouseEvent: boolean;
1412
+ pure: boolean;
1413
+ focusOnShow: boolean;
1414
+ trapping: boolean;
1415
+ triggerKeys: string[];
1416
+ focusOnTarget: boolean;
1417
+ teleported: boolean;
1418
+ rawContent: boolean;
1419
+ persistent: boolean;
1420
+ showArrow: boolean;
1421
+ }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
1422
+ beforeCreate?: (() => void) | (() => void)[];
1423
+ created?: (() => void) | (() => void)[];
1424
+ beforeMount?: (() => void) | (() => void)[];
1425
+ mounted?: (() => void) | (() => void)[];
1426
+ beforeUpdate?: (() => void) | (() => void)[];
1427
+ updated?: (() => void) | (() => void)[];
1428
+ activated?: (() => void) | (() => void)[];
1429
+ deactivated?: (() => void) | (() => void)[];
1430
+ beforeDestroy?: (() => void) | (() => void)[];
1431
+ beforeUnmount?: (() => void) | (() => void)[];
1432
+ destroyed?: (() => void) | (() => void)[];
1433
+ unmounted?: (() => void) | (() => void)[];
1434
+ renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
1435
+ renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
1436
+ errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
1437
+ };
1438
+ $forceUpdate: () => void;
1439
+ $nextTick: typeof import('vue').nextTick;
1440
+ $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
1441
+ disabled: boolean;
1442
+ content: string;
1443
+ offset: number;
1444
+ visible: boolean | null;
1445
+ open: boolean;
1446
+ placement: string;
1447
+ strategy: "fixed" | "absolute";
1448
+ effect: import('element-plus').PopperEffect;
1449
+ showAfter: number;
1450
+ hideAfter: number;
1451
+ autoClose: number;
1452
+ role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
1453
+ trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
1454
+ virtualTriggering: boolean;
1455
+ arrowOffset: number;
1456
+ boundariesPadding: number;
1457
+ fallbackPlacements: Placement[];
1458
+ gpuAcceleration: boolean;
1459
+ popperOptions: Partial<Options>;
1460
+ enterable: boolean;
1461
+ stopPopperMouseEvent: boolean;
1462
+ pure: boolean;
1463
+ focusOnShow: boolean;
1464
+ trapping: boolean;
1465
+ triggerKeys: string[];
1466
+ focusOnTarget: boolean;
1467
+ teleported: boolean;
1468
+ rawContent: boolean;
1469
+ persistent: boolean;
1470
+ showArrow: boolean;
1471
+ style?: import('vue').StyleValue;
1472
+ onFocus?: ((e: Event) => void) | undefined;
1473
+ onBlur?: ((e: Event) => void) | undefined;
1474
+ onKeydown?: ((e: Event) => void) | undefined;
1475
+ onMouseenter?: ((e: Event) => void) | undefined;
1476
+ onMouseleave?: ((e: Event) => void) | undefined;
1477
+ onClick?: ((e: Event) => void) | undefined;
1478
+ onContextmenu?: ((e: Event) => void) | undefined;
1479
+ transition?: string | undefined;
1480
+ className?: (string | {
1481
+ [x: string]: boolean;
1482
+ } | (string | {
1483
+ [x: string]: boolean;
1484
+ } | (string | {
1485
+ [x: string]: boolean;
1486
+ } | (string | {
1487
+ [x: string]: boolean;
1488
+ } | (string | {
1489
+ [x: string]: boolean;
1490
+ } | (string | {
1491
+ [x: string]: boolean;
1492
+ } | (string | {
1493
+ [x: string]: boolean;
1494
+ } | (string | {
1495
+ [x: string]: boolean;
1496
+ } | (string | {
1497
+ [x: string]: boolean;
1498
+ } | (string | {
1499
+ [x: string]: boolean;
1500
+ } | (string | any[] | {
1501
+ [x: string]: boolean;
1502
+ })[])[])[])[])[])[])[])[])[])[]) | undefined;
1503
+ id?: string | undefined;
1504
+ ariaLabel?: string | undefined;
1505
+ popperClass?: (string | {
1506
+ [x: string]: boolean;
1507
+ } | (string | {
1508
+ [x: string]: boolean;
1509
+ } | (string | {
1510
+ [x: string]: boolean;
1511
+ } | (string | {
1512
+ [x: string]: boolean;
1513
+ } | (string | {
1514
+ [x: string]: boolean;
1515
+ } | (string | {
1516
+ [x: string]: boolean;
1517
+ } | (string | {
1518
+ [x: string]: boolean;
1519
+ } | (string | {
1520
+ [x: string]: boolean;
1521
+ } | (string | {
1522
+ [x: string]: boolean;
1523
+ } | (string | {
1524
+ [x: string]: boolean;
1525
+ } | (string | any[] | {
1526
+ [x: string]: boolean;
1527
+ })[])[])[])[])[])[])[])[])[])[]) | undefined;
1528
+ popperStyle?: import('vue').StyleValue;
1529
+ appendTo?: (string | HTMLElement) | undefined;
1530
+ zIndex?: number | undefined;
1531
+ virtualRef?: import('element-plus').Measurable | undefined;
1532
+ referenceEl?: HTMLElement | undefined;
1533
+ triggerTargetEl?: HTMLElement | undefined;
1534
+ "onUpdate:visible"?: ((val: boolean) => void) | undefined;
1535
+ popperRef: import('element-plus').PopperInstance | undefined;
1536
+ contentRef: import('element-plus').TooltipContentInstance | undefined;
1537
+ isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
1538
+ updatePopper: () => void;
1539
+ onOpen: (event?: Event, delay?: number) => void;
1540
+ onClose: (event?: Event, delay?: number) => void;
1541
+ hide: (event?: Event) => void;
1542
+ $route: import('vue-router').TypesConfig extends Record<"$route", infer T> ? T : import('vue-router').RouteLocationNormalizedLoaded;
1543
+ $router: import('vue-router').TypesConfig extends Record<"$router", infer T> ? T : import('vue-router').Router;
1544
+ }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
17
1545
  openDelay: {
18
1546
  type: NumberConstructor;
19
1547
  default: number;
20
1548
  };
21
1549
  }>> & Readonly<{}>, {
22
1550
  openDelay: number;
23
- }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
1551
+ }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
1552
+ componentRef: ({
1553
+ $: import('vue').ComponentInternalInstance;
1554
+ $data: {};
1555
+ $props: Partial<{
1556
+ disabled: boolean;
1557
+ content: string;
1558
+ offset: number;
1559
+ visible: boolean | null;
1560
+ open: boolean;
1561
+ placement: string;
1562
+ strategy: "fixed" | "absolute";
1563
+ effect: import('element-plus').PopperEffect;
1564
+ showAfter: number;
1565
+ hideAfter: number;
1566
+ autoClose: number;
1567
+ role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
1568
+ trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
1569
+ virtualTriggering: boolean;
1570
+ arrowOffset: number;
1571
+ boundariesPadding: number;
1572
+ fallbackPlacements: Placement[];
1573
+ gpuAcceleration: boolean;
1574
+ popperOptions: Partial<Options>;
1575
+ enterable: boolean;
1576
+ stopPopperMouseEvent: boolean;
1577
+ pure: boolean;
1578
+ focusOnShow: boolean;
1579
+ trapping: boolean;
1580
+ triggerKeys: string[];
1581
+ focusOnTarget: boolean;
1582
+ teleported: boolean;
1583
+ rawContent: boolean;
1584
+ persistent: boolean;
1585
+ showArrow: boolean;
1586
+ }> & Omit<{
1587
+ readonly disabled: boolean;
1588
+ readonly visible: boolean | null;
1589
+ readonly placement: string;
1590
+ readonly popperOptions: any;
1591
+ readonly open: boolean;
1592
+ readonly effect: import('element-plus').PopperEffect;
1593
+ readonly teleported: boolean;
1594
+ readonly persistent: boolean;
1595
+ readonly showArrow: boolean;
1596
+ readonly offset: number;
1597
+ readonly arrowOffset: number;
1598
+ readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
1599
+ readonly triggerKeys: string[];
1600
+ readonly focusOnTarget: boolean;
1601
+ readonly virtualTriggering: boolean;
1602
+ readonly content: string;
1603
+ readonly rawContent: boolean;
1604
+ readonly enterable: boolean;
1605
+ readonly pure: boolean;
1606
+ readonly focusOnShow: boolean;
1607
+ readonly trapping: boolean;
1608
+ readonly stopPopperMouseEvent: boolean;
1609
+ readonly boundariesPadding: number;
1610
+ readonly gpuAcceleration: boolean;
1611
+ readonly strategy: "fixed" | "absolute";
1612
+ readonly showAfter: number;
1613
+ readonly hideAfter: number;
1614
+ readonly autoClose: number;
1615
+ readonly role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
1616
+ readonly style?: import('vue').StyleValue;
1617
+ readonly onFocus?: ((e: Event) => void) | undefined;
1618
+ readonly onBlur?: ((e: Event) => void) | undefined;
1619
+ readonly onKeydown?: ((e: Event) => void) | undefined;
1620
+ readonly onMouseenter?: ((e: Event) => void) | undefined;
1621
+ readonly onMouseleave?: ((e: Event) => void) | undefined;
1622
+ readonly onClick?: ((e: Event) => void) | undefined;
1623
+ readonly onContextmenu?: ((e: Event) => void) | undefined;
1624
+ readonly transition?: string | undefined;
1625
+ readonly className?: (string | {
1626
+ [x: string]: boolean;
1627
+ } | (string | {
1628
+ [x: string]: boolean;
1629
+ } | (string | {
1630
+ [x: string]: boolean;
1631
+ } | (string | {
1632
+ [x: string]: boolean;
1633
+ } | (string | {
1634
+ [x: string]: boolean;
1635
+ } | (string | {
1636
+ [x: string]: boolean;
1637
+ } | (string | {
1638
+ [x: string]: boolean;
1639
+ } | (string | {
1640
+ [x: string]: boolean;
1641
+ } | (string | {
1642
+ [x: string]: boolean;
1643
+ } | (string | {
1644
+ [x: string]: boolean;
1645
+ } | (string | any[] | {
1646
+ [x: string]: boolean;
1647
+ })[])[])[])[])[])[])[])[])[])[]) | undefined;
1648
+ readonly id?: string | undefined;
1649
+ readonly ariaLabel?: string | undefined;
1650
+ readonly fallbackPlacements?: Placement[] | undefined;
1651
+ readonly popperClass?: (string | {
1652
+ [x: string]: boolean;
1653
+ } | (string | {
1654
+ [x: string]: boolean;
1655
+ } | (string | {
1656
+ [x: string]: boolean;
1657
+ } | (string | {
1658
+ [x: string]: boolean;
1659
+ } | (string | {
1660
+ [x: string]: boolean;
1661
+ } | (string | {
1662
+ [x: string]: boolean;
1663
+ } | (string | {
1664
+ [x: string]: boolean;
1665
+ } | (string | {
1666
+ [x: string]: boolean;
1667
+ } | (string | {
1668
+ [x: string]: boolean;
1669
+ } | (string | {
1670
+ [x: string]: boolean;
1671
+ } | (string | any[] | {
1672
+ [x: string]: boolean;
1673
+ })[])[])[])[])[])[])[])[])[])[]) | undefined;
1674
+ readonly popperStyle?: import('vue').StyleValue;
1675
+ readonly appendTo?: (string | HTMLElement) | undefined;
1676
+ readonly zIndex?: number | undefined;
1677
+ readonly virtualRef?: import('element-plus').Measurable | undefined;
1678
+ readonly referenceEl?: HTMLElement | undefined;
1679
+ readonly triggerTargetEl?: HTMLElement | undefined;
1680
+ readonly "onUpdate:visible"?: ((val: boolean) => void) | undefined;
1681
+ } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "visible" | "placement" | "fallbackPlacements" | "popperOptions" | "open" | "effect" | "teleported" | "persistent" | "showArrow" | "offset" | "arrowOffset" | "trigger" | "triggerKeys" | "focusOnTarget" | "virtualTriggering" | "content" | "rawContent" | "enterable" | "pure" | "focusOnShow" | "trapping" | "stopPopperMouseEvent" | "boundariesPadding" | "gpuAcceleration" | "strategy" | "showAfter" | "hideAfter" | "autoClose" | "role">;
1682
+ $attrs: {
1683
+ [x: string]: unknown;
1684
+ };
1685
+ $refs: {
1686
+ [x: string]: unknown;
1687
+ };
1688
+ $slots: Readonly<{
1689
+ [name: string]: import('vue').Slot<any> | undefined;
1690
+ }>;
1691
+ $root: import('vue').ComponentPublicInstance | null;
1692
+ $parent: import('vue').ComponentPublicInstance | null;
1693
+ $host: Element | null;
1694
+ $emit: (event: string, ...args: any[]) => void;
1695
+ $el: any;
1696
+ $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
1697
+ showArrow: {
1698
+ readonly type: import('vue').PropType<boolean>;
1699
+ readonly required: false;
1700
+ readonly validator: ((val: unknown) => boolean) | undefined;
1701
+ __epPropKey: true;
1702
+ } & {
1703
+ readonly default: boolean;
1704
+ };
1705
+ arrowOffset: {
1706
+ readonly type: import('vue').PropType<number>;
1707
+ readonly required: false;
1708
+ readonly validator: ((val: unknown) => boolean) | undefined;
1709
+ __epPropKey: true;
1710
+ } & {
1711
+ readonly default: 5;
1712
+ };
1713
+ disabled: BooleanConstructor;
1714
+ trigger: {
1715
+ readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
1716
+ readonly required: false;
1717
+ readonly validator: ((val: unknown) => boolean) | undefined;
1718
+ __epPropKey: true;
1719
+ } & {
1720
+ readonly default: "hover";
1721
+ };
1722
+ triggerKeys: {
1723
+ readonly type: import('vue').PropType<string[]>;
1724
+ readonly required: false;
1725
+ readonly validator: ((val: unknown) => boolean) | undefined;
1726
+ __epPropKey: true;
1727
+ } & {
1728
+ readonly default: () => string[];
1729
+ };
1730
+ focusOnTarget: BooleanConstructor;
1731
+ virtualRef: {
1732
+ readonly type: import('vue').PropType<import('element-plus').Measurable>;
1733
+ readonly required: false;
1734
+ readonly validator: ((val: unknown) => boolean) | undefined;
1735
+ __epPropKey: true;
1736
+ };
1737
+ virtualTriggering: BooleanConstructor;
1738
+ onMouseenter: {
1739
+ readonly type: import('vue').PropType<(e: Event) => void>;
1740
+ readonly required: false;
1741
+ readonly validator: ((val: unknown) => boolean) | undefined;
1742
+ __epPropKey: true;
1743
+ };
1744
+ onMouseleave: {
1745
+ readonly type: import('vue').PropType<(e: Event) => void>;
1746
+ readonly required: false;
1747
+ readonly validator: ((val: unknown) => boolean) | undefined;
1748
+ __epPropKey: true;
1749
+ };
1750
+ onClick: {
1751
+ readonly type: import('vue').PropType<(e: Event) => void>;
1752
+ readonly required: false;
1753
+ readonly validator: ((val: unknown) => boolean) | undefined;
1754
+ __epPropKey: true;
1755
+ };
1756
+ onKeydown: {
1757
+ readonly type: import('vue').PropType<(e: Event) => void>;
1758
+ readonly required: false;
1759
+ readonly validator: ((val: unknown) => boolean) | undefined;
1760
+ __epPropKey: true;
1761
+ };
1762
+ onFocus: {
1763
+ readonly type: import('vue').PropType<(e: Event) => void>;
1764
+ readonly required: false;
1765
+ readonly validator: ((val: unknown) => boolean) | undefined;
1766
+ __epPropKey: true;
1767
+ };
1768
+ onBlur: {
1769
+ readonly type: import('vue').PropType<(e: Event) => void>;
1770
+ readonly required: false;
1771
+ readonly validator: ((val: unknown) => boolean) | undefined;
1772
+ __epPropKey: true;
1773
+ };
1774
+ onContextmenu: {
1775
+ readonly type: import('vue').PropType<(e: Event) => void>;
1776
+ readonly required: false;
1777
+ readonly validator: ((val: unknown) => boolean) | undefined;
1778
+ __epPropKey: true;
1779
+ };
1780
+ id: StringConstructor;
1781
+ open: BooleanConstructor;
1782
+ ariaLabel: StringConstructor;
1783
+ appendTo: {
1784
+ readonly type: import('vue').PropType<string | HTMLElement>;
1785
+ readonly required: false;
1786
+ readonly validator: ((val: unknown) => boolean) | undefined;
1787
+ __epPropKey: true;
1788
+ };
1789
+ content: {
1790
+ readonly type: import('vue').PropType<string>;
1791
+ readonly required: false;
1792
+ readonly validator: ((val: unknown) => boolean) | undefined;
1793
+ __epPropKey: true;
1794
+ } & {
1795
+ readonly default: "";
1796
+ };
1797
+ rawContent: BooleanConstructor;
1798
+ persistent: BooleanConstructor;
1799
+ visible: {
1800
+ readonly type: import('vue').PropType<boolean | null>;
1801
+ readonly required: false;
1802
+ readonly validator: ((val: unknown) => boolean) | undefined;
1803
+ __epPropKey: true;
1804
+ } & {
1805
+ readonly default: null;
1806
+ };
1807
+ transition: StringConstructor;
1808
+ teleported: {
1809
+ readonly type: import('vue').PropType<boolean>;
1810
+ readonly required: false;
1811
+ readonly validator: ((val: unknown) => boolean) | undefined;
1812
+ __epPropKey: true;
1813
+ } & {
1814
+ readonly default: true;
1815
+ };
1816
+ style: {
1817
+ readonly type: import('vue').PropType<import('vue').StyleValue>;
1818
+ readonly required: false;
1819
+ readonly validator: ((val: unknown) => boolean) | undefined;
1820
+ __epPropKey: true;
1821
+ };
1822
+ className: {
1823
+ readonly type: import('vue').PropType<string | {
1824
+ [x: string]: boolean;
1825
+ } | (string | {
1826
+ [x: string]: boolean;
1827
+ } | (string | {
1828
+ [x: string]: boolean;
1829
+ } | (string | {
1830
+ [x: string]: boolean;
1831
+ } | (string | {
1832
+ [x: string]: boolean;
1833
+ } | (string | {
1834
+ [x: string]: boolean;
1835
+ } | (string | {
1836
+ [x: string]: boolean;
1837
+ } | (string | {
1838
+ [x: string]: boolean;
1839
+ } | (string | {
1840
+ [x: string]: boolean;
1841
+ } | (string | {
1842
+ [x: string]: boolean;
1843
+ } | (string | any[] | {
1844
+ [x: string]: boolean;
1845
+ })[])[])[])[])[])[])[])[])[])[]>;
1846
+ readonly required: false;
1847
+ readonly validator: ((val: unknown) => boolean) | undefined;
1848
+ __epPropKey: true;
1849
+ };
1850
+ effect: {
1851
+ readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
1852
+ readonly required: false;
1853
+ readonly validator: ((val: unknown) => boolean) | undefined;
1854
+ __epPropKey: true;
1855
+ } & {
1856
+ readonly default: "dark";
1857
+ };
1858
+ enterable: {
1859
+ readonly type: import('vue').PropType<boolean>;
1860
+ readonly required: false;
1861
+ readonly validator: ((val: unknown) => boolean) | undefined;
1862
+ __epPropKey: true;
1863
+ } & {
1864
+ readonly default: true;
1865
+ };
1866
+ pure: BooleanConstructor;
1867
+ focusOnShow: BooleanConstructor;
1868
+ trapping: BooleanConstructor;
1869
+ popperClass: {
1870
+ readonly type: import('vue').PropType<string | {
1871
+ [x: string]: boolean;
1872
+ } | (string | {
1873
+ [x: string]: boolean;
1874
+ } | (string | {
1875
+ [x: string]: boolean;
1876
+ } | (string | {
1877
+ [x: string]: boolean;
1878
+ } | (string | {
1879
+ [x: string]: boolean;
1880
+ } | (string | {
1881
+ [x: string]: boolean;
1882
+ } | (string | {
1883
+ [x: string]: boolean;
1884
+ } | (string | {
1885
+ [x: string]: boolean;
1886
+ } | (string | {
1887
+ [x: string]: boolean;
1888
+ } | (string | {
1889
+ [x: string]: boolean;
1890
+ } | (string | any[] | {
1891
+ [x: string]: boolean;
1892
+ })[])[])[])[])[])[])[])[])[])[]>;
1893
+ readonly required: false;
1894
+ readonly validator: ((val: unknown) => boolean) | undefined;
1895
+ __epPropKey: true;
1896
+ };
1897
+ popperStyle: {
1898
+ readonly type: import('vue').PropType<import('vue').StyleValue>;
1899
+ readonly required: false;
1900
+ readonly validator: ((val: unknown) => boolean) | undefined;
1901
+ __epPropKey: true;
1902
+ };
1903
+ referenceEl: {
1904
+ readonly type: import('vue').PropType<HTMLElement>;
1905
+ readonly required: false;
1906
+ readonly validator: ((val: unknown) => boolean) | undefined;
1907
+ __epPropKey: true;
1908
+ };
1909
+ triggerTargetEl: {
1910
+ readonly type: import('vue').PropType<HTMLElement>;
1911
+ readonly required: false;
1912
+ readonly validator: ((val: unknown) => boolean) | undefined;
1913
+ __epPropKey: true;
1914
+ };
1915
+ stopPopperMouseEvent: {
1916
+ readonly type: import('vue').PropType<boolean>;
1917
+ readonly required: false;
1918
+ readonly validator: ((val: unknown) => boolean) | undefined;
1919
+ __epPropKey: true;
1920
+ } & {
1921
+ readonly default: true;
1922
+ };
1923
+ zIndex: NumberConstructor;
1924
+ boundariesPadding: {
1925
+ readonly type: import('vue').PropType<number>;
1926
+ readonly required: false;
1927
+ readonly validator: ((val: unknown) => boolean) | undefined;
1928
+ __epPropKey: true;
1929
+ } & {
1930
+ readonly default: 0;
1931
+ };
1932
+ fallbackPlacements: {
1933
+ readonly type: import('vue').PropType<Placement[]>;
1934
+ readonly required: false;
1935
+ readonly validator: ((val: unknown) => boolean) | undefined;
1936
+ __epPropKey: true;
1937
+ } & {
1938
+ readonly default: undefined;
1939
+ };
1940
+ gpuAcceleration: {
1941
+ readonly type: import('vue').PropType<boolean>;
1942
+ readonly required: false;
1943
+ readonly validator: ((val: unknown) => boolean) | undefined;
1944
+ __epPropKey: true;
1945
+ } & {
1946
+ readonly default: true;
1947
+ };
1948
+ offset: {
1949
+ readonly type: import('vue').PropType<number>;
1950
+ readonly required: false;
1951
+ readonly validator: ((val: unknown) => boolean) | undefined;
1952
+ __epPropKey: true;
1953
+ } & {
1954
+ readonly default: 12;
1955
+ };
1956
+ placement: {
1957
+ readonly type: import('vue').PropType<string>;
1958
+ readonly required: false;
1959
+ readonly validator: ((val: unknown) => boolean) | undefined;
1960
+ __epPropKey: true;
1961
+ } & {
1962
+ readonly default: "bottom";
1963
+ };
1964
+ popperOptions: {
1965
+ readonly type: import('vue').PropType<any>;
1966
+ readonly required: false;
1967
+ readonly validator: ((val: unknown) => boolean) | undefined;
1968
+ __epPropKey: true;
1969
+ } & {
1970
+ readonly default: () => {};
1971
+ };
1972
+ strategy: {
1973
+ readonly type: import('vue').PropType<"fixed" | "absolute">;
1974
+ readonly required: false;
1975
+ readonly validator: ((val: unknown) => boolean) | undefined;
1976
+ __epPropKey: true;
1977
+ } & {
1978
+ readonly default: "absolute";
1979
+ };
1980
+ showAfter: {
1981
+ readonly type: import('vue').PropType<number>;
1982
+ readonly required: false;
1983
+ readonly validator: ((val: unknown) => boolean) | undefined;
1984
+ __epPropKey: true;
1985
+ } & {
1986
+ readonly default: 0;
1987
+ };
1988
+ hideAfter: {
1989
+ readonly type: import('vue').PropType<number>;
1990
+ readonly required: false;
1991
+ readonly validator: ((val: unknown) => boolean) | undefined;
1992
+ __epPropKey: true;
1993
+ } & {
1994
+ readonly default: 200;
1995
+ };
1996
+ autoClose: {
1997
+ readonly type: import('vue').PropType<number>;
1998
+ readonly required: false;
1999
+ readonly validator: ((val: unknown) => boolean) | undefined;
2000
+ __epPropKey: true;
2001
+ } & {
2002
+ readonly default: 0;
2003
+ };
2004
+ "onUpdate:visible": {
2005
+ readonly type: import('vue').PropType<(val: boolean) => void>;
2006
+ readonly required: false;
2007
+ readonly validator: ((val: unknown) => boolean) | undefined;
2008
+ __epPropKey: true;
2009
+ };
2010
+ role: {
2011
+ readonly type: import('vue').PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
2012
+ readonly required: false;
2013
+ readonly validator: ((val: unknown) => boolean) | undefined;
2014
+ __epPropKey: true;
2015
+ } & {
2016
+ readonly default: "tooltip";
2017
+ };
2018
+ }>>, {
2019
+ popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
2020
+ contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
2021
+ isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
2022
+ updatePopper: () => void;
2023
+ onOpen: (event?: Event, delay?: number) => void;
2024
+ onClose: (event?: Event, delay?: number) => void;
2025
+ hide: (event?: Event) => void;
2026
+ }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
2027
+ [x: string]: (...args: any[]) => void;
2028
+ }, string, {
2029
+ disabled: boolean;
2030
+ content: string;
2031
+ offset: number;
2032
+ visible: boolean | null;
2033
+ open: boolean;
2034
+ placement: string;
2035
+ strategy: "fixed" | "absolute";
2036
+ effect: import('element-plus').PopperEffect;
2037
+ showAfter: number;
2038
+ hideAfter: number;
2039
+ autoClose: number;
2040
+ role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
2041
+ trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
2042
+ virtualTriggering: boolean;
2043
+ arrowOffset: number;
2044
+ boundariesPadding: number;
2045
+ fallbackPlacements: Placement[];
2046
+ gpuAcceleration: boolean;
2047
+ popperOptions: Partial<Options>;
2048
+ enterable: boolean;
2049
+ stopPopperMouseEvent: boolean;
2050
+ pure: boolean;
2051
+ focusOnShow: boolean;
2052
+ trapping: boolean;
2053
+ triggerKeys: string[];
2054
+ focusOnTarget: boolean;
2055
+ teleported: boolean;
2056
+ rawContent: boolean;
2057
+ persistent: boolean;
2058
+ showArrow: boolean;
2059
+ }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
2060
+ beforeCreate?: (() => void) | (() => void)[];
2061
+ created?: (() => void) | (() => void)[];
2062
+ beforeMount?: (() => void) | (() => void)[];
2063
+ mounted?: (() => void) | (() => void)[];
2064
+ beforeUpdate?: (() => void) | (() => void)[];
2065
+ updated?: (() => void) | (() => void)[];
2066
+ activated?: (() => void) | (() => void)[];
2067
+ deactivated?: (() => void) | (() => void)[];
2068
+ beforeDestroy?: (() => void) | (() => void)[];
2069
+ beforeUnmount?: (() => void) | (() => void)[];
2070
+ destroyed?: (() => void) | (() => void)[];
2071
+ unmounted?: (() => void) | (() => void)[];
2072
+ renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
2073
+ renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
2074
+ errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
2075
+ };
2076
+ $forceUpdate: () => void;
2077
+ $nextTick: typeof import('vue').nextTick;
2078
+ $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
2079
+ } & Readonly<{
2080
+ disabled: boolean;
2081
+ content: string;
2082
+ offset: number;
2083
+ visible: boolean | null;
2084
+ open: boolean;
2085
+ placement: string;
2086
+ strategy: "fixed" | "absolute";
2087
+ effect: import('element-plus').PopperEffect;
2088
+ showAfter: number;
2089
+ hideAfter: number;
2090
+ autoClose: number;
2091
+ role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
2092
+ trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
2093
+ virtualTriggering: boolean;
2094
+ arrowOffset: number;
2095
+ boundariesPadding: number;
2096
+ fallbackPlacements: Placement[];
2097
+ gpuAcceleration: boolean;
2098
+ popperOptions: Partial<Options>;
2099
+ enterable: boolean;
2100
+ stopPopperMouseEvent: boolean;
2101
+ pure: boolean;
2102
+ focusOnShow: boolean;
2103
+ trapping: boolean;
2104
+ triggerKeys: string[];
2105
+ focusOnTarget: boolean;
2106
+ teleported: boolean;
2107
+ rawContent: boolean;
2108
+ persistent: boolean;
2109
+ showArrow: boolean;
2110
+ }> & Omit<Readonly<import('vue').ExtractPropTypes<{
2111
+ showArrow: {
2112
+ readonly type: import('vue').PropType<boolean>;
2113
+ readonly required: false;
2114
+ readonly validator: ((val: unknown) => boolean) | undefined;
2115
+ __epPropKey: true;
2116
+ } & {
2117
+ readonly default: boolean;
2118
+ };
2119
+ arrowOffset: {
2120
+ readonly type: import('vue').PropType<number>;
2121
+ readonly required: false;
2122
+ readonly validator: ((val: unknown) => boolean) | undefined;
2123
+ __epPropKey: true;
2124
+ } & {
2125
+ readonly default: 5;
2126
+ };
2127
+ disabled: BooleanConstructor;
2128
+ trigger: {
2129
+ readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
2130
+ readonly required: false;
2131
+ readonly validator: ((val: unknown) => boolean) | undefined;
2132
+ __epPropKey: true;
2133
+ } & {
2134
+ readonly default: "hover";
2135
+ };
2136
+ triggerKeys: {
2137
+ readonly type: import('vue').PropType<string[]>;
2138
+ readonly required: false;
2139
+ readonly validator: ((val: unknown) => boolean) | undefined;
2140
+ __epPropKey: true;
2141
+ } & {
2142
+ readonly default: () => string[];
2143
+ };
2144
+ focusOnTarget: BooleanConstructor;
2145
+ virtualRef: {
2146
+ readonly type: import('vue').PropType<import('element-plus').Measurable>;
2147
+ readonly required: false;
2148
+ readonly validator: ((val: unknown) => boolean) | undefined;
2149
+ __epPropKey: true;
2150
+ };
2151
+ virtualTriggering: BooleanConstructor;
2152
+ onMouseenter: {
2153
+ readonly type: import('vue').PropType<(e: Event) => void>;
2154
+ readonly required: false;
2155
+ readonly validator: ((val: unknown) => boolean) | undefined;
2156
+ __epPropKey: true;
2157
+ };
2158
+ onMouseleave: {
2159
+ readonly type: import('vue').PropType<(e: Event) => void>;
2160
+ readonly required: false;
2161
+ readonly validator: ((val: unknown) => boolean) | undefined;
2162
+ __epPropKey: true;
2163
+ };
2164
+ onClick: {
2165
+ readonly type: import('vue').PropType<(e: Event) => void>;
2166
+ readonly required: false;
2167
+ readonly validator: ((val: unknown) => boolean) | undefined;
2168
+ __epPropKey: true;
2169
+ };
2170
+ onKeydown: {
2171
+ readonly type: import('vue').PropType<(e: Event) => void>;
2172
+ readonly required: false;
2173
+ readonly validator: ((val: unknown) => boolean) | undefined;
2174
+ __epPropKey: true;
2175
+ };
2176
+ onFocus: {
2177
+ readonly type: import('vue').PropType<(e: Event) => void>;
2178
+ readonly required: false;
2179
+ readonly validator: ((val: unknown) => boolean) | undefined;
2180
+ __epPropKey: true;
2181
+ };
2182
+ onBlur: {
2183
+ readonly type: import('vue').PropType<(e: Event) => void>;
2184
+ readonly required: false;
2185
+ readonly validator: ((val: unknown) => boolean) | undefined;
2186
+ __epPropKey: true;
2187
+ };
2188
+ onContextmenu: {
2189
+ readonly type: import('vue').PropType<(e: Event) => void>;
2190
+ readonly required: false;
2191
+ readonly validator: ((val: unknown) => boolean) | undefined;
2192
+ __epPropKey: true;
2193
+ };
2194
+ id: StringConstructor;
2195
+ open: BooleanConstructor;
2196
+ ariaLabel: StringConstructor;
2197
+ appendTo: {
2198
+ readonly type: import('vue').PropType<string | HTMLElement>;
2199
+ readonly required: false;
2200
+ readonly validator: ((val: unknown) => boolean) | undefined;
2201
+ __epPropKey: true;
2202
+ };
2203
+ content: {
2204
+ readonly type: import('vue').PropType<string>;
2205
+ readonly required: false;
2206
+ readonly validator: ((val: unknown) => boolean) | undefined;
2207
+ __epPropKey: true;
2208
+ } & {
2209
+ readonly default: "";
2210
+ };
2211
+ rawContent: BooleanConstructor;
2212
+ persistent: BooleanConstructor;
2213
+ visible: {
2214
+ readonly type: import('vue').PropType<boolean | null>;
2215
+ readonly required: false;
2216
+ readonly validator: ((val: unknown) => boolean) | undefined;
2217
+ __epPropKey: true;
2218
+ } & {
2219
+ readonly default: null;
2220
+ };
2221
+ transition: StringConstructor;
2222
+ teleported: {
2223
+ readonly type: import('vue').PropType<boolean>;
2224
+ readonly required: false;
2225
+ readonly validator: ((val: unknown) => boolean) | undefined;
2226
+ __epPropKey: true;
2227
+ } & {
2228
+ readonly default: true;
2229
+ };
2230
+ style: {
2231
+ readonly type: import('vue').PropType<import('vue').StyleValue>;
2232
+ readonly required: false;
2233
+ readonly validator: ((val: unknown) => boolean) | undefined;
2234
+ __epPropKey: true;
2235
+ };
2236
+ className: {
2237
+ readonly type: import('vue').PropType<string | {
2238
+ [x: string]: boolean;
2239
+ } | (string | {
2240
+ [x: string]: boolean;
2241
+ } | (string | {
2242
+ [x: string]: boolean;
2243
+ } | (string | {
2244
+ [x: string]: boolean;
2245
+ } | (string | {
2246
+ [x: string]: boolean;
2247
+ } | (string | {
2248
+ [x: string]: boolean;
2249
+ } | (string | {
2250
+ [x: string]: boolean;
2251
+ } | (string | {
2252
+ [x: string]: boolean;
2253
+ } | (string | {
2254
+ [x: string]: boolean;
2255
+ } | (string | {
2256
+ [x: string]: boolean;
2257
+ } | (string | any[] | {
2258
+ [x: string]: boolean;
2259
+ })[])[])[])[])[])[])[])[])[])[]>;
2260
+ readonly required: false;
2261
+ readonly validator: ((val: unknown) => boolean) | undefined;
2262
+ __epPropKey: true;
2263
+ };
2264
+ effect: {
2265
+ readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
2266
+ readonly required: false;
2267
+ readonly validator: ((val: unknown) => boolean) | undefined;
2268
+ __epPropKey: true;
2269
+ } & {
2270
+ readonly default: "dark";
2271
+ };
2272
+ enterable: {
2273
+ readonly type: import('vue').PropType<boolean>;
2274
+ readonly required: false;
2275
+ readonly validator: ((val: unknown) => boolean) | undefined;
2276
+ __epPropKey: true;
2277
+ } & {
2278
+ readonly default: true;
2279
+ };
2280
+ pure: BooleanConstructor;
2281
+ focusOnShow: BooleanConstructor;
2282
+ trapping: BooleanConstructor;
2283
+ popperClass: {
2284
+ readonly type: import('vue').PropType<string | {
2285
+ [x: string]: boolean;
2286
+ } | (string | {
2287
+ [x: string]: boolean;
2288
+ } | (string | {
2289
+ [x: string]: boolean;
2290
+ } | (string | {
2291
+ [x: string]: boolean;
2292
+ } | (string | {
2293
+ [x: string]: boolean;
2294
+ } | (string | {
2295
+ [x: string]: boolean;
2296
+ } | (string | {
2297
+ [x: string]: boolean;
2298
+ } | (string | {
2299
+ [x: string]: boolean;
2300
+ } | (string | {
2301
+ [x: string]: boolean;
2302
+ } | (string | {
2303
+ [x: string]: boolean;
2304
+ } | (string | any[] | {
2305
+ [x: string]: boolean;
2306
+ })[])[])[])[])[])[])[])[])[])[]>;
2307
+ readonly required: false;
2308
+ readonly validator: ((val: unknown) => boolean) | undefined;
2309
+ __epPropKey: true;
2310
+ };
2311
+ popperStyle: {
2312
+ readonly type: import('vue').PropType<import('vue').StyleValue>;
2313
+ readonly required: false;
2314
+ readonly validator: ((val: unknown) => boolean) | undefined;
2315
+ __epPropKey: true;
2316
+ };
2317
+ referenceEl: {
2318
+ readonly type: import('vue').PropType<HTMLElement>;
2319
+ readonly required: false;
2320
+ readonly validator: ((val: unknown) => boolean) | undefined;
2321
+ __epPropKey: true;
2322
+ };
2323
+ triggerTargetEl: {
2324
+ readonly type: import('vue').PropType<HTMLElement>;
2325
+ readonly required: false;
2326
+ readonly validator: ((val: unknown) => boolean) | undefined;
2327
+ __epPropKey: true;
2328
+ };
2329
+ stopPopperMouseEvent: {
2330
+ readonly type: import('vue').PropType<boolean>;
2331
+ readonly required: false;
2332
+ readonly validator: ((val: unknown) => boolean) | undefined;
2333
+ __epPropKey: true;
2334
+ } & {
2335
+ readonly default: true;
2336
+ };
2337
+ zIndex: NumberConstructor;
2338
+ boundariesPadding: {
2339
+ readonly type: import('vue').PropType<number>;
2340
+ readonly required: false;
2341
+ readonly validator: ((val: unknown) => boolean) | undefined;
2342
+ __epPropKey: true;
2343
+ } & {
2344
+ readonly default: 0;
2345
+ };
2346
+ fallbackPlacements: {
2347
+ readonly type: import('vue').PropType<Placement[]>;
2348
+ readonly required: false;
2349
+ readonly validator: ((val: unknown) => boolean) | undefined;
2350
+ __epPropKey: true;
2351
+ } & {
2352
+ readonly default: undefined;
2353
+ };
2354
+ gpuAcceleration: {
2355
+ readonly type: import('vue').PropType<boolean>;
2356
+ readonly required: false;
2357
+ readonly validator: ((val: unknown) => boolean) | undefined;
2358
+ __epPropKey: true;
2359
+ } & {
2360
+ readonly default: true;
2361
+ };
2362
+ offset: {
2363
+ readonly type: import('vue').PropType<number>;
2364
+ readonly required: false;
2365
+ readonly validator: ((val: unknown) => boolean) | undefined;
2366
+ __epPropKey: true;
2367
+ } & {
2368
+ readonly default: 12;
2369
+ };
2370
+ placement: {
2371
+ readonly type: import('vue').PropType<string>;
2372
+ readonly required: false;
2373
+ readonly validator: ((val: unknown) => boolean) | undefined;
2374
+ __epPropKey: true;
2375
+ } & {
2376
+ readonly default: "bottom";
2377
+ };
2378
+ popperOptions: {
2379
+ readonly type: import('vue').PropType<any>;
2380
+ readonly required: false;
2381
+ readonly validator: ((val: unknown) => boolean) | undefined;
2382
+ __epPropKey: true;
2383
+ } & {
2384
+ readonly default: () => {};
2385
+ };
2386
+ strategy: {
2387
+ readonly type: import('vue').PropType<"fixed" | "absolute">;
2388
+ readonly required: false;
2389
+ readonly validator: ((val: unknown) => boolean) | undefined;
2390
+ __epPropKey: true;
2391
+ } & {
2392
+ readonly default: "absolute";
2393
+ };
2394
+ showAfter: {
2395
+ readonly type: import('vue').PropType<number>;
2396
+ readonly required: false;
2397
+ readonly validator: ((val: unknown) => boolean) | undefined;
2398
+ __epPropKey: true;
2399
+ } & {
2400
+ readonly default: 0;
2401
+ };
2402
+ hideAfter: {
2403
+ readonly type: import('vue').PropType<number>;
2404
+ readonly required: false;
2405
+ readonly validator: ((val: unknown) => boolean) | undefined;
2406
+ __epPropKey: true;
2407
+ } & {
2408
+ readonly default: 200;
2409
+ };
2410
+ autoClose: {
2411
+ readonly type: import('vue').PropType<number>;
2412
+ readonly required: false;
2413
+ readonly validator: ((val: unknown) => boolean) | undefined;
2414
+ __epPropKey: true;
2415
+ } & {
2416
+ readonly default: 0;
2417
+ };
2418
+ "onUpdate:visible": {
2419
+ readonly type: import('vue').PropType<(val: boolean) => void>;
2420
+ readonly required: false;
2421
+ readonly validator: ((val: unknown) => boolean) | undefined;
2422
+ __epPropKey: true;
2423
+ };
2424
+ role: {
2425
+ readonly type: import('vue').PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
2426
+ readonly required: false;
2427
+ readonly validator: ((val: unknown) => boolean) | undefined;
2428
+ __epPropKey: true;
2429
+ } & {
2430
+ readonly default: "tooltip";
2431
+ };
2432
+ }>>, "disabled" | "visible" | "placement" | "fallbackPlacements" | "popperOptions" | "onOpen" | "onClose" | "open" | "effect" | "teleported" | "persistent" | "showArrow" | "offset" | "popperRef" | "arrowOffset" | "trigger" | "triggerKeys" | "focusOnTarget" | "virtualTriggering" | "content" | "rawContent" | "enterable" | "pure" | "focusOnShow" | "trapping" | "stopPopperMouseEvent" | "boundariesPadding" | "gpuAcceleration" | "strategy" | "showAfter" | "hideAfter" | "autoClose" | "role" | "contentRef" | "isFocusInsideContent" | "updatePopper" | "hide"> & import('vue').ShallowUnwrapRef<{
2433
+ popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
2434
+ contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
2435
+ isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
2436
+ updatePopper: () => void;
2437
+ onOpen: (event?: Event, delay?: number) => void;
2438
+ onClose: (event?: Event, delay?: number) => void;
2439
+ hide: (event?: Event) => void;
2440
+ }> & {} & import('vue').ComponentCustomProperties & {} & {
2441
+ $slots: {
2442
+ default?(_: {}): any;
2443
+ content?(_: {}): any;
2444
+ };
2445
+ }) | null;
2446
+ }, any>;
24
2447
  declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
25
2448
  export default _default;
26
2449
  type __VLS_WithTemplateSlots<T, S> = T & {