@vue-start/element-pro 0.2.17 → 0.2.19

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