@vue-start/element-pro 0.2.7 → 0.2.8

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