@vue-start/element-pro 0.2.19 → 0.2.20

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 (2) hide show
  1. package/dist/index.d.ts +4086 -0
  2. package/package.json +2 -2
package/dist/index.d.ts ADDED
@@ -0,0 +1,4086 @@
1
+ import * as element_plus_es_components_descriptions_src_descriptions_type from 'element-plus/es/components/descriptions/src/descriptions.type';
2
+ import * as element_plus from 'element-plus';
3
+ import { DialogProps, IUseCheckboxGroupProps, ISelectProps, MenuProps, UploadProps, UploadFile, InputNumberProps, FormItemProps } from 'element-plus';
4
+ import * as _vue_shared from '@vue/shared';
5
+ import * as element_plus_es_utils from 'element-plus/es/utils';
6
+ import * as vue from 'vue';
7
+ import { ExtractPropTypes, PropType, VNode } from 'vue';
8
+ import * as _vue_start_pro from '@vue-start/pro';
9
+ import { TOption, TFile } from '@vue-start/pro';
10
+ import { FilterMethods, Filters } from 'element-plus/es/components/table/src/table-column/defaults';
11
+ import { TreeComponentProps } from 'element-plus/es/components/tree/src/tree.type';
12
+
13
+ declare const createLoadingId: (prefix?: string) => string;
14
+ declare const proLoadingProps: () => {
15
+ loading: {
16
+ type: BooleanConstructor;
17
+ };
18
+ target: {
19
+ type: PropType<string | HTMLElement>;
20
+ };
21
+ body: {
22
+ type: BooleanConstructor;
23
+ };
24
+ fullscreen: {
25
+ type: BooleanConstructor;
26
+ };
27
+ lock: {
28
+ type: BooleanConstructor;
29
+ };
30
+ text: {
31
+ type: StringConstructor;
32
+ };
33
+ spinner: {
34
+ type: StringConstructor;
35
+ };
36
+ background: {
37
+ type: StringConstructor;
38
+ };
39
+ customClass: {
40
+ type: StringConstructor;
41
+ };
42
+ };
43
+ declare type ProLoadingProps = Partial<ExtractPropTypes<ReturnType<typeof proLoadingProps>>>;
44
+ declare const ProLoading: vue.DefineComponent<Partial<ExtractPropTypes<{
45
+ loading: {
46
+ type: BooleanConstructor;
47
+ };
48
+ target: {
49
+ type: PropType<string | HTMLElement>;
50
+ };
51
+ body: {
52
+ type: BooleanConstructor;
53
+ };
54
+ fullscreen: {
55
+ type: BooleanConstructor;
56
+ };
57
+ lock: {
58
+ type: BooleanConstructor;
59
+ };
60
+ text: {
61
+ type: StringConstructor;
62
+ };
63
+ spinner: {
64
+ type: StringConstructor;
65
+ };
66
+ background: {
67
+ type: StringConstructor;
68
+ };
69
+ customClass: {
70
+ type: StringConstructor;
71
+ };
72
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
73
+ loading: {
74
+ type: BooleanConstructor;
75
+ };
76
+ target: {
77
+ type: PropType<string | HTMLElement>;
78
+ };
79
+ body: {
80
+ type: BooleanConstructor;
81
+ };
82
+ fullscreen: {
83
+ type: BooleanConstructor;
84
+ };
85
+ lock: {
86
+ type: BooleanConstructor;
87
+ };
88
+ text: {
89
+ type: StringConstructor;
90
+ };
91
+ spinner: {
92
+ type: StringConstructor;
93
+ };
94
+ background: {
95
+ type: StringConstructor;
96
+ };
97
+ customClass: {
98
+ type: StringConstructor;
99
+ };
100
+ }>>>, {}>;
101
+
102
+ declare const proModalProps: () => {
103
+ /**
104
+ * class名称
105
+ */
106
+ clsName: {
107
+ type: StringConstructor;
108
+ default: string;
109
+ };
110
+ visible: {
111
+ type: BooleanConstructor;
112
+ default: boolean;
113
+ };
114
+ cancelText: {
115
+ type: StringConstructor;
116
+ default: string;
117
+ };
118
+ cancelButtonProps: {
119
+ type: PropType<{
120
+ readonly text: boolean;
121
+ readonly link: boolean;
122
+ readonly type: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown>;
123
+ readonly circle: boolean;
124
+ readonly disabled: boolean;
125
+ readonly loading: boolean;
126
+ readonly dark: boolean;
127
+ readonly icon: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown>;
128
+ readonly round: boolean;
129
+ readonly autofocus: boolean;
130
+ readonly loadingIcon: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown>;
131
+ readonly nativeType: element_plus_es_utils.EpPropMergeType<StringConstructor, "reset" | "submit" | "button", unknown>;
132
+ readonly plain: boolean;
133
+ readonly bg: boolean;
134
+ } & {
135
+ readonly color?: string | undefined;
136
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
137
+ readonly autoInsertSpace?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
138
+ } & {
139
+ onClick?: (() => void) | undefined;
140
+ }>;
141
+ };
142
+ okText: {
143
+ type: StringConstructor;
144
+ default: string;
145
+ };
146
+ okButtonProps: {
147
+ type: PropType<{
148
+ readonly text: boolean;
149
+ readonly link: boolean;
150
+ readonly type: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown>;
151
+ readonly circle: boolean;
152
+ readonly disabled: boolean;
153
+ readonly loading: boolean;
154
+ readonly dark: boolean;
155
+ readonly icon: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown>;
156
+ readonly round: boolean;
157
+ readonly autofocus: boolean;
158
+ readonly loadingIcon: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown>;
159
+ readonly nativeType: element_plus_es_utils.EpPropMergeType<StringConstructor, "reset" | "submit" | "button", unknown>;
160
+ readonly plain: boolean;
161
+ readonly bg: boolean;
162
+ } & {
163
+ readonly color?: string | undefined;
164
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
165
+ readonly autoInsertSpace?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
166
+ } & {
167
+ onClick?: (() => void) | undefined;
168
+ }>;
169
+ };
170
+ confirmLoading: BooleanConstructor;
171
+ footer: {
172
+ type: BooleanConstructor;
173
+ default: boolean;
174
+ };
175
+ maskClosable: {
176
+ type: (BooleanConstructor | ObjectConstructor)[];
177
+ default: undefined;
178
+ };
179
+ };
180
+ declare type ProModalProps = Partial<ExtractPropTypes<ReturnType<typeof proModalProps>>> & DialogProps;
181
+ declare const ProModal: vue.DefineComponent<ProModalProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProModalProps>, {}>;
182
+
183
+ declare const ProPagination: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
184
+ [x: string]: any;
185
+ }>;
186
+
187
+ declare const ProPopover: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
188
+ [x: string]: any;
189
+ }>;
190
+
191
+ declare const proCheckboxProps: () => {
192
+ options: PropType<(TOption & {
193
+ border: boolean;
194
+ disabled: boolean;
195
+ checked: boolean;
196
+ indeterminate: boolean;
197
+ validateEvent: boolean;
198
+ } & {
199
+ label?: string | number | boolean | Record<string, any> | undefined;
200
+ name?: string | undefined;
201
+ id?: string | undefined;
202
+ size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
203
+ modelValue?: string | number | boolean | undefined;
204
+ tabindex?: string | number | undefined;
205
+ controls?: string | undefined;
206
+ trueLabel?: string | number | undefined;
207
+ falseLabel?: string | number | undefined;
208
+ })[]>;
209
+ buttonStyle: {
210
+ type: PropType<"default" | "button">;
211
+ default: string;
212
+ };
213
+ optionType: {
214
+ type: PropType<"default" | "button">;
215
+ default: string;
216
+ };
217
+ };
218
+ declare type ProCheckboxProps = Partial<ExtractPropTypes<ReturnType<typeof proCheckboxProps>>> & IUseCheckboxGroupProps;
219
+ declare const ProCheckbox: vue.DefineComponent<ProCheckboxProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProCheckboxProps>, {}>;
220
+
221
+ declare const proRadioProps: () => {
222
+ options: {
223
+ type: PropType<(TOption & {
224
+ readonly label: element_plus_es_utils.EpPropMergeType<(NumberConstructor | StringConstructor | BooleanConstructor)[], unknown, unknown>;
225
+ readonly name: string;
226
+ readonly border: boolean;
227
+ readonly disabled: boolean;
228
+ readonly modelValue: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>;
229
+ } & {
230
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
231
+ } & {
232
+ readonly label: element_plus_es_utils.EpPropMergeType<(NumberConstructor | StringConstructor | BooleanConstructor)[], unknown, unknown>;
233
+ readonly name: string;
234
+ readonly disabled: boolean;
235
+ } & {
236
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
237
+ })[]>;
238
+ };
239
+ buttonStyle: {
240
+ type: PropType<"default" | "button">;
241
+ default: string;
242
+ };
243
+ optionType: {
244
+ type: PropType<"default" | "button">;
245
+ default: string;
246
+ };
247
+ };
248
+ declare type ProRadioProps = Partial<ExtractPropTypes<ReturnType<typeof proRadioProps>>> & Record<string, any>;
249
+ declare const ProRadio: vue.DefineComponent<ProRadioProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<ProRadioProps>>, {
250
+ [x: string]: any;
251
+ }>;
252
+
253
+ declare const proSelectProps: () => {
254
+ options: PropType<(TOption & {
255
+ created: boolean;
256
+ disabled: boolean;
257
+ hovering: boolean;
258
+ selected: boolean;
259
+ } & {
260
+ index?: number | undefined;
261
+ data?: unknown[] | undefined;
262
+ style?: Record<string, any> | undefined;
263
+ item?: Record<string, any> | undefined;
264
+ })[]>;
265
+ };
266
+ declare type ProSelectProps = Partial<ExtractPropTypes<ReturnType<typeof proSelectProps>>> & ISelectProps;
267
+ declare const ProSelect: vue.DefineComponent<ProSelectProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProSelectProps>, {
268
+ modelValue?: any;
269
+ }>;
270
+
271
+ declare const ProTabs: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
272
+ [x: string]: any;
273
+ }>;
274
+
275
+ /******************************* Menus ************************************/
276
+ declare const menuProps: () => {
277
+ convertSubMenuProps: {
278
+ type: FunctionConstructor;
279
+ };
280
+ convertMenuItemProps: {
281
+ type: FunctionConstructor;
282
+ };
283
+ onMenuItemClick: {
284
+ type: FunctionConstructor;
285
+ };
286
+ activeKey: {
287
+ type: StringConstructor;
288
+ };
289
+ options: {
290
+ type: PropType<Record<string, any>[]>;
291
+ };
292
+ fieldNames: {
293
+ type: PropType<{
294
+ children: string;
295
+ value: string;
296
+ label: string;
297
+ }>;
298
+ default: {
299
+ children: string;
300
+ value: string;
301
+ label: string;
302
+ };
303
+ };
304
+ };
305
+ declare type ProMenusProps = Partial<ExtractPropTypes<ReturnType<typeof menuProps>>> & Omit<MenuProps, "defaultActive">;
306
+ declare const ProMenus: vue.DefineComponent<ProMenusProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProMenusProps>, {}>;
307
+
308
+ declare const uploadProps: () => {
309
+ modelValue: {
310
+ type: PropType<TFile[]>;
311
+ default: undefined;
312
+ };
313
+ maxSize: {
314
+ type: NumberConstructor;
315
+ };
316
+ convertResponseData: {
317
+ type: PropType<(res: any) => Record<string, any>>;
318
+ };
319
+ convertItemData: {
320
+ type: PropType<(item: any) => UploadFile>;
321
+ default: (item: any) => any;
322
+ };
323
+ onErrorMsg: PropType<(type: string, msg: string) => void>;
324
+ onStart: PropType<(file: any) => void>;
325
+ beforeUpload: {
326
+ type: FunctionConstructor;
327
+ };
328
+ };
329
+ declare type ProUploadProps = Partial<ExtractPropTypes<ReturnType<typeof uploadProps>>> & Omit<UploadProps, "fileList">;
330
+ declare const UploadMethods: string[];
331
+ declare const ProUploader: vue.DefineComponent<ProUploadProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProUploadProps>, {}>;
332
+
333
+ declare const inputNumberProps: () => {
334
+ modelValue: {
335
+ type: PropType<number[]>;
336
+ };
337
+ start: {
338
+ type: PropType<InputNumberProps>;
339
+ };
340
+ end: {
341
+ type: PropType<InputNumberProps>;
342
+ };
343
+ /**
344
+ * true： 任何change都触发emit
345
+ * false： 两个值都输入，触发emit([v1,v2])，否则，触发emit(null)
346
+ */
347
+ singleEmit: {
348
+ type: PropType<boolean>;
349
+ default: boolean;
350
+ };
351
+ /********************slots******************/
352
+ divider: {
353
+ type: PropType<() => VNode>;
354
+ };
355
+ };
356
+ declare type ProInputNumberRangeProps = Partial<ExtractPropTypes<ReturnType<typeof inputNumberProps>>> & Omit<InputNumberProps, "modelValue">;
357
+ declare const InputNumberRange: vue.DefineComponent<ProInputNumberRangeProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProInputNumberRangeProps>, {
358
+ readonly valueOnClear: any;
359
+ }>;
360
+
361
+ declare type TFieldNames = {
362
+ key?: string;
363
+ children?: string;
364
+ title?: string;
365
+ disabled?: string;
366
+ isLeaf?: string;
367
+ class?: string;
368
+ };
369
+ declare const proTreeProps: () => {
370
+ treeData: {
371
+ type: PropType<Record<string, any>>;
372
+ };
373
+ fieldNames: {
374
+ type: PropType<TFieldNames>;
375
+ };
376
+ selectable: {
377
+ type: BooleanConstructor;
378
+ default: undefined;
379
+ };
380
+ expandedKeys: {
381
+ type: PropType<string[]>;
382
+ };
383
+ checkedKeys: {
384
+ type: PropType<string[]>;
385
+ };
386
+ };
387
+ declare type ProTreeProps = Partial<ExtractPropTypes<ReturnType<typeof proTreeProps>>> & TreeComponentProps;
388
+ declare const ProTree: vue.DefineComponent<ProTreeProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProTreeProps>, {}>;
389
+
390
+ declare const proFormItemProps: () => {
391
+ name: {
392
+ type: PropType<string | (string | number)[]>;
393
+ };
394
+ };
395
+ declare type ProFormItemProps = Partial<ExtractPropTypes<ReturnType<typeof proFormItemProps>>> & FormItemProps;
396
+ declare const ProFormItem: vue.DefineComponent<ProFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormItemProps>, {}>;
397
+ declare const FormMethods: string[];
398
+ declare const ProForm: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
399
+ [x: string]: any;
400
+ }>;
401
+
402
+ declare const ProFormText: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
403
+ name: {
404
+ type: vue.PropType<string | (string | number)[]>;
405
+ };
406
+ }>> & {
407
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
408
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
409
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
410
+ } & {
411
+ readonly error?: string | undefined;
412
+ readonly label?: string | undefined;
413
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
414
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
415
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
416
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
417
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
418
+ readonly for?: string | undefined;
419
+ } & Partial<vue.ExtractPropTypes<{
420
+ readonly: {
421
+ type: BooleanConstructor;
422
+ default: undefined;
423
+ };
424
+ fieldProps: {
425
+ type: ObjectConstructor;
426
+ };
427
+ showProps: {
428
+ type: ObjectConstructor;
429
+ };
430
+ slots: {
431
+ type: ObjectConstructor;
432
+ };
433
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
434
+ name: {
435
+ type: vue.PropType<string | (string | number)[]>;
436
+ };
437
+ }>> & {
438
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
439
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
440
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
441
+ } & {
442
+ readonly error?: string | undefined;
443
+ readonly label?: string | undefined;
444
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
445
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
446
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
447
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
448
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
449
+ readonly for?: string | undefined;
450
+ } & Partial<vue.ExtractPropTypes<{
451
+ readonly: {
452
+ type: BooleanConstructor;
453
+ default: undefined;
454
+ };
455
+ fieldProps: {
456
+ type: ObjectConstructor;
457
+ };
458
+ showProps: {
459
+ type: ObjectConstructor;
460
+ };
461
+ slots: {
462
+ type: ObjectConstructor;
463
+ };
464
+ }>> & Record<string, any>>>, {
465
+ [x: string]: any;
466
+ }>;
467
+ declare const ProFormTextNumber: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
468
+ name: {
469
+ type: vue.PropType<string | (string | number)[]>;
470
+ };
471
+ }>> & {
472
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
473
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
474
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
475
+ } & {
476
+ readonly error?: string | undefined;
477
+ readonly label?: string | undefined;
478
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
479
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
480
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
481
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
482
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
483
+ readonly for?: string | undefined;
484
+ } & Partial<vue.ExtractPropTypes<{
485
+ readonly: {
486
+ type: BooleanConstructor;
487
+ default: undefined;
488
+ };
489
+ fieldProps: {
490
+ type: ObjectConstructor;
491
+ };
492
+ showProps: {
493
+ type: ObjectConstructor;
494
+ };
495
+ slots: {
496
+ type: ObjectConstructor;
497
+ };
498
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
499
+ name: {
500
+ type: vue.PropType<string | (string | number)[]>;
501
+ };
502
+ }>> & {
503
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
504
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
505
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
506
+ } & {
507
+ readonly error?: string | undefined;
508
+ readonly label?: string | undefined;
509
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
510
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
511
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
512
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
513
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
514
+ readonly for?: string | undefined;
515
+ } & Partial<vue.ExtractPropTypes<{
516
+ readonly: {
517
+ type: BooleanConstructor;
518
+ default: undefined;
519
+ };
520
+ fieldProps: {
521
+ type: ObjectConstructor;
522
+ };
523
+ showProps: {
524
+ type: ObjectConstructor;
525
+ };
526
+ slots: {
527
+ type: ObjectConstructor;
528
+ };
529
+ }>> & Record<string, any>>>, {
530
+ [x: string]: any;
531
+ }>;
532
+ declare const ProFormInputNumberRange: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
533
+ name: {
534
+ type: vue.PropType<string | (string | number)[]>;
535
+ };
536
+ }>> & {
537
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
538
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
539
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
540
+ } & {
541
+ readonly error?: string | undefined;
542
+ readonly label?: string | undefined;
543
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
544
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
545
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
546
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
547
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
548
+ readonly for?: string | undefined;
549
+ } & Partial<vue.ExtractPropTypes<{
550
+ readonly: {
551
+ type: BooleanConstructor;
552
+ default: undefined;
553
+ };
554
+ fieldProps: {
555
+ type: ObjectConstructor;
556
+ };
557
+ showProps: {
558
+ type: ObjectConstructor;
559
+ };
560
+ slots: {
561
+ type: ObjectConstructor;
562
+ };
563
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
564
+ name: {
565
+ type: vue.PropType<string | (string | number)[]>;
566
+ };
567
+ }>> & {
568
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
569
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
570
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
571
+ } & {
572
+ readonly error?: string | undefined;
573
+ readonly label?: string | undefined;
574
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
575
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
576
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
577
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
578
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
579
+ readonly for?: string | undefined;
580
+ } & Partial<vue.ExtractPropTypes<{
581
+ readonly: {
582
+ type: BooleanConstructor;
583
+ default: undefined;
584
+ };
585
+ fieldProps: {
586
+ type: ObjectConstructor;
587
+ };
588
+ showProps: {
589
+ type: ObjectConstructor;
590
+ };
591
+ slots: {
592
+ type: ObjectConstructor;
593
+ };
594
+ }>> & Record<string, any>>>, {
595
+ [x: string]: any;
596
+ }>;
597
+ declare const ProFormDatePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
598
+ name: {
599
+ type: vue.PropType<string | (string | number)[]>;
600
+ };
601
+ }>> & {
602
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
603
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
604
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
605
+ } & {
606
+ readonly error?: string | undefined;
607
+ readonly label?: string | undefined;
608
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
609
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
610
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
611
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
612
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
613
+ readonly for?: string | undefined;
614
+ } & Partial<vue.ExtractPropTypes<{
615
+ readonly: {
616
+ type: BooleanConstructor;
617
+ default: undefined;
618
+ };
619
+ fieldProps: {
620
+ type: ObjectConstructor;
621
+ };
622
+ showProps: {
623
+ type: ObjectConstructor;
624
+ };
625
+ slots: {
626
+ type: ObjectConstructor;
627
+ };
628
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
629
+ name: {
630
+ type: vue.PropType<string | (string | number)[]>;
631
+ };
632
+ }>> & {
633
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
634
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
635
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
636
+ } & {
637
+ readonly error?: string | undefined;
638
+ readonly label?: string | undefined;
639
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
640
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
641
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
642
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
643
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
644
+ readonly for?: string | undefined;
645
+ } & Partial<vue.ExtractPropTypes<{
646
+ readonly: {
647
+ type: BooleanConstructor;
648
+ default: undefined;
649
+ };
650
+ fieldProps: {
651
+ type: ObjectConstructor;
652
+ };
653
+ showProps: {
654
+ type: ObjectConstructor;
655
+ };
656
+ slots: {
657
+ type: ObjectConstructor;
658
+ };
659
+ }>> & Record<string, any>>>, {
660
+ [x: string]: any;
661
+ }>;
662
+ declare const ProFormTimePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
663
+ name: {
664
+ type: vue.PropType<string | (string | number)[]>;
665
+ };
666
+ }>> & {
667
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
668
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
669
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
670
+ } & {
671
+ readonly error?: string | undefined;
672
+ readonly label?: string | undefined;
673
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
674
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
675
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
676
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
677
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
678
+ readonly for?: string | undefined;
679
+ } & Partial<vue.ExtractPropTypes<{
680
+ readonly: {
681
+ type: BooleanConstructor;
682
+ default: undefined;
683
+ };
684
+ fieldProps: {
685
+ type: ObjectConstructor;
686
+ };
687
+ showProps: {
688
+ type: ObjectConstructor;
689
+ };
690
+ slots: {
691
+ type: ObjectConstructor;
692
+ };
693
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
694
+ name: {
695
+ type: vue.PropType<string | (string | number)[]>;
696
+ };
697
+ }>> & {
698
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
699
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
700
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
701
+ } & {
702
+ readonly error?: string | undefined;
703
+ readonly label?: string | undefined;
704
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
705
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
706
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
707
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
708
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
709
+ readonly for?: string | undefined;
710
+ } & Partial<vue.ExtractPropTypes<{
711
+ readonly: {
712
+ type: BooleanConstructor;
713
+ default: undefined;
714
+ };
715
+ fieldProps: {
716
+ type: ObjectConstructor;
717
+ };
718
+ showProps: {
719
+ type: ObjectConstructor;
720
+ };
721
+ slots: {
722
+ type: ObjectConstructor;
723
+ };
724
+ }>> & Record<string, any>>>, {
725
+ [x: string]: any;
726
+ }>;
727
+ declare const ProFormSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
728
+ name: {
729
+ type: vue.PropType<string | (string | number)[]>;
730
+ };
731
+ }>> & {
732
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
733
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
734
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
735
+ } & {
736
+ readonly error?: string | undefined;
737
+ readonly label?: string | undefined;
738
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
739
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
740
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
741
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
742
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
743
+ readonly for?: string | undefined;
744
+ } & Partial<vue.ExtractPropTypes<{
745
+ readonly: {
746
+ type: BooleanConstructor;
747
+ default: undefined;
748
+ };
749
+ fieldProps: {
750
+ type: ObjectConstructor;
751
+ };
752
+ showProps: {
753
+ type: ObjectConstructor;
754
+ };
755
+ slots: {
756
+ type: ObjectConstructor;
757
+ };
758
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
759
+ name: {
760
+ type: vue.PropType<string | (string | number)[]>;
761
+ };
762
+ }>> & {
763
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
764
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
765
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
766
+ } & {
767
+ readonly error?: string | undefined;
768
+ readonly label?: string | undefined;
769
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
770
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
771
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
772
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
773
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
774
+ readonly for?: string | undefined;
775
+ } & Partial<vue.ExtractPropTypes<{
776
+ readonly: {
777
+ type: BooleanConstructor;
778
+ default: undefined;
779
+ };
780
+ fieldProps: {
781
+ type: ObjectConstructor;
782
+ };
783
+ showProps: {
784
+ type: ObjectConstructor;
785
+ };
786
+ slots: {
787
+ type: ObjectConstructor;
788
+ };
789
+ }>> & Record<string, any>>>, {
790
+ [x: string]: any;
791
+ }>;
792
+ declare const ProFormTreeSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
793
+ name: {
794
+ type: vue.PropType<string | (string | number)[]>;
795
+ };
796
+ }>> & {
797
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
798
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
799
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
800
+ } & {
801
+ readonly error?: string | undefined;
802
+ readonly label?: string | undefined;
803
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
804
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
805
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
806
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
807
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
808
+ readonly for?: string | undefined;
809
+ } & Partial<vue.ExtractPropTypes<{
810
+ readonly: {
811
+ type: BooleanConstructor;
812
+ default: undefined;
813
+ };
814
+ fieldProps: {
815
+ type: ObjectConstructor;
816
+ };
817
+ showProps: {
818
+ type: ObjectConstructor;
819
+ };
820
+ slots: {
821
+ type: ObjectConstructor;
822
+ };
823
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
824
+ name: {
825
+ type: vue.PropType<string | (string | number)[]>;
826
+ };
827
+ }>> & {
828
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
829
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
830
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
831
+ } & {
832
+ readonly error?: string | undefined;
833
+ readonly label?: string | undefined;
834
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
835
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
836
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
837
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
838
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
839
+ readonly for?: string | undefined;
840
+ } & Partial<vue.ExtractPropTypes<{
841
+ readonly: {
842
+ type: BooleanConstructor;
843
+ default: undefined;
844
+ };
845
+ fieldProps: {
846
+ type: ObjectConstructor;
847
+ };
848
+ showProps: {
849
+ type: ObjectConstructor;
850
+ };
851
+ slots: {
852
+ type: ObjectConstructor;
853
+ };
854
+ }>> & Record<string, any>>>, {
855
+ [x: string]: any;
856
+ }>;
857
+ declare const ProFormCheckbox: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
858
+ name: {
859
+ type: vue.PropType<string | (string | number)[]>;
860
+ };
861
+ }>> & {
862
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
863
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
864
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
865
+ } & {
866
+ readonly error?: string | undefined;
867
+ readonly label?: string | undefined;
868
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
869
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
870
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
871
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
872
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
873
+ readonly for?: string | undefined;
874
+ } & Partial<vue.ExtractPropTypes<{
875
+ readonly: {
876
+ type: BooleanConstructor;
877
+ default: undefined;
878
+ };
879
+ fieldProps: {
880
+ type: ObjectConstructor;
881
+ };
882
+ showProps: {
883
+ type: ObjectConstructor;
884
+ };
885
+ slots: {
886
+ type: ObjectConstructor;
887
+ };
888
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
889
+ name: {
890
+ type: vue.PropType<string | (string | number)[]>;
891
+ };
892
+ }>> & {
893
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
894
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
895
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
896
+ } & {
897
+ readonly error?: string | undefined;
898
+ readonly label?: string | undefined;
899
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
900
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
901
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
902
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
903
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
904
+ readonly for?: string | undefined;
905
+ } & Partial<vue.ExtractPropTypes<{
906
+ readonly: {
907
+ type: BooleanConstructor;
908
+ default: undefined;
909
+ };
910
+ fieldProps: {
911
+ type: ObjectConstructor;
912
+ };
913
+ showProps: {
914
+ type: ObjectConstructor;
915
+ };
916
+ slots: {
917
+ type: ObjectConstructor;
918
+ };
919
+ }>> & Record<string, any>>>, {
920
+ [x: string]: any;
921
+ }>;
922
+ declare const ProFormRadio: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
923
+ name: {
924
+ type: vue.PropType<string | (string | number)[]>;
925
+ };
926
+ }>> & {
927
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
928
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
929
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
930
+ } & {
931
+ readonly error?: string | undefined;
932
+ readonly label?: string | undefined;
933
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
934
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
935
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
936
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
937
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
938
+ readonly for?: string | undefined;
939
+ } & Partial<vue.ExtractPropTypes<{
940
+ readonly: {
941
+ type: BooleanConstructor;
942
+ default: undefined;
943
+ };
944
+ fieldProps: {
945
+ type: ObjectConstructor;
946
+ };
947
+ showProps: {
948
+ type: ObjectConstructor;
949
+ };
950
+ slots: {
951
+ type: ObjectConstructor;
952
+ };
953
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
954
+ name: {
955
+ type: vue.PropType<string | (string | number)[]>;
956
+ };
957
+ }>> & {
958
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
959
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
960
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
961
+ } & {
962
+ readonly error?: string | undefined;
963
+ readonly label?: string | undefined;
964
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
965
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
966
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
967
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
968
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
969
+ readonly for?: string | undefined;
970
+ } & Partial<vue.ExtractPropTypes<{
971
+ readonly: {
972
+ type: BooleanConstructor;
973
+ default: undefined;
974
+ };
975
+ fieldProps: {
976
+ type: ObjectConstructor;
977
+ };
978
+ showProps: {
979
+ type: ObjectConstructor;
980
+ };
981
+ slots: {
982
+ type: ObjectConstructor;
983
+ };
984
+ }>> & Record<string, any>>>, {
985
+ [x: string]: any;
986
+ }>;
987
+ declare const ProFormSwitch: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
988
+ name: {
989
+ type: vue.PropType<string | (string | number)[]>;
990
+ };
991
+ }>> & {
992
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
993
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
994
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
995
+ } & {
996
+ readonly error?: string | undefined;
997
+ readonly label?: string | undefined;
998
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
999
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1000
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1001
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
1002
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1003
+ readonly for?: string | undefined;
1004
+ } & Partial<vue.ExtractPropTypes<{
1005
+ readonly: {
1006
+ type: BooleanConstructor;
1007
+ default: undefined;
1008
+ };
1009
+ fieldProps: {
1010
+ type: ObjectConstructor;
1011
+ };
1012
+ showProps: {
1013
+ type: ObjectConstructor;
1014
+ };
1015
+ slots: {
1016
+ type: ObjectConstructor;
1017
+ };
1018
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
1019
+ name: {
1020
+ type: vue.PropType<string | (string | number)[]>;
1021
+ };
1022
+ }>> & {
1023
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1024
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1025
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1026
+ } & {
1027
+ readonly error?: string | undefined;
1028
+ readonly label?: string | undefined;
1029
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
1030
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1031
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1032
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
1033
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1034
+ readonly for?: string | undefined;
1035
+ } & Partial<vue.ExtractPropTypes<{
1036
+ readonly: {
1037
+ type: BooleanConstructor;
1038
+ default: undefined;
1039
+ };
1040
+ fieldProps: {
1041
+ type: ObjectConstructor;
1042
+ };
1043
+ showProps: {
1044
+ type: ObjectConstructor;
1045
+ };
1046
+ slots: {
1047
+ type: ObjectConstructor;
1048
+ };
1049
+ }>> & Record<string, any>>>, {
1050
+ [x: string]: any;
1051
+ }>;
1052
+ declare const ProFormCascader: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1053
+ name: {
1054
+ type: vue.PropType<string | (string | number)[]>;
1055
+ };
1056
+ }>> & {
1057
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1058
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1059
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1060
+ } & {
1061
+ readonly error?: string | undefined;
1062
+ readonly label?: string | undefined;
1063
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
1064
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1065
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1066
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
1067
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1068
+ readonly for?: string | undefined;
1069
+ } & Partial<vue.ExtractPropTypes<{
1070
+ readonly: {
1071
+ type: BooleanConstructor;
1072
+ default: undefined;
1073
+ };
1074
+ fieldProps: {
1075
+ type: ObjectConstructor;
1076
+ };
1077
+ showProps: {
1078
+ type: ObjectConstructor;
1079
+ };
1080
+ slots: {
1081
+ type: ObjectConstructor;
1082
+ };
1083
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
1084
+ name: {
1085
+ type: vue.PropType<string | (string | number)[]>;
1086
+ };
1087
+ }>> & {
1088
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1089
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1090
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1091
+ } & {
1092
+ readonly error?: string | undefined;
1093
+ readonly label?: string | undefined;
1094
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
1095
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1096
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1097
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
1098
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1099
+ readonly for?: string | undefined;
1100
+ } & Partial<vue.ExtractPropTypes<{
1101
+ readonly: {
1102
+ type: BooleanConstructor;
1103
+ default: undefined;
1104
+ };
1105
+ fieldProps: {
1106
+ type: ObjectConstructor;
1107
+ };
1108
+ showProps: {
1109
+ type: ObjectConstructor;
1110
+ };
1111
+ slots: {
1112
+ type: ObjectConstructor;
1113
+ };
1114
+ }>> & Record<string, any>>>, {
1115
+ [x: string]: any;
1116
+ }>;
1117
+
1118
+ declare const createFormItemComponent: ({ InputComp, valueType, name }: {
1119
+ InputComp: any;
1120
+ valueType: string;
1121
+ name?: string | undefined;
1122
+ }) => vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1123
+ name: {
1124
+ type: vue.PropType<string | (string | number)[]>;
1125
+ };
1126
+ }>> & {
1127
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1128
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1129
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1130
+ } & {
1131
+ readonly error?: string | undefined;
1132
+ readonly label?: string | undefined;
1133
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
1134
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1135
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1136
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
1137
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1138
+ readonly for?: string | undefined;
1139
+ } & Partial<vue.ExtractPropTypes<{
1140
+ readonly: {
1141
+ type: BooleanConstructor;
1142
+ default: undefined;
1143
+ };
1144
+ fieldProps: {
1145
+ type: ObjectConstructor;
1146
+ };
1147
+ showProps: {
1148
+ type: ObjectConstructor;
1149
+ };
1150
+ slots: {
1151
+ type: ObjectConstructor;
1152
+ };
1153
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
1154
+ name: {
1155
+ type: vue.PropType<string | (string | number)[]>;
1156
+ };
1157
+ }>> & {
1158
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1159
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1160
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1161
+ } & {
1162
+ readonly error?: string | undefined;
1163
+ readonly label?: string | undefined;
1164
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
1165
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1166
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1167
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
1168
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1169
+ readonly for?: string | undefined;
1170
+ } & Partial<vue.ExtractPropTypes<{
1171
+ readonly: {
1172
+ type: BooleanConstructor;
1173
+ default: undefined;
1174
+ };
1175
+ fieldProps: {
1176
+ type: ObjectConstructor;
1177
+ };
1178
+ showProps: {
1179
+ type: ObjectConstructor;
1180
+ };
1181
+ slots: {
1182
+ type: ObjectConstructor;
1183
+ };
1184
+ }>> & Record<string, any>>>, {
1185
+ [x: string]: any;
1186
+ }>;
1187
+
1188
+ declare type TConvert = (...params: any[]) => any;
1189
+
1190
+ interface TableColumnCtx<T> {
1191
+ id?: string;
1192
+ realWidth?: number;
1193
+ type?: string;
1194
+ /********* title兼容 ********/
1195
+ label?: string;
1196
+ renderHeader?: (data: {
1197
+ column: TableColumnCtx<T>;
1198
+ $index: number;
1199
+ }) => VNode;
1200
+ title?: string | VNode;
1201
+ /********* dataIndex兼容 ********/
1202
+ prop?: string;
1203
+ dataIndex?: string | number;
1204
+ className?: string;
1205
+ labelClassName?: string;
1206
+ property?: string;
1207
+ width?: string | number;
1208
+ minWidth?: string | number;
1209
+ sortable?: boolean | string;
1210
+ sortMethod?: (a: T, b: T) => number;
1211
+ sortBy?: string | ((row: T, index: number) => string) | string[];
1212
+ resizable?: boolean;
1213
+ columnKey?: string;
1214
+ rawColumnKey?: string;
1215
+ align?: string;
1216
+ headerAlign?: string;
1217
+ showTooltipWhenOverflow?: boolean;
1218
+ showOverflowTooltip?: boolean;
1219
+ fixed?: boolean | string;
1220
+ formatter?: (row: T, column: TableColumnCtx<T>, cellValue: any, index: number) => VNode | string;
1221
+ customRender?: (opt: {
1222
+ value: any;
1223
+ text: any;
1224
+ record: T;
1225
+ index: number;
1226
+ column: TableColumnCtx<T>;
1227
+ }) => VNode | string | null;
1228
+ selectable?: (row: T, index: number) => boolean;
1229
+ reserveSelection?: boolean;
1230
+ filterMethod?: FilterMethods<T>;
1231
+ filteredValue?: string[];
1232
+ filters?: Filters;
1233
+ filterPlacement?: string;
1234
+ filterMultiple?: boolean;
1235
+ index?: number | ((index: number) => number);
1236
+ sortOrders?: ("ascending" | "descending" | null)[];
1237
+ renderCell?: (data: any) => void;
1238
+ colSpan?: number;
1239
+ rowSpan?: number;
1240
+ children?: TableColumnCtx<T>[];
1241
+ level?: number;
1242
+ filterable?: boolean | FilterMethods<T> | Filters;
1243
+ order?: string;
1244
+ isColumnGroup?: boolean;
1245
+ isSubColumn?: boolean;
1246
+ columns?: TableColumnCtx<T>[];
1247
+ getColumnIndex?: () => number;
1248
+ no?: number;
1249
+ filterOpened?: boolean;
1250
+ }
1251
+
1252
+ declare type ProTableColumnProps = TableColumnCtx<any>;
1253
+ declare const ProTableColumn: vue.DefineComponent<ProTableColumnProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProTableColumnProps>, {}>;
1254
+ declare const TableMethods: string[];
1255
+ declare const ProTable: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
1256
+ [x: string]: any;
1257
+ }>;
1258
+ declare const ProTableOperateItem: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
1259
+ [x: string]: any;
1260
+ }>;
1261
+
1262
+ declare const elementMap: {
1263
+ [x: string]: vue.DefineComponent<_vue_start_pro.ProFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<_vue_start_pro.ProFormProps>, {}> | vue.DefineComponent<_vue_start_pro.ProSearchFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<_vue_start_pro.ProSearchFormProps>, {}> | vue.DefineComponent<_vue_start_pro.ProTableProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<_vue_start_pro.ProTableProps>, {}> | vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1264
+ clsName: {
1265
+ type: StringConstructor;
1266
+ default: string;
1267
+ };
1268
+ searchProps: {
1269
+ type: vue.PropType<Record<string, any>>;
1270
+ };
1271
+ searchInTable: {
1272
+ type: BooleanConstructor;
1273
+ default: boolean;
1274
+ };
1275
+ tableProps: {
1276
+ type: vue.PropType<Record<string, any>>;
1277
+ };
1278
+ paginationProps: {
1279
+ type: (vue.PropType<Record<string, any>> | vue.PropType<boolean>)[];
1280
+ default: undefined;
1281
+ };
1282
+ pageState: {
1283
+ type: vue.PropType<_vue_start_pro.TPageState>;
1284
+ };
1285
+ start: {
1286
+ type: FunctionConstructor;
1287
+ };
1288
+ divide: {
1289
+ type: FunctionConstructor;
1290
+ };
1291
+ divide2: {
1292
+ type: FunctionConstructor;
1293
+ };
1294
+ end: {
1295
+ type: FunctionConstructor;
1296
+ };
1297
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<vue.ExtractPropTypes<{
1298
+ clsName: {
1299
+ type: StringConstructor;
1300
+ default: string;
1301
+ };
1302
+ searchProps: {
1303
+ type: vue.PropType<Record<string, any>>;
1304
+ };
1305
+ searchInTable: {
1306
+ type: BooleanConstructor;
1307
+ default: boolean;
1308
+ };
1309
+ tableProps: {
1310
+ type: vue.PropType<Record<string, any>>;
1311
+ };
1312
+ paginationProps: {
1313
+ type: (vue.PropType<Record<string, any>> | vue.PropType<boolean>)[];
1314
+ default: undefined;
1315
+ };
1316
+ pageState: {
1317
+ type: vue.PropType<_vue_start_pro.TPageState>;
1318
+ };
1319
+ start: {
1320
+ type: FunctionConstructor;
1321
+ };
1322
+ divide: {
1323
+ type: FunctionConstructor;
1324
+ };
1325
+ divide2: {
1326
+ type: FunctionConstructor;
1327
+ };
1328
+ end: {
1329
+ type: FunctionConstructor;
1330
+ };
1331
+ }>>>, {}> | vue.DefineComponent<{
1332
+ value: {
1333
+ type: (NumberConstructor | StringConstructor)[];
1334
+ };
1335
+ showProps: {
1336
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1337
+ content: {
1338
+ type: (NumberConstructor | StringConstructor)[];
1339
+ };
1340
+ ellipsis: {
1341
+ type: (BooleanConstructor | vue.PropType<{
1342
+ rows?: number | undefined;
1343
+ num?: number | undefined;
1344
+ }>)[];
1345
+ };
1346
+ popoverProps: ObjectConstructor;
1347
+ }>>>;
1348
+ };
1349
+ convert: {
1350
+ type: vue.PropType<TConvert>;
1351
+ };
1352
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1353
+ value: {
1354
+ type: (NumberConstructor | StringConstructor)[];
1355
+ };
1356
+ showProps: {
1357
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1358
+ content: {
1359
+ type: (NumberConstructor | StringConstructor)[];
1360
+ };
1361
+ ellipsis: {
1362
+ type: (BooleanConstructor | vue.PropType<{
1363
+ rows?: number | undefined;
1364
+ num?: number | undefined;
1365
+ }>)[];
1366
+ };
1367
+ popoverProps: ObjectConstructor;
1368
+ }>>>;
1369
+ };
1370
+ convert: {
1371
+ type: vue.PropType<TConvert>;
1372
+ };
1373
+ }>>, {}> | vue.DefineComponent<{
1374
+ decimalFixed: {
1375
+ type: NumberConstructor;
1376
+ default: number;
1377
+ };
1378
+ thousandDivision: {
1379
+ type: BooleanConstructor;
1380
+ default: boolean;
1381
+ };
1382
+ value: {
1383
+ type: (NumberConstructor | StringConstructor)[];
1384
+ };
1385
+ showProps: {
1386
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1387
+ content: {
1388
+ type: (NumberConstructor | StringConstructor)[];
1389
+ };
1390
+ ellipsis: {
1391
+ type: (BooleanConstructor | vue.PropType<{
1392
+ rows?: number | undefined;
1393
+ num?: number | undefined;
1394
+ }>)[];
1395
+ };
1396
+ popoverProps: ObjectConstructor;
1397
+ }>>>;
1398
+ };
1399
+ convert: {
1400
+ type: vue.PropType<TConvert>;
1401
+ };
1402
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1403
+ decimalFixed: {
1404
+ type: NumberConstructor;
1405
+ default: number;
1406
+ };
1407
+ thousandDivision: {
1408
+ type: BooleanConstructor;
1409
+ default: boolean;
1410
+ };
1411
+ value: {
1412
+ type: (NumberConstructor | StringConstructor)[];
1413
+ };
1414
+ showProps: {
1415
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1416
+ content: {
1417
+ type: (NumberConstructor | StringConstructor)[];
1418
+ };
1419
+ ellipsis: {
1420
+ type: (BooleanConstructor | vue.PropType<{
1421
+ rows?: number | undefined;
1422
+ num?: number | undefined;
1423
+ }>)[];
1424
+ };
1425
+ popoverProps: ObjectConstructor;
1426
+ }>>>;
1427
+ };
1428
+ convert: {
1429
+ type: vue.PropType<TConvert>;
1430
+ };
1431
+ }>>, {
1432
+ decimalFixed: number;
1433
+ thousandDivision: boolean;
1434
+ }> | vue.DefineComponent<{
1435
+ value: {
1436
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
1437
+ };
1438
+ options: vue.PropType<_vue_start_pro.TOptions>;
1439
+ splitStr: {
1440
+ type: StringConstructor;
1441
+ default: string;
1442
+ };
1443
+ colorMap: {
1444
+ type: ObjectConstructor;
1445
+ };
1446
+ showProps: {
1447
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1448
+ content: {
1449
+ type: (NumberConstructor | StringConstructor)[];
1450
+ };
1451
+ ellipsis: {
1452
+ type: (BooleanConstructor | vue.PropType<{
1453
+ rows?: number | undefined;
1454
+ num?: number | undefined;
1455
+ }>)[];
1456
+ };
1457
+ popoverProps: ObjectConstructor;
1458
+ }>>>;
1459
+ };
1460
+ convert: {
1461
+ type: vue.PropType<TConvert>;
1462
+ };
1463
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1464
+ value: {
1465
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
1466
+ };
1467
+ options: vue.PropType<_vue_start_pro.TOptions>;
1468
+ splitStr: {
1469
+ type: StringConstructor;
1470
+ default: string;
1471
+ };
1472
+ colorMap: {
1473
+ type: ObjectConstructor;
1474
+ };
1475
+ showProps: {
1476
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1477
+ content: {
1478
+ type: (NumberConstructor | StringConstructor)[];
1479
+ };
1480
+ ellipsis: {
1481
+ type: (BooleanConstructor | vue.PropType<{
1482
+ rows?: number | undefined;
1483
+ num?: number | undefined;
1484
+ }>)[];
1485
+ };
1486
+ popoverProps: ObjectConstructor;
1487
+ }>>>;
1488
+ };
1489
+ convert: {
1490
+ type: vue.PropType<TConvert>;
1491
+ };
1492
+ }>>, {
1493
+ splitStr: string;
1494
+ }> | vue.DefineComponent<{
1495
+ value: {
1496
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
1497
+ };
1498
+ splitStr: {
1499
+ type: StringConstructor;
1500
+ default: string;
1501
+ };
1502
+ treeData: vue.PropType<Record<string, any>>;
1503
+ data: vue.PropType<Record<string, any>>;
1504
+ options: vue.PropType<Record<string, any>>;
1505
+ fieldNames: ObjectConstructor;
1506
+ props: ObjectConstructor;
1507
+ showProps: {
1508
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1509
+ content: {
1510
+ type: (NumberConstructor | StringConstructor)[];
1511
+ };
1512
+ ellipsis: {
1513
+ type: (BooleanConstructor | vue.PropType<{
1514
+ rows?: number | undefined;
1515
+ num?: number | undefined;
1516
+ }>)[];
1517
+ };
1518
+ popoverProps: ObjectConstructor;
1519
+ }>>>;
1520
+ };
1521
+ convert: {
1522
+ type: vue.PropType<TConvert>;
1523
+ };
1524
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1525
+ value: {
1526
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
1527
+ };
1528
+ splitStr: {
1529
+ type: StringConstructor;
1530
+ default: string;
1531
+ };
1532
+ treeData: vue.PropType<Record<string, any>>;
1533
+ data: vue.PropType<Record<string, any>>;
1534
+ options: vue.PropType<Record<string, any>>;
1535
+ fieldNames: ObjectConstructor;
1536
+ props: ObjectConstructor;
1537
+ showProps: {
1538
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1539
+ content: {
1540
+ type: (NumberConstructor | StringConstructor)[];
1541
+ };
1542
+ ellipsis: {
1543
+ type: (BooleanConstructor | vue.PropType<{
1544
+ rows?: number | undefined;
1545
+ num?: number | undefined;
1546
+ }>)[];
1547
+ };
1548
+ popoverProps: ObjectConstructor;
1549
+ }>>>;
1550
+ };
1551
+ convert: {
1552
+ type: vue.PropType<TConvert>;
1553
+ };
1554
+ }>>, {
1555
+ splitStr: string;
1556
+ }> | vue.DefineComponent<{
1557
+ value: {
1558
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
1559
+ };
1560
+ splitStr: {
1561
+ type: StringConstructor;
1562
+ default: string;
1563
+ };
1564
+ format: {
1565
+ type: StringConstructor;
1566
+ default: string;
1567
+ };
1568
+ isUnix: {
1569
+ type: BooleanConstructor;
1570
+ default: boolean;
1571
+ };
1572
+ showProps: {
1573
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1574
+ content: {
1575
+ type: (NumberConstructor | StringConstructor)[];
1576
+ };
1577
+ ellipsis: {
1578
+ type: (BooleanConstructor | vue.PropType<{
1579
+ rows?: number | undefined;
1580
+ num?: number | undefined;
1581
+ }>)[];
1582
+ };
1583
+ popoverProps: ObjectConstructor;
1584
+ }>>>;
1585
+ };
1586
+ convert: {
1587
+ type: vue.PropType<TConvert>;
1588
+ };
1589
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1590
+ value: {
1591
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
1592
+ };
1593
+ splitStr: {
1594
+ type: StringConstructor;
1595
+ default: string;
1596
+ };
1597
+ format: {
1598
+ type: StringConstructor;
1599
+ default: string;
1600
+ };
1601
+ isUnix: {
1602
+ type: BooleanConstructor;
1603
+ default: boolean;
1604
+ };
1605
+ showProps: {
1606
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1607
+ content: {
1608
+ type: (NumberConstructor | StringConstructor)[];
1609
+ };
1610
+ ellipsis: {
1611
+ type: (BooleanConstructor | vue.PropType<{
1612
+ rows?: number | undefined;
1613
+ num?: number | undefined;
1614
+ }>)[];
1615
+ };
1616
+ popoverProps: ObjectConstructor;
1617
+ }>>>;
1618
+ };
1619
+ convert: {
1620
+ type: vue.PropType<TConvert>;
1621
+ };
1622
+ }>>, {
1623
+ splitStr: string;
1624
+ format: string;
1625
+ isUnix: boolean;
1626
+ }> | vue.DefineComponent<_vue_start_pro.ProCurdProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<_vue_start_pro.ProCurdProps>, {}> | vue.DefineComponent<ProFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormItemProps>, {}> | vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
1627
+ [x: string]: any;
1628
+ }> | vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1629
+ loading: {
1630
+ type: BooleanConstructor;
1631
+ };
1632
+ target: {
1633
+ type: vue.PropType<string | HTMLElement>;
1634
+ };
1635
+ body: {
1636
+ type: BooleanConstructor;
1637
+ };
1638
+ fullscreen: {
1639
+ type: BooleanConstructor;
1640
+ };
1641
+ lock: {
1642
+ type: BooleanConstructor;
1643
+ };
1644
+ text: {
1645
+ type: StringConstructor;
1646
+ };
1647
+ spinner: {
1648
+ type: StringConstructor;
1649
+ };
1650
+ background: {
1651
+ type: StringConstructor;
1652
+ };
1653
+ customClass: {
1654
+ type: StringConstructor;
1655
+ };
1656
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<vue.ExtractPropTypes<{
1657
+ loading: {
1658
+ type: BooleanConstructor;
1659
+ };
1660
+ target: {
1661
+ type: vue.PropType<string | HTMLElement>;
1662
+ };
1663
+ body: {
1664
+ type: BooleanConstructor;
1665
+ };
1666
+ fullscreen: {
1667
+ type: BooleanConstructor;
1668
+ };
1669
+ lock: {
1670
+ type: BooleanConstructor;
1671
+ };
1672
+ text: {
1673
+ type: StringConstructor;
1674
+ };
1675
+ spinner: {
1676
+ type: StringConstructor;
1677
+ };
1678
+ background: {
1679
+ type: StringConstructor;
1680
+ };
1681
+ customClass: {
1682
+ type: StringConstructor;
1683
+ };
1684
+ }>>>, {}> | vue.DefineComponent<ProModalProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProModalProps>, {}> | (element_plus_es_utils.SFCWithInstall<vue.DefineComponent<{
1685
+ readonly size: {
1686
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1687
+ readonly required: false;
1688
+ readonly validator: ((val: unknown) => boolean) | undefined;
1689
+ __epPropKey: true;
1690
+ };
1691
+ readonly disabled: BooleanConstructor;
1692
+ readonly type: element_plus_es_utils.EpPropFinalized<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown, "", boolean>;
1693
+ readonly icon: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown, "", boolean>;
1694
+ readonly nativeType: element_plus_es_utils.EpPropFinalized<StringConstructor, "reset" | "submit" | "button", unknown, "button", boolean>;
1695
+ readonly loading: BooleanConstructor;
1696
+ readonly loadingIcon: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown, () => vue.DefineComponent<{}, {}, {}, vue.ComputedOptions, vue.MethodOptions, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{}>>, {}>, boolean>;
1697
+ readonly plain: BooleanConstructor;
1698
+ readonly text: BooleanConstructor;
1699
+ readonly link: BooleanConstructor;
1700
+ readonly bg: BooleanConstructor;
1701
+ readonly autofocus: BooleanConstructor;
1702
+ readonly round: BooleanConstructor;
1703
+ readonly circle: BooleanConstructor;
1704
+ readonly color: StringConstructor;
1705
+ readonly dark: BooleanConstructor;
1706
+ readonly autoInsertSpace: element_plus_es_utils.EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
1707
+ }, {
1708
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
1709
+ readonly size: {
1710
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1711
+ readonly required: false;
1712
+ readonly validator: ((val: unknown) => boolean) | undefined;
1713
+ __epPropKey: true;
1714
+ };
1715
+ readonly disabled: BooleanConstructor;
1716
+ readonly type: element_plus_es_utils.EpPropFinalized<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown, "", boolean>;
1717
+ readonly icon: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown, "", boolean>;
1718
+ readonly nativeType: element_plus_es_utils.EpPropFinalized<StringConstructor, "reset" | "submit" | "button", unknown, "button", boolean>;
1719
+ readonly loading: BooleanConstructor;
1720
+ readonly loadingIcon: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown, () => vue.DefineComponent<{}, {}, {}, vue.ComputedOptions, vue.MethodOptions, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{}>>, {}>, boolean>;
1721
+ readonly plain: BooleanConstructor;
1722
+ readonly text: BooleanConstructor;
1723
+ readonly link: BooleanConstructor;
1724
+ readonly bg: BooleanConstructor;
1725
+ readonly autofocus: BooleanConstructor;
1726
+ readonly round: BooleanConstructor;
1727
+ readonly circle: BooleanConstructor;
1728
+ readonly color: StringConstructor;
1729
+ readonly dark: BooleanConstructor;
1730
+ readonly autoInsertSpace: element_plus_es_utils.EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
1731
+ }>> & {
1732
+ onClick?: ((evt: MouseEvent) => any) | undefined;
1733
+ }>>;
1734
+ emit: (event: "click", evt: MouseEvent) => void;
1735
+ slots: Readonly<{
1736
+ [name: string]: vue.Slot | undefined;
1737
+ }>;
1738
+ buttonGroupContext: element_plus.ButtonGroupContext | undefined;
1739
+ globalConfig: vue.Ref<element_plus.ButtonConfigContext | undefined>;
1740
+ ns: {
1741
+ namespace: vue.ComputedRef<string>;
1742
+ b: (blockSuffix?: string | undefined) => string;
1743
+ e: (element?: string | undefined) => string;
1744
+ m: (modifier?: string | undefined) => string;
1745
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
1746
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
1747
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
1748
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
1749
+ is: {
1750
+ (name: string, state: boolean | undefined): string;
1751
+ (name: string): string;
1752
+ };
1753
+ cssVar: (object: Record<string, string>) => Record<string, string>;
1754
+ cssVarName: (name: string) => string;
1755
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
1756
+ cssVarBlockName: (name: string) => string;
1757
+ };
1758
+ form: element_plus.FormContext | undefined;
1759
+ _size: vue.ComputedRef<"" | "small" | "default" | "large">;
1760
+ _disabled: vue.ComputedRef<boolean>;
1761
+ _ref: vue.Ref<HTMLButtonElement | undefined>;
1762
+ _type: vue.ComputedRef<"" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info">;
1763
+ autoInsertSpace: vue.ComputedRef<element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>>;
1764
+ shouldAddSpace: vue.ComputedRef<boolean>;
1765
+ buttonStyle: vue.ComputedRef<Record<string, string>>;
1766
+ handleClick: (evt: MouseEvent) => void;
1767
+ ElIcon: element_plus_es_utils.SFCWithInstall<vue.DefineComponent<{
1768
+ readonly size: {
1769
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
1770
+ readonly required: false;
1771
+ readonly validator: ((val: unknown) => boolean) | undefined;
1772
+ __epPropKey: true;
1773
+ };
1774
+ readonly color: {
1775
+ readonly type: vue.PropType<string>;
1776
+ readonly required: false;
1777
+ readonly validator: ((val: unknown) => boolean) | undefined;
1778
+ __epPropKey: true;
1779
+ };
1780
+ }, {
1781
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
1782
+ readonly size: {
1783
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
1784
+ readonly required: false;
1785
+ readonly validator: ((val: unknown) => boolean) | undefined;
1786
+ __epPropKey: true;
1787
+ };
1788
+ readonly color: {
1789
+ readonly type: vue.PropType<string>;
1790
+ readonly required: false;
1791
+ readonly validator: ((val: unknown) => boolean) | undefined;
1792
+ __epPropKey: true;
1793
+ };
1794
+ }>> & {
1795
+ [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
1796
+ }>>;
1797
+ ns: {
1798
+ namespace: vue.ComputedRef<string>;
1799
+ b: (blockSuffix?: string | undefined) => string;
1800
+ e: (element?: string | undefined) => string;
1801
+ m: (modifier?: string | undefined) => string;
1802
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
1803
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
1804
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
1805
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
1806
+ is: {
1807
+ (name: string, state: boolean | undefined): string;
1808
+ (name: string): string;
1809
+ };
1810
+ cssVar: (object: Record<string, string>) => Record<string, string>;
1811
+ cssVarName: (name: string) => string;
1812
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
1813
+ cssVarBlockName: (name: string) => string;
1814
+ };
1815
+ style: vue.ComputedRef<vue.CSSProperties>;
1816
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1817
+ readonly size: {
1818
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
1819
+ readonly required: false;
1820
+ readonly validator: ((val: unknown) => boolean) | undefined;
1821
+ __epPropKey: true;
1822
+ };
1823
+ readonly color: {
1824
+ readonly type: vue.PropType<string>;
1825
+ readonly required: false;
1826
+ readonly validator: ((val: unknown) => boolean) | undefined;
1827
+ __epPropKey: true;
1828
+ };
1829
+ }>>, {}>> & Record<string, any>;
1830
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
1831
+ click: (evt: MouseEvent) => boolean;
1832
+ }, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1833
+ readonly size: {
1834
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1835
+ readonly required: false;
1836
+ readonly validator: ((val: unknown) => boolean) | undefined;
1837
+ __epPropKey: true;
1838
+ };
1839
+ readonly disabled: BooleanConstructor;
1840
+ readonly type: element_plus_es_utils.EpPropFinalized<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown, "", boolean>;
1841
+ readonly icon: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown, "", boolean>;
1842
+ readonly nativeType: element_plus_es_utils.EpPropFinalized<StringConstructor, "reset" | "submit" | "button", unknown, "button", boolean>;
1843
+ readonly loading: BooleanConstructor;
1844
+ readonly loadingIcon: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown, () => vue.DefineComponent<{}, {}, {}, vue.ComputedOptions, vue.MethodOptions, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{}>>, {}>, boolean>;
1845
+ readonly plain: BooleanConstructor;
1846
+ readonly text: BooleanConstructor;
1847
+ readonly link: BooleanConstructor;
1848
+ readonly bg: BooleanConstructor;
1849
+ readonly autofocus: BooleanConstructor;
1850
+ readonly round: BooleanConstructor;
1851
+ readonly circle: BooleanConstructor;
1852
+ readonly color: StringConstructor;
1853
+ readonly dark: BooleanConstructor;
1854
+ readonly autoInsertSpace: element_plus_es_utils.EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
1855
+ }>> & {
1856
+ onClick?: ((evt: MouseEvent) => any) | undefined;
1857
+ }, {
1858
+ readonly type: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown>;
1859
+ readonly text: boolean;
1860
+ readonly icon: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown>;
1861
+ readonly nativeType: element_plus_es_utils.EpPropMergeType<StringConstructor, "reset" | "submit" | "button", unknown>;
1862
+ readonly loadingIcon: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown>;
1863
+ readonly autoInsertSpace: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1864
+ readonly disabled: boolean;
1865
+ readonly loading: boolean;
1866
+ readonly plain: boolean;
1867
+ readonly link: boolean;
1868
+ readonly bg: boolean;
1869
+ readonly autofocus: boolean;
1870
+ readonly round: boolean;
1871
+ readonly circle: boolean;
1872
+ readonly dark: boolean;
1873
+ }>> & {
1874
+ ButtonGroup: vue.DefineComponent<{
1875
+ readonly size: {
1876
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1877
+ readonly required: false;
1878
+ readonly validator: ((val: unknown) => boolean) | undefined;
1879
+ __epPropKey: true;
1880
+ };
1881
+ readonly type: element_plus_es_utils.EpPropFinalized<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown, "", boolean>;
1882
+ }, {
1883
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
1884
+ readonly size: {
1885
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1886
+ readonly required: false;
1887
+ readonly validator: ((val: unknown) => boolean) | undefined;
1888
+ __epPropKey: true;
1889
+ };
1890
+ readonly type: element_plus_es_utils.EpPropFinalized<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown, "", boolean>;
1891
+ }>> & {
1892
+ [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
1893
+ }>>;
1894
+ ns: {
1895
+ namespace: vue.ComputedRef<string>;
1896
+ b: (blockSuffix?: string | undefined) => string;
1897
+ e: (element?: string | undefined) => string;
1898
+ m: (modifier?: string | undefined) => string;
1899
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
1900
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
1901
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
1902
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
1903
+ is: {
1904
+ (name: string, state: boolean | undefined): string;
1905
+ (name: string): string;
1906
+ };
1907
+ cssVar: (object: Record<string, string>) => Record<string, string>;
1908
+ cssVarName: (name: string) => string;
1909
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
1910
+ cssVarBlockName: (name: string) => string;
1911
+ };
1912
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1913
+ readonly size: {
1914
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1915
+ readonly required: false;
1916
+ readonly validator: ((val: unknown) => boolean) | undefined;
1917
+ __epPropKey: true;
1918
+ };
1919
+ readonly type: element_plus_es_utils.EpPropFinalized<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown, "", boolean>;
1920
+ }>>, {
1921
+ readonly type: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown>;
1922
+ }>;
1923
+ }) | (element_plus_es_utils.SFCWithInstall<vue.DefineComponent<{
1924
+ modelValue: {
1925
+ type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
1926
+ default: () => undefined;
1927
+ };
1928
+ label: {
1929
+ type: (NumberConstructor | StringConstructor | BooleanConstructor | ObjectConstructor)[];
1930
+ };
1931
+ indeterminate: BooleanConstructor;
1932
+ disabled: BooleanConstructor;
1933
+ checked: BooleanConstructor;
1934
+ name: {
1935
+ type: StringConstructor;
1936
+ default: undefined;
1937
+ };
1938
+ trueLabel: {
1939
+ type: (NumberConstructor | StringConstructor)[];
1940
+ default: undefined;
1941
+ };
1942
+ falseLabel: {
1943
+ type: (NumberConstructor | StringConstructor)[];
1944
+ default: undefined;
1945
+ };
1946
+ id: {
1947
+ type: StringConstructor;
1948
+ default: undefined;
1949
+ };
1950
+ controls: {
1951
+ type: StringConstructor;
1952
+ default: undefined;
1953
+ };
1954
+ border: BooleanConstructor;
1955
+ size: {
1956
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1957
+ readonly required: false;
1958
+ readonly validator: ((val: unknown) => boolean) | undefined;
1959
+ __epPropKey: true;
1960
+ };
1961
+ tabindex: (NumberConstructor | StringConstructor)[];
1962
+ validateEvent: {
1963
+ type: BooleanConstructor;
1964
+ default: boolean;
1965
+ };
1966
+ }, {
1967
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
1968
+ modelValue: {
1969
+ type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
1970
+ default: () => undefined;
1971
+ };
1972
+ label: {
1973
+ type: (NumberConstructor | StringConstructor | BooleanConstructor | ObjectConstructor)[];
1974
+ };
1975
+ indeterminate: BooleanConstructor;
1976
+ disabled: BooleanConstructor;
1977
+ checked: BooleanConstructor;
1978
+ name: {
1979
+ type: StringConstructor;
1980
+ default: undefined;
1981
+ };
1982
+ trueLabel: {
1983
+ type: (NumberConstructor | StringConstructor)[];
1984
+ default: undefined;
1985
+ };
1986
+ falseLabel: {
1987
+ type: (NumberConstructor | StringConstructor)[];
1988
+ default: undefined;
1989
+ };
1990
+ id: {
1991
+ type: StringConstructor;
1992
+ default: undefined;
1993
+ };
1994
+ controls: {
1995
+ type: StringConstructor;
1996
+ default: undefined;
1997
+ };
1998
+ border: BooleanConstructor;
1999
+ size: {
2000
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2001
+ readonly required: false;
2002
+ readonly validator: ((val: unknown) => boolean) | undefined;
2003
+ __epPropKey: true;
2004
+ };
2005
+ tabindex: (NumberConstructor | StringConstructor)[];
2006
+ validateEvent: {
2007
+ type: BooleanConstructor;
2008
+ default: boolean;
2009
+ };
2010
+ }>> & {
2011
+ onChange?: ((val: element_plus.CheckboxValueType) => any) | undefined;
2012
+ "onUpdate:modelValue"?: ((val: element_plus.CheckboxValueType) => any) | undefined;
2013
+ }>>;
2014
+ slots: Readonly<{
2015
+ [name: string]: vue.Slot | undefined;
2016
+ }>;
2017
+ inputId: vue.Ref<string | undefined>;
2018
+ isLabeledByFormItem: vue.ComputedRef<boolean>;
2019
+ isChecked: vue.ComputedRef<boolean>;
2020
+ isDisabled: vue.ComputedRef<boolean>;
2021
+ checkboxSize: vue.ComputedRef<"" | "small" | "default" | "large">;
2022
+ hasOwnLabel: vue.ComputedRef<boolean>;
2023
+ model: vue.WritableComputedRef<any>;
2024
+ handleChange: (e: Event) => void;
2025
+ onClickRoot: (e: MouseEvent) => Promise<void>;
2026
+ focus: vue.Ref<boolean>;
2027
+ ns: {
2028
+ namespace: vue.ComputedRef<string>;
2029
+ b: (blockSuffix?: string | undefined) => string;
2030
+ e: (element?: string | undefined) => string;
2031
+ m: (modifier?: string | undefined) => string;
2032
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
2033
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
2034
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
2035
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
2036
+ is: {
2037
+ (name: string, state: boolean | undefined): string;
2038
+ (name: string): string;
2039
+ };
2040
+ cssVar: (object: Record<string, string>) => Record<string, string>;
2041
+ cssVarName: (name: string) => string;
2042
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
2043
+ cssVarBlockName: (name: string) => string;
2044
+ };
2045
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2046
+ "update:modelValue": (val: element_plus.CheckboxValueType) => boolean;
2047
+ change: (val: element_plus.CheckboxValueType) => boolean;
2048
+ }, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2049
+ modelValue: {
2050
+ type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
2051
+ default: () => undefined;
2052
+ };
2053
+ label: {
2054
+ type: (NumberConstructor | StringConstructor | BooleanConstructor | ObjectConstructor)[];
2055
+ };
2056
+ indeterminate: BooleanConstructor;
2057
+ disabled: BooleanConstructor;
2058
+ checked: BooleanConstructor;
2059
+ name: {
2060
+ type: StringConstructor;
2061
+ default: undefined;
2062
+ };
2063
+ trueLabel: {
2064
+ type: (NumberConstructor | StringConstructor)[];
2065
+ default: undefined;
2066
+ };
2067
+ falseLabel: {
2068
+ type: (NumberConstructor | StringConstructor)[];
2069
+ default: undefined;
2070
+ };
2071
+ id: {
2072
+ type: StringConstructor;
2073
+ default: undefined;
2074
+ };
2075
+ controls: {
2076
+ type: StringConstructor;
2077
+ default: undefined;
2078
+ };
2079
+ border: BooleanConstructor;
2080
+ size: {
2081
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2082
+ readonly required: false;
2083
+ readonly validator: ((val: unknown) => boolean) | undefined;
2084
+ __epPropKey: true;
2085
+ };
2086
+ tabindex: (NumberConstructor | StringConstructor)[];
2087
+ validateEvent: {
2088
+ type: BooleanConstructor;
2089
+ default: boolean;
2090
+ };
2091
+ }>> & {
2092
+ onChange?: ((val: element_plus.CheckboxValueType) => any) | undefined;
2093
+ "onUpdate:modelValue"?: ((val: element_plus.CheckboxValueType) => any) | undefined;
2094
+ }, {
2095
+ disabled: boolean;
2096
+ name: string;
2097
+ id: string;
2098
+ modelValue: string | number | boolean;
2099
+ validateEvent: boolean;
2100
+ border: boolean;
2101
+ indeterminate: boolean;
2102
+ checked: boolean;
2103
+ trueLabel: string | number;
2104
+ falseLabel: string | number;
2105
+ controls: string;
2106
+ }>> & {
2107
+ CheckboxButton: vue.DefineComponent<{
2108
+ modelValue: {
2109
+ type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
2110
+ default: () => undefined;
2111
+ };
2112
+ label: {
2113
+ type: (NumberConstructor | StringConstructor | BooleanConstructor | ObjectConstructor)[];
2114
+ };
2115
+ indeterminate: BooleanConstructor;
2116
+ disabled: BooleanConstructor;
2117
+ checked: BooleanConstructor;
2118
+ name: {
2119
+ type: StringConstructor;
2120
+ default: undefined;
2121
+ };
2122
+ trueLabel: {
2123
+ type: (NumberConstructor | StringConstructor)[];
2124
+ default: undefined;
2125
+ };
2126
+ falseLabel: {
2127
+ type: (NumberConstructor | StringConstructor)[];
2128
+ default: undefined;
2129
+ };
2130
+ id: {
2131
+ type: StringConstructor;
2132
+ default: undefined;
2133
+ };
2134
+ controls: {
2135
+ type: StringConstructor;
2136
+ default: undefined;
2137
+ };
2138
+ border: BooleanConstructor;
2139
+ size: {
2140
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2141
+ readonly required: false;
2142
+ readonly validator: ((val: unknown) => boolean) | undefined;
2143
+ __epPropKey: true;
2144
+ };
2145
+ tabindex: (NumberConstructor | StringConstructor)[];
2146
+ validateEvent: {
2147
+ type: BooleanConstructor;
2148
+ default: boolean;
2149
+ };
2150
+ }, {
2151
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
2152
+ modelValue: {
2153
+ type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
2154
+ default: () => undefined;
2155
+ };
2156
+ label: {
2157
+ type: (NumberConstructor | StringConstructor | BooleanConstructor | ObjectConstructor)[];
2158
+ };
2159
+ indeterminate: BooleanConstructor;
2160
+ disabled: BooleanConstructor;
2161
+ checked: BooleanConstructor;
2162
+ name: {
2163
+ type: StringConstructor;
2164
+ default: undefined;
2165
+ };
2166
+ trueLabel: {
2167
+ type: (NumberConstructor | StringConstructor)[];
2168
+ default: undefined;
2169
+ };
2170
+ falseLabel: {
2171
+ type: (NumberConstructor | StringConstructor)[];
2172
+ default: undefined;
2173
+ };
2174
+ id: {
2175
+ type: StringConstructor;
2176
+ default: undefined;
2177
+ };
2178
+ controls: {
2179
+ type: StringConstructor;
2180
+ default: undefined;
2181
+ };
2182
+ border: BooleanConstructor;
2183
+ size: {
2184
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2185
+ readonly required: false;
2186
+ readonly validator: ((val: unknown) => boolean) | undefined;
2187
+ __epPropKey: true;
2188
+ };
2189
+ tabindex: (NumberConstructor | StringConstructor)[];
2190
+ validateEvent: {
2191
+ type: BooleanConstructor;
2192
+ default: boolean;
2193
+ };
2194
+ }>> & {
2195
+ onChange?: ((val: element_plus.CheckboxValueType) => any) | undefined;
2196
+ "onUpdate:modelValue"?: ((val: element_plus.CheckboxValueType) => any) | undefined;
2197
+ }>>;
2198
+ slots: Readonly<{
2199
+ [name: string]: vue.Slot | undefined;
2200
+ }>;
2201
+ focus: vue.Ref<boolean>;
2202
+ isChecked: vue.ComputedRef<boolean>;
2203
+ isDisabled: vue.ComputedRef<boolean>;
2204
+ size: vue.ComputedRef<"" | "small" | "default" | "large">;
2205
+ model: vue.WritableComputedRef<any>;
2206
+ handleChange: (e: Event) => void;
2207
+ checkboxGroup: element_plus.ICheckboxGroupInstance;
2208
+ ns: {
2209
+ namespace: vue.ComputedRef<string>;
2210
+ b: (blockSuffix?: string | undefined) => string;
2211
+ e: (element?: string | undefined) => string;
2212
+ m: (modifier?: string | undefined) => string;
2213
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
2214
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
2215
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
2216
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
2217
+ is: {
2218
+ (name: string, state: boolean | undefined): string;
2219
+ (name: string): string;
2220
+ };
2221
+ cssVar: (object: Record<string, string>) => Record<string, string>;
2222
+ cssVarName: (name: string) => string;
2223
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
2224
+ cssVarBlockName: (name: string) => string;
2225
+ };
2226
+ activeStyle: vue.ComputedRef<vue.CSSProperties>;
2227
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2228
+ "update:modelValue": (val: element_plus.CheckboxValueType) => boolean;
2229
+ change: (val: element_plus.CheckboxValueType) => boolean;
2230
+ }, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2231
+ modelValue: {
2232
+ type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
2233
+ default: () => undefined;
2234
+ };
2235
+ label: {
2236
+ type: (NumberConstructor | StringConstructor | BooleanConstructor | ObjectConstructor)[];
2237
+ };
2238
+ indeterminate: BooleanConstructor;
2239
+ disabled: BooleanConstructor;
2240
+ checked: BooleanConstructor;
2241
+ name: {
2242
+ type: StringConstructor;
2243
+ default: undefined;
2244
+ };
2245
+ trueLabel: {
2246
+ type: (NumberConstructor | StringConstructor)[];
2247
+ default: undefined;
2248
+ };
2249
+ falseLabel: {
2250
+ type: (NumberConstructor | StringConstructor)[];
2251
+ default: undefined;
2252
+ };
2253
+ id: {
2254
+ type: StringConstructor;
2255
+ default: undefined;
2256
+ };
2257
+ controls: {
2258
+ type: StringConstructor;
2259
+ default: undefined;
2260
+ };
2261
+ border: BooleanConstructor;
2262
+ size: {
2263
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2264
+ readonly required: false;
2265
+ readonly validator: ((val: unknown) => boolean) | undefined;
2266
+ __epPropKey: true;
2267
+ };
2268
+ tabindex: (NumberConstructor | StringConstructor)[];
2269
+ validateEvent: {
2270
+ type: BooleanConstructor;
2271
+ default: boolean;
2272
+ };
2273
+ }>> & {
2274
+ onChange?: ((val: element_plus.CheckboxValueType) => any) | undefined;
2275
+ "onUpdate:modelValue"?: ((val: element_plus.CheckboxValueType) => any) | undefined;
2276
+ }, {
2277
+ disabled: boolean;
2278
+ name: string;
2279
+ id: string;
2280
+ modelValue: string | number | boolean;
2281
+ validateEvent: boolean;
2282
+ border: boolean;
2283
+ indeterminate: boolean;
2284
+ checked: boolean;
2285
+ trueLabel: string | number;
2286
+ falseLabel: string | number;
2287
+ controls: string;
2288
+ }>;
2289
+ CheckboxGroup: vue.DefineComponent<{
2290
+ modelValue: {
2291
+ type: vue.PropType<(string | number)[]>;
2292
+ default: () => never[];
2293
+ };
2294
+ disabled: BooleanConstructor;
2295
+ min: {
2296
+ type: NumberConstructor;
2297
+ default: undefined;
2298
+ };
2299
+ max: {
2300
+ type: NumberConstructor;
2301
+ default: undefined;
2302
+ };
2303
+ size: {
2304
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2305
+ readonly required: false;
2306
+ readonly validator: ((val: unknown) => boolean) | undefined;
2307
+ __epPropKey: true;
2308
+ };
2309
+ id: {
2310
+ type: StringConstructor;
2311
+ default: undefined;
2312
+ };
2313
+ label: {
2314
+ type: StringConstructor;
2315
+ default: undefined;
2316
+ };
2317
+ fill: {
2318
+ type: StringConstructor;
2319
+ default: undefined;
2320
+ };
2321
+ textColor: {
2322
+ type: StringConstructor;
2323
+ default: undefined;
2324
+ };
2325
+ tag: {
2326
+ type: StringConstructor;
2327
+ default: string;
2328
+ };
2329
+ validateEvent: {
2330
+ type: BooleanConstructor;
2331
+ default: boolean;
2332
+ };
2333
+ }, {
2334
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
2335
+ modelValue: {
2336
+ type: vue.PropType<(string | number)[]>;
2337
+ default: () => never[];
2338
+ };
2339
+ disabled: BooleanConstructor;
2340
+ min: {
2341
+ type: NumberConstructor;
2342
+ default: undefined;
2343
+ };
2344
+ max: {
2345
+ type: NumberConstructor;
2346
+ default: undefined;
2347
+ };
2348
+ size: {
2349
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2350
+ readonly required: false;
2351
+ readonly validator: ((val: unknown) => boolean) | undefined;
2352
+ __epPropKey: true;
2353
+ };
2354
+ id: {
2355
+ type: StringConstructor;
2356
+ default: undefined;
2357
+ };
2358
+ label: {
2359
+ type: StringConstructor;
2360
+ default: undefined;
2361
+ };
2362
+ fill: {
2363
+ type: StringConstructor;
2364
+ default: undefined;
2365
+ };
2366
+ textColor: {
2367
+ type: StringConstructor;
2368
+ default: undefined;
2369
+ };
2370
+ tag: {
2371
+ type: StringConstructor;
2372
+ default: string;
2373
+ };
2374
+ validateEvent: {
2375
+ type: BooleanConstructor;
2376
+ default: boolean;
2377
+ };
2378
+ }>> & {
2379
+ onChange?: ((val: element_plus.CheckboxValueType[]) => any) | undefined;
2380
+ "onUpdate:modelValue"?: ((val: element_plus.CheckboxValueType[]) => any) | undefined;
2381
+ }>>;
2382
+ emit: ((event: "update:modelValue", val: element_plus.CheckboxValueType[]) => void) & ((event: "change", val: element_plus.CheckboxValueType[]) => void);
2383
+ elFormItem: element_plus.FormItemContext | undefined;
2384
+ groupId: vue.Ref<string | undefined>;
2385
+ isLabeledByFormItem: vue.ComputedRef<boolean>;
2386
+ checkboxGroupSize: vue.ComputedRef<"" | "small" | "default" | "large">;
2387
+ ns: {
2388
+ namespace: vue.ComputedRef<string>;
2389
+ b: (blockSuffix?: string | undefined) => string;
2390
+ e: (element?: string | undefined) => string;
2391
+ m: (modifier?: string | undefined) => string;
2392
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
2393
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
2394
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
2395
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
2396
+ is: {
2397
+ (name: string, state: boolean | undefined): string;
2398
+ (name: string): string;
2399
+ };
2400
+ cssVar: (object: Record<string, string>) => Record<string, string>;
2401
+ cssVarName: (name: string) => string;
2402
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
2403
+ cssVarBlockName: (name: string) => string;
2404
+ };
2405
+ changeEvent: (value: element_plus.CheckboxValueType[]) => void;
2406
+ modelValue: vue.WritableComputedRef<element_plus.CheckboxValueType[]>;
2407
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2408
+ "update:modelValue": (val: element_plus.CheckboxValueType[]) => boolean;
2409
+ change: (val: element_plus.CheckboxValueType[]) => boolean;
2410
+ }, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2411
+ modelValue: {
2412
+ type: vue.PropType<(string | number)[]>;
2413
+ default: () => never[];
2414
+ };
2415
+ disabled: BooleanConstructor;
2416
+ min: {
2417
+ type: NumberConstructor;
2418
+ default: undefined;
2419
+ };
2420
+ max: {
2421
+ type: NumberConstructor;
2422
+ default: undefined;
2423
+ };
2424
+ size: {
2425
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2426
+ readonly required: false;
2427
+ readonly validator: ((val: unknown) => boolean) | undefined;
2428
+ __epPropKey: true;
2429
+ };
2430
+ id: {
2431
+ type: StringConstructor;
2432
+ default: undefined;
2433
+ };
2434
+ label: {
2435
+ type: StringConstructor;
2436
+ default: undefined;
2437
+ };
2438
+ fill: {
2439
+ type: StringConstructor;
2440
+ default: undefined;
2441
+ };
2442
+ textColor: {
2443
+ type: StringConstructor;
2444
+ default: undefined;
2445
+ };
2446
+ tag: {
2447
+ type: StringConstructor;
2448
+ default: string;
2449
+ };
2450
+ validateEvent: {
2451
+ type: BooleanConstructor;
2452
+ default: boolean;
2453
+ };
2454
+ }>> & {
2455
+ onChange?: ((val: element_plus.CheckboxValueType[]) => any) | undefined;
2456
+ "onUpdate:modelValue"?: ((val: element_plus.CheckboxValueType[]) => any) | undefined;
2457
+ }, {
2458
+ disabled: boolean;
2459
+ label: string;
2460
+ id: string;
2461
+ modelValue: (string | number)[];
2462
+ fill: string;
2463
+ textColor: string;
2464
+ validateEvent: boolean;
2465
+ min: number;
2466
+ max: number;
2467
+ tag: string;
2468
+ }>;
2469
+ }) | vue.DefineComponent<ProMenusProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProMenusProps>, {}> | vue.DefineComponent<ProUploadProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProUploadProps>, {}> | (element_plus_es_utils.SFCWithInstall<vue.DefineComponent<{
2470
+ readonly border: element_plus_es_utils.EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
2471
+ readonly column: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 3, boolean>;
2472
+ readonly direction: element_plus_es_utils.EpPropFinalized<StringConstructor, "vertical" | "horizontal", unknown, "horizontal", boolean>;
2473
+ readonly size: {
2474
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2475
+ readonly required: false;
2476
+ readonly validator: ((val: unknown) => boolean) | undefined;
2477
+ __epPropKey: true;
2478
+ };
2479
+ readonly title: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
2480
+ readonly extra: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
2481
+ }, {
2482
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
2483
+ readonly border: element_plus_es_utils.EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
2484
+ readonly column: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 3, boolean>;
2485
+ readonly direction: element_plus_es_utils.EpPropFinalized<StringConstructor, "vertical" | "horizontal", unknown, "horizontal", boolean>;
2486
+ readonly size: {
2487
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2488
+ readonly required: false;
2489
+ readonly validator: ((val: unknown) => boolean) | undefined;
2490
+ __epPropKey: true;
2491
+ };
2492
+ readonly title: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
2493
+ readonly extra: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
2494
+ }>> & {
2495
+ [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
2496
+ }>>;
2497
+ ns: {
2498
+ namespace: vue.ComputedRef<string>;
2499
+ b: (blockSuffix?: string | undefined) => string;
2500
+ e: (element?: string | undefined) => string;
2501
+ m: (modifier?: string | undefined) => string;
2502
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
2503
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
2504
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
2505
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
2506
+ is: {
2507
+ (name: string, state: boolean | undefined): string;
2508
+ (name: string): string;
2509
+ };
2510
+ cssVar: (object: Record<string, string>) => Record<string, string>;
2511
+ cssVarName: (name: string) => string;
2512
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
2513
+ cssVarBlockName: (name: string) => string;
2514
+ };
2515
+ descriptionsSize: vue.ComputedRef<"" | "small" | "default" | "large">;
2516
+ slots: Readonly<{
2517
+ [name: string]: vue.Slot | undefined;
2518
+ }>;
2519
+ descriptionKls: vue.ComputedRef<string[]>;
2520
+ flattedChildren: (children: any) => never[];
2521
+ filledNode: (node: any, span: any, count: any, isLast?: boolean | undefined) => any;
2522
+ getRows: () => never[];
2523
+ ElDescriptionsRow: vue.DefineComponent<{
2524
+ readonly row: element_plus_es_utils.EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
2525
+ }, {
2526
+ descriptions: element_plus_es_components_descriptions_src_descriptions_type.IDescriptionsInject;
2527
+ ElDescriptionsCell: vue.DefineComponent<{
2528
+ cell: {
2529
+ type: ObjectConstructor;
2530
+ };
2531
+ tag: {
2532
+ type: StringConstructor;
2533
+ };
2534
+ type: {
2535
+ type: StringConstructor;
2536
+ };
2537
+ }, {
2538
+ descriptions: element_plus_es_components_descriptions_src_descriptions_type.IDescriptionsInject;
2539
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2540
+ cell: {
2541
+ type: ObjectConstructor;
2542
+ };
2543
+ tag: {
2544
+ type: StringConstructor;
2545
+ };
2546
+ type: {
2547
+ type: StringConstructor;
2548
+ };
2549
+ }>>, {}>;
2550
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2551
+ readonly row: element_plus_es_utils.EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
2552
+ }>>, {
2553
+ readonly row: unknown[];
2554
+ }>;
2555
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2556
+ readonly border: element_plus_es_utils.EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
2557
+ readonly column: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 3, boolean>;
2558
+ readonly direction: element_plus_es_utils.EpPropFinalized<StringConstructor, "vertical" | "horizontal", unknown, "horizontal", boolean>;
2559
+ readonly size: {
2560
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2561
+ readonly required: false;
2562
+ readonly validator: ((val: unknown) => boolean) | undefined;
2563
+ __epPropKey: true;
2564
+ };
2565
+ readonly title: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
2566
+ readonly extra: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
2567
+ }>>, {
2568
+ readonly title: string;
2569
+ readonly column: number;
2570
+ readonly border: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
2571
+ readonly direction: element_plus_es_utils.EpPropMergeType<StringConstructor, "vertical" | "horizontal", unknown>;
2572
+ readonly extra: string;
2573
+ }>> & {
2574
+ DescriptionsItem: vue.DefineComponent<{
2575
+ label: {
2576
+ type: StringConstructor;
2577
+ default: string;
2578
+ };
2579
+ span: {
2580
+ type: NumberConstructor;
2581
+ default: number;
2582
+ };
2583
+ width: {
2584
+ type: (NumberConstructor | StringConstructor)[];
2585
+ default: string;
2586
+ };
2587
+ minWidth: {
2588
+ type: (NumberConstructor | StringConstructor)[];
2589
+ default: string;
2590
+ };
2591
+ align: {
2592
+ type: StringConstructor;
2593
+ default: string;
2594
+ };
2595
+ labelAlign: {
2596
+ type: StringConstructor;
2597
+ default: string;
2598
+ };
2599
+ className: {
2600
+ type: StringConstructor;
2601
+ default: string;
2602
+ };
2603
+ labelClassName: {
2604
+ type: StringConstructor;
2605
+ default: string;
2606
+ };
2607
+ }, unknown, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2608
+ label: {
2609
+ type: StringConstructor;
2610
+ default: string;
2611
+ };
2612
+ span: {
2613
+ type: NumberConstructor;
2614
+ default: number;
2615
+ };
2616
+ width: {
2617
+ type: (NumberConstructor | StringConstructor)[];
2618
+ default: string;
2619
+ };
2620
+ minWidth: {
2621
+ type: (NumberConstructor | StringConstructor)[];
2622
+ default: string;
2623
+ };
2624
+ align: {
2625
+ type: StringConstructor;
2626
+ default: string;
2627
+ };
2628
+ labelAlign: {
2629
+ type: StringConstructor;
2630
+ default: string;
2631
+ };
2632
+ className: {
2633
+ type: StringConstructor;
2634
+ default: string;
2635
+ };
2636
+ labelClassName: {
2637
+ type: StringConstructor;
2638
+ default: string;
2639
+ };
2640
+ }>>, {
2641
+ label: string;
2642
+ width: string | number;
2643
+ className: string;
2644
+ minWidth: string | number;
2645
+ span: number;
2646
+ align: string;
2647
+ labelAlign: string;
2648
+ labelClassName: string;
2649
+ }>;
2650
+ }) | (element_plus_es_utils.SFCWithInstall<vue.DefineComponent<{
2651
+ readonly tag: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
2652
+ readonly gutter: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2653
+ readonly justify: element_plus_es_utils.EpPropFinalized<StringConstructor, "end" | "start" | "space-around" | "space-between" | "center" | "space-evenly", unknown, "start", boolean>;
2654
+ readonly align: element_plus_es_utils.EpPropFinalized<StringConstructor, "bottom" | "top" | "middle", unknown, "top", boolean>;
2655
+ }, {
2656
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
2657
+ readonly tag: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
2658
+ readonly gutter: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2659
+ readonly justify: element_plus_es_utils.EpPropFinalized<StringConstructor, "end" | "start" | "space-around" | "space-between" | "center" | "space-evenly", unknown, "start", boolean>;
2660
+ readonly align: element_plus_es_utils.EpPropFinalized<StringConstructor, "bottom" | "top" | "middle", unknown, "top", boolean>;
2661
+ }>> & {
2662
+ [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
2663
+ }>>;
2664
+ ns: {
2665
+ namespace: vue.ComputedRef<string>;
2666
+ b: (blockSuffix?: string | undefined) => string;
2667
+ e: (element?: string | undefined) => string;
2668
+ m: (modifier?: string | undefined) => string;
2669
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
2670
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
2671
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
2672
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
2673
+ is: {
2674
+ (name: string, state: boolean | undefined): string;
2675
+ (name: string): string;
2676
+ };
2677
+ cssVar: (object: Record<string, string>) => Record<string, string>;
2678
+ cssVarName: (name: string) => string;
2679
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
2680
+ cssVarBlockName: (name: string) => string;
2681
+ };
2682
+ gutter: vue.ComputedRef<number>;
2683
+ style: vue.ComputedRef<vue.CSSProperties>;
2684
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2685
+ readonly tag: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
2686
+ readonly gutter: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2687
+ readonly justify: element_plus_es_utils.EpPropFinalized<StringConstructor, "end" | "start" | "space-around" | "space-between" | "center" | "space-evenly", unknown, "start", boolean>;
2688
+ readonly align: element_plus_es_utils.EpPropFinalized<StringConstructor, "bottom" | "top" | "middle", unknown, "top", boolean>;
2689
+ }>>, {
2690
+ readonly justify: element_plus_es_utils.EpPropMergeType<StringConstructor, "end" | "start" | "space-around" | "space-between" | "center" | "space-evenly", unknown>;
2691
+ readonly tag: string;
2692
+ readonly gutter: number;
2693
+ readonly align: element_plus_es_utils.EpPropMergeType<StringConstructor, "bottom" | "top" | "middle", unknown>;
2694
+ }>> & Record<string, any>) | (element_plus_es_utils.SFCWithInstall<vue.DefineComponent<{
2695
+ readonly tag: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
2696
+ readonly span: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 24, boolean>;
2697
+ readonly offset: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2698
+ readonly pull: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2699
+ readonly push: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2700
+ readonly xs: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2701
+ readonly sm: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2702
+ readonly md: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2703
+ readonly lg: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2704
+ readonly xl: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2705
+ }, {
2706
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
2707
+ readonly tag: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
2708
+ readonly span: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 24, boolean>;
2709
+ readonly offset: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2710
+ readonly pull: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2711
+ readonly push: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2712
+ readonly xs: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2713
+ readonly sm: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2714
+ readonly md: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2715
+ readonly lg: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2716
+ readonly xl: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2717
+ }>> & {
2718
+ [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
2719
+ }>>;
2720
+ gutter: vue.ComputedRef<number>;
2721
+ ns: {
2722
+ namespace: vue.ComputedRef<string>;
2723
+ b: (blockSuffix?: string | undefined) => string;
2724
+ e: (element?: string | undefined) => string;
2725
+ m: (modifier?: string | undefined) => string;
2726
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
2727
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
2728
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
2729
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
2730
+ is: {
2731
+ (name: string, state: boolean | undefined): string;
2732
+ (name: string): string;
2733
+ };
2734
+ cssVar: (object: Record<string, string>) => Record<string, string>;
2735
+ cssVarName: (name: string) => string;
2736
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
2737
+ cssVarBlockName: (name: string) => string;
2738
+ };
2739
+ style: vue.ComputedRef<vue.CSSProperties>;
2740
+ classes: vue.ComputedRef<string[]>;
2741
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2742
+ readonly tag: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
2743
+ readonly span: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 24, boolean>;
2744
+ readonly offset: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2745
+ readonly pull: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2746
+ readonly push: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2747
+ readonly xs: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2748
+ readonly sm: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2749
+ readonly md: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2750
+ readonly lg: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2751
+ readonly xl: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2752
+ }>>, {
2753
+ readonly offset: number;
2754
+ readonly push: number;
2755
+ readonly tag: string;
2756
+ readonly span: number;
2757
+ readonly pull: number;
2758
+ readonly xs: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown>;
2759
+ readonly sm: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown>;
2760
+ readonly md: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown>;
2761
+ readonly lg: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown>;
2762
+ readonly xl: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown>;
2763
+ }>> & Record<string, any>) | element_plus_es_utils.SFCWithInstall<vue.DefineComponent<{
2764
+ label: {
2765
+ type: StringConstructor;
2766
+ default: string;
2767
+ };
2768
+ span: {
2769
+ type: NumberConstructor;
2770
+ default: number;
2771
+ };
2772
+ width: {
2773
+ type: (NumberConstructor | StringConstructor)[];
2774
+ default: string;
2775
+ };
2776
+ minWidth: {
2777
+ type: (NumberConstructor | StringConstructor)[];
2778
+ default: string;
2779
+ };
2780
+ align: {
2781
+ type: StringConstructor;
2782
+ default: string;
2783
+ };
2784
+ labelAlign: {
2785
+ type: StringConstructor;
2786
+ default: string;
2787
+ };
2788
+ className: {
2789
+ type: StringConstructor;
2790
+ default: string;
2791
+ };
2792
+ labelClassName: {
2793
+ type: StringConstructor;
2794
+ default: string;
2795
+ };
2796
+ }, unknown, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2797
+ label: {
2798
+ type: StringConstructor;
2799
+ default: string;
2800
+ };
2801
+ span: {
2802
+ type: NumberConstructor;
2803
+ default: number;
2804
+ };
2805
+ width: {
2806
+ type: (NumberConstructor | StringConstructor)[];
2807
+ default: string;
2808
+ };
2809
+ minWidth: {
2810
+ type: (NumberConstructor | StringConstructor)[];
2811
+ default: string;
2812
+ };
2813
+ align: {
2814
+ type: StringConstructor;
2815
+ default: string;
2816
+ };
2817
+ labelAlign: {
2818
+ type: StringConstructor;
2819
+ default: string;
2820
+ };
2821
+ className: {
2822
+ type: StringConstructor;
2823
+ default: string;
2824
+ };
2825
+ labelClassName: {
2826
+ type: StringConstructor;
2827
+ default: string;
2828
+ };
2829
+ }>>, {
2830
+ label: string;
2831
+ width: string | number;
2832
+ className: string;
2833
+ minWidth: string | number;
2834
+ span: number;
2835
+ align: string;
2836
+ labelAlign: string;
2837
+ labelClassName: string;
2838
+ }>>;
2839
+ text: vue.DefineComponent<{
2840
+ value: {
2841
+ type: (NumberConstructor | StringConstructor)[];
2842
+ };
2843
+ showProps: {
2844
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2845
+ content: {
2846
+ type: (NumberConstructor | StringConstructor)[];
2847
+ };
2848
+ ellipsis: {
2849
+ type: (BooleanConstructor | vue.PropType<{
2850
+ rows?: number | undefined;
2851
+ num?: number | undefined;
2852
+ }>)[];
2853
+ };
2854
+ popoverProps: ObjectConstructor;
2855
+ }>>>;
2856
+ };
2857
+ convert: {
2858
+ type: vue.PropType<TConvert>;
2859
+ };
2860
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2861
+ value: {
2862
+ type: (NumberConstructor | StringConstructor)[];
2863
+ };
2864
+ showProps: {
2865
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2866
+ content: {
2867
+ type: (NumberConstructor | StringConstructor)[];
2868
+ };
2869
+ ellipsis: {
2870
+ type: (BooleanConstructor | vue.PropType<{
2871
+ rows?: number | undefined;
2872
+ num?: number | undefined;
2873
+ }>)[];
2874
+ };
2875
+ popoverProps: ObjectConstructor;
2876
+ }>>>;
2877
+ };
2878
+ convert: {
2879
+ type: vue.PropType<TConvert>;
2880
+ };
2881
+ }>>, {}>;
2882
+ digit: vue.DefineComponent<{
2883
+ decimalFixed: {
2884
+ type: NumberConstructor;
2885
+ default: number;
2886
+ };
2887
+ thousandDivision: {
2888
+ type: BooleanConstructor;
2889
+ default: boolean;
2890
+ };
2891
+ value: {
2892
+ type: (NumberConstructor | StringConstructor)[];
2893
+ };
2894
+ showProps: {
2895
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2896
+ content: {
2897
+ type: (NumberConstructor | StringConstructor)[];
2898
+ };
2899
+ ellipsis: {
2900
+ type: (BooleanConstructor | vue.PropType<{
2901
+ rows?: number | undefined;
2902
+ num?: number | undefined;
2903
+ }>)[];
2904
+ };
2905
+ popoverProps: ObjectConstructor;
2906
+ }>>>;
2907
+ };
2908
+ convert: {
2909
+ type: vue.PropType<TConvert>;
2910
+ };
2911
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2912
+ decimalFixed: {
2913
+ type: NumberConstructor;
2914
+ default: number;
2915
+ };
2916
+ thousandDivision: {
2917
+ type: BooleanConstructor;
2918
+ default: boolean;
2919
+ };
2920
+ value: {
2921
+ type: (NumberConstructor | StringConstructor)[];
2922
+ };
2923
+ showProps: {
2924
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2925
+ content: {
2926
+ type: (NumberConstructor | StringConstructor)[];
2927
+ };
2928
+ ellipsis: {
2929
+ type: (BooleanConstructor | vue.PropType<{
2930
+ rows?: number | undefined;
2931
+ num?: number | undefined;
2932
+ }>)[];
2933
+ };
2934
+ popoverProps: ObjectConstructor;
2935
+ }>>>;
2936
+ };
2937
+ convert: {
2938
+ type: vue.PropType<TConvert>;
2939
+ };
2940
+ }>>, {
2941
+ decimalFixed: number;
2942
+ thousandDivision: boolean;
2943
+ }>;
2944
+ date: vue.DefineComponent<{
2945
+ value: {
2946
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
2947
+ };
2948
+ splitStr: {
2949
+ type: StringConstructor;
2950
+ default: string;
2951
+ };
2952
+ format: {
2953
+ type: StringConstructor;
2954
+ default: string;
2955
+ };
2956
+ isUnix: {
2957
+ type: BooleanConstructor;
2958
+ default: boolean;
2959
+ };
2960
+ showProps: {
2961
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2962
+ content: {
2963
+ type: (NumberConstructor | StringConstructor)[];
2964
+ };
2965
+ ellipsis: {
2966
+ type: (BooleanConstructor | vue.PropType<{
2967
+ rows?: number | undefined;
2968
+ num?: number | undefined;
2969
+ }>)[];
2970
+ };
2971
+ popoverProps: ObjectConstructor;
2972
+ }>>>;
2973
+ };
2974
+ convert: {
2975
+ type: vue.PropType<TConvert>;
2976
+ };
2977
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2978
+ value: {
2979
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
2980
+ };
2981
+ splitStr: {
2982
+ type: StringConstructor;
2983
+ default: string;
2984
+ };
2985
+ format: {
2986
+ type: StringConstructor;
2987
+ default: string;
2988
+ };
2989
+ isUnix: {
2990
+ type: BooleanConstructor;
2991
+ default: boolean;
2992
+ };
2993
+ showProps: {
2994
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2995
+ content: {
2996
+ type: (NumberConstructor | StringConstructor)[];
2997
+ };
2998
+ ellipsis: {
2999
+ type: (BooleanConstructor | vue.PropType<{
3000
+ rows?: number | undefined;
3001
+ num?: number | undefined;
3002
+ }>)[];
3003
+ };
3004
+ popoverProps: ObjectConstructor;
3005
+ }>>>;
3006
+ };
3007
+ convert: {
3008
+ type: vue.PropType<TConvert>;
3009
+ };
3010
+ }>>, {
3011
+ splitStr: string;
3012
+ format: string;
3013
+ isUnix: boolean;
3014
+ }>;
3015
+ time: vue.DefineComponent<{
3016
+ value: {
3017
+ type: (NumberConstructor | StringConstructor)[];
3018
+ };
3019
+ showProps: {
3020
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3021
+ content: {
3022
+ type: (NumberConstructor | StringConstructor)[];
3023
+ };
3024
+ ellipsis: {
3025
+ type: (BooleanConstructor | vue.PropType<{
3026
+ rows?: number | undefined;
3027
+ num?: number | undefined;
3028
+ }>)[];
3029
+ };
3030
+ popoverProps: ObjectConstructor;
3031
+ }>>>;
3032
+ };
3033
+ convert: {
3034
+ type: vue.PropType<TConvert>;
3035
+ };
3036
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
3037
+ value: {
3038
+ type: (NumberConstructor | StringConstructor)[];
3039
+ };
3040
+ showProps: {
3041
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3042
+ content: {
3043
+ type: (NumberConstructor | StringConstructor)[];
3044
+ };
3045
+ ellipsis: {
3046
+ type: (BooleanConstructor | vue.PropType<{
3047
+ rows?: number | undefined;
3048
+ num?: number | undefined;
3049
+ }>)[];
3050
+ };
3051
+ popoverProps: ObjectConstructor;
3052
+ }>>>;
3053
+ };
3054
+ convert: {
3055
+ type: vue.PropType<TConvert>;
3056
+ };
3057
+ }>>, {}>;
3058
+ select: vue.DefineComponent<{
3059
+ value: {
3060
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3061
+ };
3062
+ options: vue.PropType<_vue_start_pro.TOptions>;
3063
+ splitStr: {
3064
+ type: StringConstructor;
3065
+ default: string;
3066
+ };
3067
+ colorMap: {
3068
+ type: ObjectConstructor;
3069
+ };
3070
+ showProps: {
3071
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3072
+ content: {
3073
+ type: (NumberConstructor | StringConstructor)[];
3074
+ };
3075
+ ellipsis: {
3076
+ type: (BooleanConstructor | vue.PropType<{
3077
+ rows?: number | undefined;
3078
+ num?: number | undefined;
3079
+ }>)[];
3080
+ };
3081
+ popoverProps: ObjectConstructor;
3082
+ }>>>;
3083
+ };
3084
+ convert: {
3085
+ type: vue.PropType<TConvert>;
3086
+ };
3087
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
3088
+ value: {
3089
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3090
+ };
3091
+ options: vue.PropType<_vue_start_pro.TOptions>;
3092
+ splitStr: {
3093
+ type: StringConstructor;
3094
+ default: string;
3095
+ };
3096
+ colorMap: {
3097
+ type: ObjectConstructor;
3098
+ };
3099
+ showProps: {
3100
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3101
+ content: {
3102
+ type: (NumberConstructor | StringConstructor)[];
3103
+ };
3104
+ ellipsis: {
3105
+ type: (BooleanConstructor | vue.PropType<{
3106
+ rows?: number | undefined;
3107
+ num?: number | undefined;
3108
+ }>)[];
3109
+ };
3110
+ popoverProps: ObjectConstructor;
3111
+ }>>>;
3112
+ };
3113
+ convert: {
3114
+ type: vue.PropType<TConvert>;
3115
+ };
3116
+ }>>, {
3117
+ splitStr: string;
3118
+ }>;
3119
+ radio: vue.DefineComponent<{
3120
+ value: {
3121
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3122
+ };
3123
+ options: vue.PropType<_vue_start_pro.TOptions>;
3124
+ splitStr: {
3125
+ type: StringConstructor;
3126
+ default: string;
3127
+ };
3128
+ colorMap: {
3129
+ type: ObjectConstructor;
3130
+ };
3131
+ showProps: {
3132
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3133
+ content: {
3134
+ type: (NumberConstructor | StringConstructor)[];
3135
+ };
3136
+ ellipsis: {
3137
+ type: (BooleanConstructor | vue.PropType<{
3138
+ rows?: number | undefined;
3139
+ num?: number | undefined;
3140
+ }>)[];
3141
+ };
3142
+ popoverProps: ObjectConstructor;
3143
+ }>>>;
3144
+ };
3145
+ convert: {
3146
+ type: vue.PropType<TConvert>;
3147
+ };
3148
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
3149
+ value: {
3150
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3151
+ };
3152
+ options: vue.PropType<_vue_start_pro.TOptions>;
3153
+ splitStr: {
3154
+ type: StringConstructor;
3155
+ default: string;
3156
+ };
3157
+ colorMap: {
3158
+ type: ObjectConstructor;
3159
+ };
3160
+ showProps: {
3161
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3162
+ content: {
3163
+ type: (NumberConstructor | StringConstructor)[];
3164
+ };
3165
+ ellipsis: {
3166
+ type: (BooleanConstructor | vue.PropType<{
3167
+ rows?: number | undefined;
3168
+ num?: number | undefined;
3169
+ }>)[];
3170
+ };
3171
+ popoverProps: ObjectConstructor;
3172
+ }>>>;
3173
+ };
3174
+ convert: {
3175
+ type: vue.PropType<TConvert>;
3176
+ };
3177
+ }>>, {
3178
+ splitStr: string;
3179
+ }>;
3180
+ checkbox: vue.DefineComponent<{
3181
+ value: {
3182
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3183
+ };
3184
+ options: vue.PropType<_vue_start_pro.TOptions>;
3185
+ splitStr: {
3186
+ type: StringConstructor;
3187
+ default: string;
3188
+ };
3189
+ colorMap: {
3190
+ type: ObjectConstructor;
3191
+ };
3192
+ showProps: {
3193
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3194
+ content: {
3195
+ type: (NumberConstructor | StringConstructor)[];
3196
+ };
3197
+ ellipsis: {
3198
+ type: (BooleanConstructor | vue.PropType<{
3199
+ rows?: number | undefined;
3200
+ num?: number | undefined;
3201
+ }>)[];
3202
+ };
3203
+ popoverProps: ObjectConstructor;
3204
+ }>>>;
3205
+ };
3206
+ convert: {
3207
+ type: vue.PropType<TConvert>;
3208
+ };
3209
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
3210
+ value: {
3211
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3212
+ };
3213
+ options: vue.PropType<_vue_start_pro.TOptions>;
3214
+ splitStr: {
3215
+ type: StringConstructor;
3216
+ default: string;
3217
+ };
3218
+ colorMap: {
3219
+ type: ObjectConstructor;
3220
+ };
3221
+ showProps: {
3222
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3223
+ content: {
3224
+ type: (NumberConstructor | StringConstructor)[];
3225
+ };
3226
+ ellipsis: {
3227
+ type: (BooleanConstructor | vue.PropType<{
3228
+ rows?: number | undefined;
3229
+ num?: number | undefined;
3230
+ }>)[];
3231
+ };
3232
+ popoverProps: ObjectConstructor;
3233
+ }>>>;
3234
+ };
3235
+ convert: {
3236
+ type: vue.PropType<TConvert>;
3237
+ };
3238
+ }>>, {
3239
+ splitStr: string;
3240
+ }>;
3241
+ treeSelect: vue.DefineComponent<{
3242
+ value: {
3243
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3244
+ };
3245
+ splitStr: {
3246
+ type: StringConstructor;
3247
+ default: string;
3248
+ };
3249
+ treeData: vue.PropType<Record<string, any>>;
3250
+ data: vue.PropType<Record<string, any>>;
3251
+ options: vue.PropType<Record<string, any>>;
3252
+ fieldNames: ObjectConstructor;
3253
+ props: ObjectConstructor;
3254
+ showProps: {
3255
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3256
+ content: {
3257
+ type: (NumberConstructor | StringConstructor)[];
3258
+ };
3259
+ ellipsis: {
3260
+ type: (BooleanConstructor | vue.PropType<{
3261
+ rows?: number | undefined;
3262
+ num?: number | undefined;
3263
+ }>)[];
3264
+ };
3265
+ popoverProps: ObjectConstructor;
3266
+ }>>>;
3267
+ };
3268
+ convert: {
3269
+ type: vue.PropType<TConvert>;
3270
+ };
3271
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
3272
+ value: {
3273
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3274
+ };
3275
+ splitStr: {
3276
+ type: StringConstructor;
3277
+ default: string;
3278
+ };
3279
+ treeData: vue.PropType<Record<string, any>>;
3280
+ data: vue.PropType<Record<string, any>>;
3281
+ options: vue.PropType<Record<string, any>>;
3282
+ fieldNames: ObjectConstructor;
3283
+ props: ObjectConstructor;
3284
+ showProps: {
3285
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3286
+ content: {
3287
+ type: (NumberConstructor | StringConstructor)[];
3288
+ };
3289
+ ellipsis: {
3290
+ type: (BooleanConstructor | vue.PropType<{
3291
+ rows?: number | undefined;
3292
+ num?: number | undefined;
3293
+ }>)[];
3294
+ };
3295
+ popoverProps: ObjectConstructor;
3296
+ }>>>;
3297
+ };
3298
+ convert: {
3299
+ type: vue.PropType<TConvert>;
3300
+ };
3301
+ }>>, {
3302
+ splitStr: string;
3303
+ }>;
3304
+ cascader: vue.DefineComponent<{
3305
+ value: {
3306
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3307
+ };
3308
+ splitStr: {
3309
+ type: StringConstructor;
3310
+ default: string;
3311
+ };
3312
+ treeData: vue.PropType<Record<string, any>>;
3313
+ data: vue.PropType<Record<string, any>>;
3314
+ options: vue.PropType<Record<string, any>>;
3315
+ fieldNames: ObjectConstructor;
3316
+ props: ObjectConstructor;
3317
+ showProps: {
3318
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3319
+ content: {
3320
+ type: (NumberConstructor | StringConstructor)[];
3321
+ };
3322
+ ellipsis: {
3323
+ type: (BooleanConstructor | vue.PropType<{
3324
+ rows?: number | undefined;
3325
+ num?: number | undefined;
3326
+ }>)[];
3327
+ };
3328
+ popoverProps: ObjectConstructor;
3329
+ }>>>;
3330
+ };
3331
+ convert: {
3332
+ type: vue.PropType<TConvert>;
3333
+ };
3334
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
3335
+ value: {
3336
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3337
+ };
3338
+ splitStr: {
3339
+ type: StringConstructor;
3340
+ default: string;
3341
+ };
3342
+ treeData: vue.PropType<Record<string, any>>;
3343
+ data: vue.PropType<Record<string, any>>;
3344
+ options: vue.PropType<Record<string, any>>;
3345
+ fieldNames: ObjectConstructor;
3346
+ props: ObjectConstructor;
3347
+ showProps: {
3348
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3349
+ content: {
3350
+ type: (NumberConstructor | StringConstructor)[];
3351
+ };
3352
+ ellipsis: {
3353
+ type: (BooleanConstructor | vue.PropType<{
3354
+ rows?: number | undefined;
3355
+ num?: number | undefined;
3356
+ }>)[];
3357
+ };
3358
+ popoverProps: ObjectConstructor;
3359
+ }>>>;
3360
+ };
3361
+ convert: {
3362
+ type: vue.PropType<TConvert>;
3363
+ };
3364
+ }>>, {
3365
+ splitStr: string;
3366
+ }>;
3367
+ };
3368
+ declare const formElementMap: {
3369
+ text: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3370
+ name: {
3371
+ type: vue.PropType<string | (string | number)[]>;
3372
+ };
3373
+ }>> & {
3374
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3375
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3376
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3377
+ } & {
3378
+ readonly error?: string | undefined;
3379
+ readonly label?: string | undefined;
3380
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3381
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3382
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3383
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3384
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3385
+ readonly for?: string | undefined;
3386
+ } & Partial<vue.ExtractPropTypes<{
3387
+ readonly: {
3388
+ type: BooleanConstructor;
3389
+ default: undefined;
3390
+ };
3391
+ fieldProps: {
3392
+ type: ObjectConstructor;
3393
+ };
3394
+ showProps: {
3395
+ type: ObjectConstructor;
3396
+ };
3397
+ slots: {
3398
+ type: ObjectConstructor;
3399
+ };
3400
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3401
+ name: {
3402
+ type: vue.PropType<string | (string | number)[]>;
3403
+ };
3404
+ }>> & {
3405
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3406
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3407
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3408
+ } & {
3409
+ readonly error?: string | undefined;
3410
+ readonly label?: string | undefined;
3411
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3412
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3413
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3414
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3415
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3416
+ readonly for?: string | undefined;
3417
+ } & Partial<vue.ExtractPropTypes<{
3418
+ readonly: {
3419
+ type: BooleanConstructor;
3420
+ default: undefined;
3421
+ };
3422
+ fieldProps: {
3423
+ type: ObjectConstructor;
3424
+ };
3425
+ showProps: {
3426
+ type: ObjectConstructor;
3427
+ };
3428
+ slots: {
3429
+ type: ObjectConstructor;
3430
+ };
3431
+ }>> & Record<string, any>>>, {
3432
+ [x: string]: any;
3433
+ }>;
3434
+ digit: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3435
+ name: {
3436
+ type: vue.PropType<string | (string | number)[]>;
3437
+ };
3438
+ }>> & {
3439
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3440
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3441
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3442
+ } & {
3443
+ readonly error?: string | undefined;
3444
+ readonly label?: string | undefined;
3445
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3446
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3447
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3448
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3449
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3450
+ readonly for?: string | undefined;
3451
+ } & Partial<vue.ExtractPropTypes<{
3452
+ readonly: {
3453
+ type: BooleanConstructor;
3454
+ default: undefined;
3455
+ };
3456
+ fieldProps: {
3457
+ type: ObjectConstructor;
3458
+ };
3459
+ showProps: {
3460
+ type: ObjectConstructor;
3461
+ };
3462
+ slots: {
3463
+ type: ObjectConstructor;
3464
+ };
3465
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3466
+ name: {
3467
+ type: vue.PropType<string | (string | number)[]>;
3468
+ };
3469
+ }>> & {
3470
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3471
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3472
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3473
+ } & {
3474
+ readonly error?: string | undefined;
3475
+ readonly label?: string | undefined;
3476
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3477
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3478
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3479
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3480
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3481
+ readonly for?: string | undefined;
3482
+ } & Partial<vue.ExtractPropTypes<{
3483
+ readonly: {
3484
+ type: BooleanConstructor;
3485
+ default: undefined;
3486
+ };
3487
+ fieldProps: {
3488
+ type: ObjectConstructor;
3489
+ };
3490
+ showProps: {
3491
+ type: ObjectConstructor;
3492
+ };
3493
+ slots: {
3494
+ type: ObjectConstructor;
3495
+ };
3496
+ }>> & Record<string, any>>>, {
3497
+ [x: string]: any;
3498
+ }>;
3499
+ digitRange: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3500
+ name: {
3501
+ type: vue.PropType<string | (string | number)[]>;
3502
+ };
3503
+ }>> & {
3504
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3505
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3506
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3507
+ } & {
3508
+ readonly error?: string | undefined;
3509
+ readonly label?: string | undefined;
3510
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3511
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3512
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3513
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3514
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3515
+ readonly for?: string | undefined;
3516
+ } & Partial<vue.ExtractPropTypes<{
3517
+ readonly: {
3518
+ type: BooleanConstructor;
3519
+ default: undefined;
3520
+ };
3521
+ fieldProps: {
3522
+ type: ObjectConstructor;
3523
+ };
3524
+ showProps: {
3525
+ type: ObjectConstructor;
3526
+ };
3527
+ slots: {
3528
+ type: ObjectConstructor;
3529
+ };
3530
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3531
+ name: {
3532
+ type: vue.PropType<string | (string | number)[]>;
3533
+ };
3534
+ }>> & {
3535
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3536
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3537
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3538
+ } & {
3539
+ readonly error?: string | undefined;
3540
+ readonly label?: string | undefined;
3541
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3542
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3543
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3544
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3545
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3546
+ readonly for?: string | undefined;
3547
+ } & Partial<vue.ExtractPropTypes<{
3548
+ readonly: {
3549
+ type: BooleanConstructor;
3550
+ default: undefined;
3551
+ };
3552
+ fieldProps: {
3553
+ type: ObjectConstructor;
3554
+ };
3555
+ showProps: {
3556
+ type: ObjectConstructor;
3557
+ };
3558
+ slots: {
3559
+ type: ObjectConstructor;
3560
+ };
3561
+ }>> & Record<string, any>>>, {
3562
+ [x: string]: any;
3563
+ }>;
3564
+ date: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3565
+ name: {
3566
+ type: vue.PropType<string | (string | number)[]>;
3567
+ };
3568
+ }>> & {
3569
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3570
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3571
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3572
+ } & {
3573
+ readonly error?: string | undefined;
3574
+ readonly label?: string | undefined;
3575
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3576
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3577
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3578
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3579
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3580
+ readonly for?: string | undefined;
3581
+ } & Partial<vue.ExtractPropTypes<{
3582
+ readonly: {
3583
+ type: BooleanConstructor;
3584
+ default: undefined;
3585
+ };
3586
+ fieldProps: {
3587
+ type: ObjectConstructor;
3588
+ };
3589
+ showProps: {
3590
+ type: ObjectConstructor;
3591
+ };
3592
+ slots: {
3593
+ type: ObjectConstructor;
3594
+ };
3595
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3596
+ name: {
3597
+ type: vue.PropType<string | (string | number)[]>;
3598
+ };
3599
+ }>> & {
3600
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3601
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3602
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3603
+ } & {
3604
+ readonly error?: string | undefined;
3605
+ readonly label?: string | undefined;
3606
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3607
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3608
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3609
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3610
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3611
+ readonly for?: string | undefined;
3612
+ } & Partial<vue.ExtractPropTypes<{
3613
+ readonly: {
3614
+ type: BooleanConstructor;
3615
+ default: undefined;
3616
+ };
3617
+ fieldProps: {
3618
+ type: ObjectConstructor;
3619
+ };
3620
+ showProps: {
3621
+ type: ObjectConstructor;
3622
+ };
3623
+ slots: {
3624
+ type: ObjectConstructor;
3625
+ };
3626
+ }>> & Record<string, any>>>, {
3627
+ [x: string]: any;
3628
+ }>;
3629
+ time: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3630
+ name: {
3631
+ type: vue.PropType<string | (string | number)[]>;
3632
+ };
3633
+ }>> & {
3634
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3635
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3636
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3637
+ } & {
3638
+ readonly error?: string | undefined;
3639
+ readonly label?: string | undefined;
3640
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3641
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3642
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3643
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3644
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3645
+ readonly for?: string | undefined;
3646
+ } & Partial<vue.ExtractPropTypes<{
3647
+ readonly: {
3648
+ type: BooleanConstructor;
3649
+ default: undefined;
3650
+ };
3651
+ fieldProps: {
3652
+ type: ObjectConstructor;
3653
+ };
3654
+ showProps: {
3655
+ type: ObjectConstructor;
3656
+ };
3657
+ slots: {
3658
+ type: ObjectConstructor;
3659
+ };
3660
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3661
+ name: {
3662
+ type: vue.PropType<string | (string | number)[]>;
3663
+ };
3664
+ }>> & {
3665
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3666
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3667
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3668
+ } & {
3669
+ readonly error?: string | undefined;
3670
+ readonly label?: string | undefined;
3671
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3672
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3673
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3674
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3675
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3676
+ readonly for?: string | undefined;
3677
+ } & Partial<vue.ExtractPropTypes<{
3678
+ readonly: {
3679
+ type: BooleanConstructor;
3680
+ default: undefined;
3681
+ };
3682
+ fieldProps: {
3683
+ type: ObjectConstructor;
3684
+ };
3685
+ showProps: {
3686
+ type: ObjectConstructor;
3687
+ };
3688
+ slots: {
3689
+ type: ObjectConstructor;
3690
+ };
3691
+ }>> & Record<string, any>>>, {
3692
+ [x: string]: any;
3693
+ }>;
3694
+ select: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3695
+ name: {
3696
+ type: vue.PropType<string | (string | number)[]>;
3697
+ };
3698
+ }>> & {
3699
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3700
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3701
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3702
+ } & {
3703
+ readonly error?: string | undefined;
3704
+ readonly label?: string | undefined;
3705
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3706
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3707
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3708
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3709
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3710
+ readonly for?: string | undefined;
3711
+ } & Partial<vue.ExtractPropTypes<{
3712
+ readonly: {
3713
+ type: BooleanConstructor;
3714
+ default: undefined;
3715
+ };
3716
+ fieldProps: {
3717
+ type: ObjectConstructor;
3718
+ };
3719
+ showProps: {
3720
+ type: ObjectConstructor;
3721
+ };
3722
+ slots: {
3723
+ type: ObjectConstructor;
3724
+ };
3725
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3726
+ name: {
3727
+ type: vue.PropType<string | (string | number)[]>;
3728
+ };
3729
+ }>> & {
3730
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3731
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3732
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3733
+ } & {
3734
+ readonly error?: string | undefined;
3735
+ readonly label?: string | undefined;
3736
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3737
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3738
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3739
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3740
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3741
+ readonly for?: string | undefined;
3742
+ } & Partial<vue.ExtractPropTypes<{
3743
+ readonly: {
3744
+ type: BooleanConstructor;
3745
+ default: undefined;
3746
+ };
3747
+ fieldProps: {
3748
+ type: ObjectConstructor;
3749
+ };
3750
+ showProps: {
3751
+ type: ObjectConstructor;
3752
+ };
3753
+ slots: {
3754
+ type: ObjectConstructor;
3755
+ };
3756
+ }>> & Record<string, any>>>, {
3757
+ [x: string]: any;
3758
+ }>;
3759
+ treeSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3760
+ name: {
3761
+ type: vue.PropType<string | (string | number)[]>;
3762
+ };
3763
+ }>> & {
3764
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3765
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3766
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3767
+ } & {
3768
+ readonly error?: string | undefined;
3769
+ readonly label?: string | undefined;
3770
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3771
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3772
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3773
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3774
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3775
+ readonly for?: string | undefined;
3776
+ } & Partial<vue.ExtractPropTypes<{
3777
+ readonly: {
3778
+ type: BooleanConstructor;
3779
+ default: undefined;
3780
+ };
3781
+ fieldProps: {
3782
+ type: ObjectConstructor;
3783
+ };
3784
+ showProps: {
3785
+ type: ObjectConstructor;
3786
+ };
3787
+ slots: {
3788
+ type: ObjectConstructor;
3789
+ };
3790
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3791
+ name: {
3792
+ type: vue.PropType<string | (string | number)[]>;
3793
+ };
3794
+ }>> & {
3795
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3796
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3797
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3798
+ } & {
3799
+ readonly error?: string | undefined;
3800
+ readonly label?: string | undefined;
3801
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3802
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3803
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3804
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3805
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3806
+ readonly for?: string | undefined;
3807
+ } & Partial<vue.ExtractPropTypes<{
3808
+ readonly: {
3809
+ type: BooleanConstructor;
3810
+ default: undefined;
3811
+ };
3812
+ fieldProps: {
3813
+ type: ObjectConstructor;
3814
+ };
3815
+ showProps: {
3816
+ type: ObjectConstructor;
3817
+ };
3818
+ slots: {
3819
+ type: ObjectConstructor;
3820
+ };
3821
+ }>> & Record<string, any>>>, {
3822
+ [x: string]: any;
3823
+ }>;
3824
+ checkbox: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3825
+ name: {
3826
+ type: vue.PropType<string | (string | number)[]>;
3827
+ };
3828
+ }>> & {
3829
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3830
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3831
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3832
+ } & {
3833
+ readonly error?: string | undefined;
3834
+ readonly label?: string | undefined;
3835
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3836
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3837
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3838
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3839
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3840
+ readonly for?: string | undefined;
3841
+ } & Partial<vue.ExtractPropTypes<{
3842
+ readonly: {
3843
+ type: BooleanConstructor;
3844
+ default: undefined;
3845
+ };
3846
+ fieldProps: {
3847
+ type: ObjectConstructor;
3848
+ };
3849
+ showProps: {
3850
+ type: ObjectConstructor;
3851
+ };
3852
+ slots: {
3853
+ type: ObjectConstructor;
3854
+ };
3855
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3856
+ name: {
3857
+ type: vue.PropType<string | (string | number)[]>;
3858
+ };
3859
+ }>> & {
3860
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3861
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3862
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3863
+ } & {
3864
+ readonly error?: string | undefined;
3865
+ readonly label?: string | undefined;
3866
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3867
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3868
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3869
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3870
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3871
+ readonly for?: string | undefined;
3872
+ } & Partial<vue.ExtractPropTypes<{
3873
+ readonly: {
3874
+ type: BooleanConstructor;
3875
+ default: undefined;
3876
+ };
3877
+ fieldProps: {
3878
+ type: ObjectConstructor;
3879
+ };
3880
+ showProps: {
3881
+ type: ObjectConstructor;
3882
+ };
3883
+ slots: {
3884
+ type: ObjectConstructor;
3885
+ };
3886
+ }>> & Record<string, any>>>, {
3887
+ [x: string]: any;
3888
+ }>;
3889
+ radio: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3890
+ name: {
3891
+ type: vue.PropType<string | (string | number)[]>;
3892
+ };
3893
+ }>> & {
3894
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3895
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3896
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3897
+ } & {
3898
+ readonly error?: string | undefined;
3899
+ readonly label?: string | undefined;
3900
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3901
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3902
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3903
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3904
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3905
+ readonly for?: string | undefined;
3906
+ } & Partial<vue.ExtractPropTypes<{
3907
+ readonly: {
3908
+ type: BooleanConstructor;
3909
+ default: undefined;
3910
+ };
3911
+ fieldProps: {
3912
+ type: ObjectConstructor;
3913
+ };
3914
+ showProps: {
3915
+ type: ObjectConstructor;
3916
+ };
3917
+ slots: {
3918
+ type: ObjectConstructor;
3919
+ };
3920
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3921
+ name: {
3922
+ type: vue.PropType<string | (string | number)[]>;
3923
+ };
3924
+ }>> & {
3925
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3926
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3927
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3928
+ } & {
3929
+ readonly error?: string | undefined;
3930
+ readonly label?: string | undefined;
3931
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3932
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3933
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3934
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3935
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3936
+ readonly for?: string | undefined;
3937
+ } & Partial<vue.ExtractPropTypes<{
3938
+ readonly: {
3939
+ type: BooleanConstructor;
3940
+ default: undefined;
3941
+ };
3942
+ fieldProps: {
3943
+ type: ObjectConstructor;
3944
+ };
3945
+ showProps: {
3946
+ type: ObjectConstructor;
3947
+ };
3948
+ slots: {
3949
+ type: ObjectConstructor;
3950
+ };
3951
+ }>> & Record<string, any>>>, {
3952
+ [x: string]: any;
3953
+ }>;
3954
+ switch: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3955
+ name: {
3956
+ type: vue.PropType<string | (string | number)[]>;
3957
+ };
3958
+ }>> & {
3959
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3960
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3961
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3962
+ } & {
3963
+ readonly error?: string | undefined;
3964
+ readonly label?: string | undefined;
3965
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3966
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3967
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3968
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
3969
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3970
+ readonly for?: string | undefined;
3971
+ } & Partial<vue.ExtractPropTypes<{
3972
+ readonly: {
3973
+ type: BooleanConstructor;
3974
+ default: undefined;
3975
+ };
3976
+ fieldProps: {
3977
+ type: ObjectConstructor;
3978
+ };
3979
+ showProps: {
3980
+ type: ObjectConstructor;
3981
+ };
3982
+ slots: {
3983
+ type: ObjectConstructor;
3984
+ };
3985
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3986
+ name: {
3987
+ type: vue.PropType<string | (string | number)[]>;
3988
+ };
3989
+ }>> & {
3990
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3991
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3992
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3993
+ } & {
3994
+ readonly error?: string | undefined;
3995
+ readonly label?: string | undefined;
3996
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3997
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3998
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
3999
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
4000
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
4001
+ readonly for?: string | undefined;
4002
+ } & Partial<vue.ExtractPropTypes<{
4003
+ readonly: {
4004
+ type: BooleanConstructor;
4005
+ default: undefined;
4006
+ };
4007
+ fieldProps: {
4008
+ type: ObjectConstructor;
4009
+ };
4010
+ showProps: {
4011
+ type: ObjectConstructor;
4012
+ };
4013
+ slots: {
4014
+ type: ObjectConstructor;
4015
+ };
4016
+ }>> & Record<string, any>>>, {
4017
+ [x: string]: any;
4018
+ }>;
4019
+ cascader: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
4020
+ name: {
4021
+ type: vue.PropType<string | (string | number)[]>;
4022
+ };
4023
+ }>> & {
4024
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
4025
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
4026
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
4027
+ } & {
4028
+ readonly error?: string | undefined;
4029
+ readonly label?: string | undefined;
4030
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
4031
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
4032
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
4033
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
4034
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
4035
+ readonly for?: string | undefined;
4036
+ } & Partial<vue.ExtractPropTypes<{
4037
+ readonly: {
4038
+ type: BooleanConstructor;
4039
+ default: undefined;
4040
+ };
4041
+ fieldProps: {
4042
+ type: ObjectConstructor;
4043
+ };
4044
+ showProps: {
4045
+ type: ObjectConstructor;
4046
+ };
4047
+ slots: {
4048
+ type: ObjectConstructor;
4049
+ };
4050
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
4051
+ name: {
4052
+ type: vue.PropType<string | (string | number)[]>;
4053
+ };
4054
+ }>> & {
4055
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
4056
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
4057
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
4058
+ } & {
4059
+ readonly error?: string | undefined;
4060
+ readonly label?: string | undefined;
4061
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
4062
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
4063
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
4064
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
4065
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
4066
+ readonly for?: string | undefined;
4067
+ } & Partial<vue.ExtractPropTypes<{
4068
+ readonly: {
4069
+ type: BooleanConstructor;
4070
+ default: undefined;
4071
+ };
4072
+ fieldProps: {
4073
+ type: ObjectConstructor;
4074
+ };
4075
+ showProps: {
4076
+ type: ObjectConstructor;
4077
+ };
4078
+ slots: {
4079
+ type: ObjectConstructor;
4080
+ };
4081
+ }>> & Record<string, any>>>, {
4082
+ [x: string]: any;
4083
+ }>;
4084
+ };
4085
+
4086
+ export { FormMethods, InputNumberRange, ProCheckbox, ProCheckboxProps, ProForm, ProFormCascader, ProFormCheckbox, ProFormDatePicker, ProFormInputNumberRange, ProFormItem, ProFormItemProps, ProFormRadio, ProFormSelect, ProFormSwitch, ProFormText, ProFormTextNumber, ProFormTimePicker, ProFormTreeSelect, ProInputNumberRangeProps, ProLoading, ProLoadingProps, ProMenus, ProMenusProps, ProModal, ProModalProps, ProPagination, ProPopover, ProRadio, ProRadioProps, ProSelect, ProSelectProps, ProTable, ProTableColumn, ProTableColumnProps, ProTableOperateItem, ProTabs, ProTree, ProTreeProps, ProUploadProps, ProUploader, TableMethods, UploadMethods, createFormItemComponent, createLoadingId, elementMap, formElementMap };