@vunk/form 2.12.0 → 2.12.2

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 (10) hide show
  1. package/components/dialog-input-collection/index.cjs +129 -106
  2. package/components/dialog-input-collection/index.mjs +128 -105
  3. package/components/dialog-input-collection/src/ctx.d.ts +6 -3
  4. package/components/dialog-input-collection/src/dialog-form.vue.d.ts +1184 -49
  5. package/components/dialog-input-collection/src/index.vue.d.ts +1365 -223
  6. package/components/dialog-input-collection/src/layout.vue.d.ts +27 -27
  7. package/components/dialog-input-collection/src/types.d.ts +1 -1
  8. package/components/form-item-renderer/index.cjs +5 -3
  9. package/components/form-item-renderer/index.mjs +5 -3
  10. package/package.json +1 -1
package/components/dialog-input-collection/src/dialog-form.vue.d.ts CHANGED
@@ -1,3 +1,5 @@
1
+ import type { AnyFunc } from '@vunk/shared';
2
+ import { type PropType } from 'vue';
1
3
  declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
2
4
  title: {
3
5
  type: StringConstructor;
@@ -23,6 +25,13 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
23
25
  type: ObjectConstructor;
24
26
  default: () => {};
25
27
  };
28
+ validateCatch: {
29
+ type: PropType<AnyFunc>;
30
+ default: (err: any, init?: {
31
+ prefix?: string;
32
+ suffix?: string;
33
+ }) => void;
34
+ };
26
35
  }>, {
27
36
  props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
28
37
  title: {
@@ -49,6 +58,13 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
49
58
  type: ObjectConstructor;
50
59
  default: () => {};
51
60
  };
61
+ validateCatch: {
62
+ type: PropType<AnyFunc>;
63
+ default: (err: any, init?: {
64
+ prefix?: string;
65
+ suffix?: string;
66
+ }) => void;
67
+ };
52
68
  }>> & Readonly<{
53
69
  "onUpdate:visible"?: (...args: any[]) => any;
54
70
  "onUpdate:modelValue"?: (...args: any[]) => any;
@@ -56,7 +72,1119 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
56
72
  }> & {}>;
57
73
  emit: (event: "update:modelValue" | "change" | "update:visible", ...args: any[]) => void;
58
74
  formData: import("vue").Ref<Record<string, any>, Record<string, any>>;
