@vue-start/element-pro 0.2.8 → 0.2.10

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 (4) hide show
  1. package/dist/index.d.ts +1036 -1303
  2. package/dist/index.es.js +425 -340
  3. package/dist/index.js +1 -1
  4. package/package.json +2 -2
package/dist/index.d.ts CHANGED
@@ -1,1332 +1,1065 @@
1
1
  import * as vue from 'vue';
2
2
  import { ExtractPropTypes, PropType, VNode } from 'vue';
3
3
  import * as element_plus from 'element-plus';
4
- import { FormItemProps, DialogProps, ElSelect, ElCheckboxGroup } from 'element-plus';
4
+ import { FormItemProps, DialogProps, IUseCheckboxGroupProps, ISelectProps } from 'element-plus';
5
5
  import * as element_plus_es_utils from 'element-plus/es/utils';
6
6
  import { FilterMethods, Filters } from 'element-plus/es/components/table/src/table-column/defaults';
7
- import { TOptions as TOptions$1 } from '@vue-start/pro';
8
- import { RadioGroupProps } from 'element-plus/es/components/radio/src/radio-group';
7
+ import { TOption } from '@vue-start/pro';
9
8
 
10
- declare const proFormItemProps: () => {
11
- name: {
12
- type: PropType<string | (string | number)[]>;
13
- };
14
- };
15
- declare type ProFormItemProps = Partial<ExtractPropTypes<ReturnType<typeof proFormItemProps>>> & FormItemProps;
16
- declare const ProFormItem: vue.DefineComponent<ProFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormItemProps>, {}>;
17
- declare const FormMethods: string[];
18
- 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>, {} | {
19
- [x: string]: any;
9
+ declare const proFormItemProps: () => {
10
+ name: {
11
+ type: PropType<string | (string | number)[]>;
12
+ };
13
+ };
14
+ declare type ProFormItemProps = Partial<ExtractPropTypes<ReturnType<typeof proFormItemProps>>> & FormItemProps;
15
+ declare const ProFormItem: vue.DefineComponent<ProFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormItemProps>, {}>;
16
+ declare const FormMethods: string[];
17
+ 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>, {} | {
18
+ [x: string]: any;
20
19
  }>;
21
20
 
22
- declare const ProFormText: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
23
- name: {
24
- type: vue.PropType<string | (string | number)[]>;
25
- };
26
- }>> & {
27
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
28
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
29
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
30
- } & {
31
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
32
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
33
- 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;
34
- readonly label?: string | undefined;
35
- 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;
36
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
37
- readonly error?: string | undefined;
38
- readonly for?: string | undefined;
39
- } & Partial<vue.ExtractPropTypes<{
40
- readonly: {
41
- type: BooleanConstructor;
42
- default: undefined;
43
- };
44
- fieldProps: {
45
- type: ObjectConstructor;
46
- };
47
- showProps: {
48
- type: ObjectConstructor;
49
- };
50
- slots: {
51
- type: ObjectConstructor;
52
- };
53
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
54
- readonly: {
55
- type: BooleanConstructor;
56
- default: undefined;
57
- };
58
- fieldProps: {
59
- type: ObjectConstructor;
60
- };
61
- showProps: {
62
- type: ObjectConstructor;
63
- };
64
- slots: {
65
- type: ObjectConstructor;
66
- };
67
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
68
- name: {
69
- type: vue.PropType<string | (string | number)[]>;
70
- };
71
- }>> & {
72
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
73
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
74
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
75
- } & {
76
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
77
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
78
- 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;
79
- readonly label?: string | undefined;
80
- 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;
81
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
82
- readonly error?: string | undefined;
83
- readonly for?: string | undefined;
84
- } & Partial<vue.ExtractPropTypes<{
85
- readonly: {
86
- type: BooleanConstructor;
87
- default: undefined;
88
- };
89
- fieldProps: {
90
- type: ObjectConstructor;
91
- };
92
- showProps: {
93
- type: ObjectConstructor;
94
- };
95
- slots: {
96
- type: ObjectConstructor;
97
- };
98
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
99
- readonly: {
100
- type: BooleanConstructor;
101
- default: undefined;
102
- };
103
- fieldProps: {
104
- type: ObjectConstructor;
105
- };
106
- showProps: {
107
- type: ObjectConstructor;
108
- };
109
- slots: {
110
- type: ObjectConstructor;
111
- };
112
- }>>>>, {
113
- [x: string]: any;
114
- }>;
115
- declare const ProFormTextNumber: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
116
- name: {
117
- type: vue.PropType<string | (string | number)[]>;
118
- };
119
- }>> & {
120
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
121
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
122
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
123
- } & {
124
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
125
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
126
- 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;
127
- readonly label?: string | undefined;
128
- 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;
129
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
130
- readonly error?: string | undefined;
131
- readonly for?: string | undefined;
132
- } & Partial<vue.ExtractPropTypes<{
133
- readonly: {
134
- type: BooleanConstructor;
135
- default: undefined;
136
- };
137
- fieldProps: {
138
- type: ObjectConstructor;
139
- };
140
- showProps: {
141
- type: ObjectConstructor;
142
- };
143
- slots: {
144
- type: ObjectConstructor;
145
- };
146
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
147
- readonly: {
148
- type: BooleanConstructor;
149
- default: undefined;
150
- };
151
- fieldProps: {
152
- type: ObjectConstructor;
153
- };
154
- showProps: {
155
- type: ObjectConstructor;
156
- };
157
- slots: {
158
- type: ObjectConstructor;
159
- };
160
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
161
- name: {
162
- type: vue.PropType<string | (string | number)[]>;
163
- };
164
- }>> & {
165
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
166
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
167
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
168
- } & {
169
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
170
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
171
- 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;
172
- readonly label?: string | undefined;
173
- 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;
174
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
175
- readonly error?: string | undefined;
176
- readonly for?: string | undefined;
177
- } & Partial<vue.ExtractPropTypes<{
178
- readonly: {
179
- type: BooleanConstructor;
180
- default: undefined;
181
- };
182
- fieldProps: {
183
- type: ObjectConstructor;
184
- };
185
- showProps: {
186
- type: ObjectConstructor;
187
- };
188
- slots: {
189
- type: ObjectConstructor;
190
- };
191
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
192
- readonly: {
193
- type: BooleanConstructor;
194
- default: undefined;
195
- };
196
- fieldProps: {
197
- type: ObjectConstructor;
198
- };
199
- showProps: {
200
- type: ObjectConstructor;
201
- };
202
- slots: {
203
- type: ObjectConstructor;
204
- };
205
- }>>>>, {
206
- [x: string]: any;
207
- }>;
208
- declare const ProFormDatePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
209
- name: {
210
- type: vue.PropType<string | (string | number)[]>;
211
- };
212
- }>> & {
213
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
214
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
215
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
216
- } & {
217
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
218
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
219
- 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;
220
- readonly label?: string | undefined;
221
- 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;
222
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
223
- readonly error?: string | undefined;
224
- readonly for?: string | undefined;
225
- } & Partial<vue.ExtractPropTypes<{
226
- readonly: {
227
- type: BooleanConstructor;
228
- default: undefined;
229
- };
230
- fieldProps: {
231
- type: ObjectConstructor;
232
- };
233
- showProps: {
234
- type: ObjectConstructor;
235
- };
236
- slots: {
237
- type: ObjectConstructor;
238
- };
239
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
240
- readonly: {
241
- type: BooleanConstructor;
242
- default: undefined;
243
- };
244
- fieldProps: {
245
- type: ObjectConstructor;
246
- };
247
- showProps: {
248
- type: ObjectConstructor;
249
- };
250
- slots: {
251
- type: ObjectConstructor;
252
- };
253
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
254
- name: {
255
- type: vue.PropType<string | (string | number)[]>;
256
- };
257
- }>> & {
258
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
259
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
260
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
261
- } & {
262
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
263
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
264
- 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;
265
- readonly label?: string | undefined;
266
- 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;
267
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
268
- readonly error?: string | undefined;
269
- readonly for?: string | undefined;
270
- } & Partial<vue.ExtractPropTypes<{
271
- readonly: {
272
- type: BooleanConstructor;
273
- default: undefined;
274
- };
275
- fieldProps: {
276
- type: ObjectConstructor;
277
- };
278
- showProps: {
279
- type: ObjectConstructor;
280
- };
281
- slots: {
282
- type: ObjectConstructor;
283
- };
284
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
285
- readonly: {
286
- type: BooleanConstructor;
287
- default: undefined;
288
- };
289
- fieldProps: {
290
- type: ObjectConstructor;
291
- };
292
- showProps: {
293
- type: ObjectConstructor;
294
- };
295
- slots: {
296
- type: ObjectConstructor;
297
- };
298
- }>>>>, {
299
- [x: string]: any;
300
- }>;
301
- declare const ProFormTimePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
302
- name: {
303
- type: vue.PropType<string | (string | number)[]>;
304
- };
305
- }>> & {
306
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
307
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
308
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
309
- } & {
310
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
311
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
312
- 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;
313
- readonly label?: string | undefined;
314
- 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;
315
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
316
- readonly error?: string | undefined;
317
- readonly for?: string | undefined;
318
- } & Partial<vue.ExtractPropTypes<{
319
- readonly: {
320
- type: BooleanConstructor;
321
- default: undefined;
322
- };
323
- fieldProps: {
324
- type: ObjectConstructor;
325
- };
326
- showProps: {
327
- type: ObjectConstructor;
328
- };
329
- slots: {
330
- type: ObjectConstructor;
331
- };
332
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
333
- readonly: {
334
- type: BooleanConstructor;
335
- default: undefined;
336
- };
337
- fieldProps: {
338
- type: ObjectConstructor;
339
- };
340
- showProps: {
341
- type: ObjectConstructor;
342
- };
343
- slots: {
344
- type: ObjectConstructor;
345
- };
346
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
347
- name: {
348
- type: vue.PropType<string | (string | number)[]>;
349
- };
350
- }>> & {
351
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
352
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
353
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
354
- } & {
355
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
356
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
357
- 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;
358
- readonly label?: string | undefined;
359
- 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;
360
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
361
- readonly error?: string | undefined;
362
- readonly for?: string | undefined;
363
- } & Partial<vue.ExtractPropTypes<{
364
- readonly: {
365
- type: BooleanConstructor;
366
- default: undefined;
367
- };
368
- fieldProps: {
369
- type: ObjectConstructor;
370
- };
371
- showProps: {
372
- type: ObjectConstructor;
373
- };
374
- slots: {
375
- type: ObjectConstructor;
376
- };
377
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
378
- readonly: {
379
- type: BooleanConstructor;
380
- default: undefined;
381
- };
382
- fieldProps: {
383
- type: ObjectConstructor;
384
- };
385
- showProps: {
386
- type: ObjectConstructor;
387
- };
388
- slots: {
389
- type: ObjectConstructor;
390
- };
391
- }>>>>, {
392
- [x: string]: any;
393
- }>;
394
- declare const ProFormSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
395
- name: {
396
- type: vue.PropType<string | (string | number)[]>;
397
- };
398
- }>> & {
399
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
400
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
401
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
402
- } & {
403
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
404
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
405
- 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;
406
- readonly label?: string | undefined;
407
- 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;
408
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
409
- readonly error?: string | undefined;
410
- readonly for?: string | undefined;
411
- } & Partial<vue.ExtractPropTypes<{
412
- readonly: {
413
- type: BooleanConstructor;
414
- default: undefined;
415
- };
416
- fieldProps: {
417
- type: ObjectConstructor;
418
- };
419
- showProps: {
420
- type: ObjectConstructor;
421
- };
422
- slots: {
423
- type: ObjectConstructor;
424
- };
425
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
426
- readonly: {
427
- type: BooleanConstructor;
428
- default: undefined;
429
- };
430
- fieldProps: {
431
- type: ObjectConstructor;
432
- };
433
- showProps: {
434
- type: ObjectConstructor;
435
- };
436
- slots: {
437
- type: ObjectConstructor;
438
- };
439
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
440
- name: {
441
- type: vue.PropType<string | (string | number)[]>;
442
- };
443
- }>> & {
444
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
445
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
446
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
447
- } & {
448
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
449
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
450
- 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;
451
- readonly label?: string | undefined;
452
- 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;
453
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
454
- readonly error?: string | undefined;
455
- readonly for?: string | undefined;
456
- } & Partial<vue.ExtractPropTypes<{
457
- readonly: {
458
- type: BooleanConstructor;
459
- default: undefined;
460
- };
461
- fieldProps: {
462
- type: ObjectConstructor;
463
- };
464
- showProps: {
465
- type: ObjectConstructor;
466
- };
467
- slots: {
468
- type: ObjectConstructor;
469
- };
470
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
471
- readonly: {
472
- type: BooleanConstructor;
473
- default: undefined;
474
- };
475
- fieldProps: {
476
- type: ObjectConstructor;
477
- };
478
- showProps: {
479
- type: ObjectConstructor;
480
- };
481
- slots: {
482
- type: ObjectConstructor;
483
- };
484
- }>>>>, {
485
- [x: string]: any;
486
- }>;
487
- declare const ProFormTreeSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
488
- name: {
489
- type: vue.PropType<string | (string | number)[]>;
490
- };
491
- }>> & {
492
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
493
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
494
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
495
- } & {
496
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
497
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
498
- 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;
499
- readonly label?: string | undefined;
500
- 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;
501
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
502
- readonly error?: string | undefined;
503
- readonly for?: string | undefined;
504
- } & Partial<vue.ExtractPropTypes<{
505
- readonly: {
506
- type: BooleanConstructor;
507
- default: undefined;
508
- };
509
- fieldProps: {
510
- type: ObjectConstructor;
511
- };
512
- showProps: {
513
- type: ObjectConstructor;
514
- };
515
- slots: {
516
- type: ObjectConstructor;
517
- };
518
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
519
- readonly: {
520
- type: BooleanConstructor;
521
- default: undefined;
522
- };
523
- fieldProps: {
524
- type: ObjectConstructor;
525
- };
526
- showProps: {
527
- type: ObjectConstructor;
528
- };
529
- slots: {
530
- type: ObjectConstructor;
531
- };
532
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<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 required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
542
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
543
- 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;
544
- readonly label?: string | 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 validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
547
- readonly error?: string | 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> & Partial<vue.ExtractPropTypes<{
564
- readonly: {
565
- type: BooleanConstructor;
566
- default: undefined;
567
- };
568
- fieldProps: {
569
- type: ObjectConstructor;
570
- };
571
- showProps: {
572
- type: ObjectConstructor;
573
- };
574
- slots: {
575
- type: ObjectConstructor;
576
- };
577
- }>>>>, {
578
- [x: string]: any;
579
- }>;
580
- declare const ProFormCheckbox: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
581
- name: {
582
- type: vue.PropType<string | (string | number)[]>;
583
- };
584
- }>> & {
585
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
586
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
587
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
588
- } & {
589
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
590
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
591
- 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;
592
- readonly label?: string | undefined;
593
- 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;
594
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
595
- readonly error?: string | undefined;
596
- readonly for?: string | undefined;
597
- } & Partial<vue.ExtractPropTypes<{
598
- readonly: {
599
- type: BooleanConstructor;
600
- default: undefined;
601
- };
602
- fieldProps: {
603
- type: ObjectConstructor;
604
- };
605
- showProps: {
606
- type: ObjectConstructor;
607
- };
608
- slots: {
609
- type: ObjectConstructor;
610
- };
611
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
612
- readonly: {
613
- type: BooleanConstructor;
614
- default: undefined;
615
- };
616
- fieldProps: {
617
- type: ObjectConstructor;
618
- };
619
- showProps: {
620
- type: ObjectConstructor;
621
- };
622
- slots: {
623
- type: ObjectConstructor;
624
- };
625
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
626
- name: {
627
- type: vue.PropType<string | (string | number)[]>;
628
- };
629
- }>> & {
630
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
631
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
632
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
633
- } & {
634
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
635
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
636
- 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;
637
- readonly label?: string | undefined;
638
- 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;
639
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
640
- readonly error?: string | undefined;
641
- readonly for?: string | undefined;
642
- } & Partial<vue.ExtractPropTypes<{
643
- readonly: {
644
- type: BooleanConstructor;
645
- default: undefined;
646
- };
647
- fieldProps: {
648
- type: ObjectConstructor;
649
- };
650
- showProps: {
651
- type: ObjectConstructor;
652
- };
653
- slots: {
654
- type: ObjectConstructor;
655
- };
656
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
657
- readonly: {
658
- type: BooleanConstructor;
659
- default: undefined;
660
- };
661
- fieldProps: {
662
- type: ObjectConstructor;
663
- };
664
- showProps: {
665
- type: ObjectConstructor;
666
- };
667
- slots: {
668
- type: ObjectConstructor;
669
- };
670
- }>>>>, {
671
- [x: string]: any;
672
- }>;
673
- declare const ProFormRadio: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
674
- name: {
675
- type: vue.PropType<string | (string | number)[]>;
676
- };
677
- }>> & {
678
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
679
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
680
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
681
- } & {
682
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
683
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
684
- 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;
685
- readonly label?: string | undefined;
686
- 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;
687
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
688
- readonly error?: string | undefined;
689
- readonly for?: string | undefined;
690
- } & Partial<vue.ExtractPropTypes<{
691
- readonly: {
692
- type: BooleanConstructor;
693
- default: undefined;
694
- };
695
- fieldProps: {
696
- type: ObjectConstructor;
697
- };
698
- showProps: {
699
- type: ObjectConstructor;
700
- };
701
- slots: {
702
- type: ObjectConstructor;
703
- };
704
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
705
- readonly: {
706
- type: BooleanConstructor;
707
- default: undefined;
708
- };
709
- fieldProps: {
710
- type: ObjectConstructor;
711
- };
712
- showProps: {
713
- type: ObjectConstructor;
714
- };
715
- slots: {
716
- type: ObjectConstructor;
717
- };
718
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
719
- name: {
720
- type: vue.PropType<string | (string | number)[]>;
721
- };
722
- }>> & {
723
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
724
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
725
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
726
- } & {
727
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
728
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
729
- 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;
730
- readonly label?: string | undefined;
731
- 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;
732
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
733
- readonly error?: string | undefined;
734
- readonly for?: string | undefined;
735
- } & Partial<vue.ExtractPropTypes<{
736
- readonly: {
737
- type: BooleanConstructor;
738
- default: undefined;
739
- };
740
- fieldProps: {
741
- type: ObjectConstructor;
742
- };
743
- showProps: {
744
- type: ObjectConstructor;
745
- };
746
- slots: {
747
- type: ObjectConstructor;
748
- };
749
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
750
- readonly: {
751
- type: BooleanConstructor;
752
- default: undefined;
753
- };
754
- fieldProps: {
755
- type: ObjectConstructor;
756
- };
757
- showProps: {
758
- type: ObjectConstructor;
759
- };
760
- slots: {
761
- type: ObjectConstructor;
762
- };
763
- }>>>>, {
764
- [x: string]: any;
765
- }>;
766
- declare const ProFormSwitch: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
767
- name: {
768
- type: vue.PropType<string | (string | number)[]>;
769
- };
770
- }>> & {
771
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
772
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
773
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
774
- } & {
775
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
776
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
777
- 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;
778
- readonly label?: string | undefined;
779
- 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;
780
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
781
- readonly error?: string | undefined;
782
- readonly for?: string | undefined;
783
- } & Partial<vue.ExtractPropTypes<{
784
- readonly: {
785
- type: BooleanConstructor;
786
- default: undefined;
787
- };
788
- fieldProps: {
789
- type: ObjectConstructor;
790
- };
791
- showProps: {
792
- type: ObjectConstructor;
793
- };
794
- slots: {
795
- type: ObjectConstructor;
796
- };
797
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
798
- readonly: {
799
- type: BooleanConstructor;
800
- default: undefined;
801
- };
802
- fieldProps: {
803
- type: ObjectConstructor;
804
- };
805
- showProps: {
806
- type: ObjectConstructor;
807
- };
808
- slots: {
809
- type: ObjectConstructor;
810
- };
811
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
812
- name: {
813
- type: vue.PropType<string | (string | number)[]>;
814
- };
815
- }>> & {
816
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
817
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
818
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
819
- } & {
820
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
821
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
822
- 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;
823
- readonly label?: string | undefined;
824
- 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;
825
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
826
- readonly error?: string | undefined;
827
- readonly for?: string | undefined;
828
- } & Partial<vue.ExtractPropTypes<{
829
- readonly: {
830
- type: BooleanConstructor;
831
- default: undefined;
832
- };
833
- fieldProps: {
834
- type: ObjectConstructor;
835
- };
836
- showProps: {
837
- type: ObjectConstructor;
838
- };
839
- slots: {
840
- type: ObjectConstructor;
841
- };
842
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
843
- readonly: {
844
- type: BooleanConstructor;
845
- default: undefined;
846
- };
847
- fieldProps: {
848
- type: ObjectConstructor;
849
- };
850
- showProps: {
851
- type: ObjectConstructor;
852
- };
853
- slots: {
854
- type: ObjectConstructor;
855
- };
856
- }>>>>, {
857
- [x: string]: any;
858
- }>;
859
- declare const ProFormCascader: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
860
- name: {
861
- type: vue.PropType<string | (string | number)[]>;
862
- };
863
- }>> & {
864
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
865
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
866
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
867
- } & {
868
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
869
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
870
- 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;
871
- readonly label?: string | undefined;
872
- 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;
873
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
874
- readonly error?: string | undefined;
875
- readonly for?: string | undefined;
876
- } & Partial<vue.ExtractPropTypes<{
877
- readonly: {
878
- type: BooleanConstructor;
879
- default: undefined;
880
- };
881
- fieldProps: {
882
- type: ObjectConstructor;
883
- };
884
- showProps: {
885
- type: ObjectConstructor;
886
- };
887
- slots: {
888
- type: ObjectConstructor;
889
- };
890
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
891
- readonly: {
892
- type: BooleanConstructor;
893
- default: undefined;
894
- };
895
- fieldProps: {
896
- type: ObjectConstructor;
897
- };
898
- showProps: {
899
- type: ObjectConstructor;
900
- };
901
- slots: {
902
- type: ObjectConstructor;
903
- };
904
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
905
- name: {
906
- type: vue.PropType<string | (string | number)[]>;
907
- };
908
- }>> & {
909
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
910
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
911
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
912
- } & {
913
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
914
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
915
- 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;
916
- readonly label?: string | undefined;
917
- 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;
918
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
919
- readonly error?: string | undefined;
920
- readonly for?: string | undefined;
921
- } & Partial<vue.ExtractPropTypes<{
922
- readonly: {
923
- type: BooleanConstructor;
924
- default: undefined;
925
- };
926
- fieldProps: {
927
- type: ObjectConstructor;
928
- };
929
- showProps: {
930
- type: ObjectConstructor;
931
- };
932
- slots: {
933
- type: ObjectConstructor;
934
- };
935
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
936
- readonly: {
937
- type: BooleanConstructor;
938
- default: undefined;
939
- };
940
- fieldProps: {
941
- type: ObjectConstructor;
942
- };
943
- showProps: {
944
- type: ObjectConstructor;
945
- };
946
- slots: {
947
- type: ObjectConstructor;
948
- };
949
- }>>>>, {
950
- [x: string]: any;
21
+ declare const ProFormText: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
22
+ name: {
23
+ type: vue.PropType<string | (string | number)[]>;
24
+ };
25
+ }>> & {
26
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
27
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
28
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
29
+ } & {
30
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
31
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
32
+ readonly error?: string | undefined;
33
+ readonly label?: string | undefined;
34
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
35
+ 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;
36
+ 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;
37
+ readonly for?: string | undefined;
38
+ } & Partial<vue.ExtractPropTypes<{
39
+ readonly: {
40
+ type: BooleanConstructor;
41
+ default: undefined;
42
+ };
43
+ fieldProps: {
44
+ type: ObjectConstructor;
45
+ };
46
+ showProps: {
47
+ type: ObjectConstructor;
48
+ };
49
+ slots: {
50
+ type: ObjectConstructor;
51
+ };
52
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
53
+ name: {
54
+ type: vue.PropType<string | (string | number)[]>;
55
+ };
56
+ }>> & {
57
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
58
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
59
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
60
+ } & {
61
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
62
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
63
+ readonly error?: string | undefined;
64
+ readonly label?: string | undefined;
65
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
66
+ 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;
67
+ 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;
68
+ readonly for?: string | undefined;
69
+ } & Partial<vue.ExtractPropTypes<{
70
+ readonly: {
71
+ type: BooleanConstructor;
72
+ default: undefined;
73
+ };
74
+ fieldProps: {
75
+ type: ObjectConstructor;
76
+ };
77
+ showProps: {
78
+ type: ObjectConstructor;
79
+ };
80
+ slots: {
81
+ type: ObjectConstructor;
82
+ };
83
+ }>> & Record<string, any>>>, {
84
+ [x: string]: any;
85
+ }>;
86
+ declare const ProFormTextNumber: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
87
+ name: {
88
+ type: vue.PropType<string | (string | number)[]>;
89
+ };
90
+ }>> & {
91
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
92
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
93
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
94
+ } & {
95
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
96
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
97
+ readonly error?: string | undefined;
98
+ readonly label?: string | undefined;
99
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
100
+ 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;
101
+ 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;
102
+ readonly for?: string | undefined;
103
+ } & Partial<vue.ExtractPropTypes<{
104
+ readonly: {
105
+ type: BooleanConstructor;
106
+ default: undefined;
107
+ };
108
+ fieldProps: {
109
+ type: ObjectConstructor;
110
+ };
111
+ showProps: {
112
+ type: ObjectConstructor;
113
+ };
114
+ slots: {
115
+ type: ObjectConstructor;
116
+ };
117
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
118
+ name: {
119
+ type: vue.PropType<string | (string | number)[]>;
120
+ };
121
+ }>> & {
122
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
123
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
124
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
125
+ } & {
126
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
127
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
128
+ readonly error?: string | undefined;
129
+ readonly label?: string | undefined;
130
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
131
+ 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;
132
+ 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;
133
+ readonly for?: string | undefined;
134
+ } & Partial<vue.ExtractPropTypes<{
135
+ readonly: {
136
+ type: BooleanConstructor;
137
+ default: undefined;
138
+ };
139
+ fieldProps: {
140
+ type: ObjectConstructor;
141
+ };
142
+ showProps: {
143
+ type: ObjectConstructor;
144
+ };
145
+ slots: {
146
+ type: ObjectConstructor;
147
+ };
148
+ }>> & Record<string, any>>>, {
149
+ [x: string]: any;
150
+ }>;
151
+ declare const ProFormDatePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
152
+ name: {
153
+ type: vue.PropType<string | (string | number)[]>;
154
+ };
155
+ }>> & {
156
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
157
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
158
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
159
+ } & {
160
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
161
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
162
+ readonly error?: string | undefined;
163
+ readonly label?: string | undefined;
164
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
165
+ 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;
166
+ 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;
167
+ readonly for?: string | undefined;
168
+ } & Partial<vue.ExtractPropTypes<{
169
+ readonly: {
170
+ type: BooleanConstructor;
171
+ default: undefined;
172
+ };
173
+ fieldProps: {
174
+ type: ObjectConstructor;
175
+ };
176
+ showProps: {
177
+ type: ObjectConstructor;
178
+ };
179
+ slots: {
180
+ type: ObjectConstructor;
181
+ };
182
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
183
+ name: {
184
+ type: vue.PropType<string | (string | number)[]>;
185
+ };
186
+ }>> & {
187
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
188
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
189
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
190
+ } & {
191
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
192
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
193
+ readonly error?: string | undefined;
194
+ readonly label?: string | undefined;
195
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
196
+ 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;
197
+ 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;
198
+ readonly for?: string | undefined;
199
+ } & Partial<vue.ExtractPropTypes<{
200
+ readonly: {
201
+ type: BooleanConstructor;
202
+ default: undefined;
203
+ };
204
+ fieldProps: {
205
+ type: ObjectConstructor;
206
+ };
207
+ showProps: {
208
+ type: ObjectConstructor;
209
+ };
210
+ slots: {
211
+ type: ObjectConstructor;
212
+ };
213
+ }>> & Record<string, any>>>, {
214
+ [x: string]: any;
215
+ }>;
216
+ declare const ProFormTimePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
217
+ name: {
218
+ type: vue.PropType<string | (string | number)[]>;
219
+ };
220
+ }>> & {
221
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
222
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
223
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
224
+ } & {
225
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
226
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
227
+ readonly error?: string | undefined;
228
+ readonly label?: string | undefined;
229
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
230
+ 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;
231
+ 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;
232
+ readonly for?: string | undefined;
233
+ } & Partial<vue.ExtractPropTypes<{
234
+ readonly: {
235
+ type: BooleanConstructor;
236
+ default: undefined;
237
+ };
238
+ fieldProps: {
239
+ type: ObjectConstructor;
240
+ };
241
+ showProps: {
242
+ type: ObjectConstructor;
243
+ };
244
+ slots: {
245
+ type: ObjectConstructor;
246
+ };
247
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
248
+ name: {
249
+ type: vue.PropType<string | (string | number)[]>;
250
+ };
251
+ }>> & {
252
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
253
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
254
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
255
+ } & {
256
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
257
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
258
+ readonly error?: string | undefined;
259
+ readonly label?: string | undefined;
260
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
261
+ 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;
262
+ 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;
263
+ readonly for?: string | undefined;
264
+ } & Partial<vue.ExtractPropTypes<{
265
+ readonly: {
266
+ type: BooleanConstructor;
267
+ default: undefined;
268
+ };
269
+ fieldProps: {
270
+ type: ObjectConstructor;
271
+ };
272
+ showProps: {
273
+ type: ObjectConstructor;
274
+ };
275
+ slots: {
276
+ type: ObjectConstructor;
277
+ };
278
+ }>> & Record<string, any>>>, {
279
+ [x: string]: any;
280
+ }>;
281
+ declare const ProFormSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
282
+ name: {
283
+ type: vue.PropType<string | (string | number)[]>;
284
+ };
285
+ }>> & {
286
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
287
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
288
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
289
+ } & {
290
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
291
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
292
+ readonly error?: string | undefined;
293
+ readonly label?: string | undefined;
294
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
295
+ 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;
296
+ 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;
297
+ readonly for?: string | undefined;
298
+ } & Partial<vue.ExtractPropTypes<{
299
+ readonly: {
300
+ type: BooleanConstructor;
301
+ default: undefined;
302
+ };
303
+ fieldProps: {
304
+ type: ObjectConstructor;
305
+ };
306
+ showProps: {
307
+ type: ObjectConstructor;
308
+ };
309
+ slots: {
310
+ type: ObjectConstructor;
311
+ };
312
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
313
+ name: {
314
+ type: vue.PropType<string | (string | number)[]>;
315
+ };
316
+ }>> & {
317
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
318
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
319
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
320
+ } & {
321
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
322
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
323
+ readonly error?: string | undefined;
324
+ readonly label?: string | undefined;
325
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
326
+ 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;
327
+ 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;
328
+ readonly for?: string | undefined;
329
+ } & Partial<vue.ExtractPropTypes<{
330
+ readonly: {
331
+ type: BooleanConstructor;
332
+ default: undefined;
333
+ };
334
+ fieldProps: {
335
+ type: ObjectConstructor;
336
+ };
337
+ showProps: {
338
+ type: ObjectConstructor;
339
+ };
340
+ slots: {
341
+ type: ObjectConstructor;
342
+ };
343
+ }>> & Record<string, any>>>, {
344
+ [x: string]: any;
345
+ }>;
346
+ declare const ProFormTreeSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
347
+ name: {
348
+ type: vue.PropType<string | (string | number)[]>;
349
+ };
350
+ }>> & {
351
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
352
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
353
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
354
+ } & {
355
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
356
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
357
+ readonly error?: string | undefined;
358
+ readonly label?: string | undefined;
359
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
360
+ 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;
361
+ 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;
362
+ readonly for?: string | undefined;
363
+ } & Partial<vue.ExtractPropTypes<{
364
+ readonly: {
365
+ type: BooleanConstructor;
366
+ default: undefined;
367
+ };
368
+ fieldProps: {
369
+ type: ObjectConstructor;
370
+ };
371
+ showProps: {
372
+ type: ObjectConstructor;
373
+ };
374
+ slots: {
375
+ type: ObjectConstructor;
376
+ };
377
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
378
+ name: {
379
+ type: vue.PropType<string | (string | number)[]>;
380
+ };
381
+ }>> & {
382
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
383
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
384
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
385
+ } & {
386
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
387
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
388
+ readonly error?: string | undefined;
389
+ readonly label?: string | undefined;
390
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
391
+ 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;
392
+ 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;
393
+ readonly for?: string | undefined;
394
+ } & Partial<vue.ExtractPropTypes<{
395
+ readonly: {
396
+ type: BooleanConstructor;
397
+ default: undefined;
398
+ };
399
+ fieldProps: {
400
+ type: ObjectConstructor;
401
+ };
402
+ showProps: {
403
+ type: ObjectConstructor;
404
+ };
405
+ slots: {
406
+ type: ObjectConstructor;
407
+ };
408
+ }>> & Record<string, any>>>, {
409
+ [x: string]: any;
410
+ }>;
411
+ declare const ProFormCheckbox: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
412
+ name: {
413
+ type: vue.PropType<string | (string | number)[]>;
414
+ };
415
+ }>> & {
416
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
417
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
418
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
419
+ } & {
420
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
421
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
422
+ readonly error?: string | undefined;
423
+ readonly label?: string | undefined;
424
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
425
+ 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;
426
+ 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;
427
+ readonly for?: string | undefined;
428
+ } & Partial<vue.ExtractPropTypes<{
429
+ readonly: {
430
+ type: BooleanConstructor;
431
+ default: undefined;
432
+ };
433
+ fieldProps: {
434
+ type: ObjectConstructor;
435
+ };
436
+ showProps: {
437
+ type: ObjectConstructor;
438
+ };
439
+ slots: {
440
+ type: ObjectConstructor;
441
+ };
442
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
443
+ name: {
444
+ type: vue.PropType<string | (string | number)[]>;
445
+ };
446
+ }>> & {
447
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
448
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
449
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
450
+ } & {
451
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
452
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
453
+ readonly error?: string | undefined;
454
+ readonly label?: string | undefined;
455
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
456
+ 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;
457
+ 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;
458
+ readonly for?: string | undefined;
459
+ } & Partial<vue.ExtractPropTypes<{
460
+ readonly: {
461
+ type: BooleanConstructor;
462
+ default: undefined;
463
+ };
464
+ fieldProps: {
465
+ type: ObjectConstructor;
466
+ };
467
+ showProps: {
468
+ type: ObjectConstructor;
469
+ };
470
+ slots: {
471
+ type: ObjectConstructor;
472
+ };
473
+ }>> & Record<string, any>>>, {
474
+ [x: string]: any;
475
+ }>;
476
+ declare const ProFormRadio: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
477
+ name: {
478
+ type: vue.PropType<string | (string | number)[]>;
479
+ };
480
+ }>> & {
481
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
482
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
483
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
484
+ } & {
485
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
486
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
487
+ readonly error?: string | undefined;
488
+ readonly label?: string | undefined;
489
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
490
+ 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;
491
+ 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;
492
+ readonly for?: string | undefined;
493
+ } & Partial<vue.ExtractPropTypes<{
494
+ readonly: {
495
+ type: BooleanConstructor;
496
+ default: undefined;
497
+ };
498
+ fieldProps: {
499
+ type: ObjectConstructor;
500
+ };
501
+ showProps: {
502
+ type: ObjectConstructor;
503
+ };
504
+ slots: {
505
+ type: ObjectConstructor;
506
+ };
507
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
508
+ name: {
509
+ type: vue.PropType<string | (string | number)[]>;
510
+ };
511
+ }>> & {
512
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
513
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
514
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
515
+ } & {
516
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
517
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
518
+ readonly error?: string | undefined;
519
+ readonly label?: string | undefined;
520
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
521
+ 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;
522
+ 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;
523
+ readonly for?: string | undefined;
524
+ } & Partial<vue.ExtractPropTypes<{
525
+ readonly: {
526
+ type: BooleanConstructor;
527
+ default: undefined;
528
+ };
529
+ fieldProps: {
530
+ type: ObjectConstructor;
531
+ };
532
+ showProps: {
533
+ type: ObjectConstructor;
534
+ };
535
+ slots: {
536
+ type: ObjectConstructor;
537
+ };
538
+ }>> & Record<string, any>>>, {
539
+ [x: string]: any;
540
+ }>;
541
+ declare const ProFormSwitch: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
542
+ name: {
543
+ type: vue.PropType<string | (string | number)[]>;
544
+ };
545
+ }>> & {
546
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
547
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
548
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
549
+ } & {
550
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
551
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
552
+ readonly error?: string | undefined;
553
+ readonly label?: string | undefined;
554
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
555
+ 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;
556
+ 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;
557
+ readonly for?: string | undefined;
558
+ } & Partial<vue.ExtractPropTypes<{
559
+ readonly: {
560
+ type: BooleanConstructor;
561
+ default: undefined;
562
+ };
563
+ fieldProps: {
564
+ type: ObjectConstructor;
565
+ };
566
+ showProps: {
567
+ type: ObjectConstructor;
568
+ };
569
+ slots: {
570
+ type: ObjectConstructor;
571
+ };
572
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
573
+ name: {
574
+ type: vue.PropType<string | (string | number)[]>;
575
+ };
576
+ }>> & {
577
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
578
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
579
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
580
+ } & {
581
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
582
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
583
+ readonly error?: string | undefined;
584
+ readonly label?: string | undefined;
585
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
586
+ 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;
587
+ 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;
588
+ readonly for?: string | undefined;
589
+ } & Partial<vue.ExtractPropTypes<{
590
+ readonly: {
591
+ type: BooleanConstructor;
592
+ default: undefined;
593
+ };
594
+ fieldProps: {
595
+ type: ObjectConstructor;
596
+ };
597
+ showProps: {
598
+ type: ObjectConstructor;
599
+ };
600
+ slots: {
601
+ type: ObjectConstructor;
602
+ };
603
+ }>> & Record<string, any>>>, {
604
+ [x: string]: any;
605
+ }>;
606
+ declare const ProFormCascader: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
607
+ name: {
608
+ type: vue.PropType<string | (string | number)[]>;
609
+ };
610
+ }>> & {
611
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
612
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
613
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
614
+ } & {
615
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
616
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
617
+ readonly error?: string | undefined;
618
+ readonly label?: string | undefined;
619
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
620
+ 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;
621
+ 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;
622
+ readonly for?: string | undefined;
623
+ } & Partial<vue.ExtractPropTypes<{
624
+ readonly: {
625
+ type: BooleanConstructor;
626
+ default: undefined;
627
+ };
628
+ fieldProps: {
629
+ type: ObjectConstructor;
630
+ };
631
+ showProps: {
632
+ type: ObjectConstructor;
633
+ };
634
+ slots: {
635
+ type: ObjectConstructor;
636
+ };
637
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
638
+ name: {
639
+ type: vue.PropType<string | (string | number)[]>;
640
+ };
641
+ }>> & {
642
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
643
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
644
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
645
+ } & {
646
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
647
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
648
+ readonly error?: string | undefined;
649
+ readonly label?: string | undefined;
650
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
651
+ 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;
652
+ 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;
653
+ readonly for?: string | undefined;
654
+ } & Partial<vue.ExtractPropTypes<{
655
+ readonly: {
656
+ type: BooleanConstructor;
657
+ default: undefined;
658
+ };
659
+ fieldProps: {
660
+ type: ObjectConstructor;
661
+ };
662
+ showProps: {
663
+ type: ObjectConstructor;
664
+ };
665
+ slots: {
666
+ type: ObjectConstructor;
667
+ };
668
+ }>> & Record<string, any>>>, {
669
+ [x: string]: any;
951
670
  }>;
