sd-render 1.0.25 → 1.0.26

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 (34) hide show
  1. package/package.json +1 -1
  2. package/{sd-lib-Beap5Rlw.js → sd-lib-BRDqWpkQ.js} +3 -3
  3. package/{sd-render-E0INO1rV.js → sd-render-DK3Yjbxt.js} +2 -2
  4. package/sd-render.es.js +2 -2
  5. package/sd-render.style.css +1 -1
  6. package/types/src/components/input3/eltiptap/widget/ExtensionViews/ImageView.vue.d.ts +128 -622
  7. package/types/src/components/input3/eltiptap/widget/ExtensionViews/TaskItemView.vue.d.ts +109 -623
  8. package/types/src/components/input3/eltiptap/widget/MenuCommands/AddYoutubeCommandButton.vue.d.ts +541 -4734
  9. package/types/src/components/input3/eltiptap/widget/MenuCommands/ColorPopover.vue.d.ts +314 -1649
  10. package/types/src/components/input3/eltiptap/widget/MenuCommands/CommandButton.vue.d.ts +117 -1061
  11. package/types/src/components/input3/eltiptap/widget/MenuCommands/FontFamilyDropdown.vue.d.ts +1925 -645
  12. package/types/src/components/input3/eltiptap/widget/MenuCommands/FontSizeDropdown.vue.d.ts +1923 -645
  13. package/types/src/components/input3/eltiptap/widget/MenuCommands/HeadingDropdown.vue.d.ts +1923 -645
  14. package/types/src/components/input3/eltiptap/widget/MenuCommands/HighlightPopover.vue.d.ts +314 -1649
  15. package/types/src/components/input3/eltiptap/widget/MenuCommands/Image/EditImageCommandButton.vue.d.ts +444 -4366
  16. package/types/src/components/input3/eltiptap/widget/MenuCommands/Image/ImageDisplayCommandButton.vue.d.ts +129 -623
  17. package/types/src/components/input3/eltiptap/widget/MenuCommands/Image/InsertImageCommandButton.vue.d.ts +291 -1843
  18. package/types/src/components/input3/eltiptap/widget/MenuCommands/LineHeightDropdown.vue.d.ts +1923 -645
  19. package/types/src/components/input3/eltiptap/widget/MenuCommands/Link/AddLinkCommandButton.vue.d.ts +541 -4734
  20. package/types/src/components/input3/eltiptap/widget/MenuCommands/Link/EditLinkCommandButton.vue.d.ts +541 -4734
  21. package/types/src/components/input3/eltiptap/widget/MenuCommands/Link/UploadFileCommandButton.vue.d.ts +541 -4734
  22. package/types/src/components/input3/eltiptap/widget/MenuCommands/TablePopover/CreateTablePopover.vue.d.ts +129 -623
  23. package/types/src/components/input3/eltiptap/widget/MenuCommands/TablePopover/index.vue.d.ts +129 -623
  24. package/types/src/components/sdwidget/SDImportAndModified.vue.d.ts +1 -1
  25. package/types/src/components/sdwidget/SDImportData.vue.d.ts +1 -1
  26. package/types/src/components/sdwidget/SDImportMapData.vue.d.ts +1 -1
  27. package/types/src/components/sdwidget/SdCrudForm.vue.d.ts +38 -30
  28. package/types/src/components/sdwidget/SdCrudPopupForm.vue.d.ts +38 -30
  29. package/types/src/components/sdwidget/SdFormSchema.vue.d.ts +48 -1362
  30. package/types/src/components/sdwidget/SdFormSchemaForm.vue.d.ts +48 -1362
  31. package/types/src/components/sdwidget/SdGallery.vue.d.ts +144 -616
  32. package/types/src/components/sdwidget/SdReport.vue.d.ts +38 -30
  33. package/types/src/types/Connect.d.ts +1 -1
  34. package/types/src/types/StateStore.d.ts +1 -0
package/types/src/components/input3/eltiptap/widget/MenuCommands/TablePopover/CreateTablePopover.vue.d.ts CHANGED
@@ -16,515 +16,135 @@ declare const _default: import('vue').DefineComponent<{}, {
16
16
  selectTableGridSize(row: number, col: number): void;
17
17
  resetTableGridSize(): void;
18
18
  }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
