ra-element 0.1.4 → 0.1.6

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 (26) hide show
  1. package/README.md +8 -1
  2. package/docs/ra-select.md +1 -0
  3. package/lib/components/index.d.ts +20 -1
  4. package/lib/components/ra-auto-scroll/index.vue.d.ts +100 -76
  5. package/lib/components/ra-button/index.vue.d.ts +772 -599
  6. package/lib/components/ra-checkbox-group/index.vue.d.ts +442 -329
  7. package/lib/components/ra-date-picker/index.vue.d.ts +1261 -1062
  8. package/lib/components/ra-dialog/index.vue.d.ts +1130 -931
  9. package/lib/components/ra-dialog-select/index.vue.d.ts +81 -57
  10. package/lib/components/ra-help-tip/index.vue.d.ts +65 -41
  11. package/lib/components/ra-input/index.vue.d.ts +1256 -1042
  12. package/lib/components/ra-pagination/index.vue.d.ts +643 -528
  13. package/lib/components/ra-radio-group/index.vue.d.ts +538 -425
  14. package/lib/components/ra-select/index.vue.d.ts +1759 -1647
  15. package/lib/components/ra-svg/index.vue.d.ts +35 -11
  16. package/lib/components/ra-table/component/pagination-group.vue.d.ts +104 -80
  17. package/lib/components/ra-textarea/index.vue.d.ts +55 -31
  18. package/lib/components/ra-tool-tip/index.vue.d.ts +38 -14
  19. package/lib/components/ra-tree-select/index.vue.d.ts +59 -35
  20. package/lib/components/ra-upload/index.vue.d.ts +173 -149
  21. package/lib/index.d.ts +6 -6
  22. package/lib/ra-element.css +1 -1
  23. package/lib/ra-element.es.js +2078 -2072
  24. package/lib/ra-element.umd.js +13 -13
  25. package/package.json +1 -1
  26. package/lib/index-CkAUSFIX.js +0 -4
package/lib/components/ra-dialog/index.vue.d.ts CHANGED
@@ -11,945 +11,1144 @@ declare function __VLS_template(): {
11
11
  rootEl: any;
12
12
  };
13
13
  type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