952
671
 
953
- declare const createFormItemComponent: ({ InputComp, valueType, name }: {
954
- InputComp: any;
955
- valueType: string;
956
- name?: string | undefined;
957
- }) => vue.DefineComponent<Partial<vue.ExtractPropTypes<{
958
- name: {
959
- type: vue.PropType<string | (string | number)[]>;
960
- };
961
- }>> & {
962
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
963
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
964
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
965
- } & {
966
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
967
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
968
- 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;
969
- readonly label?: string | undefined;
970
- 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;
971
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
972
- readonly error?: string | undefined;
973
- readonly for?: string | undefined;
974
- } & Partial<vue.ExtractPropTypes<{
975
- readonly: {
976
- type: BooleanConstructor;
977
- default: undefined;
978
- };
979
- fieldProps: {
980
- type: ObjectConstructor;
981
- };
982
- showProps: {
983
- type: ObjectConstructor;
984
- };
985
- slots: {
986
- type: ObjectConstructor;
987
- };
988
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
989
- readonly: {
990
- type: BooleanConstructor;
991
- default: undefined;
992
- };
993
- fieldProps: {
994
- type: ObjectConstructor;
995
- };
996
- showProps: {
997
- type: ObjectConstructor;
998
- };
999
- slots: {
1000
- type: ObjectConstructor;
1001
- };
1002
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
1003
- name: {
1004
- type: vue.PropType<string | (string | number)[]>;
1005
- };
1006
- }>> & {
1007
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1008
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1009
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1010
- } & {
1011
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1012
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
1013
- 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;
1014
- readonly label?: string | undefined;
1015
- 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;
1016
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
1017
- readonly error?: string | undefined;
1018
- readonly for?: string | undefined;
1019
- } & Partial<vue.ExtractPropTypes<{
1020
- readonly: {
1021
- type: BooleanConstructor;
1022
- default: undefined;
1023
- };
1024
- fieldProps: {
1025
- type: ObjectConstructor;
1026
- };
1027
- showProps: {
1028
- type: ObjectConstructor;
1029
- };
1030
- slots: {
1031
- type: ObjectConstructor;
1032
- };
1033
- }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
1034
- readonly: {
1035
- type: BooleanConstructor;
1036
- default: undefined;
1037
- };
1038
- fieldProps: {
1039
- type: ObjectConstructor;
1040
- };
1041
- showProps: {
1042
- type: ObjectConstructor;
1043
- };
1044
- slots: {
1045
- type: ObjectConstructor;
1046
- };
1047
- }>>>>, {
1048
- [x: string]: any;
672
+ declare const createFormItemComponent: ({ InputComp, valueType, name }: {
673
+ InputComp: any;
674
+ valueType: string;
675
+ name?: string | undefined;
676
+ }) => vue.DefineComponent<Partial<vue.ExtractPropTypes<{
677
+ name: {
678
+ type: vue.PropType<string | (string | number)[]>;
679
+ };
680
+ }>> & {
681
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
682
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
683
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
684
+ } & {
685
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
686
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
687
+ readonly error?: string | undefined;
688
+ readonly label?: string | undefined;
689
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
690
+ 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;
691
+ 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;
692
+ readonly for?: string | undefined;
693
+ } & Partial<vue.ExtractPropTypes<{
694
+ readonly: {
695
+ type: BooleanConstructor;
696
+ default: undefined;
697
+ };
698
+ fieldProps: {
699
+ type: ObjectConstructor;
700
+ };
701
+ showProps: {
702
+ type: ObjectConstructor;
703
+ };
704
+ slots: {
705
+ type: ObjectConstructor;
706
+ };
707
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
708
+ name: {
709
+ type: vue.PropType<string | (string | number)[]>;
710
+ };
711
+ }>> & {
712
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
713
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
714
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
715
+ } & {
716
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
717
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
718
+ readonly error?: string | undefined;
719
+ readonly label?: string | undefined;
720
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
721
+ 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;
722
+ 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;
723
+ readonly for?: string | undefined;
724
+ } & Partial<vue.ExtractPropTypes<{
725
+ readonly: {
726
+ type: BooleanConstructor;
727
+ default: undefined;
728
+ };
729
+ fieldProps: {
730
+ type: ObjectConstructor;
731
+ };
732
+ showProps: {
733
+ type: ObjectConstructor;
734
+ };
735
+ slots: {
736
+ type: ObjectConstructor;
737
+ };
738
+ }>> & Record<string, any>>>, {
739
+ [x: string]: any;
1049
740
  }>;
1050
741
 
1051
- declare type TOption = {
1052
- label?: string;
1053
- value: string | number;
1054
- disabled?: boolean;
1055
- };
1056
- declare type TOptions = TOption[];
1057
- interface TableColumnCtx<T> {
1058
- id?: string;
1059
- realWidth?: number;
1060
- type?: string;
1061
- /********* title兼容 ********/
1062
- label?: string;
1063
- renderHeader?: (data: {
1064
- column: TableColumnCtx<T>;
1065
- $index: number;
1066
- }) => VNode;
1067
- title?: string | VNode;
1068
- /********* dataIndex兼容 ********/
1069
- prop?: string;
1070
- dataIndex?: string | number;
1071
- className?: string;
1072
- labelClassName?: string;
1073
- property?: string;
1074
- width?: string | number;
1075
- minWidth?: string | number;
1076
- sortable?: boolean | string;
1077
- sortMethod?: (a: T, b: T) => number;
1078
- sortBy?: string | ((row: T, index: number) => string) | string[];
1079
- resizable?: boolean;
1080
- columnKey?: string;
1081
- rawColumnKey?: string;
1082
- align?: string;
1083
- headerAlign?: string;
1084
- showTooltipWhenOverflow?: boolean;
1085
- showOverflowTooltip?: boolean;
1086
- fixed?: boolean | string;
1087
- formatter?: (row: T, column: TableColumnCtx<T>, cellValue: any, index: number) => VNode | string;
1088
- customRender?: (opt: {
1089
- value: any;
1090
- text: any;
1091
- record: T;
1092
- index: number;
1093
- column: TableColumnCtx<T>;
1094
- }) => VNode | string | null;
1095
- selectable?: (row: T, index: number) => boolean;
1096
- reserveSelection?: boolean;
1097
- filterMethod?: FilterMethods<T>;
1098
- filteredValue?: string[];
1099
- filters?: Filters;
1100
- filterPlacement?: string;
1101
- filterMultiple?: boolean;
1102
- index?: number | ((index: number) => number);
1103
- sortOrders?: ("ascending" | "descending" | null)[];
1104
- renderCell?: (data: any) => void;
1105
- colSpan?: number;
1106
- rowSpan?: number;
1107
- children?: TableColumnCtx<T>[];
1108
- level?: number;
1109
- filterable?: boolean | FilterMethods<T> | Filters;
1110
- order?: string;
1111
- isColumnGroup?: boolean;
1112
- isSubColumn?: boolean;
1113
- columns?: TableColumnCtx<T>[];
1114
- getColumnIndex?: () => number;
1115
- no?: number;
1116
- filterOpened?: boolean;
742
+ interface TableColumnCtx<T> {
743
+ id?: string;
744
+ realWidth?: number;
745
+ type?: string;
746
+ /********* title兼容 ********/
747
+ label?: string;
748
+ renderHeader?: (data: {
749
+ column: TableColumnCtx<T>;
750
+ $index: number;
751
+ }) => VNode;
752
+ title?: string | VNode;
753
+ /********* dataIndex兼容 ********/
754
+ prop?: string;
755
+ dataIndex?: string | number;
756
+ className?: string;
757
+ labelClassName?: string;
758
+ property?: string;
759
+ width?: string | number;
760
+ minWidth?: string | number;
761
+ sortable?: boolean | string;
762
+ sortMethod?: (a: T, b: T) => number;
763
+ sortBy?: string | ((row: T, index: number) => string) | string[];
764
+ resizable?: boolean;
765
+ columnKey?: string;
766
+ rawColumnKey?: string;
767
+ align?: string;
768
+ headerAlign?: string;
769
+ showTooltipWhenOverflow?: boolean;
770
+ showOverflowTooltip?: boolean;
771
+ fixed?: boolean | string;
772
+ formatter?: (row: T, column: TableColumnCtx<T>, cellValue: any, index: number) => VNode | string;
773
+ customRender?: (opt: {
774
+ value: any;
775
+ text: any;
776
+ record: T;
777
+ index: number;
778
+ column: TableColumnCtx<T>;
779
+ }) => VNode | string | null;
780
+ selectable?: (row: T, index: number) => boolean;
781
+ reserveSelection?: boolean;
782
+ filterMethod?: FilterMethods<T>;
783
+ filteredValue?: string[];
784
+ filters?: Filters;
785
+ filterPlacement?: string;
786
+ filterMultiple?: boolean;
787
+ index?: number | ((index: number) => number);
788
+ sortOrders?: ("ascending" | "descending" | null)[];
789
+ renderCell?: (data: any) => void;
790
+ colSpan?: number;
791
+ rowSpan?: number;
792
+ children?: TableColumnCtx<T>[];
793
+ level?: number;
794
+ filterable?: boolean | FilterMethods<T> | Filters;
795
+ order?: string;
796
+ isColumnGroup?: boolean;
797
+ isSubColumn?: boolean;
798
+ columns?: TableColumnCtx<T>[];
799
+ getColumnIndex?: () => number;
800
+ no?: number;
801
+ filterOpened?: boolean;
1117
802
  }
1118
803
 
1119
- declare type ProTableColumnProps = TableColumnCtx<any>;
1120
- declare const ProTableColumn: vue.DefineComponent<ProTableColumnProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProTableColumnProps>, {}>;
1121
- declare const TableMethods: string[];
1122
- 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>, {} | {
1123
- [x: string]: any;
804
+ declare type ProTableColumnProps = TableColumnCtx<any>;
805
+ declare const ProTableColumn: vue.DefineComponent<ProTableColumnProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProTableColumnProps>, {}>;
806
+ declare const TableMethods: string[];
807
+ 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>, {} | {
808
+ [x: string]: any;
1124
809
  }>;
1125
810
 
1126
- declare const createLoadingId: (prefix?: string) => string;
1127
- declare const proLoadingProps: () => {
1128
- loading: {
1129
- type: BooleanConstructor;
1130
- };
1131
- target: {
1132
- type: PropType<string | HTMLElement>;
1133
- };
1134
- body: {
1135
- type: BooleanConstructor;
1136
- };
1137
- fullscreen: {
1138
- type: BooleanConstructor;
1139
- };
1140
- lock: {
1141
- type: BooleanConstructor;
1142
- };
1143
- text: {
1144
- type: StringConstructor;
1145
- };
1146
- spinner: {
1147
- type: StringConstructor;
1148
- };
1149
- background: {
1150
- type: StringConstructor;
1151
- };
1152
- customClass: {
1153
- type: StringConstructor;
1154
- };
1155
- };
1156
- declare type ProLoadingProps = Partial<ExtractPropTypes<ReturnType<typeof proLoadingProps>>>;
1157
- declare const ProLoading: vue.DefineComponent<Partial<ExtractPropTypes<{
1158
- loading: {
1159
- type: BooleanConstructor;
1160
- };
1161
- target: {
1162
- type: PropType<string | HTMLElement>;
1163
- };
1164
- body: {
1165
- type: BooleanConstructor;
1166
- };
1167
- fullscreen: {
1168
- type: BooleanConstructor;
1169
- };
1170
- lock: {
1171
- type: BooleanConstructor;
1172
- };
1173
- text: {
1174
- type: StringConstructor;
1175
- };
1176
- spinner: {
1177
- type: StringConstructor;
1178
- };
1179
- background: {
1180
- type: StringConstructor;
1181
- };
1182
- customClass: {
1183
- type: StringConstructor;
1184
- };
1185
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
1186
- loading: {
1187
- type: BooleanConstructor;
1188
- };
1189
- target: {
1190
- type: PropType<string | HTMLElement>;
1191
- };
1192
- body: {
1193
- type: BooleanConstructor;
1194
- };
1195
- fullscreen: {
1196
- type: BooleanConstructor;
1197
- };
1198
- lock: {
1199
- type: BooleanConstructor;
1200
- };
1201
- text: {
1202
- type: StringConstructor;
1203
- };
1204
- spinner: {
1205
- type: StringConstructor;
1206
- };
1207
- background: {
1208
- type: StringConstructor;
1209
- };
1210
- customClass: {
1211
- type: StringConstructor;
1212
- };
811
+ declare const createLoadingId: (prefix?: string) => string;
812
+ declare const proLoadingProps: () => {
813
+ loading: {
814
+ type: BooleanConstructor;
815
+ };
816
+ target: {
817
+ type: PropType<string | HTMLElement>;
818
+ };
819
+ body: {
820
+ type: BooleanConstructor;
821
+ };
822
+ fullscreen: {
823
+ type: BooleanConstructor;
824
+ };
825
+ lock: {
826
+ type: BooleanConstructor;
827
+ };
828
+ text: {
829
+ type: StringConstructor;
830
+ };
831
+ spinner: {
832
+ type: StringConstructor;
833
+ };
834
+ background: {
835
+ type: StringConstructor;
836
+ };
837
+ customClass: {
838
+ type: StringConstructor;
839
+ };
840
+ };
841
+ declare type ProLoadingProps = Partial<ExtractPropTypes<ReturnType<typeof proLoadingProps>>>;
842
+ declare const ProLoading: vue.DefineComponent<Partial<ExtractPropTypes<{
843
+ loading: {
844
+ type: BooleanConstructor;
845
+ };
846
+ target: {
847
+ type: PropType<string | HTMLElement>;
848
+ };
849
+ body: {
850
+ type: BooleanConstructor;
851
+ };
852
+ fullscreen: {
853
+ type: BooleanConstructor;
854
+ };
855
+ lock: {
856
+ type: BooleanConstructor;
857
+ };
858
+ text: {
859
+ type: StringConstructor;
860
+ };
861
+ spinner: {
862
+ type: StringConstructor;
863
+ };
864
+ background: {
865
+ type: StringConstructor;
866
+ };
867
+ customClass: {
868
+ type: StringConstructor;
869
+ };
870
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
871
+ loading: {
872
+ type: BooleanConstructor;
873
+ };
874
+ target: {
875
+ type: PropType<string | HTMLElement>;
876
+ };
877
+ body: {
878
+ type: BooleanConstructor;
879
+ };
880
+ fullscreen: {
881
+ type: BooleanConstructor;
882
+ };
883
+ lock: {
884
+ type: BooleanConstructor;
885
+ };
886
+ text: {
887
+ type: StringConstructor;
888
+ };
889
+ spinner: {
890
+ type: StringConstructor;
891
+ };
892
+ background: {
893
+ type: StringConstructor;
894
+ };
895
+ customClass: {
896
+ type: StringConstructor;
897
+ };
1213
898
  }>>>, {}>;
1214
899
 
1215
- declare const proModalProps: () => {
1216
- /**
1217
- * class名称
1218
- */
1219
- clsName: {
1220
- type: StringConstructor;
1221
- default: string;
1222
- };
1223
- visible: {
1224
- type: BooleanConstructor;
1225
- default: boolean;
1226
- };
1227
- cancelText: {
1228
- type: StringConstructor;
1229
- default: string;
1230
- };
1231
- cancelButtonProps: {
1232
- type: PropType<{
1233
- readonly type: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "success" | "warning" | "text" | "danger" | "info" | "primary", unknown>;
1234
- readonly link: boolean;
1235
- readonly loading: boolean;
1236
- readonly disabled: boolean;
1237
- readonly text: boolean;
1238
- readonly autofocus: boolean;
1239
- 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>;
1240
- readonly circle: boolean;
1241
- 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>;
1242
- readonly nativeType: element_plus_es_utils.EpPropMergeType<StringConstructor, "submit" | "button" | "reset", unknown>;
1243
- readonly plain: boolean;
1244
- readonly bg: boolean;
1245
- readonly round: boolean;
1246
- readonly dark: boolean;
1247
- } & {
1248
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never> | undefined;
1249
- readonly color?: string | undefined;
1250
- readonly autoInsertSpace?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1251
- } & {
1252
- onClick?: (() => void) | undefined;
1253
- }>;
1254
- };
1255
- okText: {
1256
- type: StringConstructor;
1257
- default: string;
1258
- };
1259
- okButtonProps: {
1260
- type: PropType<{
1261
- readonly type: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "success" | "warning" | "text" | "danger" | "info" | "primary", unknown>;
1262
- readonly link: boolean;
1263
- readonly loading: boolean;
1264
- readonly disabled: boolean;
1265
- readonly text: boolean;
1266
- readonly autofocus: boolean;
1267
- 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>;
1268
- readonly circle: boolean;
1269
- 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>;
1270
- readonly nativeType: element_plus_es_utils.EpPropMergeType<StringConstructor, "submit" | "button" | "reset", unknown>;
1271
- readonly plain: boolean;
1272
- readonly bg: boolean;
1273
- readonly round: boolean;
1274
- readonly dark: boolean;
1275
- } & {
1276
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never> | undefined;
1277
- readonly color?: string | undefined;
1278
- readonly autoInsertSpace?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1279
- } & {
1280
- onClick?: (() => void) | undefined;
1281
- }>;
1282
- };
1283
- confirmLoading: BooleanConstructor;
1284
- footer: {
1285
- type: BooleanConstructor;
1286
- default: boolean;
1287
- };
1288
- maskClosable: {
1289
- type: (BooleanConstructor | ObjectConstructor)[];
1290
- default: undefined;
1291
- };
1292
- };
1293
- declare type ProModalProps = Partial<ExtractPropTypes<ReturnType<typeof proModalProps>>> & DialogProps;
900
+ declare const proModalProps: () => {
901
+ /**
902
+ * class名称
903
+ */
904
+ clsName: {
905
+ type: StringConstructor;
906
+ default: string;
907
+ };
908
+ visible: {
909
+ type: BooleanConstructor;
910
+ default: boolean;
911
+ };
912
+ cancelText: {
913
+ type: StringConstructor;
914
+ default: string;
915
+ };
916
+ cancelButtonProps: {
917
+ type: PropType<{
918
+ readonly type: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "text" | "primary" | "success" | "warning" | "danger" | "info", unknown>;
919
+ readonly link: boolean;
920
+ readonly loading: boolean;
921
+ readonly text: boolean;
922
+ readonly circle: boolean;
923
+ readonly disabled: boolean;
924
+ readonly autofocus: boolean;
925
+ 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>;
926
+ 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>;
927
+ readonly nativeType: element_plus_es_utils.EpPropMergeType<StringConstructor, "reset" | "submit" | "button", unknown>;
928
+ readonly plain: boolean;
929
+ readonly bg: boolean;
930
+ readonly round: boolean;
931
+ readonly dark: boolean;
932
+ } & {
933
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never> | undefined;
934
+ readonly color?: string | undefined;
935
+ readonly autoInsertSpace?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
936
+ } & {
937
+ onClick?: (() => void) | undefined;
938
+ }>;
939
+ };
940
+ okText: {
941
+ type: StringConstructor;
942
+ default: string;
943
+ };
944
+ okButtonProps: {
945
+ type: PropType<{
946
+ readonly type: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "text" | "primary" | "success" | "warning" | "danger" | "info", unknown>;
947
+ readonly link: boolean;
948
+ readonly loading: boolean;
949
+ readonly text: boolean;
950
+ readonly circle: boolean;
951
+ readonly disabled: boolean;
952
+ readonly autofocus: boolean;
953
+ 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>;
954
+ 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>;
955
+ readonly nativeType: element_plus_es_utils.EpPropMergeType<StringConstructor, "reset" | "submit" | "button", unknown>;
956
+ readonly plain: boolean;
957
+ readonly bg: boolean;
958
+ readonly round: boolean;
959
+ readonly dark: boolean;
960
+ } & {
961
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never> | undefined;
962
+ readonly color?: string | undefined;
963
+ readonly autoInsertSpace?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
964
+ } & {
965
+ onClick?: (() => void) | undefined;
966
+ }>;
967
+ };
968
+ confirmLoading: BooleanConstructor;
969
+ footer: {
970
+ type: BooleanConstructor;
971
+ default: boolean;
972
+ };
973
+ maskClosable: {
974
+ type: (BooleanConstructor | ObjectConstructor)[];
975
+ default: undefined;
976
+ };
977
+ };
978
+ declare type ProModalProps = Partial<ExtractPropTypes<ReturnType<typeof proModalProps>>> & DialogProps;
1294
979
  declare const ProModal: vue.DefineComponent<ProModalProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProModalProps>, {}>;
1295
980
 
1296
- 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>, {} | {
1297
- [x: string]: any;
981
+ 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>, {} | {
982
+ [x: string]: any;
1298
983
  }>;
1299
984
 
1300
- 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>, {} | {
1301
- [x: string]: any;
985
+ 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>, {} | {
986
+ [x: string]: any;
1302
987
  }>;
1303
988
 
1304
- declare const proSelectProps: () => {
1305
- options: PropType<TOptions>;
1306
- };
1307
- declare type ProSelectProps = Partial<ExtractPropTypes<ReturnType<typeof proSelectProps>>> & typeof ElSelect.props;
1308
- declare const ProSelect: vue.DefineComponent<any, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
1309
- [x: string]: any;
989
+ declare const proCheckboxProps: () => {
990
+ options: PropType<(TOption & {
991
+ disabled: boolean;
992
+ checked: boolean;
993
+ indeterminate: boolean;
994
+ border: boolean;
995
+ validateEvent: boolean;
996
+ } & {
997
+ size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never> | undefined;
998
+ label?: string | number | boolean | Record<string, any> | undefined;
999
+ name?: string | undefined;
1000
+ id?: string | undefined;
1001
+ tabindex?: string | number | undefined;
1002
+ controls?: string | undefined;
1003
+ modelValue?: string | number | boolean | undefined;
1004
+ trueLabel?: string | number | undefined;
1005
+ falseLabel?: string | number | undefined;
1006
+ })[]>;
1007
+ buttonStyle: {
1008
+ type: PropType<"default" | "button">;
1009
+ default: string;
1010
+ };
1011
+ };
1012
+ declare type ProCheckboxProps = Partial<ExtractPropTypes<ReturnType<typeof proCheckboxProps>>> & IUseCheckboxGroupProps;
1013
+ declare const ProCheckbox: vue.DefineComponent<ProCheckboxProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProCheckboxProps>, {}>;
1014
+
1015
+ declare const proRadioProps: () => {
1016
+ options: {
1017
+ type: PropType<(TOption & {
1018
+ readonly label: element_plus_es_utils.EpPropMergeType<(BooleanConstructor | StringConstructor | NumberConstructor)[], unknown, unknown>;
1019
+ readonly name: string;
1020
+ readonly disabled: boolean;
1021
+ readonly modelValue: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>;
1022
+ readonly border: boolean;
1023
+ } & {
1024
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never> | undefined;
1025
+ } & {
1026
+ readonly label: element_plus_es_utils.EpPropMergeType<(BooleanConstructor | StringConstructor | NumberConstructor)[], unknown, unknown>;
1027
+ readonly name: string;
1028
+ readonly disabled: boolean;
1029
+ } & {
1030
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never> | undefined;
1031
+ })[]>;
1032
+ };
1033
+ buttonStyle: {
1034
+ type: PropType<"default" | "button">;
1035
+ default: string;
1036
+ };
1037
+ };
1038
+ declare type ProRadioProps = Partial<ExtractPropTypes<ReturnType<typeof proRadioProps>>> & Record<string, any>;
1039
+ declare const ProRadio: vue.DefineComponent<ProRadioProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<ProRadioProps>>, {
1040
+ [x: string]: any;
1310
1041
  }>;
1311
1042
 
1312
- declare const proRadioProps: () => {
1313
- options: {
1314
- type: PropType<TOptions$1>;
1315
- };
1316
- buttonStyle: {
1317
- type: PropType<"default" | "button">;
1318
- default: string;
1319
- };
1320
- };
1321
- declare type ProRadioProps = Partial<ExtractPropTypes<ReturnType<typeof proRadioProps>>> & Partial<RadioGroupProps>;
1322
- declare const ProRadio: vue.DefineComponent<ProRadioProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProRadioProps>, {}>;
1043
+ declare const proSelectProps: () => {
1044
+ options: PropType<(TOption & {
1045
+ created: boolean;
1046
+ disabled: boolean;
1047
+ hovering: boolean;
1048
+ selected: boolean;
1049
+ } & {
1050
+ style?: Record<string, any> | undefined;
1051
+ data?: unknown[] | undefined;
1052
+ index?: number | undefined;
1053
+ item?: Record<string, any> | undefined;
1054
+ })[]>;
1055
+ };
1056
+ declare type ProSelectProps = Partial<ExtractPropTypes<ReturnType<typeof proSelectProps>>> & ISelectProps;
1057
+ declare const ProSelect: vue.DefineComponent<ProSelectProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProSelectProps>, {
1058
+ modelValue?: any;
1059
+ }>;
1323
1060
 
1324
- declare const proCheckboxProps: () => {
1325
- options: PropType<TOptions>;
1326
- };
1327
- declare type ProCheckboxProps = Partial<ExtractPropTypes<ReturnType<typeof proCheckboxProps>>> & typeof ElCheckboxGroup.props;
1328
- declare const ProCheckbox: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
1329
- [x: string]: any;
1061
+ 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>, {} | {
1062
+ [x: string]: any;
1330
1063
  }>;
1331
1064
 
1332
- export { FormMethods, ProCheckbox, ProCheckboxProps, ProForm, ProFormCascader, ProFormCheckbox, ProFormDatePicker, ProFormItem, ProFormItemProps, ProFormRadio, ProFormSelect, ProFormSwitch, ProFormText, ProFormTextNumber, ProFormTimePicker, ProFormTreeSelect, ProLoading, ProLoadingProps, ProModal, ProModalProps, ProPagination, ProPopover, ProRadio, ProRadioProps, ProSelect, ProSelectProps, ProTable, ProTableColumn, ProTableColumnProps, TableMethods, createFormItemComponent, createLoadingId };
1065
+ export { FormMethods, ProCheckbox, ProCheckboxProps, ProForm, ProFormCascader, ProFormCheckbox, ProFormDatePicker, ProFormItem, ProFormItemProps, ProFormRadio, ProFormSelect, ProFormSwitch, ProFormText, ProFormTextNumber, ProFormTimePicker, ProFormTreeSelect, ProLoading, ProLoadingProps, ProModal, ProModalProps, ProPagination, ProPopover, ProRadio, ProRadioProps, ProSelect, ProSelectProps, ProTable, ProTableColumn, ProTableColumnProps, ProTabs, TableMethods, createFormItemComponent, createLoadingId };