19
- ElPopover: ({
20
- new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
21
- readonly trigger: {
22
- readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
23
- readonly required: false;
24
- readonly validator: ((val: unknown) => boolean) | undefined;
25
- __epPropKey: true;
26
- } & {
27
- readonly default: "hover";
28
- };
29
- readonly triggerKeys: {
30
- readonly type: import('vue').PropType<string[]>;
31
- readonly required: false;
32
- readonly validator: ((val: unknown) => boolean) | undefined;
33
- __epPropKey: true;
34
- } & {
35
- readonly default: () => string[];
36
- };
37
- readonly placement: {
38
- readonly type: import('vue').PropType<any>;
39
- readonly required: false;
40
- readonly validator: ((val: unknown) => boolean) | undefined;
41
- __epPropKey: true;
42
- } & {
43
- readonly default: "bottom";
44
- };
45
- readonly disabled: BooleanConstructor;
46
- readonly visible: {
47
- readonly type: import('vue').PropType<boolean | null>;
48
- readonly required: false;
49
- readonly validator: ((val: unknown) => boolean) | undefined;
50
- __epPropKey: true;
51
- } & {
52
- readonly default: null;
53
- };
54
- readonly transition: StringConstructor;
55
- readonly popperOptions: {
56
- readonly type: import('vue').PropType<any>;
57
- readonly required: false;
58
- readonly validator: ((val: unknown) => boolean) | undefined;
59
- __epPropKey: true;
60
- } & {
61
- readonly default: () => {};
62
- };
63
- readonly tabindex: {
64
- readonly type: import('vue').PropType<string | number>;
65
- readonly required: false;
66
- readonly validator: ((val: unknown) => boolean) | undefined;
67
- __epPropKey: true;
68
- } & {
69
- readonly default: 0;
70
- };
71
- readonly content: {
72
- readonly type: import('vue').PropType<string>;
73
- readonly required: false;
74
- readonly validator: ((val: unknown) => boolean) | undefined;
75
- __epPropKey: true;
76
- } & {
77
- readonly default: "";
78
- };
79
- readonly popperStyle: {
80
- readonly type: import('vue').PropType<import('vue').StyleValue>;
81
- readonly required: false;
82
- readonly validator: ((val: unknown) => boolean) | undefined;
83
- __epPropKey: true;
84
- };
85
- readonly popperClass: {
86
- readonly type: import('vue').PropType<string | {
87
- [x: string]: boolean;
88
- } | (string | {
89
- [x: string]: boolean;
90
- } | (string | {
91
- [x: string]: boolean;
92
- } | (string | {
93
- [x: string]: boolean;
94
- } | (string | {
95
- [x: string]: boolean;
96
- } | (string | {
97
- [x: string]: boolean;
98
- } | (string | {
99
- [x: string]: boolean;
100
- } | (string | {
101
- [x: string]: boolean;
102
- } | (string | {
103
- [x: string]: boolean;
104
- } | (string | {
105
- [x: string]: boolean;
106
- } | (string | any[] | {
107
- [x: string]: boolean;
108
- })[])[])[])[])[])[])[])[])[])[]>;
109
- readonly required: false;
110
- readonly validator: ((val: unknown) => boolean) | undefined;
111
- __epPropKey: true;
112
- };
113
- readonly enterable: {
114
- readonly default: true;
115
- readonly type: import('vue').PropType<boolean>;
116
- readonly required: false;
117
- readonly validator: ((val: unknown) => boolean) | undefined;
118
- readonly __epPropKey: true;
119
- };
120
- readonly effect: {
121
- readonly default: "light";
122
- readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
123
- readonly required: false;
124
- readonly validator: ((val: unknown) => boolean) | undefined;
125
- readonly __epPropKey: true;
126
- };
127
- readonly teleported: {
128
- readonly type: import('vue').PropType<boolean>;
129
- readonly required: false;
130
- readonly validator: ((val: unknown) => boolean) | undefined;
131
- __epPropKey: true;
132
- } & {
133
- readonly default: true;
134
- };
135
- readonly appendTo: {
136
- readonly type: import('vue').PropType<string | HTMLElement>;
137
- readonly required: false;
138
- readonly validator: ((val: unknown) => boolean) | undefined;
139
- __epPropKey: true;
140
- };
141
- readonly title: StringConstructor;
142
- readonly width: {
143
- readonly type: import('vue').PropType<string | number>;
144
- readonly required: false;
145
- readonly validator: ((val: unknown) => boolean) | undefined;
146
- __epPropKey: true;
147
- } & {
148
- readonly default: 150;
149
- };
150
- readonly offset: {
151
- readonly type: import('vue').PropType<number>;
152
- readonly required: false;
153
- readonly validator: ((val: unknown) => boolean) | undefined;
154
- __epPropKey: true;
155
- } & {
156
- readonly default: undefined;
157
- };
158
- readonly showAfter: {
159
- readonly type: import('vue').PropType<number>;
160
- readonly required: false;
161
- readonly validator: ((val: unknown) => boolean) | undefined;
162
- __epPropKey: true;
163
- } & {
164
- readonly default: 0;
165
- };
166
- readonly hideAfter: {
167
- readonly type: import('vue').PropType<number>;
168
- readonly required: false;
169
- readonly validator: ((val: unknown) => boolean) | undefined;
170
- __epPropKey: true;
171
- } & {
172
- readonly default: 200;
173
- };
174
- readonly autoClose: {
175
- readonly type: import('vue').PropType<number>;
176
- readonly required: false;
177
- readonly validator: ((val: unknown) => boolean) | undefined;
178
- __epPropKey: true;
179
- } & {
180
- readonly default: 0;
181
- };
182
- readonly showArrow: {
183
- readonly type: import('vue').PropType<boolean>;
184
- readonly required: false;
185
- readonly validator: ((val: unknown) => boolean) | undefined;
186
- __epPropKey: true;
187
- } & {
188
- readonly default: true;
189
- };
190
- readonly persistent: {
191
- readonly type: import('vue').PropType<boolean>;
192
- readonly required: false;
193
- readonly validator: ((val: unknown) => boolean) | undefined;
194
- __epPropKey: true;
195
- } & {
196
- readonly default: true;
197
- };
198
- readonly "onUpdate:visible": {
199
- readonly type: import('vue').PropType<(visible: boolean) => void>;
200
- readonly required: false;
201
- readonly validator: ((val: unknown) => boolean) | undefined;
202
- __epPropKey: true;
203
- };
204
- }>> & {
19
+ ElPopover: {
20
+ new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').PopoverProps> & Readonly<{
205
21
  "onUpdate:visible"?: ((value: boolean) => any) | undefined;
206
- "onAfter-enter"?: (() => any) | undefined;
207
- "onAfter-leave"?: (() => any) | undefined;
208
22
  "onBefore-enter"?: (() => any) | undefined;
209
23
  "onBefore-leave"?: (() => any) | undefined;
210
- }, {
24
+ "onAfter-enter"?: (() => any) | undefined;
25
+ "onAfter-leave"?: (() => any) | undefined;
26
+ }>, {
211
27
  popperRef: import('vue').ComputedRef<import('element-plus').PopperInstance | undefined>;
212
28
  hide: () => void;
213
- }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
214
- "after-enter": () => void;
215
- "after-leave": () => void;
29
+ }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
30
+ "update:visible": (value: boolean) => void;
216
31
  "before-enter": () => void;
217
32
  "before-leave": () => void;
218
- "update:visible": (value: boolean) => void;
219
- }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
220
- readonly disabled: boolean;
221
- readonly tabindex: string | number;
222
- readonly width: string | number;
223
- readonly content: string;
224
- readonly offset: number;
225
- readonly visible: boolean | null;
226
- readonly placement: any;
227
- readonly effect: import('element-plus').PopperEffect;
228
- readonly showAfter: number;
229
- readonly hideAfter: number;
230
- readonly autoClose: number;
231
- readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
232
- readonly popperOptions: Partial<Options>;
233
- readonly enterable: boolean;
234
- readonly triggerKeys: string[];
235
- readonly teleported: boolean;
236
- readonly persistent: boolean;
237
- readonly showArrow: boolean;
238
- }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
33
+ "after-enter": () => void;
34
+ "after-leave": () => void;
35
+ }, import('vue').PublicProps, {
36
+ effect: import('element-plus').PopperEffect;
37
+ placement: Placement;
38
+ popperStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
39
+ teleported: boolean;
40
+ persistent: boolean;
41
+ visible: boolean | null;
42
+ enterable: boolean;
43
+ offset: number;
44
+ popperOptions: Partial<Options>;
45
+ showArrow: boolean;
46
+ content: string;
47
+ showAfter: number;
48
+ hideAfter: number;
49
+ autoClose: number;
50
+ trigger: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
51
+ triggerKeys: string[];
52
+ width: string | number;
53
+ tabindex: string | number;
54
+ }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
239
55
  P: {};