75
+ formDef: {
76
+ _ref: import("vue").ShallowRef<{
77
+ $: import("vue").ComponentInternalInstance;
78
+ $data: {};
79
+ $props: Partial<{
80
+ readonly disabled: boolean;
81
+ readonly inline: boolean;
82
+ readonly labelWidth: string | number;
83
+ readonly labelPosition: "top" | "left" | "right";
84
+ readonly inlineMessage: boolean;
85
+ readonly showMessage: boolean;
86
+ readonly requireAsteriskPosition: "left" | "right";
87
+ readonly labelSuffix: string;
88
+ readonly validateOnRuleChange: boolean;
89
+ readonly scrollIntoViewOptions: boolean | Record<string, any>;
90
+ readonly statusIcon: boolean;
91
+ readonly hideRequiredAsterisk: boolean;
92
+ readonly scrollToError: boolean;
93
+ }> & Omit<{
94
+ readonly inline: boolean;
95
+ readonly labelWidth: string | number;
96
+ readonly labelPosition: "top" | "left" | "right";
97
+ readonly inlineMessage: boolean;
98
+ readonly showMessage: boolean;
99
+ readonly disabled: boolean;
100
+ readonly requireAsteriskPosition: "left" | "right";
101
+ readonly labelSuffix: string;
102
+ readonly statusIcon: boolean;
103
+ readonly validateOnRuleChange: boolean;
104
+ readonly hideRequiredAsterisk: boolean;
105
+ readonly scrollToError: boolean;
106
+ readonly scrollIntoViewOptions: boolean | Record<string, any>;
107
+ readonly size?: "" | "default" | "small" | "large";
108
+ readonly rules?: Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>;
109
+ readonly model?: Record<string, any>;
110
+ onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
111
+ } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "inline" | "labelWidth" | "labelPosition" | "inlineMessage" | "showMessage" | "disabled" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError" | "scrollIntoViewOptions">;
112
+ $attrs: {
113
+ [x: string]: unknown;
114
+ };
115
+ $refs: {
116
+ [x: string]: unknown;
117
+ };
118
+ $slots: Readonly<{
119
+ [name: string]: import("vue").Slot<any>;
120
+ }>;
121
+ $root: import("vue").ComponentPublicInstance | null;
122
+ $parent: import("vue").ComponentPublicInstance | null;
123
+ $host: Element | null;
124
+ $emit: (event: "validate", prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => void;
125
+ $el: any;
126
+ $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
127
+ readonly model: ObjectConstructor;
128
+ readonly rules: {
129
+ readonly type: PropType<Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>>;
130
+ readonly required: false;
131
+ readonly validator: ((val: unknown) => boolean) | undefined;
132
+ __epPropKey: true;
133
+ };
134
+ readonly labelPosition: {
135
+ readonly type: PropType<"top" | "left" | "right">;
136
+ readonly required: false;
137
+ readonly validator: ((val: unknown) => boolean) | undefined;
138
+ __epPropKey: true;
139
+ } & {
140
+ readonly default: "right";
141
+ };
142
+ readonly requireAsteriskPosition: {
143
+ readonly type: PropType<"left" | "right">;
144
+ readonly required: false;
145
+ readonly validator: ((val: unknown) => boolean) | undefined;
146
+ __epPropKey: true;
147
+ } & {
148
+ readonly default: "left";
149
+ };
150
+ readonly labelWidth: {
151
+ readonly type: PropType<string | number>;
152
+ readonly required: false;
153
+ readonly validator: ((val: unknown) => boolean) | undefined;
154
+ __epPropKey: true;
155
+ } & {
156
+ readonly default: "";
157
+ };
158
+ readonly labelSuffix: {
159
+ readonly type: PropType<string>;
160
+ readonly required: false;
161
+ readonly validator: ((val: unknown) => boolean) | undefined;
162
+ __epPropKey: true;
163
+ } & {
164
+ readonly default: "";
165
+ };
166
+ readonly inline: BooleanConstructor;
167
+ readonly inlineMessage: BooleanConstructor;
168
+ readonly statusIcon: BooleanConstructor;
169
+ readonly showMessage: {
170
+ readonly type: PropType<boolean>;
171
+ readonly required: false;
172
+ readonly validator: ((val: unknown) => boolean) | undefined;
173
+ __epPropKey: true;
174
+ } & {
175
+ readonly default: true;
176
+ };
177
+ readonly validateOnRuleChange: {
178
+ readonly type: PropType<boolean>;
179
+ readonly required: false;
180
+ readonly validator: ((val: unknown) => boolean) | undefined;
181
+ __epPropKey: true;
182
+ } & {
183
+ readonly default: true;
184
+ };
185
+ readonly hideRequiredAsterisk: BooleanConstructor;
186
+ readonly scrollToError: BooleanConstructor;
187
+ readonly scrollIntoViewOptions: {
188
+ readonly type: PropType<boolean | Record<string, any>>;
189
+ readonly required: false;
190
+ readonly validator: ((val: unknown) => boolean) | undefined;
191
+ __epPropKey: true;
192
+ } & {
193
+ readonly default: true;
194
+ };
195
+ readonly size: {
196
+ readonly type: PropType<"" | "default" | "small" | "large">;
197
+ readonly required: false;
198
+ readonly validator: ((val: unknown) => boolean) | undefined;
199
+ __epPropKey: true;
200
+ };
201
+ readonly disabled: BooleanConstructor;
202
+ }>> & {
203
+ onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
204
+ }, {
205
+ validate: (callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
206
+ validateField: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[], callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
207
+ resetFields: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[]) => void;
208
+ clearValidate: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[]) => void;
209
+ scrollToField: (prop: import("element-plus").FormItemProp) => void;
210
+ getField: (prop: import("element-plus").FormItemProp) => import("element-plus").FormItemContext | undefined;
211
+ fields: import("vue").Reactive<import("element-plus").FormItemContext[]>;
212
+ }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
213
+ validate: (prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => void;
214
+ }, string, {
215
+ readonly disabled: boolean;
216
+ readonly inline: boolean;
217
+ readonly labelWidth: string | number;
218
+ readonly labelPosition: "top" | "left" | "right";
219
+ readonly inlineMessage: boolean;
220
+ readonly showMessage: boolean;
221
+ readonly requireAsteriskPosition: "left" | "right";
222
+ readonly labelSuffix: string;
223
+ readonly validateOnRuleChange: boolean;
224
+ readonly scrollIntoViewOptions: boolean | Record<string, any>;
225
+ readonly statusIcon: boolean;
226
+ readonly hideRequiredAsterisk: boolean;
227
+ readonly scrollToError: boolean;
228
+ }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
229
+ beforeCreate?: (() => void) | (() => void)[];
230
+ created?: (() => void) | (() => void)[];
231
+ beforeMount?: (() => void) | (() => void)[];
232
+ mounted?: (() => void) | (() => void)[];
233
+ beforeUpdate?: (() => void) | (() => void)[];
234
+ updated?: (() => void) | (() => void)[];
235
+ activated?: (() => void) | (() => void)[];
236
+ deactivated?: (() => void) | (() => void)[];
237
+ beforeDestroy?: (() => void) | (() => void)[];
238
+ beforeUnmount?: (() => void) | (() => void)[];
239
+ destroyed?: (() => void) | (() => void)[];
240
+ unmounted?: (() => void) | (() => void)[];
241
+ renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
242
+ renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
243
+ errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
244
+ };
245
+ $forceUpdate: () => void;
246
+ $nextTick: typeof import("vue").nextTick;
247
+ $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;
248
+ } & Readonly<{
249
+ readonly disabled: boolean;
250
+ readonly inline: boolean;
251
+ readonly labelWidth: string | number;
252
+ readonly labelPosition: "top" | "left" | "right";
253
+ readonly inlineMessage: boolean;
254
+ readonly showMessage: boolean;
255
+ readonly requireAsteriskPosition: "left" | "right";
256
+ readonly labelSuffix: string;
257
+ readonly validateOnRuleChange: boolean;
258
+ readonly scrollIntoViewOptions: boolean | Record<string, any>;
259
+ readonly statusIcon: boolean;
260
+ readonly hideRequiredAsterisk: boolean;
261
+ readonly scrollToError: boolean;
262
+ }> & Omit<Readonly<import("vue").ExtractPropTypes<{
263
+ readonly model: ObjectConstructor;
264
+ readonly rules: {
265
+ readonly type: PropType<Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>>;
266
+ readonly required: false;
267
+ readonly validator: ((val: unknown) => boolean) | undefined;
268
+ __epPropKey: true;
269
+ };
270
+ readonly labelPosition: {
271
+ readonly type: PropType<"top" | "left" | "right">;
272
+ readonly required: false;
273
+ readonly validator: ((val: unknown) => boolean) | undefined;
274
+ __epPropKey: true;
275
+ } & {
276
+ readonly default: "right";
277
+ };
278
+ readonly requireAsteriskPosition: {
279
+ readonly type: PropType<"left" | "right">;
280
+ readonly required: false;
281
+ readonly validator: ((val: unknown) => boolean) | undefined;
282
+ __epPropKey: true;
283
+ } & {
284
+ readonly default: "left";
285
+ };
286
+ readonly labelWidth: {
287
+ readonly type: PropType<string | number>;
288
+ readonly required: false;
289
+ readonly validator: ((val: unknown) => boolean) | undefined;
290
+ __epPropKey: true;
291
+ } & {
292
+ readonly default: "";
293
+ };
294
+ readonly labelSuffix: {
295
+ readonly type: PropType<string>;
296
+ readonly required: false;
297
+ readonly validator: ((val: unknown) => boolean) | undefined;
298
+ __epPropKey: true;
299
+ } & {
300
+ readonly default: "";
301
+ };
302
+ readonly inline: BooleanConstructor;
303
+ readonly inlineMessage: BooleanConstructor;
304
+ readonly statusIcon: BooleanConstructor;
305
+ readonly showMessage: {
306
+ readonly type: PropType<boolean>;
307
+ readonly required: false;
308
+ readonly validator: ((val: unknown) => boolean) | undefined;
309
+ __epPropKey: true;
310
+ } & {
311
+ readonly default: true;
312
+ };
313
+ readonly validateOnRuleChange: {
314
+ readonly type: PropType<boolean>;
315
+ readonly required: false;
316
+ readonly validator: ((val: unknown) => boolean) | undefined;
317
+ __epPropKey: true;
318
+ } & {
319
+ readonly default: true;
320
+ };
321
+ readonly hideRequiredAsterisk: BooleanConstructor;
322
+ readonly scrollToError: BooleanConstructor;
323
+ readonly scrollIntoViewOptions: {
324
+ readonly type: PropType<boolean | Record<string, any>>;
325
+ readonly required: false;
326
+ readonly validator: ((val: unknown) => boolean) | undefined;
327
+ __epPropKey: true;
328
+ } & {
329
+ readonly default: true;
330
+ };
331
+ readonly size: {
332
+ readonly type: PropType<"" | "default" | "small" | "large">;
333
+ readonly required: false;
334
+ readonly validator: ((val: unknown) => boolean) | undefined;
335
+ __epPropKey: true;
336
+ };
337
+ readonly disabled: BooleanConstructor;
338
+ }>> & {
339
+ onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
340
+ }, "inline" | "labelWidth" | "labelPosition" | "inlineMessage" | "showMessage" | "disabled" | "fields" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError" | "scrollIntoViewOptions" | "validate" | "validateField" | "resetFields" | "clearValidate" | "scrollToField" | "getField"> & import("vue").ShallowUnwrapRef<{
341
+ validate: (callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
342
+ validateField: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[], callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
343
+ resetFields: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[]) => void;
344
+ clearValidate: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[]) => void;
345
+ scrollToField: (prop: import("element-plus").FormItemProp) => void;
346
+ getField: (prop: import("element-plus").FormItemProp) => import("element-plus").FormItemContext | undefined;
347
+ fields: import("vue").Reactive<import("element-plus").FormItemContext[]>;
348
+ }> & {} & import("@vue/runtime-core").ComponentCustomProperties & {} & {
349
+ $slots: {
350
+ default?(_: {}): any;
351
+ };
352
+ }, {
353
+ $: import("vue").ComponentInternalInstance;
354
+ $data: {};
355
+ $props: Partial<{
356
+ readonly disabled: boolean;
357
+ readonly inline: boolean;
358
+ readonly labelWidth: string | number;
359
+ readonly labelPosition: "top" | "left" | "right";
360
+ readonly inlineMessage: boolean;
361
+ readonly showMessage: boolean;
362
+ readonly requireAsteriskPosition: "left" | "right";
363
+ readonly labelSuffix: string;
364
+ readonly validateOnRuleChange: boolean;
365
+ readonly scrollIntoViewOptions: boolean | Record<string, any>;
366
+ readonly statusIcon: boolean;
367
+ readonly hideRequiredAsterisk: boolean;
368
+ readonly scrollToError: boolean;
369
+ }> & Omit<{
370
+ readonly inline: boolean;
371
+ readonly labelWidth: string | number;
372
+ readonly labelPosition: "top" | "left" | "right";
373
+ readonly inlineMessage: boolean;
374
+ readonly showMessage: boolean;
375
+ readonly disabled: boolean;
376
+ readonly requireAsteriskPosition: "left" | "right";
377
+ readonly labelSuffix: string;
378
+ readonly statusIcon: boolean;
379
+ readonly validateOnRuleChange: boolean;
380
+ readonly hideRequiredAsterisk: boolean;
381
+ readonly scrollToError: boolean;
382
+ readonly scrollIntoViewOptions: boolean | Record<string, any>;
383
+ readonly size?: "" | "default" | "small" | "large";
384
+ readonly rules?: Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>;
385
+ readonly model?: Record<string, any>;
386
+ onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
387
+ } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "inline" | "labelWidth" | "labelPosition" | "inlineMessage" | "showMessage" | "disabled" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError" | "scrollIntoViewOptions">;
388
+ $attrs: {
389
+ [x: string]: unknown;
390
+ };
391
+ $refs: {
392
+ [x: string]: unknown;
393
+ };
394
+ $slots: Readonly<{
395
+ [name: string]: import("vue").Slot<any>;
396
+ }>;
397
+ $root: import("vue").ComponentPublicInstance | null;
398
+ $parent: import("vue").ComponentPublicInstance | null;
399
+ $host: Element | null;
400
+ $emit: (event: "validate", prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => void;
401
+ $el: any;
402
+ $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
403
+ readonly model: ObjectConstructor;
404
+ readonly rules: {
405
+ readonly type: PropType<Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>>;
406
+ readonly required: false;
407
+ readonly validator: ((val: unknown) => boolean) | undefined;
408
+ __epPropKey: true;
409
+ };
410
+ readonly labelPosition: {
411
+ readonly type: PropType<"top" | "left" | "right">;
412
+ readonly required: false;
413
+ readonly validator: ((val: unknown) => boolean) | undefined;
414
+ __epPropKey: true;
415
+ } & {
416
+ readonly default: "right";
417
+ };
418
+ readonly requireAsteriskPosition: {
419
+ readonly type: PropType<"left" | "right">;
420
+ readonly required: false;
421
+ readonly validator: ((val: unknown) => boolean) | undefined;
422
+ __epPropKey: true;
423
+ } & {
424
+ readonly default: "left";
425
+ };
426
+ readonly labelWidth: {
427
+ readonly type: PropType<string | number>;
428
+ readonly required: false;
429
+ readonly validator: ((val: unknown) => boolean) | undefined;
430
+ __epPropKey: true;
431
+ } & {
432
+ readonly default: "";
433
+ };
434
+ readonly labelSuffix: {
435
+ readonly type: PropType<string>;
436
+ readonly required: false;
437
+ readonly validator: ((val: unknown) => boolean) | undefined;
438
+ __epPropKey: true;
439
+ } & {
440
+ readonly default: "";
441
+ };
442
+ readonly inline: BooleanConstructor;
443
+ readonly inlineMessage: BooleanConstructor;
444
+ readonly statusIcon: BooleanConstructor;
445
+ readonly showMessage: {
446
+ readonly type: PropType<boolean>;
447
+ readonly required: false;
448
+ readonly validator: ((val: unknown) => boolean) | undefined;
449
+ __epPropKey: true;
450
+ } & {
451
+ readonly default: true;
452
+ };
453
+ readonly validateOnRuleChange: {
454
+ readonly type: PropType<boolean>;
455
+ readonly required: false;
456
+ readonly validator: ((val: unknown) => boolean) | undefined;
457
+ __epPropKey: true;
458
+ } & {
459
+ readonly default: true;
460
+ };
461
+ readonly hideRequiredAsterisk: BooleanConstructor;
462
+ readonly scrollToError: BooleanConstructor;
463
+ readonly scrollIntoViewOptions: {
464
+ readonly type: PropType<boolean | Record<string, any>>;
465
+ readonly required: false;
466
+ readonly validator: ((val: unknown) => boolean) | undefined;
467
+ __epPropKey: true;
468
+ } & {
469
+ readonly default: true;
470
+ };
471
+ readonly size: {
472
+ readonly type: PropType<"" | "default" | "small" | "large">;
473
+ readonly required: false;
474
+ readonly validator: ((val: unknown) => boolean) | undefined;
475
+ __epPropKey: true;
476
+ };
477
+ readonly disabled: BooleanConstructor;
478
+ }>> & {
479
+ onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
480
+ }, {
481
+ validate: (callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
482
+ validateField: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[], callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
483
+ resetFields: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[]) => void;
484
+ clearValidate: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[]) => void;
485
+ scrollToField: (prop: import("element-plus").FormItemProp) => void;
486
+ getField: (prop: import("element-plus").FormItemProp) => import("element-plus").FormItemContext | undefined;
487
+ fields: import("vue").Reactive<import("element-plus").FormItemContext[]>;
488
+ }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
489
+ validate: (prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => void;
490
+ }, string, {
491
+ readonly disabled: boolean;
492
+ readonly inline: boolean;
493
+ readonly labelWidth: string | number;
494
+ readonly labelPosition: "top" | "left" | "right";
495
+ readonly inlineMessage: boolean;
496
+ readonly showMessage: boolean;
497
+ readonly requireAsteriskPosition: "left" | "right";
498
+ readonly labelSuffix: string;
499
+ readonly validateOnRuleChange: boolean;
500
+ readonly scrollIntoViewOptions: boolean | Record<string, any>;
501
+ readonly statusIcon: boolean;
502
+ readonly hideRequiredAsterisk: boolean;
503
+ readonly scrollToError: boolean;
504
+ }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
505
+ beforeCreate?: (() => void) | (() => void)[];
506
+ created?: (() => void) | (() => void)[];
507
+ beforeMount?: (() => void) | (() => void)[];
508
+ mounted?: (() => void) | (() => void)[];
509
+ beforeUpdate?: (() => void) | (() => void)[];
510
+ updated?: (() => void) | (() => void)[];
511
+ activated?: (() => void) | (() => void)[];
512
+ deactivated?: (() => void) | (() => void)[];
513
+ beforeDestroy?: (() => void) | (() => void)[];
514
+ beforeUnmount?: (() => void) | (() => void)[];
515
+ destroyed?: (() => void) | (() => void)[];
516
+ unmounted?: (() => void) | (() => void)[];
517
+ renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
518
+ renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
519
+ errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
520
+ };
521
+ $forceUpdate: () => void;
522
+ $nextTick: typeof import("vue").nextTick;
523
+ $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;
524
+ } & Readonly<{
525
+ readonly disabled: boolean;
526
+ readonly inline: boolean;
527
+ readonly labelWidth: string | number;
528
+ readonly labelPosition: "top" | "left" | "right";
529
+ readonly inlineMessage: boolean;
530
+ readonly showMessage: boolean;
531
+ readonly requireAsteriskPosition: "left" | "right";
532
+ readonly labelSuffix: string;
533
+ readonly validateOnRuleChange: boolean;
534
+ readonly scrollIntoViewOptions: boolean | Record<string, any>;
535
+ readonly statusIcon: boolean;
536
+ readonly hideRequiredAsterisk: boolean;
537
+ readonly scrollToError: boolean;
538
+ }> & Omit<Readonly<import("vue").ExtractPropTypes<{
539
+ readonly model: ObjectConstructor;
540
+ readonly rules: {
541
+ readonly type: PropType<Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>>;
542
+ readonly required: false;
543
+ readonly validator: ((val: unknown) => boolean) | undefined;
544
+ __epPropKey: true;
545
+ };
546
+ readonly labelPosition: {
547
+ readonly type: PropType<"top" | "left" | "right">;
548
+ readonly required: false;
549
+ readonly validator: ((val: unknown) => boolean) | undefined;
550
+ __epPropKey: true;
551
+ } & {
552
+ readonly default: "right";
553
+ };
554
+ readonly requireAsteriskPosition: {
555
+ readonly type: PropType<"left" | "right">;
556
+ readonly required: false;
557
+ readonly validator: ((val: unknown) => boolean) | undefined;
558
+ __epPropKey: true;
559
+ } & {
560
+ readonly default: "left";
561
+ };
562
+ readonly labelWidth: {
563
+ readonly type: PropType<string | number>;
564
+ readonly required: false;
565
+ readonly validator: ((val: unknown) => boolean) | undefined;
566
+ __epPropKey: true;
567
+ } & {
568
+ readonly default: "";
569
+ };
570
+ readonly labelSuffix: {
571
+ readonly type: PropType<string>;
572
+ readonly required: false;
573
+ readonly validator: ((val: unknown) => boolean) | undefined;
574
+ __epPropKey: true;
575
+ } & {
576
+ readonly default: "";
577
+ };
578
+ readonly inline: BooleanConstructor;
579
+ readonly inlineMessage: BooleanConstructor;
580
+ readonly statusIcon: BooleanConstructor;
581
+ readonly showMessage: {
582
+ readonly type: PropType<boolean>;
583
+ readonly required: false;
584
+ readonly validator: ((val: unknown) => boolean) | undefined;
585
+ __epPropKey: true;
586
+ } & {
587
+ readonly default: true;
588
+ };
589
+ readonly validateOnRuleChange: {
590
+ readonly type: PropType<boolean>;
591
+ readonly required: false;
592
+ readonly validator: ((val: unknown) => boolean) | undefined;
593
+ __epPropKey: true;
594
+ } & {
595
+ readonly default: true;
596
+ };
597
+ readonly hideRequiredAsterisk: BooleanConstructor;
598
+ readonly scrollToError: BooleanConstructor;
599
+ readonly scrollIntoViewOptions: {
600
+ readonly type: PropType<boolean | Record<string, any>>;
601
+ readonly required: false;
602
+ readonly validator: ((val: unknown) => boolean) | undefined;
603
+ __epPropKey: true;
604
+ } & {
605
+ readonly default: true;
606
+ };
607
+ readonly size: {
608
+ readonly type: PropType<"" | "default" | "small" | "large">;
609
+ readonly required: false;
610
+ readonly validator: ((val: unknown) => boolean) | undefined;
611
+ __epPropKey: true;
612
+ };
613
+ readonly disabled: BooleanConstructor;
614
+ }>> & {
615
+ onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
616
+ }, "inline" | "labelWidth" | "labelPosition" | "inlineMessage" | "showMessage" | "disabled" | "fields" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError" | "scrollIntoViewOptions" | "validate" | "validateField" | "resetFields" | "clearValidate" | "scrollToField" | "getField"> & import("vue").ShallowUnwrapRef<{
617
+ validate: (callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
618
+ validateField: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[], callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
619
+ resetFields: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[]) => void;
620
+ clearValidate: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[]) => void;
621
+ scrollToField: (prop: import("element-plus").FormItemProp) => void;
622
+ getField: (prop: import("element-plus").FormItemProp) => import("element-plus").FormItemContext | undefined;
623
+ fields: import("vue").Reactive<import("element-plus").FormItemContext[]>;
624
+ }> & {} & import("@vue/runtime-core").ComponentCustomProperties & {} & {
625
+ $slots: {
626
+ default?(_: {}): any;
627
+ };
628
+ }>;
629
+ readonly value: {
630
+ $: import("vue").ComponentInternalInstance;
631
+ $data: {};
632
+ $props: Partial<{
633
+ readonly disabled: boolean;
634
+ readonly inline: boolean;
635
+ readonly labelWidth: string | number;
636
+ readonly labelPosition: "top" | "left" | "right";
637
+ readonly inlineMessage: boolean;
638
+ readonly showMessage: boolean;
639
+ readonly requireAsteriskPosition: "left" | "right";
640
+ readonly labelSuffix: string;
641
+ readonly validateOnRuleChange: boolean;
642
+ readonly scrollIntoViewOptions: boolean | Record<string, any>;
643
+ readonly statusIcon: boolean;
644
+ readonly hideRequiredAsterisk: boolean;
645
+ readonly scrollToError: boolean;
646
+ }> & Omit<{
647
+ readonly inline: boolean;
648
+ readonly labelWidth: string | number;
649
+ readonly labelPosition: "top" | "left" | "right";
650
+ readonly inlineMessage: boolean;
651
+ readonly showMessage: boolean;
652
+ readonly disabled: boolean;
653
+ readonly requireAsteriskPosition: "left" | "right";
654
+ readonly labelSuffix: string;
655
+ readonly statusIcon: boolean;
656
+ readonly validateOnRuleChange: boolean;
657
+ readonly hideRequiredAsterisk: boolean;
658
+ readonly scrollToError: boolean;
659
+ readonly scrollIntoViewOptions: boolean | Record<string, any>;
660
+ readonly size?: "" | "default" | "small" | "large";
661
+ readonly rules?: Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>;
662
+ readonly model?: Record<string, any>;
663
+ onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
664
+ } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "inline" | "labelWidth" | "labelPosition" | "inlineMessage" | "showMessage" | "disabled" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError" | "scrollIntoViewOptions">;
665
+ $attrs: {
666
+ [x: string]: unknown;
667
+ };
668
+ $refs: {
669
+ [x: string]: unknown;
670
+ };
671
+ $slots: Readonly<{
672
+ [name: string]: import("vue").Slot<any>;
673
+ }>;
674
+ $root: import("vue").ComponentPublicInstance | null;
675
+ $parent: import("vue").ComponentPublicInstance | null;
676
+ $host: Element | null;
677
+ $emit: (event: "validate", prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => void;
678
+ $el: any;
679
+ $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
680
+ readonly model: ObjectConstructor;
681
+ readonly rules: {
682
+ readonly type: PropType<Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>>;
683
+ readonly required: false;
684
+ readonly validator: ((val: unknown) => boolean) | undefined;
685
+ __epPropKey: true;
686
+ };
687
+ readonly labelPosition: {
688
+ readonly type: PropType<"top" | "left" | "right">;
689
+ readonly required: false;
690
+ readonly validator: ((val: unknown) => boolean) | undefined;
691
+ __epPropKey: true;
692
+ } & {
693
+ readonly default: "right";
694
+ };
695
+ readonly requireAsteriskPosition: {
696
+ readonly type: PropType<"left" | "right">;
697
+ readonly required: false;
698
+ readonly validator: ((val: unknown) => boolean) | undefined;
699
+ __epPropKey: true;
700
+ } & {
701
+ readonly default: "left";
702
+ };
703
+ readonly labelWidth: {
704
+ readonly type: PropType<string | number>;
705
+ readonly required: false;
706
+ readonly validator: ((val: unknown) => boolean) | undefined;
707
+ __epPropKey: true;
708
+ } & {
709
+ readonly default: "";
710
+ };
711
+ readonly labelSuffix: {
712
+ readonly type: PropType<string>;
713
+ readonly required: false;
714
+ readonly validator: ((val: unknown) => boolean) | undefined;
715
+ __epPropKey: true;
716
+ } & {
717
+ readonly default: "";
718
+ };
719
+ readonly inline: BooleanConstructor;
720
+ readonly inlineMessage: BooleanConstructor;
721
+ readonly statusIcon: BooleanConstructor;
722
+ readonly showMessage: {
723
+ readonly type: PropType<boolean>;
724
+ readonly required: false;
725
+ readonly validator: ((val: unknown) => boolean) | undefined;
726
+ __epPropKey: true;
727
+ } & {
728
+ readonly default: true;
729
+ };
730
+ readonly validateOnRuleChange: {
731
+ readonly type: PropType<boolean>;
732
+ readonly required: false;
733
+ readonly validator: ((val: unknown) => boolean) | undefined;
734
+ __epPropKey: true;
735
+ } & {
736
+ readonly default: true;
737
+ };
738
+ readonly hideRequiredAsterisk: BooleanConstructor;
739
+ readonly scrollToError: BooleanConstructor;
740
+ readonly scrollIntoViewOptions: {
741
+ readonly type: PropType<boolean | Record<string, any>>;
742
+ readonly required: false;
743
+ readonly validator: ((val: unknown) => boolean) | undefined;
744
+ __epPropKey: true;
745
+ } & {
746
+ readonly default: true;
747
+ };
748
+ readonly size: {
749
+ readonly type: PropType<"" | "default" | "small" | "large">;
750
+ readonly required: false;
751
+ readonly validator: ((val: unknown) => boolean) | undefined;
752
+ __epPropKey: true;
753
+ };
754
+ readonly disabled: BooleanConstructor;
755
+ }>> & {
756
+ onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
757
+ }, {
758
+ validate: (callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
759
+ validateField: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[], callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
760
+ resetFields: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[]) => void;
761
+ clearValidate: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[]) => void;
762
+ scrollToField: (prop: import("element-plus").FormItemProp) => void;
763
+ getField: (prop: import("element-plus").FormItemProp) => import("element-plus").FormItemContext | undefined;
764
+ fields: import("vue").Reactive<import("element-plus").FormItemContext[]>;
765
+ }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
766
+ validate: (prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => void;
767
+ }, string, {
768
+ readonly disabled: boolean;
769
+ readonly inline: boolean;
770
+ readonly labelWidth: string | number;
771
+ readonly labelPosition: "top" | "left" | "right";
772
+ readonly inlineMessage: boolean;
773
+ readonly showMessage: boolean;
774
+ readonly requireAsteriskPosition: "left" | "right";
775
+ readonly labelSuffix: string;
776
+ readonly validateOnRuleChange: boolean;
777
+ readonly scrollIntoViewOptions: boolean | Record<string, any>;
778
+ readonly statusIcon: boolean;
779
+ readonly hideRequiredAsterisk: boolean;
780
+ readonly scrollToError: boolean;
781
+ }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
782
+ beforeCreate?: (() => void) | (() => void)[];
783
+ created?: (() => void) | (() => void)[];
784
+ beforeMount?: (() => void) | (() => void)[];
785
+ mounted?: (() => void) | (() => void)[];
786
+ beforeUpdate?: (() => void) | (() => void)[];
787
+ updated?: (() => void) | (() => void)[];
788
+ activated?: (() => void) | (() => void)[];
789
+ deactivated?: (() => void) | (() => void)[];
790
+ beforeDestroy?: (() => void) | (() => void)[];
791
+ beforeUnmount?: (() => void) | (() => void)[];
792
+ destroyed?: (() => void) | (() => void)[];
793
+ unmounted?: (() => void) | (() => void)[];
794
+ renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
795
+ renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
796
+ errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
797
+ };
798
+ $forceUpdate: () => void;
799
+ $nextTick: typeof import("vue").nextTick;
800
+ $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;
801
+ } & Readonly<{
802
+ readonly disabled: boolean;
803
+ readonly inline: boolean;
804
+ readonly labelWidth: string | number;
805
+ readonly labelPosition: "top" | "left" | "right";
806
+ readonly inlineMessage: boolean;
807
+ readonly showMessage: boolean;
808
+ readonly requireAsteriskPosition: "left" | "right";
809
+ readonly labelSuffix: string;
810
+ readonly validateOnRuleChange: boolean;
811
+ readonly scrollIntoViewOptions: boolean | Record<string, any>;
812
+ readonly statusIcon: boolean;
813
+ readonly hideRequiredAsterisk: boolean;
814
+ readonly scrollToError: boolean;
815
+ }> & Omit<Readonly<import("vue").ExtractPropTypes<{
816
+ readonly model: ObjectConstructor;
817
+ readonly rules: {
818
+ readonly type: PropType<Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>>;
819
+ readonly required: false;
820
+ readonly validator: ((val: unknown) => boolean) | undefined;
821
+ __epPropKey: true;
822
+ };
823
+ readonly labelPosition: {
824
+ readonly type: PropType<"top" | "left" | "right">;
825
+ readonly required: false;
826
+ readonly validator: ((val: unknown) => boolean) | undefined;
827
+ __epPropKey: true;
828
+ } & {
829
+ readonly default: "right";
830
+ };
831
+ readonly requireAsteriskPosition: {
832
+ readonly type: PropType<"left" | "right">;
833
+ readonly required: false;
834
+ readonly validator: ((val: unknown) => boolean) | undefined;
835
+ __epPropKey: true;
836
+ } & {
837
+ readonly default: "left";
838
+ };
839
+ readonly labelWidth: {
840
+ readonly type: PropType<string | number>;
841
+ readonly required: false;
842
+ readonly validator: ((val: unknown) => boolean) | undefined;
843
+ __epPropKey: true;
844
+ } & {
845
+ readonly default: "";
846
+ };
847
+ readonly labelSuffix: {
848
+ readonly type: PropType<string>;
849
+ readonly required: false;
850
+ readonly validator: ((val: unknown) => boolean) | undefined;
851
+ __epPropKey: true;
852
+ } & {
853
+ readonly default: "";
854
+ };
855
+ readonly inline: BooleanConstructor;
856
+ readonly inlineMessage: BooleanConstructor;
857
+ readonly statusIcon: BooleanConstructor;
858
+ readonly showMessage: {
859
+ readonly type: PropType<boolean>;
860
+ readonly required: false;
861
+ readonly validator: ((val: unknown) => boolean) | undefined;
862
+ __epPropKey: true;
863
+ } & {
864
+ readonly default: true;
865
+ };
866
+ readonly validateOnRuleChange: {
867
+ readonly type: PropType<boolean>;
868
+ readonly required: false;
869
+ readonly validator: ((val: unknown) => boolean) | undefined;
870
+ __epPropKey: true;
871
+ } & {
872
+ readonly default: true;
873
+ };
874
+ readonly hideRequiredAsterisk: BooleanConstructor;
875
+ readonly scrollToError: BooleanConstructor;
876
+ readonly scrollIntoViewOptions: {
877
+ readonly type: PropType<boolean | Record<string, any>>;
878
+ readonly required: false;
879
+ readonly validator: ((val: unknown) => boolean) | undefined;
880
+ __epPropKey: true;
881
+ } & {
882
+ readonly default: true;
883
+ };
884
+ readonly size: {
885
+ readonly type: PropType<"" | "default" | "small" | "large">;
886
+ readonly required: false;
887
+ readonly validator: ((val: unknown) => boolean) | undefined;
888
+ __epPropKey: true;
889
+ };
890
+ readonly disabled: BooleanConstructor;
891
+ }>> & {
892
+ onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
893
+ }, "inline" | "labelWidth" | "labelPosition" | "inlineMessage" | "showMessage" | "disabled" | "fields" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError" | "scrollIntoViewOptions" | "validate" | "validateField" | "resetFields" | "clearValidate" | "scrollToField" | "getField"> & import("vue").ShallowUnwrapRef<{
894
+ validate: (callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
895
+ validateField: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[], callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
896
+ resetFields: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[]) => void;
897
+ clearValidate: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[]) => void;
898
+ scrollToField: (prop: import("element-plus").FormItemProp) => void;
899
+ getField: (prop: import("element-plus").FormItemProp) => import("element-plus").FormItemContext | undefined;
900
+ fields: import("vue").Reactive<import("element-plus").FormItemContext[]>;
901
+ }> & {} & import("@vue/runtime-core").ComponentCustomProperties & {} & {
902
+ $slots: {
903
+ default?(_: {}): any;
904
+ };
905
+ };
906
+ promise: Promise<{
907
+ $: import("vue").ComponentInternalInstance;
908
+ $data: {};
909
+ $props: Partial<{
910
+ readonly disabled: boolean;
911
+ readonly inline: boolean;
912
+ readonly labelWidth: string | number;
913
+ readonly labelPosition: "top" | "left" | "right";
914
+ readonly inlineMessage: boolean;
915
+ readonly showMessage: boolean;
916
+ readonly requireAsteriskPosition: "left" | "right";
917
+ readonly labelSuffix: string;
918
+ readonly validateOnRuleChange: boolean;
919
+ readonly scrollIntoViewOptions: boolean | Record<string, any>;
920
+ readonly statusIcon: boolean;
921
+ readonly hideRequiredAsterisk: boolean;
922
+ readonly scrollToError: boolean;
923
+ }> & Omit<{
924
+ readonly inline: boolean;
925
+ readonly labelWidth: string | number;
926
+ readonly labelPosition: "top" | "left" | "right";
927
+ readonly inlineMessage: boolean;
928
+ readonly showMessage: boolean;
929
+ readonly disabled: boolean;
930
+ readonly requireAsteriskPosition: "left" | "right";
931
+ readonly labelSuffix: string;
932
+ readonly statusIcon: boolean;
933
+ readonly validateOnRuleChange: boolean;
934
+ readonly hideRequiredAsterisk: boolean;
935
+ readonly scrollToError: boolean;
936
+ readonly scrollIntoViewOptions: boolean | Record<string, any>;
937
+ readonly size?: "" | "default" | "small" | "large";
938
+ readonly rules?: Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>;
939
+ readonly model?: Record<string, any>;
940
+ onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
941
+ } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "inline" | "labelWidth" | "labelPosition" | "inlineMessage" | "showMessage" | "disabled" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError" | "scrollIntoViewOptions">;
942
+ $attrs: {
943
+ [x: string]: unknown;
944
+ };
945
+ $refs: {
946
+ [x: string]: unknown;
947
+ };
948
+ $slots: Readonly<{
949
+ [name: string]: import("vue").Slot<any>;
950
+ }>;
951
+ $root: import("vue").ComponentPublicInstance | null;
952
+ $parent: import("vue").ComponentPublicInstance | null;
953
+ $host: Element | null;
954
+ $emit: (event: "validate", prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => void;
955
+ $el: any;
956
+ $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
957
+ readonly model: ObjectConstructor;
958
+ readonly rules: {
959
+ readonly type: PropType<Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>>;
960
+ readonly required: false;
961
+ readonly validator: ((val: unknown) => boolean) | undefined;
962
+ __epPropKey: true;
963
+ };
964
+ readonly labelPosition: {
965
+ readonly type: PropType<"top" | "left" | "right">;
966
+ readonly required: false;
967
+ readonly validator: ((val: unknown) => boolean) | undefined;
968
+ __epPropKey: true;
969
+ } & {
970
+ readonly default: "right";
971
+ };
972
+ readonly requireAsteriskPosition: {
973
+ readonly type: PropType<"left" | "right">;
974
+ readonly required: false;
975
+ readonly validator: ((val: unknown) => boolean) | undefined;
976
+ __epPropKey: true;
977
+ } & {
978
+ readonly default: "left";
979
+ };
980
+ readonly labelWidth: {
981
+ readonly type: PropType<string | number>;
982
+ readonly required: false;
983
+ readonly validator: ((val: unknown) => boolean) | undefined;
984
+ __epPropKey: true;
985
+ } & {
986
+ readonly default: "";
987
+ };
988
+ readonly labelSuffix: {
989
+ readonly type: PropType<string>;
990
+ readonly required: false;
991
+ readonly validator: ((val: unknown) => boolean) | undefined;
992
+ __epPropKey: true;
993
+ } & {
994
+ readonly default: "";
995
+ };
996
+ readonly inline: BooleanConstructor;
997
+ readonly inlineMessage: BooleanConstructor;
998
+ readonly statusIcon: BooleanConstructor;
999
+ readonly showMessage: {
1000
+ readonly type: PropType<boolean>;
1001
+ readonly required: false;
1002
+ readonly validator: ((val: unknown) => boolean) | undefined;
1003
+ __epPropKey: true;
1004
+ } & {
1005
+ readonly default: true;
1006
+ };
1007
+ readonly validateOnRuleChange: {
1008
+ readonly type: PropType<boolean>;
1009
+ readonly required: false;
1010
+ readonly validator: ((val: unknown) => boolean) | undefined;
1011
+ __epPropKey: true;
1012
+ } & {
1013
+ readonly default: true;
1014
+ };
1015
+ readonly hideRequiredAsterisk: BooleanConstructor;
1016
+ readonly scrollToError: BooleanConstructor;
1017
+ readonly scrollIntoViewOptions: {
1018
+ readonly type: PropType<boolean | Record<string, any>>;
1019
+ readonly required: false;
1020
+ readonly validator: ((val: unknown) => boolean) | undefined;
1021
+ __epPropKey: true;
1022
+ } & {
1023
+ readonly default: true;
1024
+ };
1025
+ readonly size: {
1026
+ readonly type: PropType<"" | "default" | "small" | "large">;
1027
+ readonly required: false;
1028
+ readonly validator: ((val: unknown) => boolean) | undefined;
1029
+ __epPropKey: true;
1030
+ };
1031
+ readonly disabled: BooleanConstructor;
1032
+ }>> & {
1033
+ onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
1034
+ }, {
1035
+ validate: (callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
1036
+ validateField: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[], callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
1037
+ resetFields: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[]) => void;
1038
+ clearValidate: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[]) => void;
1039
+ scrollToField: (prop: import("element-plus").FormItemProp) => void;
1040
+ getField: (prop: import("element-plus").FormItemProp) => import("element-plus").FormItemContext | undefined;
1041
+ fields: import("vue").Reactive<import("element-plus").FormItemContext[]>;
1042
+ }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
1043
+ validate: (prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => void;
1044
+ }, string, {
1045
+ readonly disabled: boolean;
1046
+ readonly inline: boolean;
1047
+ readonly labelWidth: string | number;
1048
+ readonly labelPosition: "top" | "left" | "right";
1049
+ readonly inlineMessage: boolean;
1050
+ readonly showMessage: boolean;
1051
+ readonly requireAsteriskPosition: "left" | "right";
1052
+ readonly labelSuffix: string;
1053
+ readonly validateOnRuleChange: boolean;
1054
+ readonly scrollIntoViewOptions: boolean | Record<string, any>;
1055
+ readonly statusIcon: boolean;
1056
+ readonly hideRequiredAsterisk: boolean;
1057
+ readonly scrollToError: boolean;
1058
+ }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
1059
+ beforeCreate?: (() => void) | (() => void)[];
1060
+ created?: (() => void) | (() => void)[];
1061
+ beforeMount?: (() => void) | (() => void)[];
1062
+ mounted?: (() => void) | (() => void)[];
1063
+ beforeUpdate?: (() => void) | (() => void)[];
1064
+ updated?: (() => void) | (() => void)[];
1065
+ activated?: (() => void) | (() => void)[];
1066
+ deactivated?: (() => void) | (() => void)[];
1067
+ beforeDestroy?: (() => void) | (() => void)[];
1068
+ beforeUnmount?: (() => void) | (() => void)[];
1069
+ destroyed?: (() => void) | (() => void)[];
1070
+ unmounted?: (() => void) | (() => void)[];
1071
+ renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
1072
+ renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
1073
+ errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
1074
+ };
1075
+ $forceUpdate: () => void;
1076
+ $nextTick: typeof import("vue").nextTick;
1077
+ $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;
1078
+ } & Readonly<{
1079
+ readonly disabled: boolean;
1080
+ readonly inline: boolean;
1081
+ readonly labelWidth: string | number;
1082
+ readonly labelPosition: "top" | "left" | "right";
1083
+ readonly inlineMessage: boolean;
1084
+ readonly showMessage: boolean;
1085
+ readonly requireAsteriskPosition: "left" | "right";
1086
+ readonly labelSuffix: string;
1087
+ readonly validateOnRuleChange: boolean;
1088
+ readonly scrollIntoViewOptions: boolean | Record<string, any>;
1089
+ readonly statusIcon: boolean;
1090
+ readonly hideRequiredAsterisk: boolean;
1091
+ readonly scrollToError: boolean;
1092
+ }> & Omit<Readonly<import("vue").ExtractPropTypes<{
1093
+ readonly model: ObjectConstructor;
1094
+ readonly rules: {
1095
+ readonly type: PropType<Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>>;
1096
+ readonly required: false;
1097
+ readonly validator: ((val: unknown) => boolean) | undefined;
1098
+ __epPropKey: true;
1099
+ };
1100
+ readonly labelPosition: {
1101
+ readonly type: PropType<"top" | "left" | "right">;
1102
+ readonly required: false;
1103
+ readonly validator: ((val: unknown) => boolean) | undefined;
1104
+ __epPropKey: true;
1105
+ } & {
1106
+ readonly default: "right";
1107
+ };
1108
+ readonly requireAsteriskPosition: {
1109
+ readonly type: PropType<"left" | "right">;
1110
+ readonly required: false;
1111
+ readonly validator: ((val: unknown) => boolean) | undefined;
1112
+ __epPropKey: true;
1113
+ } & {
1114
+ readonly default: "left";
1115
+ };
1116
+ readonly labelWidth: {
1117
+ readonly type: PropType<string | number>;
1118
+ readonly required: false;
1119
+ readonly validator: ((val: unknown) => boolean) | undefined;
1120
+ __epPropKey: true;
1121
+ } & {
1122
+ readonly default: "";
1123
+ };
1124
+ readonly labelSuffix: {
1125
+ readonly type: PropType<string>;
1126
+ readonly required: false;
1127
+ readonly validator: ((val: unknown) => boolean) | undefined;
1128
+ __epPropKey: true;
1129
+ } & {
1130
+ readonly default: "";
1131
+ };
1132
+ readonly inline: BooleanConstructor;
1133
+ readonly inlineMessage: BooleanConstructor;
1134
+ readonly statusIcon: BooleanConstructor;
1135
+ readonly showMessage: {
1136
+ readonly type: PropType<boolean>;
1137
+ readonly required: false;
1138
+ readonly validator: ((val: unknown) => boolean) | undefined;
1139
+ __epPropKey: true;
1140
+ } & {
1141
+ readonly default: true;
1142
+ };
1143
+ readonly validateOnRuleChange: {
1144
+ readonly type: PropType<boolean>;
1145
+ readonly required: false;
1146
+ readonly validator: ((val: unknown) => boolean) | undefined;
1147
+ __epPropKey: true;
1148
+ } & {
1149
+ readonly default: true;
1150
+ };
1151
+ readonly hideRequiredAsterisk: BooleanConstructor;
1152
+ readonly scrollToError: BooleanConstructor;
1153
+ readonly scrollIntoViewOptions: {
1154
+ readonly type: PropType<boolean | Record<string, any>>;
1155
+ readonly required: false;
1156
+ readonly validator: ((val: unknown) => boolean) | undefined;
1157
+ __epPropKey: true;
1158
+ } & {
1159
+ readonly default: true;
1160
+ };
1161
+ readonly size: {
1162
+ readonly type: PropType<"" | "default" | "small" | "large">;
1163
+ readonly required: false;
1164
+ readonly validator: ((val: unknown) => boolean) | undefined;
1165
+ __epPropKey: true;
1166
+ };
1167
+ readonly disabled: BooleanConstructor;
1168
+ }>> & {
1169
+ onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
1170
+ }, "inline" | "labelWidth" | "labelPosition" | "inlineMessage" | "showMessage" | "disabled" | "fields" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError" | "scrollIntoViewOptions" | "validate" | "validateField" | "resetFields" | "clearValidate" | "scrollToField" | "getField"> & import("vue").ShallowUnwrapRef<{
1171
+ validate: (callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
1172
+ validateField: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[], callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
1173
+ resetFields: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[]) => void;
1174
+ clearValidate: (props?: import("element-plus").FormItemProp | import("element-plus").FormItemProp[]) => void;
1175
+ scrollToField: (prop: import("element-plus").FormItemProp) => void;
1176
+ getField: (prop: import("element-plus").FormItemProp) => import("element-plus").FormItemContext | undefined;
1177
+ fields: import("vue").Reactive<import("element-plus").FormItemContext[]>;
1178
+ }> & {} & import("@vue/runtime-core").ComponentCustomProperties & {} & {
1179
+ $slots: {
1180
+ default?(_: {}): any;
1181
+ };
1182
+ }>;
1183
+ resolve: import("@vunk/core").AnyFunc;
1184
+ reject: (reason?: any) => void;
1185
+ };
59
1186
  handleSubmit: () => void;