14
- declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
15
- appendToBody: {
16
- type: BooleanConstructor;
17
- default: boolean;
18
- };
19
- draggable: {
20
- type: BooleanConstructor;
21
- default: boolean;
22
- };
23
- destroyOnClose: {
24
- type: BooleanConstructor;
25
- default: boolean;
26
- };
27
- cssStyle: {
28
- type: StringConstructor;
29
- default: string;
30
- };
31
- }>, {
32
- component: import('vue').Ref<({
33
- $: import('vue').ComponentInternalInstance;
34
- $data: {};
35
- $props: Partial<{
36
- readonly title: string;
37
- readonly center: boolean;
38
- readonly overflow: boolean;
39
- readonly modelValue: boolean;
40
- readonly ariaLevel: string;
41
- readonly appendTo: string | HTMLElement;
42
- readonly showClose: boolean;
43
- readonly alignCenter: boolean;
44
- readonly draggable: boolean;
45
- readonly fullscreen: boolean;
46
- readonly closeOnClickModal: boolean;
47
- readonly closeOnPressEscape: boolean;
48
- readonly lockScroll: boolean;
49
- readonly modal: boolean;
50
- readonly openDelay: number;
51
- readonly closeDelay: number;
52
- readonly headerAriaLevel: string;
53
- readonly appendToBody: boolean;
54
- readonly destroyOnClose: boolean;
55
- readonly trapFocus: boolean;
56
- }> & Omit<{
57
- readonly title: string;
58
- readonly overflow: boolean;
59
- readonly modelValue: boolean;
60
- readonly appendToBody: boolean;
61
- readonly appendTo: string | HTMLElement;
62
- readonly destroyOnClose: boolean;
63
- readonly closeOnClickModal: boolean;
64
- readonly closeOnPressEscape: boolean;
65
- readonly lockScroll: boolean;
66
- readonly modal: boolean;
67
- readonly openDelay: number;
68
- readonly closeDelay: number;
69
- readonly trapFocus: boolean;
70
- readonly headerAriaLevel: string;
71
- readonly center: boolean;
72
- readonly alignCenter: boolean;
73
- readonly draggable: boolean;
74
- readonly fullscreen: boolean;
75
- readonly showClose: boolean;
76
- readonly ariaLevel: string;
77
- readonly width?: (string | number) | undefined;
78
- readonly top?: string | undefined;
79
- readonly beforeClose?: import('element-plus').DialogBeforeCloseFn | undefined;
80
- readonly modalClass?: string | undefined;
81
- readonly headerClass?: string | undefined;
82
- readonly bodyClass?: string | undefined;
83
- readonly footerClass?: string | undefined;
84
- readonly zIndex?: number | undefined;
85
- readonly closeIcon?: (string | import('vue').Component) | undefined;
86
- "onUpdate:modelValue"?: ((value: boolean) => any) | undefined | undefined;
87
- onOpen?: (() => any) | undefined | undefined;
88
- onClose?: (() => any) | undefined | undefined;
89
- onOpened?: (() => any) | undefined | undefined;
90
- onClosed?: (() => any) | undefined | undefined;
91
- onOpenAutoFocus?: (() => any) | undefined | undefined;
92
- onCloseAutoFocus?: (() => any) | undefined | undefined;
93
- } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "title" | "overflow" | "modelValue" | "appendToBody" | "appendTo" | "destroyOnClose" | "closeOnClickModal" | "closeOnPressEscape" | "lockScroll" | "modal" | "openDelay" | "closeDelay" | "trapFocus" | "headerAriaLevel" | "center" | "alignCenter" | "draggable" | "fullscreen" | "showClose" | "ariaLevel">;
94
- $attrs: {
95
- [x: string]: unknown;
96
- };
97
- $refs: {
98
- [x: string]: unknown;
99
- };
100
- $slots: Readonly<{
101
- [name: string]: import('vue').Slot<any> | undefined;
102
- }>;
103
- $root: import('vue').ComponentPublicInstance | null;
104
- $parent: import('vue').ComponentPublicInstance | null;
105
- $host: Element | null;
106
- $emit: ((event: "close") => void) & ((event: "update:modelValue", value: boolean) => void) & ((event: "open") => void) & ((event: "opened") => void) & ((event: "closed") => void) & ((event: "openAutoFocus") => void) & ((event: "closeAutoFocus") => void);
107
- $el: any;
108
- $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
109
- readonly appendToBody: BooleanConstructor;
110
- readonly appendTo: {
111
- readonly type: import('vue').PropType<string | HTMLElement>;
112
- readonly required: false;
113
- readonly validator: ((val: unknown) => boolean) | undefined;
114
- __epPropKey: true;
115
- } & {
116
- readonly default: "body";
117
- };
118
- readonly beforeClose: {
119
- readonly type: import('vue').PropType<import('element-plus').DialogBeforeCloseFn>;
120
- readonly required: false;
121
- readonly validator: ((val: unknown) => boolean) | undefined;
122
- __epPropKey: true;
123
- };
124
- readonly destroyOnClose: BooleanConstructor;
125
- readonly closeOnClickModal: {
126
- readonly type: import('vue').PropType<boolean>;
127
- readonly required: false;
128
- readonly validator: ((val: unknown) => boolean) | undefined;
129
- __epPropKey: true;
130
- } & {
131
- readonly default: true;
132
- };
133
- readonly closeOnPressEscape: {
134
- readonly type: import('vue').PropType<boolean>;
135
- readonly required: false;
136
- readonly validator: ((val: unknown) => boolean) | undefined;
137
- __epPropKey: true;
138
- } & {
139
- readonly default: true;
140
- };
141
- readonly lockScroll: {
142
- readonly type: import('vue').PropType<boolean>;
143
- readonly required: false;
144
- readonly validator: ((val: unknown) => boolean) | undefined;
145
- __epPropKey: true;
146
- } & {
147
- readonly default: true;
148
- };
149
- readonly modal: {
150
- readonly type: import('vue').PropType<boolean>;
151
- readonly required: false;
152
- readonly validator: ((val: unknown) => boolean) | undefined;
153
- __epPropKey: true;
154
- } & {
155
- readonly default: true;
156
- };
157
- readonly openDelay: {
158
- readonly type: import('vue').PropType<number>;
159
- readonly required: false;
160
- readonly validator: ((val: unknown) => boolean) | undefined;
161
- __epPropKey: true;
162
- } & {
163
- readonly default: 0;
164
- };
165
- readonly closeDelay: {
166
- readonly type: import('vue').PropType<number>;
167
- readonly required: false;
168
- readonly validator: ((val: unknown) => boolean) | undefined;
169
- __epPropKey: true;
170
- } & {
171
- readonly default: 0;
172
- };
173
- readonly top: {
174
- readonly type: import('vue').PropType<string>;
175
- readonly required: false;
176
- readonly validator: ((val: unknown) => boolean) | undefined;
177
- __epPropKey: true;
178
- };
179
- readonly modelValue: BooleanConstructor;
180
- readonly modalClass: StringConstructor;
181
- readonly headerClass: StringConstructor;
182
- readonly bodyClass: StringConstructor;
183
- readonly footerClass: StringConstructor;
184
- readonly width: {
185
- readonly type: import('vue').PropType<string | number>;
186
- readonly required: false;
187
- readonly validator: ((val: unknown) => boolean) | undefined;
188
- __epPropKey: true;
189
- };
190
- readonly zIndex: {
191
- readonly type: import('vue').PropType<number>;
192
- readonly required: false;
193
- readonly validator: ((val: unknown) => boolean) | undefined;
194
- __epPropKey: true;
195
- };
196
- readonly trapFocus: BooleanConstructor;
197
- readonly headerAriaLevel: {
198
- readonly type: import('vue').PropType<string>;
199
- readonly required: false;
200
- readonly validator: ((val: unknown) => boolean) | undefined;
201
- __epPropKey: true;
202
- } & {
203
- readonly default: "2";
204
- };
205
- readonly center: BooleanConstructor;
206
- readonly alignCenter: BooleanConstructor;
207
- readonly closeIcon: {
208
- readonly type: import('vue').PropType<string | import('vue').Component>;
209
- readonly required: false;
210
- readonly validator: ((val: unknown) => boolean) | undefined;
211
- __epPropKey: true;
212
- };
213
- readonly draggable: BooleanConstructor;
214
- readonly overflow: BooleanConstructor;
215
- readonly fullscreen: BooleanConstructor;
216
- readonly showClose: {
217
- readonly type: import('vue').PropType<boolean>;
218
- readonly required: false;
219
- readonly validator: ((val: unknown) => boolean) | undefined;
220
- __epPropKey: true;
221
- } & {
222
- readonly default: true;
223
- };
224
- readonly title: {
225
- readonly type: import('vue').PropType<string>;
226
- readonly required: false;
227
- readonly validator: ((val: unknown) => boolean) | undefined;
228
- __epPropKey: true;
229
- } & {
230
- readonly default: "";
231
- };
232
- readonly ariaLevel: {
233
- readonly type: import('vue').PropType<string>;
234
- readonly required: false;
235
- readonly validator: ((val: unknown) => boolean) | undefined;
236
- __epPropKey: true;
237
- } & {
238
- readonly default: "2";
239
- };
240
- }>> & {
241
- "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
242
- onOpen?: (() => any) | undefined;
243
- onClose?: (() => any) | undefined;
244
- onOpened?: (() => any) | undefined;
245
- onClosed?: (() => any) | undefined;
246
- onOpenAutoFocus?: (() => any) | undefined;
247
- onCloseAutoFocus?: (() => any) | undefined;
248
- }, {
249
- visible: import('vue').Ref<boolean>;
250
- dialogContentRef: import('vue').Ref<any>;
251
- resetPosition: () => void;
252
- handleClose: () => void;
253
- }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
254
- open: () => void;
255
- "update:modelValue": (value: boolean) => void;
256
- close: () => void;
257
- opened: () => void;
258
- closed: () => void;
259
- openAutoFocus: () => void;
260
- closeAutoFocus: () => void;
261
- }, string, {
262
- readonly title: string;
263
- readonly center: boolean;
264
- readonly overflow: boolean;
265
- readonly modelValue: boolean;
266
- readonly ariaLevel: string;
267
- readonly appendTo: string | HTMLElement;
268
- readonly showClose: boolean;
269
- readonly alignCenter: boolean;
270
- readonly draggable: boolean;
271
- readonly fullscreen: boolean;
272
- readonly closeOnClickModal: boolean;
273
- readonly closeOnPressEscape: boolean;
274
- readonly lockScroll: boolean;
275
- readonly modal: boolean;
276
- readonly openDelay: number;
277
- readonly closeDelay: number;
278
- readonly headerAriaLevel: string;
279
- readonly appendToBody: boolean;
280
- readonly destroyOnClose: boolean;
281
- readonly trapFocus: boolean;
282
- }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
283
- beforeCreate?: (() => void) | (() => void)[];
284
- created?: (() => void) | (() => void)[];
285
- beforeMount?: (() => void) | (() => void)[];
286
- mounted?: (() => void) | (() => void)[];
287
- beforeUpdate?: (() => void) | (() => void)[];
288
- updated?: (() => void) | (() => void)[];
289
- activated?: (() => void) | (() => void)[];
290
- deactivated?: (() => void) | (() => void)[];
291
- beforeDestroy?: (() => void) | (() => void)[];
292
- beforeUnmount?: (() => void) | (() => void)[];
293
- destroyed?: (() => void) | (() => void)[];
294
- unmounted?: (() => void) | (() => void)[];
295
- renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
296
- renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
297
- errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
298
- };
299
- $forceUpdate: () => void;
300
- $nextTick: typeof import('vue').nextTick;
301
- $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;
302
- } & Readonly<{
303
- readonly title: string;
304
- readonly center: boolean;
305
- readonly overflow: boolean;
306
- readonly modelValue: boolean;
307
- readonly ariaLevel: string;
308
- readonly appendTo: string | HTMLElement;
309
- readonly showClose: boolean;
310
- readonly alignCenter: boolean;
311
- readonly draggable: boolean;
312
- readonly fullscreen: boolean;
313
- readonly closeOnClickModal: boolean;
314
- readonly closeOnPressEscape: boolean;
315
- readonly lockScroll: boolean;
316
- readonly modal: boolean;
317
- readonly openDelay: number;
318
- readonly closeDelay: number;
319
- readonly headerAriaLevel: string;
320
- readonly appendToBody: boolean;
321
- readonly destroyOnClose: boolean;
322
- readonly trapFocus: boolean;
323
- }> & Omit<Readonly<import('vue').ExtractPropTypes<{
324
- readonly appendToBody: BooleanConstructor;
325
- readonly appendTo: {
326
- readonly type: import('vue').PropType<string | HTMLElement>;
327
- readonly required: false;
328
- readonly validator: ((val: unknown) => boolean) | undefined;
329
- __epPropKey: true;
330
- } & {
331
- readonly default: "body";
332
- };
333
- readonly beforeClose: {
334
- readonly type: import('vue').PropType<import('element-plus').DialogBeforeCloseFn>;
335
- readonly required: false;
336
- readonly validator: ((val: unknown) => boolean) | undefined;
337
- __epPropKey: true;
338
- };
339
- readonly destroyOnClose: BooleanConstructor;
340
- readonly closeOnClickModal: {
341
- readonly type: import('vue').PropType<boolean>;
342
- readonly required: false;
343
- readonly validator: ((val: unknown) => boolean) | undefined;
344
- __epPropKey: true;
345
- } & {
346
- readonly default: true;
347
- };
348
- readonly closeOnPressEscape: {
349
- readonly type: import('vue').PropType<boolean>;
350
- readonly required: false;
351
- readonly validator: ((val: unknown) => boolean) | undefined;
352
- __epPropKey: true;
353
- } & {
354
- readonly default: true;
355
- };
356
- readonly lockScroll: {
357
- readonly type: import('vue').PropType<boolean>;
358
- readonly required: false;
359
- readonly validator: ((val: unknown) => boolean) | undefined;
360
- __epPropKey: true;
361
- } & {
362
- readonly default: true;
363
- };
364
- readonly modal: {
365
- readonly type: import('vue').PropType<boolean>;
366
- readonly required: false;
367
- readonly validator: ((val: unknown) => boolean) | undefined;
368
- __epPropKey: true;
369
- } & {
370
- readonly default: true;
371
- };
372
- readonly openDelay: {
373
- readonly type: import('vue').PropType<number>;
374
- readonly required: false;
375
- readonly validator: ((val: unknown) => boolean) | undefined;
376
- __epPropKey: true;
377
- } & {
378
- readonly default: 0;
379
- };
380
- readonly closeDelay: {
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
- readonly top: {
389
- readonly type: import('vue').PropType<string>;
390
- readonly required: false;
391
- readonly validator: ((val: unknown) => boolean) | undefined;
392
- __epPropKey: true;
393
- };
394
- readonly modelValue: BooleanConstructor;
395
- readonly modalClass: StringConstructor;
396
- readonly headerClass: StringConstructor;
397
- readonly bodyClass: StringConstructor;
398
- readonly footerClass: StringConstructor;
399
- readonly width: {
400
- readonly type: import('vue').PropType<string | number>;
401
- readonly required: false;
402
- readonly validator: ((val: unknown) => boolean) | undefined;
403
- __epPropKey: true;
404
- };
405
- readonly zIndex: {
406
- readonly type: import('vue').PropType<number>;
407
- readonly required: false;
408
- readonly validator: ((val: unknown) => boolean) | undefined;
409
- __epPropKey: true;
410
- };
411
- readonly trapFocus: BooleanConstructor;
412
- readonly headerAriaLevel: {
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: "2";
419
- };
420
- readonly center: BooleanConstructor;
421
- readonly alignCenter: BooleanConstructor;
422
- readonly closeIcon: {
423
- readonly type: import('vue').PropType<string | import('vue').Component>;
424
- readonly required: false;
425
- readonly validator: ((val: unknown) => boolean) | undefined;
426
- __epPropKey: true;
427
- };
428
- readonly draggable: BooleanConstructor;
429
- readonly overflow: BooleanConstructor;
430
- readonly fullscreen: BooleanConstructor;
431
- readonly showClose: {
432
- readonly type: import('vue').PropType<boolean>;
433
- readonly required: false;
434
- readonly validator: ((val: unknown) => boolean) | undefined;
435
- __epPropKey: true;
436
- } & {
437
- readonly default: true;
438
- };
439
- readonly title: {
440
- readonly type: import('vue').PropType<string>;
441
- readonly required: false;
442
- readonly validator: ((val: unknown) => boolean) | undefined;
443
- __epPropKey: true;
444
- } & {
445
- readonly default: "";
14
+ declare const __VLS_component: import('vue').DefineComponent<
15
+ import('vue').ExtractPropTypes<{
16
+ appendToBody: {
17
+ type: BooleanConstructor;
18
+ default: boolean;
446
19
  };
447
- readonly ariaLevel: {
448
- readonly type: import('vue').PropType<string>;
449
- readonly required: false;
450
- readonly validator: ((val: unknown) => boolean) | undefined;
451
- __epPropKey: true;
452
- } & {
453
- readonly default: "2";
20
+ draggable: {
21
+ type: BooleanConstructor;
22
+ default: boolean;
454
23
  };
455
- }>> & {
456
- "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
457
- onOpen?: (() => any) | undefined;
458
- onClose?: (() => any) | undefined;
459
- onOpened?: (() => any) | undefined;
460
- onClosed?: (() => any) | undefined;
461
- onOpenAutoFocus?: (() => any) | undefined;
462
- onCloseAutoFocus?: (() => any) | undefined;
463
- }, "title" | "overflow" | "visible" | "modelValue" | "appendToBody" | "appendTo" | "destroyOnClose" | "closeOnClickModal" | "closeOnPressEscape" | "lockScroll" | "modal" | "openDelay" | "closeDelay" | "trapFocus" | "headerAriaLevel" | "center" | "alignCenter" | "draggable" | "fullscreen" | "showClose" | "ariaLevel" | "dialogContentRef" | "resetPosition" | "handleClose"> & import('vue').ShallowUnwrapRef<{
464
- visible: import('vue').Ref<boolean>;
465
- dialogContentRef: import('vue').Ref<any>;
466
- resetPosition: () => void;
467
- handleClose: () => void;
468
- }> & {} & import('vue').ComponentCustomProperties & {} & {
469
- $slots: {
470
- header?(_: {
471
- close: () => void;
472
- titleId: string;
473
- titleClass: string;
474
- }): any;
475
- title?(_: {}): any;
476
- default?(_: {}): any;
477
- footer?(_: {}): any;
24
+ destroyOnClose: {
25
+ type: BooleanConstructor;
26
+ default: boolean;
478
27
  };
479
- }) | null, ({
480
- $: import('vue').ComponentInternalInstance;
481
- $data: {};
482
- $props: Partial<{
483
- readonly title: string;
484
- readonly center: boolean;
485
- readonly overflow: boolean;
486
- readonly modelValue: boolean;
487
- readonly ariaLevel: string;
488
- readonly appendTo: string | HTMLElement;
489
- readonly showClose: boolean;
490
- readonly alignCenter: boolean;
491
- readonly draggable: boolean;
492
- readonly fullscreen: boolean;
493
- readonly closeOnClickModal: boolean;
494
- readonly closeOnPressEscape: boolean;
495
- readonly lockScroll: boolean;
496
- readonly modal: boolean;
497
- readonly openDelay: number;
498
- readonly closeDelay: number;
499
- readonly headerAriaLevel: string;
500
- readonly appendToBody: boolean;
501
- readonly destroyOnClose: boolean;
502
- readonly trapFocus: boolean;
503
- }> & Omit<{
504
- readonly title: string;
505
- readonly overflow: boolean;
506
- readonly modelValue: boolean;
507
- readonly appendToBody: boolean;
508
- readonly appendTo: string | HTMLElement;
509
- readonly destroyOnClose: boolean;
510
- readonly closeOnClickModal: boolean;
511
- readonly closeOnPressEscape: boolean;
512
- readonly lockScroll: boolean;
513
- readonly modal: boolean;
514
- readonly openDelay: number;
515
- readonly closeDelay: number;
516
- readonly trapFocus: boolean;
517
- readonly headerAriaLevel: string;
518
- readonly center: boolean;
519
- readonly alignCenter: boolean;
520
- readonly draggable: boolean;
521
- readonly fullscreen: boolean;
522
- readonly showClose: boolean;
523
- readonly ariaLevel: string;
524
- readonly width?: (string | number) | undefined;
525
- readonly top?: string | undefined;
526
- readonly beforeClose?: import('element-plus').DialogBeforeCloseFn | undefined;
527
- readonly modalClass?: string | undefined;
528
- readonly headerClass?: string | undefined;
529
- readonly bodyClass?: string | undefined;
530
- readonly footerClass?: string | undefined;
531
- readonly zIndex?: number | undefined;
532
- readonly closeIcon?: (string | import('vue').Component) | undefined;
533
- "onUpdate:modelValue"?: ((value: boolean) => any) | undefined | undefined;
534
- onOpen?: (() => any) | undefined | undefined;
535
- onClose?: (() => any) | undefined | undefined;
536
- onOpened?: (() => any) | undefined | undefined;
537
- onClosed?: (() => any) | undefined | undefined;
538
- onOpenAutoFocus?: (() => any) | undefined | undefined;
539
- onCloseAutoFocus?: (() => any) | undefined | undefined;
540
- } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "title" | "overflow" | "modelValue" | "appendToBody" | "appendTo" | "destroyOnClose" | "closeOnClickModal" | "closeOnPressEscape" | "lockScroll" | "modal" | "openDelay" | "closeDelay" | "trapFocus" | "headerAriaLevel" | "center" | "alignCenter" | "draggable" | "fullscreen" | "showClose" | "ariaLevel">;
541
- $attrs: {
542
- [x: string]: unknown;
28
+ cssStyle: {
29
+ type: StringConstructor;
30
+ default: string;
543
31
  };
544
- $refs: {
545
- [x: string]: unknown;
546
- };
547
- $slots: Readonly<{
548
- [name: string]: import('vue').Slot<any> | undefined;
549
- }>;
550
- $root: import('vue').ComponentPublicInstance | null;
551
- $parent: import('vue').ComponentPublicInstance | null;
552
- $host: Element | null;
553
- $emit: ((event: "close") => void) & ((event: "update:modelValue", value: boolean) => void) & ((event: "open") => void) & ((event: "opened") => void) & ((event: "closed") => void) & ((event: "openAutoFocus") => void) & ((event: "closeAutoFocus") => void);
554
- $el: any;
555
- $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
556
- readonly appendToBody: BooleanConstructor;
557
- readonly appendTo: {
558
- readonly type: import('vue').PropType<string | HTMLElement>;
559
- readonly required: false;
560
- readonly validator: ((val: unknown) => boolean) | undefined;
561
- __epPropKey: true;
562
- } & {
563
- readonly default: "body";
564
- };
565
- readonly beforeClose: {
566
- readonly type: import('vue').PropType<import('element-plus').DialogBeforeCloseFn>;
567
- readonly required: false;
568
- readonly validator: ((val: unknown) => boolean) | undefined;
569
- __epPropKey: true;
570
- };
571
- readonly destroyOnClose: BooleanConstructor;
572
- readonly closeOnClickModal: {
573
- readonly type: import('vue').PropType<boolean>;
574
- readonly required: false;
575
- readonly validator: ((val: unknown) => boolean) | undefined;
576
- __epPropKey: true;
577
- } & {
578
- readonly default: true;
579
- };
580
- readonly closeOnPressEscape: {
581
- readonly type: import('vue').PropType<boolean>;
582
- readonly required: false;
583
- readonly validator: ((val: unknown) => boolean) | undefined;
584
- __epPropKey: true;
585
- } & {
586
- readonly default: true;
587
- };
588
- readonly lockScroll: {
589
- readonly type: import('vue').PropType<boolean>;
590
- readonly required: false;
591
- readonly validator: ((val: unknown) => boolean) | undefined;
592
- __epPropKey: true;
593
- } & {
594
- readonly default: true;
595
- };
596
- readonly modal: {
597
- readonly type: import('vue').PropType<boolean>;
598
- readonly required: false;
599
- readonly validator: ((val: unknown) => boolean) | undefined;
600
- __epPropKey: true;
601
- } & {
602
- readonly default: true;
603
- };
604
- readonly openDelay: {
605
- readonly type: import('vue').PropType<number>;
606
- readonly required: false;
607
- readonly validator: ((val: unknown) => boolean) | undefined;
608
- __epPropKey: true;
609
- } & {
610
- readonly default: 0;
611
- };
612
- readonly closeDelay: {
613
- readonly type: import('vue').PropType<number>;
614
- readonly required: false;
615
- readonly validator: ((val: unknown) => boolean) | undefined;
616
- __epPropKey: true;
617
- } & {
618
- readonly default: 0;
619
- };
620
- readonly top: {
621
- readonly type: import('vue').PropType<string>;
622
- readonly required: false;
623
- readonly validator: ((val: unknown) => boolean) | undefined;
624
- __epPropKey: true;
32
+ }>,
33
+ {
34
+ component: import('vue').Ref<
35
+ | ({
36
+ $: import('vue').ComponentInternalInstance;
37
+ $data: {};
38
+ $props: Partial<{
39
+ readonly title: string;
40
+ readonly center: boolean;
41
+ readonly overflow: boolean;
42
+ readonly modelValue: boolean;
43
+ readonly ariaLevel: string;
44
+ readonly appendTo: string | HTMLElement;
45
+ readonly showClose: boolean;
46
+ readonly alignCenter: boolean;
47
+ readonly draggable: boolean;
48
+ readonly fullscreen: boolean;
49
+ readonly closeOnClickModal: boolean;
50
+ readonly closeOnPressEscape: boolean;
51
+ readonly lockScroll: boolean;
52
+ readonly modal: boolean;
53
+ readonly openDelay: number;
54
+ readonly closeDelay: number;
55
+ readonly headerAriaLevel: string;
56
+ readonly appendToBody: boolean;
57
+ readonly destroyOnClose: boolean;
58
+ readonly trapFocus: boolean;
59
+ }> &
60
+ Omit<
61
+ {
62
+ readonly title: string;
63
+ readonly overflow: boolean;
64
+ readonly modelValue: boolean;
65
+ readonly appendToBody: boolean;
66
+ readonly appendTo: string | HTMLElement;
67
+ readonly destroyOnClose: boolean;
68
+ readonly closeOnClickModal: boolean;
69
+ readonly closeOnPressEscape: boolean;
70
+ readonly lockScroll: boolean;
71
+ readonly modal: boolean;
72
+ readonly openDelay: number;
73
+ readonly closeDelay: number;
74
+ readonly trapFocus: boolean;
75
+ readonly headerAriaLevel: string;
76
+ readonly center: boolean;
77
+ readonly alignCenter: boolean;
78
+ readonly draggable: boolean;
79
+ readonly fullscreen: boolean;
80
+ readonly showClose: boolean;
81
+ readonly ariaLevel: string;
82
+ readonly width?: (string | number) | undefined;
83
+ readonly top?: string | undefined;
84
+ readonly beforeClose?: import('element-plus').DialogBeforeCloseFn | undefined;
85
+ readonly modalClass?: string | undefined;
86
+ readonly headerClass?: string | undefined;
87
+ readonly bodyClass?: string | undefined;
88
+ readonly footerClass?: string | undefined;
89
+ readonly zIndex?: number | undefined;
90
+ readonly closeIcon?: (string | import('vue').Component) | undefined;
91
+ 'onUpdate:modelValue'?: ((value: boolean) => any) | undefined | undefined;
92
+ onOpen?: (() => any) | undefined | undefined;
93
+ onClose?: (() => any) | undefined | undefined;
94
+ onOpened?: (() => any) | undefined | undefined;
95
+ onClosed?: (() => any) | undefined | undefined;
96
+ onOpenAutoFocus?: (() => any) | undefined | undefined;
97
+ onCloseAutoFocus?: (() => any) | undefined | undefined;
98
+ } & import('vue').VNodeProps &
99
+ import('vue').AllowedComponentProps &
100
+ import('vue').ComponentCustomProps,
101
+ | 'title'
102
+ | 'overflow'
103
+ | 'modelValue'
104
+ | 'appendToBody'
105
+ | 'appendTo'
106
+ | 'destroyOnClose'
107
+ | 'closeOnClickModal'
108
+ | 'closeOnPressEscape'
109
+ | 'lockScroll'
110
+ | 'modal'
111
+ | 'openDelay'
112
+ | 'closeDelay'
113
+ | 'trapFocus'
114
+ | 'headerAriaLevel'
115
+ | 'center'
116
+ | 'alignCenter'
117
+ | 'draggable'
118
+ | 'fullscreen'
119
+ | 'showClose'
120
+ | 'ariaLevel'
121
+ >;
122
+ $attrs: {
123
+ [x: string]: unknown;
124
+ };
125
+ $refs: {
126
+ [x: string]: unknown;
127
+ };
128
+ $slots: Readonly<{
129
+ [name: string]: import('vue').Slot<any> | undefined;
130
+ }>;
131
+ $root: import('vue').ComponentPublicInstance | null;
132
+ $parent: import('vue').ComponentPublicInstance | null;
133
+ $host: Element | null;
134
+ $emit: ((event: 'close') => void) &
135
+ ((event: 'update:modelValue', value: boolean) => void) &
136
+ ((event: 'open') => void) &
137
+ ((event: 'opened') => void) &
138
+ ((event: 'closed') => void) &
139
+ ((event: 'openAutoFocus') => void) &
140
+ ((event: 'closeAutoFocus') => void);
141
+ $el: any;
142
+ $options: import('vue').ComponentOptionsBase<
143
+ Readonly<
144
+ import('vue').ExtractPropTypes<{
145
+ readonly appendToBody: BooleanConstructor;
146
+ readonly appendTo: {
147
+ readonly type: import('vue').PropType<string | HTMLElement>;
148
+ readonly required: false;
149
+ readonly validator: ((val: unknown) => boolean) | undefined;
150
+ __epPropKey: true;
151
+ } & {
152
+ readonly default: 'body';
153
+ };
154
+ readonly beforeClose: {
155
+ readonly type: import('vue').PropType<import('element-plus').DialogBeforeCloseFn>;
156
+ readonly required: false;
157
+ readonly validator: ((val: unknown) => boolean) | undefined;
158
+ __epPropKey: true;
159
+ };
160
+ readonly destroyOnClose: BooleanConstructor;
161
+ readonly closeOnClickModal: {
162
+ readonly type: import('vue').PropType<boolean>;
163
+ readonly required: false;
164
+ readonly validator: ((val: unknown) => boolean) | undefined;
165
+ __epPropKey: true;
166
+ } & {
167
+ readonly default: true;
168
+ };
169
+ readonly closeOnPressEscape: {
170
+ readonly type: import('vue').PropType<boolean>;
171
+ readonly required: false;
172
+ readonly validator: ((val: unknown) => boolean) | undefined;
173
+ __epPropKey: true;
174
+ } & {
175
+ readonly default: true;
176
+ };
177
+ readonly lockScroll: {
178
+ readonly type: import('vue').PropType<boolean>;
179
+ readonly required: false;
180
+ readonly validator: ((val: unknown) => boolean) | undefined;
181
+ __epPropKey: true;
182
+ } & {
183
+ readonly default: true;
184
+ };
185
+ readonly modal: {
186
+ readonly type: import('vue').PropType<boolean>;
187
+ readonly required: false;
188
+ readonly validator: ((val: unknown) => boolean) | undefined;
189
+ __epPropKey: true;
190
+ } & {
191
+ readonly default: true;
192
+ };
193
+ readonly openDelay: {
194
+ readonly type: import('vue').PropType<number>;
195
+ readonly required: false;
196
+ readonly validator: ((val: unknown) => boolean) | undefined;
197
+ __epPropKey: true;
198
+ } & {
199
+ readonly default: 0;
200
+ };
201
+ readonly closeDelay: {
202
+ readonly type: import('vue').PropType<number>;
203
+ readonly required: false;
204
+ readonly validator: ((val: unknown) => boolean) | undefined;
205
+ __epPropKey: true;
206
+ } & {
207
+ readonly default: 0;
208
+ };
209
+ readonly top: {
210
+ readonly type: import('vue').PropType<string>;
211
+ readonly required: false;
212
+ readonly validator: ((val: unknown) => boolean) | undefined;
213
+ __epPropKey: true;
214
+ };
215
+ readonly modelValue: BooleanConstructor;
216
+ readonly modalClass: StringConstructor;
217
+ readonly headerClass: StringConstructor;
218
+ readonly bodyClass: StringConstructor;
219
+ readonly footerClass: StringConstructor;
220
+ readonly width: {
221
+ readonly type: import('vue').PropType<string | number>;
222
+ readonly required: false;
223
+ readonly validator: ((val: unknown) => boolean) | undefined;
224
+ __epPropKey: true;
225
+ };
226
+ readonly zIndex: {
227
+ readonly type: import('vue').PropType<number>;
228
+ readonly required: false;
229
+ readonly validator: ((val: unknown) => boolean) | undefined;
230
+ __epPropKey: true;
231
+ };
232
+ readonly trapFocus: BooleanConstructor;
233
+ readonly headerAriaLevel: {
234
+ readonly type: import('vue').PropType<string>;
235
+ readonly required: false;
236
+ readonly validator: ((val: unknown) => boolean) | undefined;
237
+ __epPropKey: true;
238
+ } & {
239
+ readonly default: '2';
240
+ };
241
+ readonly center: BooleanConstructor;
242
+ readonly alignCenter: BooleanConstructor;
243
+ readonly closeIcon: {
244
+ readonly type: import('vue').PropType<string | import('vue').Component>;
245
+ readonly required: false;
246
+ readonly validator: ((val: unknown) => boolean) | undefined;
247
+ __epPropKey: true;
248
+ };
249
+ readonly draggable: BooleanConstructor;
250
+ readonly overflow: BooleanConstructor;
251
+ readonly fullscreen: BooleanConstructor;
252
+ readonly showClose: {
253
+ readonly type: import('vue').PropType<boolean>;
254
+ readonly required: false;
255
+ readonly validator: ((val: unknown) => boolean) | undefined;
256
+ __epPropKey: true;
257
+ } & {
258
+ readonly default: true;
259
+ };
260
+ readonly title: {
261
+ readonly type: import('vue').PropType<string>;
262
+ readonly required: false;
263
+ readonly validator: ((val: unknown) => boolean) | undefined;
264
+ __epPropKey: true;
265
+ } & {
266
+ readonly default: '';
267
+ };
268
+ readonly ariaLevel: {
269
+ readonly type: import('vue').PropType<string>;
270
+ readonly required: false;
271
+ readonly validator: ((val: unknown) => boolean) | undefined;
272
+ __epPropKey: true;
273
+ } & {
274
+ readonly default: '2';
275
+ };
276
+ }>
277
+ > & {
278
+ 'onUpdate:modelValue'?: ((value: boolean) => any) | undefined;
279
+ onOpen?: (() => any) | undefined;
280
+ onClose?: (() => any) | undefined;
281
+ onOpened?: (() => any) | undefined;
282
+ onClosed?: (() => any) | undefined;
283
+ onOpenAutoFocus?: (() => any) | undefined;
284
+ onCloseAutoFocus?: (() => any) | undefined;
285
+ },
286
+ {
287
+ visible: import('vue').Ref<boolean>;
288
+ dialogContentRef: import('vue').Ref<any>;
289
+ resetPosition: () => void;
290
+ handleClose: () => void;
291
+ },
292
+ unknown,
293
+ {},
294
+ {},
295
+ import('vue').ComponentOptionsMixin,
296
+ import('vue').ComponentOptionsMixin,
297
+ {
298
+ open: () => void;
299
+ 'update:modelValue': (value: boolean) => void;
300
+ close: () => void;
301
+ opened: () => void;
302
+ closed: () => void;
303
+ openAutoFocus: () => void;
304
+ closeAutoFocus: () => void;
305
+ },
306
+ string,
307
+ {
308
+ readonly title: string;
309
+ readonly center: boolean;
310
+ readonly overflow: boolean;
311
+ readonly modelValue: boolean;
312
+ readonly ariaLevel: string;
313
+ readonly appendTo: string | HTMLElement;
314
+ readonly showClose: boolean;
315
+ readonly alignCenter: boolean;
316
+ readonly draggable: boolean;
317
+ readonly fullscreen: boolean;
318
+ readonly closeOnClickModal: boolean;
319
+ readonly closeOnPressEscape: boolean;
320
+ readonly lockScroll: boolean;
321
+ readonly modal: boolean;
322
+ readonly openDelay: number;
323
+ readonly closeDelay: number;
324
+ readonly headerAriaLevel: string;
325
+ readonly appendToBody: boolean;
326
+ readonly destroyOnClose: boolean;
327
+ readonly trapFocus: boolean;
328
+ },
329
+ {},
330
+ string,
331
+ {},
332
+ import('vue').GlobalComponents,
333
+ import('vue').GlobalDirectives,
334
+ string,
335
+ import('vue').ComponentProvideOptions
336
+ > & {
337
+ beforeCreate?: (() => void) | (() => void)[];
338
+ created?: (() => void) | (() => void)[];
339
+ beforeMount?: (() => void) | (() => void)[];
340
+ mounted?: (() => void) | (() => void)[];
341
+ beforeUpdate?: (() => void) | (() => void)[];
342
+ updated?: (() => void) | (() => void)[];
343
+ activated?: (() => void) | (() => void)[];
344
+ deactivated?: (() => void) | (() => void)[];
345
+ beforeDestroy?: (() => void) | (() => void)[];
346
+ beforeUnmount?: (() => void) | (() => void)[];
347
+ destroyed?: (() => void) | (() => void)[];
348
+ unmounted?: (() => void) | (() => void)[];
349
+ renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
350
+ renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
351
+ errorCaptured?:
352
+ | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)
353
+ | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
354
+ };
355
+ $forceUpdate: () => void;
356
+ $nextTick: typeof import('vue').nextTick;
357
+ $watch<T extends string | ((...args: any) => any)>(
358
+ source: T,
359
+ cb: T extends (...args: any) => infer R
360
+ ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any
361
+ : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any,
362
+ options?: import('vue').WatchOptions,
363
+ ): import('vue').WatchStopHandle;
364
+ } & Readonly<{
365
+ readonly title: string;
366
+ readonly center: boolean;
367
+ readonly overflow: boolean;
368
+ readonly modelValue: boolean;
369
+ readonly ariaLevel: string;
370
+ readonly appendTo: string | HTMLElement;
371
+ readonly showClose: boolean;
372
+ readonly alignCenter: boolean;
373
+ readonly draggable: boolean;
374
+ readonly fullscreen: boolean;
375
+ readonly closeOnClickModal: boolean;
376
+ readonly closeOnPressEscape: boolean;
377
+ readonly lockScroll: boolean;
378
+ readonly modal: boolean;
379
+ readonly openDelay: number;
380
+ readonly closeDelay: number;
381
+ readonly headerAriaLevel: string;
382
+ readonly appendToBody: boolean;
383
+ readonly destroyOnClose: boolean;
384
+ readonly trapFocus: boolean;
385
+ }> &
386
+ Omit<
387
+ Readonly<
388
+ import('vue').ExtractPropTypes<{
389
+ readonly appendToBody: BooleanConstructor;
390
+ readonly appendTo: {
391
+ readonly type: import('vue').PropType<string | HTMLElement>;
392
+ readonly required: false;
393
+ readonly validator: ((val: unknown) => boolean) | undefined;
394
+ __epPropKey: true;
395
+ } & {
396
+ readonly default: 'body';
397
+ };
398
+ readonly beforeClose: {
399
+ readonly type: import('vue').PropType<import('element-plus').DialogBeforeCloseFn>;
400
+ readonly required: false;
401
+ readonly validator: ((val: unknown) => boolean) | undefined;
402
+ __epPropKey: true;
403
+ };
404
+ readonly destroyOnClose: BooleanConstructor;
405
+ readonly closeOnClickModal: {
406
+ readonly type: import('vue').PropType<boolean>;
407
+ readonly required: false;
408
+ readonly validator: ((val: unknown) => boolean) | undefined;
409
+ __epPropKey: true;
410
+ } & {
411
+ readonly default: true;
412
+ };
413
+ readonly closeOnPressEscape: {
414
+ readonly type: import('vue').PropType<boolean>;
415
+ readonly required: false;
416
+ readonly validator: ((val: unknown) => boolean) | undefined;
417
+ __epPropKey: true;
418
+ } & {
419
+ readonly default: true;
420
+ };
421
+ readonly lockScroll: {
422
+ readonly type: import('vue').PropType<boolean>;
423
+ readonly required: false;
424
+ readonly validator: ((val: unknown) => boolean) | undefined;
425
+ __epPropKey: true;
426
+ } & {
427
+ readonly default: true;
428
+ };
429
+ readonly modal: {
430
+ readonly type: import('vue').PropType<boolean>;
431
+ readonly required: false;
432
+ readonly validator: ((val: unknown) => boolean) | undefined;
433
+ __epPropKey: true;
434
+ } & {
435
+ readonly default: true;
436
+ };
437
+ readonly openDelay: {
438
+ readonly type: import('vue').PropType<number>;
439
+ readonly required: false;
440
+ readonly validator: ((val: unknown) => boolean) | undefined;
441
+ __epPropKey: true;
442
+ } & {
443
+ readonly default: 0;
444
+ };
445
+ readonly closeDelay: {
446
+ readonly type: import('vue').PropType<number>;
447
+ readonly required: false;
448
+ readonly validator: ((val: unknown) => boolean) | undefined;
449
+ __epPropKey: true;
450
+ } & {
451
+ readonly default: 0;
452
+ };
453
+ readonly top: {
454
+ readonly type: import('vue').PropType<string>;
455
+ readonly required: false;
456
+ readonly validator: ((val: unknown) => boolean) | undefined;
457
+ __epPropKey: true;
458
+ };
459
+ readonly modelValue: BooleanConstructor;
460
+ readonly modalClass: StringConstructor;
461
+ readonly headerClass: StringConstructor;
462
+ readonly bodyClass: StringConstructor;
463
+ readonly footerClass: StringConstructor;
464
+ readonly width: {
465
+ readonly type: import('vue').PropType<string | number>;
466
+ readonly required: false;
467
+ readonly validator: ((val: unknown) => boolean) | undefined;
468
+ __epPropKey: true;
469
+ };
470
+ readonly zIndex: {
471
+ readonly type: import('vue').PropType<number>;
472
+ readonly required: false;
473
+ readonly validator: ((val: unknown) => boolean) | undefined;
474
+ __epPropKey: true;
475
+ };
476
+ readonly trapFocus: BooleanConstructor;
477
+ readonly headerAriaLevel: {
478
+ readonly type: import('vue').PropType<string>;
479
+ readonly required: false;
480
+ readonly validator: ((val: unknown) => boolean) | undefined;
481
+ __epPropKey: true;
482
+ } & {
483
+ readonly default: '2';
484
+ };
485
+ readonly center: BooleanConstructor;
486
+ readonly alignCenter: BooleanConstructor;
487
+ readonly closeIcon: {
488
+ readonly type: import('vue').PropType<string | import('vue').Component>;
489
+ readonly required: false;
490
+ readonly validator: ((val: unknown) => boolean) | undefined;
491
+ __epPropKey: true;
492
+ };
493
+ readonly draggable: BooleanConstructor;
494
+ readonly overflow: BooleanConstructor;
495
+ readonly fullscreen: BooleanConstructor;
496
+ readonly showClose: {
497
+ readonly type: import('vue').PropType<boolean>;
498
+ readonly required: false;
499
+ readonly validator: ((val: unknown) => boolean) | undefined;
500
+ __epPropKey: true;
501
+ } & {
502
+ readonly default: true;
503
+ };
504
+ readonly title: {
505
+ readonly type: import('vue').PropType<string>;
506
+ readonly required: false;
507
+ readonly validator: ((val: unknown) => boolean) | undefined;
508
+ __epPropKey: true;
509
+ } & {
510
+ readonly default: '';
511
+ };
512
+ readonly ariaLevel: {
513
+ readonly type: import('vue').PropType<string>;
514
+ readonly required: false;
515
+ readonly validator: ((val: unknown) => boolean) | undefined;
516
+ __epPropKey: true;
517
+ } & {
518
+ readonly default: '2';
519
+ };
520
+ }>
521
+ > & {
522
+ 'onUpdate:modelValue'?: ((value: boolean) => any) | undefined;
523
+ onOpen?: (() => any) | undefined;
524
+ onClose?: (() => any) | undefined;
525
+ onOpened?: (() => any) | undefined;
526
+ onClosed?: (() => any) | undefined;
527
+ onOpenAutoFocus?: (() => any) | undefined;
528
+ onCloseAutoFocus?: (() => any) | undefined;
529
+ },
530
+ | 'title'
531
+ | 'overflow'
532
+ | 'visible'
533
+ | 'modelValue'
534
+ | 'appendToBody'
535
+ | 'appendTo'
536
+ | 'destroyOnClose'
537
+ | 'closeOnClickModal'
538
+ | 'closeOnPressEscape'
539
+ | 'lockScroll'
540
+ | 'modal'
541
+ | 'openDelay'
542
+ | 'closeDelay'
543
+ | 'trapFocus'
544
+ | 'headerAriaLevel'
545
+ | 'center'
546
+ | 'alignCenter'
547
+ | 'draggable'
548
+ | 'fullscreen'
549
+ | 'showClose'
550
+ | 'ariaLevel'
551
+ | 'dialogContentRef'
552
+ | 'resetPosition'
553
+ | 'handleClose'
554
+ > &
555
+ import('vue').ShallowUnwrapRef<{
556
+ visible: import('vue').Ref<boolean>;
557
+ dialogContentRef: import('vue').Ref<any>;
558
+ resetPosition: () => void;
559
+ handleClose: () => void;
560
+ }> & {} & import('vue').ComponentCustomProperties & {} & {
561
+ $slots: {
562
+ header?(_: { close: () => void; titleId: string; titleClass: string }): any;
563
+ title?(_: {}): any;
564
+ default?(_: {}): any;
565
+ footer?(_: {}): any;
566
+ };
567
+ })
568
+ | null,
569
+ | ({
570
+ $: import('vue').ComponentInternalInstance;
571
+ $data: {};
572
+ $props: Partial<{
573
+ readonly title: string;
574
+ readonly center: boolean;
575
+ readonly overflow: boolean;
576
+ readonly modelValue: boolean;
577
+ readonly ariaLevel: string;
578
+ readonly appendTo: string | HTMLElement;
579
+ readonly showClose: boolean;
580
+ readonly alignCenter: boolean;
581
+ readonly draggable: boolean;
582
+ readonly fullscreen: boolean;
583
+ readonly closeOnClickModal: boolean;
584
+ readonly closeOnPressEscape: boolean;
585
+ readonly lockScroll: boolean;
586
+ readonly modal: boolean;
587
+ readonly openDelay: number;
588
+ readonly closeDelay: number;
589
+ readonly headerAriaLevel: string;
590
+ readonly appendToBody: boolean;
591
+ readonly destroyOnClose: boolean;
592
+ readonly trapFocus: boolean;
593
+ }> &
594
+ Omit<
595
+ {
596
+ readonly title: string;
597
+ readonly overflow: boolean;
598
+ readonly modelValue: boolean;
599
+ readonly appendToBody: boolean;
600
+ readonly appendTo: string | HTMLElement;
601
+ readonly destroyOnClose: boolean;
602
+ readonly closeOnClickModal: boolean;
603
+ readonly closeOnPressEscape: boolean;
604
+ readonly lockScroll: boolean;
605
+ readonly modal: boolean;
606
+ readonly openDelay: number;
607
+ readonly closeDelay: number;
608
+ readonly trapFocus: boolean;
609
+ readonly headerAriaLevel: string;
610
+ readonly center: boolean;
611
+ readonly alignCenter: boolean;
612
+ readonly draggable: boolean;
613
+ readonly fullscreen: boolean;
614
+ readonly showClose: boolean;
615
+ readonly ariaLevel: string;
616
+ readonly width?: (string | number) | undefined;
617
+ readonly top?: string | undefined;
618
+ readonly beforeClose?: import('element-plus').DialogBeforeCloseFn | undefined;
619
+ readonly modalClass?: string | undefined;
620
+ readonly headerClass?: string | undefined;
621
+ readonly bodyClass?: string | undefined;
622
+ readonly footerClass?: string | undefined;
623
+ readonly zIndex?: number | undefined;
624
+ readonly closeIcon?: (string | import('vue').Component) | undefined;
625
+ 'onUpdate:modelValue'?: ((value: boolean) => any) | undefined | undefined;
626
+ onOpen?: (() => any) | undefined | undefined;
627
+ onClose?: (() => any) | undefined | undefined;
628
+ onOpened?: (() => any) | undefined | undefined;
629
+ onClosed?: (() => any) | undefined | undefined;
630
+ onOpenAutoFocus?: (() => any) | undefined | undefined;
631
+ onCloseAutoFocus?: (() => any) | undefined | undefined;
632
+ } & import('vue').VNodeProps &
633
+ import('vue').AllowedComponentProps &
634
+ import('vue').ComponentCustomProps,
635
+ | 'title'
636
+ | 'overflow'
637
+ | 'modelValue'
638
+ | 'appendToBody'
639
+ | 'appendTo'
640
+ | 'destroyOnClose'
641
+ | 'closeOnClickModal'
642
+ | 'closeOnPressEscape'
643
+ | 'lockScroll'
644
+ | 'modal'
645
+ | 'openDelay'
646
+ | 'closeDelay'
647
+ | 'trapFocus'
648
+ | 'headerAriaLevel'
649
+ | 'center'
650
+ | 'alignCenter'
651
+ | 'draggable'
652
+ | 'fullscreen'
653
+ | 'showClose'
654
+ | 'ariaLevel'
655
+ >;
656
+ $attrs: {
657
+ [x: string]: unknown;
658
+ };
659
+ $refs: {
660
+ [x: string]: unknown;
661
+ };
662
+ $slots: Readonly<{
663
+ [name: string]: import('vue').Slot<any> | undefined;
664
+ }>;
665
+ $root: import('vue').ComponentPublicInstance | null;
666
+ $parent: import('vue').ComponentPublicInstance | null;
667
+ $host: Element | null;
668
+ $emit: ((event: 'close') => void) &
669
+ ((event: 'update:modelValue', value: boolean) => void) &
670
+ ((event: 'open') => void) &
671
+ ((event: 'opened') => void) &
672
+ ((event: 'closed') => void) &
673
+ ((event: 'openAutoFocus') => void) &
674
+ ((event: 'closeAutoFocus') => void);
675
+ $el: any;
676
+ $options: import('vue').ComponentOptionsBase<
677
+ Readonly<
678
+ import('vue').ExtractPropTypes<{
679
+ readonly appendToBody: BooleanConstructor;
680
+ readonly appendTo: {
681
+ readonly type: import('vue').PropType<string | HTMLElement>;
682
+ readonly required: false;
683
+ readonly validator: ((val: unknown) => boolean) | undefined;
684
+ __epPropKey: true;
685
+ } & {
686
+ readonly default: 'body';
687
+ };
688
+ readonly beforeClose: {
689
+ readonly type: import('vue').PropType<import('element-plus').DialogBeforeCloseFn>;
690
+ readonly required: false;
691
+ readonly validator: ((val: unknown) => boolean) | undefined;
692
+ __epPropKey: true;
693
+ };
694
+ readonly destroyOnClose: BooleanConstructor;
695
+ readonly closeOnClickModal: {
696
+ readonly type: import('vue').PropType<boolean>;
697
+ readonly required: false;
698
+ readonly validator: ((val: unknown) => boolean) | undefined;
699
+ __epPropKey: true;
700
+ } & {
701
+ readonly default: true;
702
+ };
703
+ readonly closeOnPressEscape: {
704
+ readonly type: import('vue').PropType<boolean>;
705
+ readonly required: false;
706
+ readonly validator: ((val: unknown) => boolean) | undefined;
707
+ __epPropKey: true;
708
+ } & {
709
+ readonly default: true;
710
+ };
711
+ readonly lockScroll: {
712
+ readonly type: import('vue').PropType<boolean>;
713
+ readonly required: false;
714
+ readonly validator: ((val: unknown) => boolean) | undefined;
715
+ __epPropKey: true;
716
+ } & {
717
+ readonly default: true;
718
+ };
719
+ readonly modal: {
720
+ readonly type: import('vue').PropType<boolean>;
721
+ readonly required: false;
722
+ readonly validator: ((val: unknown) => boolean) | undefined;
723
+ __epPropKey: true;
724
+ } & {
725
+ readonly default: true;
726
+ };
727
+ readonly openDelay: {
728
+ readonly type: import('vue').PropType<number>;
729
+ readonly required: false;
730
+ readonly validator: ((val: unknown) => boolean) | undefined;
731
+ __epPropKey: true;
732
+ } & {
733
+ readonly default: 0;
734
+ };
735
+ readonly closeDelay: {
736
+ readonly type: import('vue').PropType<number>;
737
+ readonly required: false;
738
+ readonly validator: ((val: unknown) => boolean) | undefined;
739
+ __epPropKey: true;
740
+ } & {
741
+ readonly default: 0;
742
+ };
743
+ readonly top: {
744
+ readonly type: import('vue').PropType<string>;
745
+ readonly required: false;
746
+ readonly validator: ((val: unknown) => boolean) | undefined;
747
+ __epPropKey: true;
748
+ };
749
+ readonly modelValue: BooleanConstructor;
750
+ readonly modalClass: StringConstructor;
751
+ readonly headerClass: StringConstructor;
752
+ readonly bodyClass: StringConstructor;
753
+ readonly footerClass: StringConstructor;
754
+ readonly width: {
755
+ readonly type: import('vue').PropType<string | number>;
756
+ readonly required: false;
757
+ readonly validator: ((val: unknown) => boolean) | undefined;
758
+ __epPropKey: true;
759
+ };
760
+ readonly zIndex: {
761
+ readonly type: import('vue').PropType<number>;
762
+ readonly required: false;
763
+ readonly validator: ((val: unknown) => boolean) | undefined;
764
+ __epPropKey: true;
765
+ };
766
+ readonly trapFocus: BooleanConstructor;
767
+ readonly headerAriaLevel: {
768
+ readonly type: import('vue').PropType<string>;
769
+ readonly required: false;
770
+ readonly validator: ((val: unknown) => boolean) | undefined;
771
+ __epPropKey: true;
772
+ } & {
773
+ readonly default: '2';
774
+ };
775
+ readonly center: BooleanConstructor;
776
+ readonly alignCenter: BooleanConstructor;
777
+ readonly closeIcon: {
778
+ readonly type: import('vue').PropType<string | import('vue').Component>;
779
+ readonly required: false;
780
+ readonly validator: ((val: unknown) => boolean) | undefined;
781
+ __epPropKey: true;
782
+ };
783
+ readonly draggable: BooleanConstructor;
784
+ readonly overflow: BooleanConstructor;
785
+ readonly fullscreen: BooleanConstructor;
786
+ readonly showClose: {
787
+ readonly type: import('vue').PropType<boolean>;
788
+ readonly required: false;
789
+ readonly validator: ((val: unknown) => boolean) | undefined;
790
+ __epPropKey: true;
791
+ } & {
792
+ readonly default: true;
793
+ };
794
+ readonly title: {
795
+ readonly type: import('vue').PropType<string>;
796
+ readonly required: false;
797
+ readonly validator: ((val: unknown) => boolean) | undefined;
798
+ __epPropKey: true;
799
+ } & {
800
+ readonly default: '';
801
+ };
802
+ readonly ariaLevel: {
803
+ readonly type: import('vue').PropType<string>;
804
+ readonly required: false;
805
+ readonly validator: ((val: unknown) => boolean) | undefined;
806
+ __epPropKey: true;
807
+ } & {
808
+ readonly default: '2';
809
+ };
810
+ }>
811
+ > & {
812
+ 'onUpdate:modelValue'?: ((value: boolean) => any) | undefined;
813
+ onOpen?: (() => any) | undefined;
814
+ onClose?: (() => any) | undefined;
815
+ onOpened?: (() => any) | undefined;
816
+ onClosed?: (() => any) | undefined;
817
+ onOpenAutoFocus?: (() => any) | undefined;
818
+ onCloseAutoFocus?: (() => any) | undefined;
819
+ },
820
+ {
821
+ visible: import('vue').Ref<boolean>;
822
+ dialogContentRef: import('vue').Ref<any>;
823
+ resetPosition: () => void;
824
+ handleClose: () => void;
825
+ },
826
+ unknown,
827
+ {},
828
+ {},
829
+ import('vue').ComponentOptionsMixin,
830
+ import('vue').ComponentOptionsMixin,
831
+ {
832
+ open: () => void;
833
+ 'update:modelValue': (value: boolean) => void;
834
+ close: () => void;
835
+ opened: () => void;
836
+ closed: () => void;
837
+ openAutoFocus: () => void;
838
+ closeAutoFocus: () => void;
839
+ },
840
+ string,
841
+ {
842
+ readonly title: string;
843
+ readonly center: boolean;
844
+ readonly overflow: boolean;
845
+ readonly modelValue: boolean;
846
+ readonly ariaLevel: string;
847
+ readonly appendTo: string | HTMLElement;
848
+ readonly showClose: boolean;
849
+ readonly alignCenter: boolean;
850
+ readonly draggable: boolean;
851
+ readonly fullscreen: boolean;
852
+ readonly closeOnClickModal: boolean;
853
+ readonly closeOnPressEscape: boolean;
854
+ readonly lockScroll: boolean;
855
+ readonly modal: boolean;
856
+ readonly openDelay: number;
857
+ readonly closeDelay: number;
858
+ readonly headerAriaLevel: string;
859
+ readonly appendToBody: boolean;
860
+ readonly destroyOnClose: boolean;
861
+ readonly trapFocus: boolean;
862
+ },
863
+ {},
864
+ string,
865
+ {},
866
+ import('vue').GlobalComponents,
867
+ import('vue').GlobalDirectives,
868
+ string,
869
+ import('vue').ComponentProvideOptions
870
+ > & {
871
+ beforeCreate?: (() => void) | (() => void)[];
872
+ created?: (() => void) | (() => void)[];
873
+ beforeMount?: (() => void) | (() => void)[];
874
+ mounted?: (() => void) | (() => void)[];
875
+ beforeUpdate?: (() => void) | (() => void)[];
876
+ updated?: (() => void) | (() => void)[];
877
+ activated?: (() => void) | (() => void)[];
878
+ deactivated?: (() => void) | (() => void)[];
879
+ beforeDestroy?: (() => void) | (() => void)[];
880
+ beforeUnmount?: (() => void) | (() => void)[];
881
+ destroyed?: (() => void) | (() => void)[];
882
+ unmounted?: (() => void) | (() => void)[];
883
+ renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
884
+ renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
885
+ errorCaptured?:
886
+ | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)
887
+ | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
888
+ };
889
+ $forceUpdate: () => void;
890
+ $nextTick: typeof import('vue').nextTick;
891
+ $watch<T extends string | ((...args: any) => any)>(
892
+ source: T,
893
+ cb: T extends (...args: any) => infer R
894
+ ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any
895
+ : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any,
896
+ options?: import('vue').WatchOptions,
897
+ ): import('vue').WatchStopHandle;
898
+ } & Readonly<{
899
+ readonly title: string;
900
+ readonly center: boolean;
901
+ readonly overflow: boolean;
902
+ readonly modelValue: boolean;
903
+ readonly ariaLevel: string;
904
+ readonly appendTo: string | HTMLElement;
905
+ readonly showClose: boolean;
906
+ readonly alignCenter: boolean;
907
+ readonly draggable: boolean;
908
+ readonly fullscreen: boolean;
909
+ readonly closeOnClickModal: boolean;
910
+ readonly closeOnPressEscape: boolean;
911
+ readonly lockScroll: boolean;
912
+ readonly modal: boolean;
913
+ readonly openDelay: number;
914
+ readonly closeDelay: number;
915
+ readonly headerAriaLevel: string;
916
+ readonly appendToBody: boolean;
917
+ readonly destroyOnClose: boolean;
918
+ readonly trapFocus: boolean;
919
+ }> &
920
+ Omit<
921
+ Readonly<
922
+ import('vue').ExtractPropTypes<{
923
+ readonly appendToBody: BooleanConstructor;
924
+ readonly appendTo: {
925
+ readonly type: import('vue').PropType<string | HTMLElement>;
926
+ readonly required: false;
927
+ readonly validator: ((val: unknown) => boolean) | undefined;
928
+ __epPropKey: true;
929
+ } & {
930
+ readonly default: 'body';
931
+ };
932
+ readonly beforeClose: {
933
+ readonly type: import('vue').PropType<import('element-plus').DialogBeforeCloseFn>;
934
+ readonly required: false;
935
+ readonly validator: ((val: unknown) => boolean) | undefined;
936
+ __epPropKey: true;
937
+ };
938
+ readonly destroyOnClose: BooleanConstructor;
939
+ readonly closeOnClickModal: {
940
+ readonly type: import('vue').PropType<boolean>;
941
+ readonly required: false;
942
+ readonly validator: ((val: unknown) => boolean) | undefined;
943
+ __epPropKey: true;
944
+ } & {
945
+ readonly default: true;
946
+ };
947
+ readonly closeOnPressEscape: {
948
+ readonly type: import('vue').PropType<boolean>;
949
+ readonly required: false;
950
+ readonly validator: ((val: unknown) => boolean) | undefined;
951
+ __epPropKey: true;
952
+ } & {
953
+ readonly default: true;
954
+ };
955
+ readonly lockScroll: {
956
+ readonly type: import('vue').PropType<boolean>;
957
+ readonly required: false;
958
+ readonly validator: ((val: unknown) => boolean) | undefined;
959
+ __epPropKey: true;
960
+ } & {
961
+ readonly default: true;
962
+ };
963
+ readonly modal: {
964
+ readonly type: import('vue').PropType<boolean>;
965
+ readonly required: false;
966
+ readonly validator: ((val: unknown) => boolean) | undefined;
967
+ __epPropKey: true;
968
+ } & {
969
+ readonly default: true;
970
+ };
971
+ readonly openDelay: {
972
+ readonly type: import('vue').PropType<number>;
973
+ readonly required: false;
974
+ readonly validator: ((val: unknown) => boolean) | undefined;
975
+ __epPropKey: true;
976
+ } & {
977
+ readonly default: 0;
978
+ };
979
+ readonly closeDelay: {
980
+ readonly type: import('vue').PropType<number>;
981
+ readonly required: false;
982
+ readonly validator: ((val: unknown) => boolean) | undefined;
983
+ __epPropKey: true;
984
+ } & {
985
+ readonly default: 0;
986
+ };
987
+ readonly top: {
988
+ readonly type: import('vue').PropType<string>;
989
+ readonly required: false;
990
+ readonly validator: ((val: unknown) => boolean) | undefined;
991
+ __epPropKey: true;
992
+ };
993
+ readonly modelValue: BooleanConstructor;
994
+ readonly modalClass: StringConstructor;
995
+ readonly headerClass: StringConstructor;
996
+ readonly bodyClass: StringConstructor;
997
+ readonly footerClass: StringConstructor;
998
+ readonly width: {
999
+ readonly type: import('vue').PropType<string | number>;
1000
+ readonly required: false;
1001
+ readonly validator: ((val: unknown) => boolean) | undefined;
1002
+ __epPropKey: true;
1003
+ };
1004
+ readonly zIndex: {
1005
+ readonly type: import('vue').PropType<number>;
1006
+ readonly required: false;
1007
+ readonly validator: ((val: unknown) => boolean) | undefined;
1008
+ __epPropKey: true;
1009
+ };
1010
+ readonly trapFocus: BooleanConstructor;
1011
+ readonly headerAriaLevel: {
1012
+ readonly type: import('vue').PropType<string>;
1013
+ readonly required: false;
1014
+ readonly validator: ((val: unknown) => boolean) | undefined;
1015
+ __epPropKey: true;
1016
+ } & {
1017
+ readonly default: '2';
1018
+ };
1019
+ readonly center: BooleanConstructor;
1020
+ readonly alignCenter: BooleanConstructor;
1021
+ readonly closeIcon: {
1022
+ readonly type: import('vue').PropType<string | import('vue').Component>;
1023
+ readonly required: false;
1024
+ readonly validator: ((val: unknown) => boolean) | undefined;
1025
+ __epPropKey: true;
1026
+ };
1027
+ readonly draggable: BooleanConstructor;
1028
+ readonly overflow: BooleanConstructor;
1029
+ readonly fullscreen: BooleanConstructor;
1030
+ readonly showClose: {
1031
+ readonly type: import('vue').PropType<boolean>;
1032
+ readonly required: false;
1033
+ readonly validator: ((val: unknown) => boolean) | undefined;
1034
+ __epPropKey: true;
1035
+ } & {
1036
+ readonly default: true;
1037
+ };
1038
+ readonly title: {
1039
+ readonly type: import('vue').PropType<string>;
1040
+ readonly required: false;
1041
+ readonly validator: ((val: unknown) => boolean) | undefined;
1042
+ __epPropKey: true;
1043
+ } & {
1044
+ readonly default: '';
1045
+ };
1046
+ readonly ariaLevel: {
1047
+ readonly type: import('vue').PropType<string>;
1048
+ readonly required: false;
1049
+ readonly validator: ((val: unknown) => boolean) | undefined;
1050
+ __epPropKey: true;
1051
+ } & {
1052
+ readonly default: '2';
1053
+ };
1054
+ }>
1055
+ > & {
1056
+ 'onUpdate:modelValue'?: ((value: boolean) => any) | undefined;
1057
+ onOpen?: (() => any) | undefined;
1058
+ onClose?: (() => any) | undefined;
1059
+ onOpened?: (() => any) | undefined;
1060
+ onClosed?: (() => any) | undefined;
1061
+ onOpenAutoFocus?: (() => any) | undefined;
1062
+ onCloseAutoFocus?: (() => any) | undefined;
1063
+ },
1064
+ | 'title'
1065
+ | 'overflow'
1066
+ | 'visible'
1067
+ | 'modelValue'
1068
+ | 'appendToBody'
1069
+ | 'appendTo'
1070
+ | 'destroyOnClose'
1071
+ | 'closeOnClickModal'
1072
+ | 'closeOnPressEscape'
1073
+ | 'lockScroll'
1074
+ | 'modal'
1075
+ | 'openDelay'
1076
+ | 'closeDelay'
1077
+ | 'trapFocus'
1078
+ | 'headerAriaLevel'
1079
+ | 'center'
1080
+ | 'alignCenter'
1081
+ | 'draggable'
1082
+ | 'fullscreen'
1083
+ | 'showClose'
1084
+ | 'ariaLevel'
1085
+ | 'dialogContentRef'
1086
+ | 'resetPosition'
1087
+ | 'handleClose'
1088
+ > &
1089
+ import('vue').ShallowUnwrapRef<{
1090
+ visible: import('vue').Ref<boolean>;
1091
+ dialogContentRef: import('vue').Ref<any>;
1092
+ resetPosition: () => void;
1093
+ handleClose: () => void;
1094
+ }> & {} & import('vue').ComponentCustomProperties & {} & {
1095
+ $slots: {
1096
+ header?(_: { close: () => void; titleId: string; titleClass: string }): any;
1097
+ title?(_: {}): any;
1098
+ default?(_: {}): any;
1099
+ footer?(_: {}): any;
1100
+ };
1101
+ })
1102
+ | null
1103
+ >;
1104
+ },
1105
+ {},
1106
+ {},
1107
+ {},
1108
+ import('vue').ComponentOptionsMixin,
1109
+ import('vue').ComponentOptionsMixin,
1110
+ {},
1111
+ string,
1112
+ import('vue').PublicProps,
1113
+ Readonly<
1114
+ import('vue').ExtractPropTypes<{
1115
+ appendToBody: {
1116
+ type: BooleanConstructor;
1117
+ default: boolean;
625
1118
  };
626
- readonly modelValue: BooleanConstructor;
627
- readonly modalClass: StringConstructor;
628
- readonly headerClass: StringConstructor;
629
- readonly bodyClass: StringConstructor;
630
- readonly footerClass: StringConstructor;
631
- readonly width: {
632
- readonly type: import('vue').PropType<string | number>;
633
- readonly required: false;
634
- readonly validator: ((val: unknown) => boolean) | undefined;
635
- __epPropKey: true;
1119
+ draggable: {
1120
+ type: BooleanConstructor;
1121
+ default: boolean;
636
1122
  };
637
- readonly zIndex: {
638
- readonly type: import('vue').PropType<number>;
639
- readonly required: false;
640
- readonly validator: ((val: unknown) => boolean) | undefined;
641
- __epPropKey: true;
1123
+ destroyOnClose: {
1124
+ type: BooleanConstructor;
1125
+ default: boolean;
642
1126
  };
643
- readonly trapFocus: BooleanConstructor;
644
- readonly headerAriaLevel: {
645
- readonly type: import('vue').PropType<string>;
646
- readonly required: false;
647
- readonly validator: ((val: unknown) => boolean) | undefined;
648
- __epPropKey: true;
649
- } & {
650
- readonly default: "2";
1127
+ cssStyle: {
1128
+ type: StringConstructor;
1129
+ default: string;
651
1130
  };
652
- readonly center: BooleanConstructor;
653
- readonly alignCenter: BooleanConstructor;
654
- readonly closeIcon: {
655
- readonly type: import('vue').PropType<string | import('vue').Component>;
656
- readonly required: false;
657
- readonly validator: ((val: unknown) => boolean) | undefined;
658
- __epPropKey: true;
659
- };
660
- readonly draggable: BooleanConstructor;
661
- readonly overflow: BooleanConstructor;
662
- readonly fullscreen: BooleanConstructor;
663
- readonly showClose: {
664
- readonly type: import('vue').PropType<boolean>;
665
- readonly required: false;
666
- readonly validator: ((val: unknown) => boolean) | undefined;
667
- __epPropKey: true;
668
- } & {
669
- readonly default: true;
670
- };
671
- readonly title: {
672
- readonly type: import('vue').PropType<string>;
673
- readonly required: false;
674
- readonly validator: ((val: unknown) => boolean) | undefined;
675
- __epPropKey: true;
676
- } & {
677
- readonly default: "";
678
- };
679
- readonly ariaLevel: {
680
- readonly type: import('vue').PropType<string>;
681
- readonly required: false;
682
- readonly validator: ((val: unknown) => boolean) | undefined;
683
- __epPropKey: true;
684
- } & {
685
- readonly default: "2";
686
- };
687
- }>> & {
688
- "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
689
- onOpen?: (() => any) | undefined;
690
- onClose?: (() => any) | undefined;
691
- onOpened?: (() => any) | undefined;
692
- onClosed?: (() => any) | undefined;
693
- onOpenAutoFocus?: (() => any) | undefined;
694
- onCloseAutoFocus?: (() => any) | undefined;
695
- }, {
696
- visible: import('vue').Ref<boolean>;
697
- dialogContentRef: import('vue').Ref<any>;
698
- resetPosition: () => void;
699
- handleClose: () => void;
700
- }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
701
- open: () => void;
702
- "update:modelValue": (value: boolean) => void;
703
- close: () => void;
704
- opened: () => void;
705
- closed: () => void;
706
- openAutoFocus: () => void;
707
- closeAutoFocus: () => void;
708
- }, string, {
709
- readonly title: string;
710
- readonly center: boolean;
711
- readonly overflow: boolean;
712
- readonly modelValue: boolean;
713
- readonly ariaLevel: string;
714
- readonly appendTo: string | HTMLElement;
715
- readonly showClose: boolean;
716
- readonly alignCenter: boolean;
717
- readonly draggable: boolean;
718
- readonly fullscreen: boolean;
719
- readonly closeOnClickModal: boolean;
720
- readonly closeOnPressEscape: boolean;
721
- readonly lockScroll: boolean;
722
- readonly modal: boolean;
723
- readonly openDelay: number;
724
- readonly closeDelay: number;
725
- readonly headerAriaLevel: string;
726
- readonly appendToBody: boolean;
727
- readonly destroyOnClose: boolean;
728
- readonly trapFocus: boolean;
729
- }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
730
- beforeCreate?: (() => void) | (() => void)[];
731
- created?: (() => void) | (() => void)[];
732
- beforeMount?: (() => void) | (() => void)[];
733
- mounted?: (() => void) | (() => void)[];
734
- beforeUpdate?: (() => void) | (() => void)[];
735
- updated?: (() => void) | (() => void)[];
736
- activated?: (() => void) | (() => void)[];
737
- deactivated?: (() => void) | (() => void)[];
738
- beforeDestroy?: (() => void) | (() => void)[];
739
- beforeUnmount?: (() => void) | (() => void)[];
740
- destroyed?: (() => void) | (() => void)[];
741
- unmounted?: (() => void) | (() => void)[];
742
- renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
743
- renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
744
- errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
745
- };
746
- $forceUpdate: () => void;
747
- $nextTick: typeof import('vue').nextTick;
748
- $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;
749
- } & Readonly<{
750
- readonly title: string;
751
- readonly center: boolean;
752
- readonly overflow: boolean;
753
- readonly modelValue: boolean;
754
- readonly ariaLevel: string;
755
- readonly appendTo: string | HTMLElement;
756
- readonly showClose: boolean;
757
- readonly alignCenter: boolean;
758
- readonly draggable: boolean;
759
- readonly fullscreen: boolean;
760
- readonly closeOnClickModal: boolean;
761
- readonly closeOnPressEscape: boolean;
762
- readonly lockScroll: boolean;
763
- readonly modal: boolean;
764
- readonly openDelay: number;
765
- readonly closeDelay: number;
766
- readonly headerAriaLevel: string;
767
- readonly appendToBody: boolean;
768
- readonly destroyOnClose: boolean;
769
- readonly trapFocus: boolean;
770
- }> & Omit<Readonly<import('vue').ExtractPropTypes<{
771
- readonly appendToBody: BooleanConstructor;
772
- readonly appendTo: {
773
- readonly type: import('vue').PropType<string | HTMLElement>;
774
- readonly required: false;
775
- readonly validator: ((val: unknown) => boolean) | undefined;
776
- __epPropKey: true;
777
- } & {
778
- readonly default: "body";
779
- };
780
- readonly beforeClose: {
781
- readonly type: import('vue').PropType<import('element-plus').DialogBeforeCloseFn>;
782
- readonly required: false;
783
- readonly validator: ((val: unknown) => boolean) | undefined;
784
- __epPropKey: true;
785
- };
786
- readonly destroyOnClose: BooleanConstructor;
787
- readonly closeOnClickModal: {
788
- readonly type: import('vue').PropType<boolean>;
789
- readonly required: false;
790
- readonly validator: ((val: unknown) => boolean) | undefined;
791
- __epPropKey: true;
792
- } & {
793
- readonly default: true;
794
- };
795
- readonly closeOnPressEscape: {
796
- readonly type: import('vue').PropType<boolean>;
797
- readonly required: false;
798
- readonly validator: ((val: unknown) => boolean) | undefined;
799
- __epPropKey: true;
800
- } & {
801
- readonly default: true;
802
- };
803
- readonly lockScroll: {
804
- readonly type: import('vue').PropType<boolean>;
805
- readonly required: false;
806
- readonly validator: ((val: unknown) => boolean) | undefined;
807
- __epPropKey: true;
808
- } & {
809
- readonly default: true;
810
- };
811
- readonly modal: {
812
- readonly type: import('vue').PropType<boolean>;
813
- readonly required: false;
814
- readonly validator: ((val: unknown) => boolean) | undefined;
815
- __epPropKey: true;
816
- } & {
817
- readonly default: true;
818
- };
819
- readonly openDelay: {
820
- readonly type: import('vue').PropType<number>;
821
- readonly required: false;
822
- readonly validator: ((val: unknown) => boolean) | undefined;
823
- __epPropKey: true;
824
- } & {
825
- readonly default: 0;
826
- };
827
- readonly closeDelay: {
828
- readonly type: import('vue').PropType<number>;
829
- readonly required: false;
830
- readonly validator: ((val: unknown) => boolean) | undefined;
831
- __epPropKey: true;
832
- } & {
833
- readonly default: 0;
834
- };
835
- readonly top: {
836
- readonly type: import('vue').PropType<string>;
837
- readonly required: false;
838
- readonly validator: ((val: unknown) => boolean) | undefined;
839
- __epPropKey: true;
840
- };
841
- readonly modelValue: BooleanConstructor;
842
- readonly modalClass: StringConstructor;
843
- readonly headerClass: StringConstructor;
844
- readonly bodyClass: StringConstructor;
845
- readonly footerClass: StringConstructor;
846
- readonly width: {
847
- readonly type: import('vue').PropType<string | number>;
848
- readonly required: false;
849
- readonly validator: ((val: unknown) => boolean) | undefined;
850
- __epPropKey: true;
851
- };
852
- readonly zIndex: {
853
- readonly type: import('vue').PropType<number>;
854
- readonly required: false;
855
- readonly validator: ((val: unknown) => boolean) | undefined;
856
- __epPropKey: true;
857
- };
858
- readonly trapFocus: BooleanConstructor;
859
- readonly headerAriaLevel: {
860
- readonly type: import('vue').PropType<string>;
861
- readonly required: false;
862
- readonly validator: ((val: unknown) => boolean) | undefined;
863
- __epPropKey: true;
864
- } & {
865
- readonly default: "2";
866
- };
867
- readonly center: BooleanConstructor;
868
- readonly alignCenter: BooleanConstructor;
869
- readonly closeIcon: {
870
- readonly type: import('vue').PropType<string | import('vue').Component>;
871
- readonly required: false;
872
- readonly validator: ((val: unknown) => boolean) | undefined;
873
- __epPropKey: true;
874
- };
875
- readonly draggable: BooleanConstructor;
876
- readonly overflow: BooleanConstructor;
877
- readonly fullscreen: BooleanConstructor;
878
- readonly showClose: {
879
- readonly type: import('vue').PropType<boolean>;
880
- readonly required: false;
881
- readonly validator: ((val: unknown) => boolean) | undefined;
882
- __epPropKey: true;
883
- } & {
884
- readonly default: true;
885
- };
886
- readonly title: {
887
- readonly type: import('vue').PropType<string>;
888
- readonly required: false;
889
- readonly validator: ((val: unknown) => boolean) | undefined;
890
- __epPropKey: true;
891
- } & {
892
- readonly default: "";
893
- };
894
- readonly ariaLevel: {
895
- readonly type: import('vue').PropType<string>;
896
- readonly required: false;
897
- readonly validator: ((val: unknown) => boolean) | undefined;
898
- __epPropKey: true;
899
- } & {
900
- readonly default: "2";
901
- };
902
- }>> & {
903
- "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
904
- onOpen?: (() => any) | undefined;
905
- onClose?: (() => any) | undefined;
906
- onOpened?: (() => any) | undefined;
907
- onClosed?: (() => any) | undefined;
908
- onOpenAutoFocus?: (() => any) | undefined;
909
- onCloseAutoFocus?: (() => any) | undefined;
910
- }, "title" | "overflow" | "visible" | "modelValue" | "appendToBody" | "appendTo" | "destroyOnClose" | "closeOnClickModal" | "closeOnPressEscape" | "lockScroll" | "modal" | "openDelay" | "closeDelay" | "trapFocus" | "headerAriaLevel" | "center" | "alignCenter" | "draggable" | "fullscreen" | "showClose" | "ariaLevel" | "dialogContentRef" | "resetPosition" | "handleClose"> & import('vue').ShallowUnwrapRef<{
911
- visible: import('vue').Ref<boolean>;
912
- dialogContentRef: import('vue').Ref<any>;
913
- resetPosition: () => void;
914
- handleClose: () => void;
915
- }> & {} & import('vue').ComponentCustomProperties & {} & {
916
- $slots: {
917
- header?(_: {
918
- close: () => void;
919
- titleId: string;
920
- titleClass: string;
921
- }): any;
922
- title?(_: {}): any;
923
- default?(_: {}): any;
924
- footer?(_: {}): any;
925
- };
926
- }) | null>;
927
- }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
928
- appendToBody: {
929
- type: BooleanConstructor;
930
- default: boolean;
931
- };
932
- draggable: {
933
- type: BooleanConstructor;
934
- default: boolean;
935
- };
936
- destroyOnClose: {
937
- type: BooleanConstructor;
938
- default: boolean;
939
- };
940
- cssStyle: {
941
- type: StringConstructor;
942
- default: string;
943
- };
944
- }>> & Readonly<{}>, {
945
- cssStyle: string;
946
- appendToBody: boolean;
947
- destroyOnClose: boolean;
948
- draggable: boolean;
949
- }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
950
- componentRef: unknown;
951
- }, any>;
952
- declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
1131
+ }>
1132
+ > &
1133
+ Readonly<{}>,
1134
+ {
1135
+ cssStyle: string;
1136
+ appendToBody: boolean;
1137
+ destroyOnClose: boolean;
1138
+ draggable: boolean;
1139
+ },
1140
+ {},
1141
+ {},
1142
+ {},
1143
+ string,
1144
+ import('vue').ComponentProvideOptions,
1145
+ true,
1146
+ {
1147
+ componentRef: unknown;
1148
+ },
1149
+ any
1150
+ >;
1151
+ declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult['slots']>;
953
1152
  export default _default;
954
1153
  type __VLS_WithTemplateSlots<T, S> = T & {
955
1154
  new (): {