240
56
  B: {};
241
57
  D: {};
242
58
  C: {};
243
59
  M: {};
244
60
  Defaults: {};
245
- }, Readonly<import('vue').ExtractPropTypes<{
246
- readonly trigger: {
247
- readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
248
- readonly required: false;
249
- readonly validator: ((val: unknown) => boolean) | undefined;
250
- __epPropKey: true;
251
- } & {
252
- readonly default: "hover";
253
- };
254
- readonly triggerKeys: {
255
- readonly type: import('vue').PropType<string[]>;
256
- readonly required: false;
257
- readonly validator: ((val: unknown) => boolean) | undefined;
258
- __epPropKey: true;
259
- } & {
260
- readonly default: () => string[];
261
- };
262
- readonly placement: {
263
- readonly type: import('vue').PropType<any>;
264
- readonly required: false;
265
- readonly validator: ((val: unknown) => boolean) | undefined;
266
- __epPropKey: true;
267
- } & {
268
- readonly default: "bottom";
269
- };
270
- readonly disabled: BooleanConstructor;
271
- readonly visible: {
272
- readonly type: import('vue').PropType<boolean | null>;
273
- readonly required: false;
274
- readonly validator: ((val: unknown) => boolean) | undefined;
275
- __epPropKey: true;
276
- } & {
277
- readonly default: null;
278
- };
279
- readonly transition: StringConstructor;
280
- readonly popperOptions: {
281
- readonly type: import('vue').PropType<any>;
282
- readonly required: false;
283
- readonly validator: ((val: unknown) => boolean) | undefined;
284
- __epPropKey: true;
285
- } & {
286
- readonly default: () => {};
287
- };
288
- readonly tabindex: {
289
- readonly type: import('vue').PropType<string | number>;
290
- readonly required: false;
291
- readonly validator: ((val: unknown) => boolean) | undefined;
292
- __epPropKey: true;
293
- } & {
294
- readonly default: 0;
295
- };
296
- readonly content: {
297
- readonly type: import('vue').PropType<string>;
298
- readonly required: false;
299
- readonly validator: ((val: unknown) => boolean) | undefined;
300
- __epPropKey: true;
301
- } & {
302
- readonly default: "";
303
- };
304
- readonly popperStyle: {
305
- readonly type: import('vue').PropType<import('vue').StyleValue>;
306
- readonly required: false;
307
- readonly validator: ((val: unknown) => boolean) | undefined;
308
- __epPropKey: true;
309
- };
310
- readonly popperClass: {
311
- readonly type: import('vue').PropType<string | {
312
- [x: string]: boolean;
313
- } | (string | {
314
- [x: string]: boolean;
315
- } | (string | {
316
- [x: string]: boolean;
317
- } | (string | {
318
- [x: string]: boolean;
319
- } | (string | {
320
- [x: string]: boolean;
321
- } | (string | {
322
- [x: string]: boolean;
323
- } | (string | {
324
- [x: string]: boolean;
325
- } | (string | {
326
- [x: string]: boolean;
327
- } | (string | {
328
- [x: string]: boolean;
329
- } | (string | {
330
- [x: string]: boolean;
331
- } | (string | any[] | {
332
- [x: string]: boolean;
333
- })[])[])[])[])[])[])[])[])[])[]>;
334
- readonly required: false;
335
- readonly validator: ((val: unknown) => boolean) | undefined;
336
- __epPropKey: true;
337
- };
338
- readonly enterable: {
339
- readonly default: true;
340
- readonly type: import('vue').PropType<boolean>;
341
- readonly required: false;
342
- readonly validator: ((val: unknown) => boolean) | undefined;
343
- readonly __epPropKey: true;
344
- };
345
- readonly effect: {
346
- readonly default: "light";
347
- readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
348
- readonly required: false;
349
- readonly validator: ((val: unknown) => boolean) | undefined;
350
- readonly __epPropKey: true;
351
- };
352
- readonly teleported: {
353
- readonly type: import('vue').PropType<boolean>;
354
- readonly required: false;
355
- readonly validator: ((val: unknown) => boolean) | undefined;
356
- __epPropKey: true;
357
- } & {
358
- readonly default: true;
359
- };
360
- readonly appendTo: {
361
- readonly type: import('vue').PropType<string | HTMLElement>;
362
- readonly required: false;
363
- readonly validator: ((val: unknown) => boolean) | undefined;
364
- __epPropKey: true;
365
- };
366
- readonly title: StringConstructor;
367
- readonly width: {
368
- readonly type: import('vue').PropType<string | number>;
369
- readonly required: false;
370
- readonly validator: ((val: unknown) => boolean) | undefined;
371
- __epPropKey: true;
372
- } & {
373
- readonly default: 150;
374
- };
375
- readonly offset: {
376
- readonly type: import('vue').PropType<number>;
377
- readonly required: false;
378
- readonly validator: ((val: unknown) => boolean) | undefined;
379
- __epPropKey: true;
380
- } & {
381
- readonly default: undefined;
382
- };
383
- readonly showAfter: {
384
- readonly type: import('vue').PropType<number>;
385
- readonly required: false;
386
- readonly validator: ((val: unknown) => boolean) | undefined;
387
- __epPropKey: true;
388
- } & {
389
- readonly default: 0;
390
- };
391
- readonly hideAfter: {
392
- readonly type: import('vue').PropType<number>;
393
- readonly required: false;
394
- readonly validator: ((val: unknown) => boolean) | undefined;
395
- __epPropKey: true;
396
- } & {
397
- readonly default: 200;
398
- };
399
- readonly autoClose: {
400
- readonly type: import('vue').PropType<number>;
401
- readonly required: false;
402
- readonly validator: ((val: unknown) => boolean) | undefined;
403
- __epPropKey: true;
404
- } & {
405
- readonly default: 0;
406
- };
407
- readonly showArrow: {
408
- readonly type: import('vue').PropType<boolean>;
409
- readonly required: false;
410
- readonly validator: ((val: unknown) => boolean) | undefined;
411
- __epPropKey: true;
412
- } & {
413
- readonly default: true;
414
- };
415
- readonly persistent: {
416
- readonly type: import('vue').PropType<boolean>;
417
- readonly required: false;
418
- readonly validator: ((val: unknown) => boolean) | undefined;
419
- __epPropKey: true;
420
- } & {
421
- readonly default: true;
422
- };
423
- readonly "onUpdate:visible": {
424
- readonly type: import('vue').PropType<(visible: boolean) => void>;
425
- readonly required: false;
426
- readonly validator: ((val: unknown) => boolean) | undefined;
427
- __epPropKey: true;
428
- };
429
- }>> & {
61
+ }, Readonly<import('element-plus').PopoverProps> & Readonly<{
430
62
  "onUpdate:visible"?: ((value: boolean) => any) | undefined;
431
- "onAfter-enter"?: (() => any) | undefined;
432
- "onAfter-leave"?: (() => any) | undefined;
433
63
  "onBefore-enter"?: (() => any) | undefined;
434
64
  "onBefore-leave"?: (() => any) | undefined;
435
- }, {
65
+ "onAfter-enter"?: (() => any) | undefined;
66
+ "onAfter-leave"?: (() => any) | undefined;
67
+ }>, {
436
68
  popperRef: import('vue').ComputedRef<import('element-plus').PopperInstance | undefined>;
437
69
  hide: () => void;
438
70
  }, {}, {}, {}, {
439
- readonly disabled: boolean;
440
- readonly tabindex: string | number;
441
- readonly width: string | number;
442
- readonly content: string;
443
- readonly offset: number;
444
- readonly visible: boolean | null;
445
- readonly placement: any;
446
- readonly effect: import('element-plus').PopperEffect;
447
- readonly showAfter: number;
448
- readonly hideAfter: number;
449
- readonly autoClose: number;
450
- readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
451
- readonly popperOptions: Partial<Options>;
452
- readonly enterable: boolean;
453
- readonly triggerKeys: string[];
454
- readonly teleported: boolean;
455
- readonly persistent: boolean;
456
- readonly showArrow: boolean;
71
+ effect: import('element-plus').PopperEffect;
72
+ placement: Placement;
73
+ popperStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
74
+ teleported: boolean;
75
+ persistent: boolean;
76
+ visible: boolean | null;
77
+ enterable: boolean;
78
+ offset: number;
79
+ popperOptions: Partial<Options>;
80
+ showArrow: boolean;
81
+ content: string;
82
+ showAfter: number;
83
+ hideAfter: number;
84
+ autoClose: number;
85
+ trigger: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
86
+ triggerKeys: string[];
87
+ width: string | number;
88
+ tabindex: string | number;
457
89
  }>;