1187
+ readonly setData: (obj: any, e: import("@vunk/core").SetDataEvent) => void;
60
1188
  readonly VkfForm: {
61
1189
  new (...args: any[]): any;
62
1190
  __isFragment?: never;
@@ -72,7 +1200,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
72
1200
  new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
73
1201
  readonly appendToBody: BooleanConstructor;
74
1202
  readonly appendTo: {
75
- readonly type: import("vue").PropType<string | HTMLElement>;
1203
+ readonly type: PropType<string | HTMLElement>;
76
1204
  readonly required: false;
77
1205
  readonly validator: ((val: unknown) => boolean) | undefined;
78
1206
  __epPropKey: true;
@@ -80,14 +1208,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
80
1208
  readonly default: "body";
81
1209
  };
82
1210
  readonly beforeClose: {
83
- readonly type: import("vue").PropType<import("element-plus").DialogBeforeCloseFn>;
1211
+ readonly type: PropType<import("element-plus").DialogBeforeCloseFn>;
84
1212
  readonly required: false;
85
1213
  readonly validator: ((val: unknown) => boolean) | undefined;
86
1214
  __epPropKey: true;
87
1215
  };
88
1216
  readonly destroyOnClose: BooleanConstructor;
89
1217
  readonly closeOnClickModal: {
90
- readonly type: import("vue").PropType<boolean>;
1218
+ readonly type: PropType<boolean>;
91
1219
  readonly required: false;
92
1220
  readonly validator: ((val: unknown) => boolean) | undefined;
93
1221
  __epPropKey: true;
@@ -95,7 +1223,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
95
1223
  readonly default: true;
96
1224
  };
97
1225
  readonly closeOnPressEscape: {
98
- readonly type: import("vue").PropType<boolean>;
1226
+ readonly type: PropType<boolean>;
99
1227
  readonly required: false;
100
1228
  readonly validator: ((val: unknown) => boolean) | undefined;
101
1229
  __epPropKey: true;
@@ -103,7 +1231,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
103
1231
  readonly default: true;
104
1232
  };
105
1233
  readonly lockScroll: {
106
- readonly type: import("vue").PropType<boolean>;
1234
+ readonly type: PropType<boolean>;
107
1235
  readonly required: false;
108
1236
  readonly validator: ((val: unknown) => boolean) | undefined;
109
1237
  __epPropKey: true;
@@ -111,7 +1239,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
111
1239
  readonly default: true;
112
1240
  };
113
1241
  readonly modal: {
114
- readonly type: import("vue").PropType<boolean>;
1242
+ readonly type: PropType<boolean>;
115
1243
  readonly required: false;
116
1244
  readonly validator: ((val: unknown) => boolean) | undefined;
117
1245
  __epPropKey: true;
@@ -119,7 +1247,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
119
1247
  readonly default: true;
120
1248
  };
121
1249
  readonly openDelay: {
122
- readonly type: import("vue").PropType<number>;
1250
+ readonly type: PropType<number>;
123
1251
  readonly required: false;
124
1252
  readonly validator: ((val: unknown) => boolean) | undefined;
125
1253
  __epPropKey: true;
@@ -127,7 +1255,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
127
1255
  readonly default: 0;
128
1256
  };
129
1257
  readonly closeDelay: {
130
- readonly type: import("vue").PropType<number>;
1258
+ readonly type: PropType<number>;
131
1259
  readonly required: false;
132
1260
  readonly validator: ((val: unknown) => boolean) | undefined;
133
1261
  __epPropKey: true;
@@ -135,7 +1263,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
135
1263
  readonly default: 0;
136
1264
  };
137
1265
  readonly top: {
138
- readonly type: import("vue").PropType<string>;
1266
+ readonly type: PropType<string>;
139
1267
  readonly required: false;
140
1268
  readonly validator: ((val: unknown) => boolean) | undefined;
141
1269
  __epPropKey: true;
@@ -146,20 +1274,20 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
146
1274
  readonly bodyClass: StringConstructor;
147
1275
  readonly footerClass: StringConstructor;
148
1276
  readonly width: {
149
- readonly type: import("vue").PropType<string | number>;
1277
+ readonly type: PropType<string | number>;
150
1278
  readonly required: false;
151
1279
  readonly validator: ((val: unknown) => boolean) | undefined;
152
1280
  __epPropKey: true;
153
1281
  };
154
1282
  readonly zIndex: {
155
- readonly type: import("vue").PropType<number>;
1283
+ readonly type: PropType<number>;
156
1284
  readonly required: false;
157
1285
  readonly validator: ((val: unknown) => boolean) | undefined;
158
1286
  __epPropKey: true;
159
1287
  };
160
1288
  readonly trapFocus: BooleanConstructor;
161
1289
  readonly headerAriaLevel: {
162
- readonly type: import("vue").PropType<string>;
1290
+ readonly type: PropType<string>;
163
1291
  readonly required: false;
164
1292
  readonly validator: ((val: unknown) => boolean) | undefined;
165
1293
  __epPropKey: true;
@@ -169,7 +1297,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
169
1297
  readonly center: BooleanConstructor;
170
1298
  readonly alignCenter: BooleanConstructor;
171
1299
  readonly closeIcon: {
172
- readonly type: import("vue").PropType<unknown>;
1300
+ readonly type: PropType<unknown>;
173
1301
  readonly required: false;
174
1302
  readonly validator: ((val: unknown) => boolean) | undefined;
175
1303
  __epPropKey: true;
@@ -178,7 +1306,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
178
1306
  readonly overflow: BooleanConstructor;
179
1307
  readonly fullscreen: BooleanConstructor;
180
1308
  readonly showClose: {
181
- readonly type: import("vue").PropType<boolean>;
1309
+ readonly type: PropType<boolean>;
182
1310
  readonly required: false;
183
1311
  readonly validator: ((val: unknown) => boolean) | undefined;
184
1312
  __epPropKey: true;
@@ -186,7 +1314,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
186
1314
  readonly default: true;
187
1315
  };
188
1316
  readonly title: {
189
- readonly type: import("vue").PropType<string>;
1317
+ readonly type: PropType<string>;
190
1318
  readonly required: false;
191
1319
  readonly validator: ((val: unknown) => boolean) | undefined;
192
1320
  __epPropKey: true;
@@ -194,7 +1322,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
194
1322
  readonly default: "";
195
1323
  };
196
1324
  readonly ariaLevel: {
197
- readonly type: import("vue").PropType<string>;
1325
+ readonly type: PropType<string>;
198
1326
  readonly required: false;
199
1327
  readonly validator: ((val: unknown) => boolean) | undefined;
200
1328
  __epPropKey: true;
@@ -253,7 +1381,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
253
1381
  }, Readonly<import("vue").ExtractPropTypes<{
254
1382
  readonly appendToBody: BooleanConstructor;
255
1383
  readonly appendTo: {
256
- readonly type: import("vue").PropType<string | HTMLElement>;
1384
+ readonly type: PropType<string | HTMLElement>;
257
1385
  readonly required: false;
258
1386
  readonly validator: ((val: unknown) => boolean) | undefined;
259
1387
  __epPropKey: true;
@@ -261,14 +1389,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
261
1389
  readonly default: "body";
262
1390
  };
263
1391
  readonly beforeClose: {
264
- readonly type: import("vue").PropType<import("element-plus").DialogBeforeCloseFn>;
1392
+ readonly type: PropType<import("element-plus").DialogBeforeCloseFn>;
265
1393
  readonly required: false;
266
1394
  readonly validator: ((val: unknown) => boolean) | undefined;
267
1395
  __epPropKey: true;
268
1396
  };
269
1397
  readonly destroyOnClose: BooleanConstructor;
270
1398
  readonly closeOnClickModal: {
271
- readonly type: import("vue").PropType<boolean>;
1399
+ readonly type: PropType<boolean>;
272
1400
  readonly required: false;
273
1401
  readonly validator: ((val: unknown) => boolean) | undefined;
274
1402
  __epPropKey: true;
@@ -276,7 +1404,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
276
1404
  readonly default: true;
277
1405
  };
278
1406
  readonly closeOnPressEscape: {
279
- readonly type: import("vue").PropType<boolean>;
1407
+ readonly type: PropType<boolean>;
280
1408
  readonly required: false;
281
1409
  readonly validator: ((val: unknown) => boolean) | undefined;
282
1410
  __epPropKey: true;
@@ -284,7 +1412,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
284
1412
  readonly default: true;
285
1413
  };
286
1414
  readonly lockScroll: {
287
- readonly type: import("vue").PropType<boolean>;
1415
+ readonly type: PropType<boolean>;
288
1416
  readonly required: false;
289
1417
  readonly validator: ((val: unknown) => boolean) | undefined;
290
1418
  __epPropKey: true;
@@ -292,7 +1420,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
292
1420
  readonly default: true;
293
1421
  };
294
1422
  readonly modal: {
295
- readonly type: import("vue").PropType<boolean>;
1423
+ readonly type: PropType<boolean>;
296
1424
  readonly required: false;
297
1425
  readonly validator: ((val: unknown) => boolean) | undefined;
298
1426
  __epPropKey: true;
@@ -300,7 +1428,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
300
1428
  readonly default: true;
301
1429
  };
302
1430
  readonly openDelay: {
303
- readonly type: import("vue").PropType<number>;
1431
+ readonly type: PropType<number>;
304
1432
  readonly required: false;
305
1433
  readonly validator: ((val: unknown) => boolean) | undefined;
306
1434
  __epPropKey: true;
@@ -308,7 +1436,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
308
1436
  readonly default: 0;
309
1437
  };
310
1438
  readonly closeDelay: {
311
- readonly type: import("vue").PropType<number>;
1439
+ readonly type: PropType<number>;
312
1440
  readonly required: false;
313
1441
  readonly validator: ((val: unknown) => boolean) | undefined;
314
1442
  __epPropKey: true;
@@ -316,7 +1444,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
316
1444
  readonly default: 0;
317
1445
  };
318
1446
  readonly top: {
319
- readonly type: import("vue").PropType<string>;
1447
+ readonly type: PropType<string>;
320
1448
  readonly required: false;
321
1449
  readonly validator: ((val: unknown) => boolean) | undefined;
322
1450
  __epPropKey: true;
@@ -327,20 +1455,20 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
327
1455
  readonly bodyClass: StringConstructor;
328
1456
  readonly footerClass: StringConstructor;
329
1457
  readonly width: {
330
- readonly type: import("vue").PropType<string | number>;
1458
+ readonly type: PropType<string | number>;
331
1459
  readonly required: false;
332
1460
  readonly validator: ((val: unknown) => boolean) | undefined;
333
1461
  __epPropKey: true;
334
1462
  };
335
1463
  readonly zIndex: {
336
- readonly type: import("vue").PropType<number>;
1464
+ readonly type: PropType<number>;
337
1465
  readonly required: false;
338
1466
  readonly validator: ((val: unknown) => boolean) | undefined;
339
1467
  __epPropKey: true;
340
1468
  };
341
1469
  readonly trapFocus: BooleanConstructor;
342
1470
  readonly headerAriaLevel: {
343
- readonly type: import("vue").PropType<string>;
1471
+ readonly type: PropType<string>;
344
1472
  readonly required: false;
345
1473
  readonly validator: ((val: unknown) => boolean) | undefined;
346
1474
  __epPropKey: true;
@@ -350,7 +1478,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
350
1478
  readonly center: BooleanConstructor;
351
1479
  readonly alignCenter: BooleanConstructor;
352
1480
  readonly closeIcon: {
353
- readonly type: import("vue").PropType<unknown>;
1481
+ readonly type: PropType<unknown>;
354
1482
  readonly required: false;
355
1483
  readonly validator: ((val: unknown) => boolean) | undefined;
356
1484
  __epPropKey: true;
@@ -359,7 +1487,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
359
1487
  readonly overflow: BooleanConstructor;
360
1488
  readonly fullscreen: BooleanConstructor;
361
1489
  readonly showClose: {
362
- readonly type: import("vue").PropType<boolean>;
1490
+ readonly type: PropType<boolean>;
363
1491
  readonly required: false;
364
1492
  readonly validator: ((val: unknown) => boolean) | undefined;
365
1493
  __epPropKey: true;
@@ -367,7 +1495,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
367
1495
  readonly default: true;
368
1496
  };
369
1497
  readonly title: {
370
- readonly type: import("vue").PropType<string>;
1498
+ readonly type: PropType<string>;
371
1499
  readonly required: false;
372
1500
  readonly validator: ((val: unknown) => boolean) | undefined;
373
1501
  __epPropKey: true;
@@ -375,7 +1503,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
375
1503
  readonly default: "";
376
1504
  };
377
1505
  readonly ariaLevel: {
378
- readonly type: import("vue").PropType<string>;
1506
+ readonly type: PropType<string>;
379
1507
  readonly required: false;
380
1508
  readonly validator: ((val: unknown) => boolean) | undefined;
381
1509
  __epPropKey: true;
@@ -423,7 +1551,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
423
1551
  } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
424
1552
  readonly appendToBody: BooleanConstructor;
425
1553
  readonly appendTo: {
426
- readonly type: import("vue").PropType<string | HTMLElement>;
1554
+ readonly type: PropType<string | HTMLElement>;
427
1555
  readonly required: false;
428
1556
  readonly validator: ((val: unknown) => boolean) | undefined;
429
1557
  __epPropKey: true;
@@ -431,14 +1559,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
431
1559
  readonly default: "body";
432
1560
  };
433
1561
  readonly beforeClose: {
434
- readonly type: import("vue").PropType<import("element-plus").DialogBeforeCloseFn>;
1562
+ readonly type: PropType<import("element-plus").DialogBeforeCloseFn>;
435
1563
  readonly required: false;
436
1564
  readonly validator: ((val: unknown) => boolean) | undefined;
437
1565
  __epPropKey: true;
438
1566
  };
439
1567
  readonly destroyOnClose: BooleanConstructor;
440
1568
  readonly closeOnClickModal: {
441
- readonly type: import("vue").PropType<boolean>;
1569
+ readonly type: PropType<boolean>;
442
1570
  readonly required: false;
443
1571
  readonly validator: ((val: unknown) => boolean) | undefined;
444
1572
  __epPropKey: true;
@@ -446,7 +1574,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
446
1574
  readonly default: true;
447
1575
  };
448
1576
  readonly closeOnPressEscape: {
449
- readonly type: import("vue").PropType<boolean>;
1577
+ readonly type: PropType<boolean>;
450
1578
  readonly required: false;
451
1579
  readonly validator: ((val: unknown) => boolean) | undefined;
452
1580
  __epPropKey: true;
@@ -454,7 +1582,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
454
1582
  readonly default: true;
455
1583
  };
456
1584
  readonly lockScroll: {
457
- readonly type: import("vue").PropType<boolean>;
1585
+ readonly type: PropType<boolean>;
458
1586
  readonly required: false;
459
1587
  readonly validator: ((val: unknown) => boolean) | undefined;
460
1588
  __epPropKey: true;
@@ -462,7 +1590,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
462
1590
  readonly default: true;
463
1591
  };
464
1592
  readonly modal: {
465
- readonly type: import("vue").PropType<boolean>;
1593
+ readonly type: PropType<boolean>;
466
1594
  readonly required: false;
467
1595
  readonly validator: ((val: unknown) => boolean) | undefined;
468
1596
  __epPropKey: true;
@@ -470,7 +1598,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
470
1598
  readonly default: true;
471
1599
  };
472
1600
  readonly openDelay: {
473
- readonly type: import("vue").PropType<number>;
1601
+ readonly type: PropType<number>;
474
1602
  readonly required: false;
475
1603
  readonly validator: ((val: unknown) => boolean) | undefined;
476
1604
  __epPropKey: true;
@@ -478,7 +1606,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
478
1606
  readonly default: 0;
479
1607
  };
480
1608
  readonly closeDelay: {
481
- readonly type: import("vue").PropType<number>;
1609
+ readonly type: PropType<number>;
482
1610
  readonly required: false;
483
1611
  readonly validator: ((val: unknown) => boolean) | undefined;
484
1612
  __epPropKey: true;
@@ -486,7 +1614,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
486
1614
  readonly default: 0;
487
1615
  };
488
1616
  readonly top: {
489
- readonly type: import("vue").PropType<string>;
1617
+ readonly type: PropType<string>;
490
1618
  readonly required: false;
491
1619
  readonly validator: ((val: unknown) => boolean) | undefined;
492
1620
  __epPropKey: true;
@@ -497,20 +1625,20 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
497
1625
  readonly bodyClass: StringConstructor;
498
1626
  readonly footerClass: StringConstructor;
499
1627
  readonly width: {
500
- readonly type: import("vue").PropType<string | number>;
1628
+ readonly type: PropType<string | number>;
501
1629
  readonly required: false;
502
1630
  readonly validator: ((val: unknown) => boolean) | undefined;
503
1631
  __epPropKey: true;
504
1632
  };
505
1633
  readonly zIndex: {
506
- readonly type: import("vue").PropType<number>;
1634
+ readonly type: PropType<number>;
507
1635
  readonly required: false;
508
1636
  readonly validator: ((val: unknown) => boolean) | undefined;
509
1637
  __epPropKey: true;
510
1638
  };
511
1639
  readonly trapFocus: BooleanConstructor;
512
1640
  readonly headerAriaLevel: {
513
- readonly type: import("vue").PropType<string>;
1641
+ readonly type: PropType<string>;
514
1642
  readonly required: false;
515
1643
  readonly validator: ((val: unknown) => boolean) | undefined;
516
1644
  __epPropKey: true;
@@ -520,7 +1648,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
520
1648
  readonly center: BooleanConstructor;
521
1649
  readonly alignCenter: BooleanConstructor;
522
1650
  readonly closeIcon: {
523
- readonly type: import("vue").PropType<unknown>;
1651
+ readonly type: PropType<unknown>;
524
1652
  readonly required: false;
525
1653
  readonly validator: ((val: unknown) => boolean) | undefined;
526
1654
  __epPropKey: true;
@@ -529,7 +1657,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
529
1657
  readonly overflow: BooleanConstructor;
530
1658
  readonly fullscreen: BooleanConstructor;
531
1659
  readonly showClose: {
532
- readonly type: import("vue").PropType<boolean>;
1660
+ readonly type: PropType<boolean>;
533
1661
  readonly required: false;
534
1662
  readonly validator: ((val: unknown) => boolean) | undefined;
535
1663
  __epPropKey: true;
@@ -537,7 +1665,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
537
1665
  readonly default: true;
538
1666
  };
539
1667
  readonly title: {
540
- readonly type: import("vue").PropType<string>;
1668
+ readonly type: PropType<string>;
541
1669
  readonly required: false;
542
1670
  readonly validator: ((val: unknown) => boolean) | undefined;
543
1671
  __epPropKey: true;
@@ -545,7 +1673,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
545
1673
  readonly default: "";
546
1674
  };
547
1675
  readonly ariaLevel: {
548
- readonly type: import("vue").PropType<string>;
1676
+ readonly type: PropType<string>;
549
1677
  readonly required: false;
550
1678
  readonly validator: ((val: unknown) => boolean) | undefined;
551
1679
  __epPropKey: true;
@@ -606,7 +1734,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
606
1734
  footer?(_: {}): any;
607
1735
  };
608
1736
  }) & import("vue").Plugin;
609
- readonly setData: (obj: any, e: import("@vunk/core").SetDataEvent) => void;
610
1737
  }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "change" | "update:visible")[], "update:modelValue" | "change" | "update:visible", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
611
1738
  title: {
612
1739
  type: StringConstructor;
@@ -632,6 +1759,13 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
632
1759
  type: ObjectConstructor;
633
1760
  default: () => {};
634
1761
  };
1762
+ validateCatch: {
1763
+ type: PropType<AnyFunc>;
1764
+ default: (err: any, init?: {
1765
+ prefix?: string;
1766
+ suffix?: string;
1767
+ }) => void;
1768
+ };
635
1769
  }>> & Readonly<{
636
1770
  "onUpdate:visible"?: (...args: any[]) => any;
637
1771
  "onUpdate:modelValue"?: (...args: any[]) => any;
@@ -641,6 +1775,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
641
1775
  modelValue: Record<string, any>;
642
1776
  formItems: unknown[];
643
1777
  dialogFormProps: Record<string, any>;
1778
+ validateCatch: AnyFunc;
644
1779
  title: string;
645
1780
  openReset: boolean;
646
1781
  }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;