458
90
  __isFragment?: never;
459
91
  __isTeleport?: never;
460
92
  __isSuspense?: never;
461
- } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
462
- readonly trigger: {
463
- readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
464
- readonly required: false;
465
- readonly validator: ((val: unknown) => boolean) | undefined;
466
- __epPropKey: true;
467
- } & {
468
- readonly default: "hover";
469
- };
470
- readonly triggerKeys: {
471
- readonly type: import('vue').PropType<string[]>;
472
- readonly required: false;
473
- readonly validator: ((val: unknown) => boolean) | undefined;
474
- __epPropKey: true;
475
- } & {
476
- readonly default: () => string[];
477
- };
478
- readonly placement: {
479
- readonly type: import('vue').PropType<any>;
480
- readonly required: false;
481
- readonly validator: ((val: unknown) => boolean) | undefined;
482
- __epPropKey: true;
483
- } & {
484
- readonly default: "bottom";
485
- };
486
- readonly disabled: BooleanConstructor;
487
- readonly visible: {
488
- readonly type: import('vue').PropType<boolean | null>;
489
- readonly required: false;
490
- readonly validator: ((val: unknown) => boolean) | undefined;
491
- __epPropKey: true;
492
- } & {
493
- readonly default: null;
494
- };
495
- readonly transition: StringConstructor;
496
- readonly popperOptions: {
497
- readonly type: import('vue').PropType<any>;
498
- readonly required: false;
499
- readonly validator: ((val: unknown) => boolean) | undefined;
500
- __epPropKey: true;
501
- } & {
502
- readonly default: () => {};
503
- };
504
- readonly tabindex: {
505
- readonly type: import('vue').PropType<string | number>;
506
- readonly required: false;
507
- readonly validator: ((val: unknown) => boolean) | undefined;
508
- __epPropKey: true;
509
- } & {
510
- readonly default: 0;
511
- };
512
- readonly content: {
513
- readonly type: import('vue').PropType<string>;
514
- readonly required: false;
515
- readonly validator: ((val: unknown) => boolean) | undefined;
516
- __epPropKey: true;
93
+ } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').PopoverProps> & Readonly<{
94
+ "onUpdate:visible"?: ((value: boolean) => any) | undefined;
95
+ "onBefore-enter"?: (() => any) | undefined;
96
+ "onBefore-leave"?: (() => any) | undefined;
97
+ "onAfter-enter"?: (() => any) | undefined;
98
+ "onAfter-leave"?: (() => any) | undefined;
99
+ }>, {
100
+ popperRef: import('vue').ComputedRef<import('element-plus').PopperInstance | undefined>;
101
+ hide: () => void;
102
+ }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
103
+ "update:visible": (value: boolean) => void;
104
+ "before-enter": () => void;
105
+ "before-leave": () => void;
106
+ "after-enter": () => void;
107
+ "after-leave": () => void;
108
+ }, string, {
109
+ effect: import('element-plus').PopperEffect;
110
+ placement: Placement;
111
+ popperStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
112
+ teleported: boolean;
113
+ persistent: boolean;
114
+ visible: boolean | null;
115
+ enterable: boolean;
116
+ offset: number;
117
+ popperOptions: Partial<Options>;
118
+ showArrow: boolean;
119
+ content: string;
120
+ showAfter: number;
121
+ hideAfter: number;
122
+ autoClose: number;
123
+ trigger: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
124
+ triggerKeys: string[];
125
+ width: string | number;
126
+ tabindex: string | number;
127
+ }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
128
+ $slots: {
129
+ reference?: (props: {}) => any;
517
130
  } & {
518
- readonly default: "";
519
- };
520
- readonly popperStyle: {
521
- readonly type: import('vue').PropType<import('vue').StyleValue>;
522
- readonly required: false;
523
- readonly validator: ((val: unknown) => boolean) | undefined;
524
- __epPropKey: true;
525
- };
526
- readonly popperClass: {
527
- readonly type: import('vue').PropType<string | {
131
+ default?: (props: {
132
+ hide: () => void;
133
+ }) => any;
134
+ };
135
+ }) & import('vue').ObjectPlugin & {
136
+ setPropsDefaults: (defaults: Partial<{
137
+ readonly trigger?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType> | undefined;
138
+ readonly triggerKeys?: string[] | undefined;
139
+ readonly placement?: Placement$1;
140
+ readonly disabled?: boolean | undefined;
141
+ readonly visible?: boolean | null | undefined;
142
+ readonly transition?: string | undefined;
143
+ readonly popperOptions?: Partial<Options>;
144
+ readonly tabindex?: string | number | undefined;
145
+ readonly content?: string | undefined;
146
+ readonly popperStyle?: import('vue').StyleValue;
147
+ readonly popperClass?: (string | {
528
148
  [x: string]: boolean;
529
149
  } | (string | {
530
150
  [x: string]: boolean;
@@ -544,145 +164,31 @@ declare const _default: import('vue').DefineComponent<{}, {
544
164
  [x: string]: boolean;
545
165
  } | (string | {
546
166
  [x: string]: boolean;
547
- } | (string | any[] | {
167
+ } | (string | {
548
168
  [x: string]: boolean;
549
- })[])[])[])[])[])[])[])[])[])[]>;
550
- readonly required: false;
551
- readonly validator: ((val: unknown) => boolean) | undefined;
552
- __epPropKey: true;
553
- };
554
- readonly enterable: {
555
- readonly default: true;
556
- readonly type: import('vue').PropType<boolean>;
557
- readonly required: false;
558
- readonly validator: ((val: unknown) => boolean) | undefined;
559
- readonly __epPropKey: true;
560
- };
561
- readonly effect: {
562
- readonly default: "light";
563
- readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
564
- readonly required: false;
565
- readonly validator: ((val: unknown) => boolean) | undefined;
566
- readonly __epPropKey: true;
567
- };
568
- readonly teleported: {
569
- readonly type: import('vue').PropType<boolean>;
570
- readonly required: false;
571
- readonly validator: ((val: unknown) => boolean) | undefined;
572
- __epPropKey: true;
573
- } & {
574
- readonly default: true;
575
- };
576
- readonly appendTo: {
577
- readonly type: import('vue').PropType<string | HTMLElement>;
578
- readonly required: false;
579
- readonly validator: ((val: unknown) => boolean) | undefined;
580
- __epPropKey: true;
581
- };
582
- readonly title: StringConstructor;
583
- readonly width: {
584
- readonly type: import('vue').PropType<string | number>;
585
- readonly required: false;
586
- readonly validator: ((val: unknown) => boolean) | undefined;
587
- __epPropKey: true;
588
- } & {
589
- readonly default: 150;
590
- };
591
- readonly offset: {
592
- readonly type: import('vue').PropType<number>;
593
- readonly required: false;
594
- readonly validator: ((val: unknown) => boolean) | undefined;
595
- __epPropKey: true;
596
- } & {
597
- readonly default: undefined;
598
- };
599
- readonly showAfter: {
600
- readonly type: import('vue').PropType<number>;
601
- readonly required: false;
602
- readonly validator: ((val: unknown) => boolean) | undefined;
603
- __epPropKey: true;
604
- } & {
605
- readonly default: 0;
606
- };
607
- readonly hideAfter: {
608
- readonly type: import('vue').PropType<number>;
609
- readonly required: false;
610
- readonly validator: ((val: unknown) => boolean) | undefined;
611
- __epPropKey: true;
612
- } & {
613
- readonly default: 200;
614
- };
615
- readonly autoClose: {
616
- readonly type: import('vue').PropType<number>;
617
- readonly required: false;
618
- readonly validator: ((val: unknown) => boolean) | undefined;
619
- __epPropKey: true;
620
- } & {
621
- readonly default: 0;
622
- };
623
- readonly showArrow: {
624
- readonly type: import('vue').PropType<boolean>;
625
- readonly required: false;
626
- readonly validator: ((val: unknown) => boolean) | undefined;
627
- __epPropKey: true;
628
- } & {
629
- readonly default: true;
630
- };
631
- readonly persistent: {
632
- readonly type: import('vue').PropType<boolean>;
633
- readonly required: false;
634
- readonly validator: ((val: unknown) => boolean) | undefined;
635
- __epPropKey: true;
636
- } & {
637
- readonly default: true;
638
- };
639
- readonly "onUpdate:visible": {
640
- readonly type: import('vue').PropType<(visible: boolean) => void>;
641
- readonly required: false;
642
- readonly validator: ((val: unknown) => boolean) | undefined;
643
- __epPropKey: true;
644
- };
645
- }>> & {
646
- "onUpdate:visible"?: ((value: boolean) => any) | undefined;
647
- "onAfter-enter"?: (() => any) | undefined;
648
- "onAfter-leave"?: (() => any) | undefined;
649
- "onBefore-enter"?: (() => any) | undefined;
650
- "onBefore-leave"?: (() => any) | undefined;
651
- }, {
652
- popperRef: import('vue').ComputedRef<import('element-plus').PopperInstance | undefined>;
653
- hide: () => void;
654
- }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
655
- "after-enter": () => void;
656
- "after-leave": () => void;
657
- "before-enter": () => void;
658
- "before-leave": () => void;
659
- "update:visible": (value: boolean) => void;
660
- }, string, {
661
- readonly disabled: boolean;
662
- readonly tabindex: string | number;
663
- readonly width: string | number;
664
- readonly content: string;
665
- readonly offset: number;
666
- readonly visible: boolean | null;
667
- readonly placement: any;
668
- readonly effect: import('element-plus').PopperEffect;
669
- readonly showAfter: number;
670
- readonly hideAfter: number;
671
- readonly autoClose: number;
672
- readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
673
- readonly popperOptions: Partial<Options>;
674
- readonly enterable: boolean;
675
- readonly triggerKeys: string[];
676
- readonly teleported: boolean;
677
- readonly persistent: boolean;
678
- readonly showArrow: boolean;
679
- }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
680
- $slots: {
681
- reference?(_: {}): any;
682
- default?(_: {}): any;
683
- };
684
- }) & import('vue').Plugin) & {
685
- directive: typeof import('element-plus').ElPopoverDirective;
169
+ } | (string | {
170
+ [x: string]: boolean;
171
+ } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | undefined;
172
+ readonly enterable?: boolean | undefined;
173
+ readonly effect?: import('element-plus').PopperEffect | undefined;
174
+ readonly teleported?: boolean | undefined;
175
+ readonly appendTo?: string | HTMLElement | undefined;
176
+ readonly title?: string | undefined;
177
+ readonly width?: string | number | undefined;
178
+ readonly offset?: number | undefined;
179
+ readonly showAfter?: number | undefined;
180
+ readonly hideAfter?: number | undefined;
181
+ readonly autoClose?: number | undefined;
182
+ readonly showArrow?: boolean | undefined;
183
+ readonly persistent?: boolean | undefined;
184
+ readonly "onUpdate:visible"?: (((visible: boolean) => void) & ((value: boolean) => any)) | undefined;
185
+ readonly "onBefore-enter"?: (() => any) | undefined | undefined;
186
+ readonly "onBefore-leave"?: (() => any) | undefined | undefined;
187
+ readonly "onAfter-enter"?: (() => any) | undefined | undefined;
188
+ readonly "onAfter-leave"?: (() => any) | undefined | undefined;
189
+ } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps>) => void;
190
+ } & {
191
+ directive: import('element-plus/es/utils/index.mjs').SFCWithInstall<import('vue').ObjectDirective<any, any, string, any>>;
686
192
  };
687
193
  }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
688
194
  export default _default;