@vue-start/element-pro 0.2.6 → 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 +802 -578
  2. package/dist/index.es.js +395 -337
  3. package/dist/index.js +1 -1
  4. package/package.json +2 -2
package/dist/index.d.ts CHANGED
@@ -1,263 +1,23 @@
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 } 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
10
  declare const proFormItemProps: () => {
231
11
  name: {
232
12
  type: PropType<string | (string | number)[]>;
233
13
  };
234
14
  };
235
15
  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
- }
16
+ declare const ProFormItem: vue.DefineComponent<ProFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormItemProps>, {}>;
253
17
  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>;
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;
20
+ }>;
261
21
 
262
22
  declare const ProFormText: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
263
23
  name: {
@@ -268,13 +28,13 @@ declare const ProFormText: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
268
28
  readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
269
29
  readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
270
30
  } & {
271
- readonly label?: string | undefined;
272
31
  readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
273
- readonly error?: string | undefined;
274
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
32
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
275
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;
276
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
34
+ readonly label?: string | undefined;
277
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;
278
38
  readonly for?: string | undefined;
279
39
  } & Partial<vue.ExtractPropTypes<{
280
40
  readonly: {
@@ -290,24 +50,7 @@ declare const ProFormText: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
290
50
  slots: {
291
51
  type: ObjectConstructor;
292
52
  };
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 label?: string | undefined;
303
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
304
- readonly error?: 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, "" | "small" | "default" | "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<{
53
+ }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
311
54
  readonly: {
312
55
  type: BooleanConstructor;
313
56
  default: undefined;
@@ -321,10 +64,7 @@ declare const ProFormText: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
321
64
  slots: {
322
65
  type: ObjectConstructor;
323
66
  };
324
- }>> & Record<string, any>>>, {
325
- [x: string]: any;
326
- }>;
327
- declare const ProFormTextNumber: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
67
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
328
68
  name: {
329
69
  type: vue.PropType<string | (string | number)[]>;
330
70
  };
@@ -333,13 +73,13 @@ declare const ProFormTextNumber: vue.DefineComponent<Partial<vue.ExtractPropType
333
73
  readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
334
74
  readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
335
75
  } & {
336
- readonly label?: string | undefined;
337
76
  readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
338
- readonly error?: string | undefined;
339
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
77
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
340
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;
341
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
79
+ readonly label?: string | undefined;
342
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;
343
83
  readonly for?: string | undefined;
344
84
  } & Partial<vue.ExtractPropTypes<{
345
85
  readonly: {
@@ -355,24 +95,7 @@ declare const ProFormTextNumber: vue.DefineComponent<Partial<vue.ExtractPropType
355
95
  slots: {
356
96
  type: ObjectConstructor;
357
97
  };
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 label?: string | undefined;
368
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
369
- readonly error?: 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, "" | "small" | "default" | "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<{
98
+ }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
376
99
  readonly: {
377
100
  type: BooleanConstructor;
378
101
  default: undefined;
@@ -386,10 +109,10 @@ declare const ProFormTextNumber: vue.DefineComponent<Partial<vue.ExtractPropType
386
109
  slots: {
387
110
  type: ObjectConstructor;
388
111
  };
389
- }>> & Record<string, any>>>, {
112
+ }>>>>, {
390
113
  [x: string]: any;
391
114
  }>;
392
- declare const ProFormDatePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
115
+ declare const ProFormTextNumber: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
393
116
  name: {
394
117
  type: vue.PropType<string | (string | number)[]>;
395
118
  };
@@ -398,13 +121,13 @@ declare const ProFormDatePicker: vue.DefineComponent<Partial<vue.ExtractPropType
398
121
  readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
399
122
  readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
400
123
  } & {
401
- readonly label?: string | undefined;
402
124
  readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
403
- readonly error?: string | undefined;
404
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
125
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
405
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;
406
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
127
+ readonly label?: string | undefined;
407
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;
408
131
  readonly for?: string | undefined;
409
132
  } & Partial<vue.ExtractPropTypes<{
410
133
  readonly: {
@@ -420,24 +143,7 @@ declare const ProFormDatePicker: vue.DefineComponent<Partial<vue.ExtractPropType
420
143
  slots: {
421
144
  type: ObjectConstructor;
422
145
  };
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 label?: string | undefined;
433
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
434
- readonly error?: 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, "" | "small" | "default" | "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<{
146
+ }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
441
147
  readonly: {
442
148
  type: BooleanConstructor;
443
149
  default: undefined;
@@ -451,10 +157,7 @@ declare const ProFormDatePicker: vue.DefineComponent<Partial<vue.ExtractPropType
451
157
  slots: {
452
158
  type: ObjectConstructor;
453
159
  };
454
- }>> & Record<string, any>>>, {
455
- [x: string]: any;
456
- }>;
457
- declare const ProFormTimePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
160
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
458
161
  name: {
459
162
  type: vue.PropType<string | (string | number)[]>;
460
163
  };
@@ -463,13 +166,13 @@ declare const ProFormTimePicker: vue.DefineComponent<Partial<vue.ExtractPropType
463
166
  readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
464
167
  readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
465
168
  } & {
466
- readonly label?: string | undefined;
467
169
  readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
468
- readonly error?: string | undefined;
469
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
170
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
470
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;
471
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
172
+ readonly label?: string | undefined;
472
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;
473
176
  readonly for?: string | undefined;
474
177
  } & Partial<vue.ExtractPropTypes<{
475
178
  readonly: {
@@ -485,27 +188,10 @@ declare const ProFormTimePicker: vue.DefineComponent<Partial<vue.ExtractPropType
485
188
  slots: {
486
189
  type: ObjectConstructor;
487
190
  };
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 label?: string | undefined;
498
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
499
- readonly error?: 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, "" | "small" | "default" | "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;
191
+ }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
192
+ readonly: {
193
+ type: BooleanConstructor;
194
+ default: undefined;
509
195
  };
510
196
  fieldProps: {
511
197
  type: ObjectConstructor;
@@ -516,10 +202,10 @@ declare const ProFormTimePicker: vue.DefineComponent<Partial<vue.ExtractPropType
516
202
  slots: {
517
203
  type: ObjectConstructor;
518
204
  };
519
- }>> & Record<string, any>>>, {
205
+ }>>>>, {
520
206
  [x: string]: any;
521
207
  }>;
522
- declare const ProFormSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
208
+ declare const ProFormDatePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
523
209
  name: {
524
210
  type: vue.PropType<string | (string | number)[]>;
525
211
  };
@@ -528,13 +214,13 @@ declare const ProFormSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
528
214
  readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
529
215
  readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
530
216
  } & {
531
- readonly label?: string | undefined;
532
217
  readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
533
- readonly error?: string | undefined;
534
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
218
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
535
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;
536
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
220
+ readonly label?: string | undefined;
537
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;
538
224
  readonly for?: string | undefined;
539
225
  } & Partial<vue.ExtractPropTypes<{
540
226
  readonly: {
@@ -550,24 +236,7 @@ declare const ProFormSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
550
236
  slots: {
551
237
  type: ObjectConstructor;
552
238
  };
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 label?: string | undefined;
563
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
564
- readonly error?: 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, "" | "small" | "default" | "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<{
239
+ }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
571
240
  readonly: {
572
241
  type: BooleanConstructor;
573
242
  default: undefined;
@@ -581,10 +250,7 @@ declare const ProFormSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
581
250
  slots: {
582
251
  type: ObjectConstructor;
583
252
  };
584
- }>> & Record<string, any>>>, {
585
- [x: string]: any;
586
- }>;
587
- declare const ProFormTreeSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
253
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
588
254
  name: {
589
255
  type: vue.PropType<string | (string | number)[]>;
590
256
  };
@@ -593,13 +259,13 @@ declare const ProFormTreeSelect: vue.DefineComponent<Partial<vue.ExtractPropType
593
259
  readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
594
260
  readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
595
261
  } & {
596
- readonly label?: string | undefined;
597
262
  readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
598
- readonly error?: string | undefined;
599
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
263
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
600
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;
601
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
265
+ readonly label?: string | undefined;
602
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;
603
269
  readonly for?: string | undefined;
604
270
  } & Partial<vue.ExtractPropTypes<{
605
271
  readonly: {
@@ -615,24 +281,7 @@ declare const ProFormTreeSelect: vue.DefineComponent<Partial<vue.ExtractPropType
615
281
  slots: {
616
282
  type: ObjectConstructor;
617
283
  };
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 label?: string | undefined;
628
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
629
- readonly error?: 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, "" | "small" | "default" | "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<{
284
+ }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
636
285
  readonly: {
637
286
  type: BooleanConstructor;
638
287
  default: undefined;
@@ -646,10 +295,10 @@ declare const ProFormTreeSelect: vue.DefineComponent<Partial<vue.ExtractPropType
646
295
  slots: {
647
296
  type: ObjectConstructor;
648
297
  };
649
- }>> & Record<string, any>>>, {
298
+ }>>>>, {
650
299
  [x: string]: any;
651
300
  }>;
652
- declare const ProFormCheckbox: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
301
+ declare const ProFormTimePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
653
302
  name: {
654
303
  type: vue.PropType<string | (string | number)[]>;
655
304
  };
@@ -658,13 +307,13 @@ declare const ProFormCheckbox: vue.DefineComponent<Partial<vue.ExtractPropTypes<
658
307
  readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
659
308
  readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
660
309
  } & {
661
- readonly label?: string | undefined;
662
310
  readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
663
- readonly error?: string | undefined;
664
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
311
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
665
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;
666
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
313
+ readonly label?: string | undefined;
667
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;
668
317
  readonly for?: string | undefined;
669
318
  } & Partial<vue.ExtractPropTypes<{
670
319
  readonly: {
@@ -680,7 +329,21 @@ declare const ProFormCheckbox: vue.DefineComponent<Partial<vue.ExtractPropTypes<
680
329
  slots: {
681
330
  type: ObjectConstructor;
682
331
  };
683
- }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
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<{
684
347
  name: {
685
348
  type: vue.PropType<string | (string | number)[]>;
686
349
  };
@@ -689,13 +352,13 @@ declare const ProFormCheckbox: vue.DefineComponent<Partial<vue.ExtractPropTypes<
689
352
  readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
690
353
  readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
691
354
  } & {
692
- readonly label?: string | undefined;
693
355
  readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
694
- readonly error?: string | undefined;
695
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
356
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
696
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;
697
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
358
+ readonly label?: string | undefined;
698
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;
699
362
  readonly for?: string | undefined;
700
363
  } & Partial<vue.ExtractPropTypes<{
701
364
  readonly: {
@@ -711,10 +374,24 @@ declare const ProFormCheckbox: vue.DefineComponent<Partial<vue.ExtractPropTypes<
711
374
  slots: {
712
375
  type: ObjectConstructor;
713
376
  };
714
- }>> & Record<string, any>>>, {
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
+ }>>>>, {
715
392
  [x: string]: any;
716
393
  }>;
717
- declare const ProFormRadio: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
394
+ declare const ProFormSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
718
395
  name: {
719
396
  type: vue.PropType<string | (string | number)[]>;
720
397
  };
@@ -723,13 +400,13 @@ declare const ProFormRadio: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
723
400
  readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
724
401
  readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
725
402
  } & {
726
- readonly label?: string | undefined;
727
403
  readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
728
- readonly error?: string | undefined;
729
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
404
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
730
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;
731
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
406
+ readonly label?: string | undefined;
732
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;
733
410
  readonly for?: string | undefined;
734
411
  } & Partial<vue.ExtractPropTypes<{
735
412
  readonly: {
@@ -745,7 +422,21 @@ declare const ProFormRadio: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
745
422
  slots: {
746
423
  type: ObjectConstructor;
747
424
  };
748
- }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
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<{
749
440
  name: {
750
441
  type: vue.PropType<string | (string | number)[]>;
751
442
  };
@@ -754,13 +445,13 @@ declare const ProFormRadio: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
754
445
  readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
755
446
  readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
756
447
  } & {
757
- readonly label?: string | undefined;
758
448
  readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
759
- readonly error?: string | undefined;
760
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
449
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
761
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;
762
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
451
+ readonly label?: string | undefined;
763
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;
764
455
  readonly for?: string | undefined;
765
456
  } & Partial<vue.ExtractPropTypes<{
766
457
  readonly: {
@@ -776,10 +467,24 @@ declare const ProFormRadio: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
776
467
  slots: {
777
468
  type: ObjectConstructor;
778
469
  };
779
- }>> & Record<string, any>>>, {
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
+ }>>>>, {
780
485
  [x: string]: any;
781
486
  }>;
782
- declare const ProFormSwitch: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
487
+ declare const ProFormTreeSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
783
488
  name: {
784
489
  type: vue.PropType<string | (string | number)[]>;
785
490
  };
@@ -788,13 +493,13 @@ declare const ProFormSwitch: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
788
493
  readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
789
494
  readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
790
495
  } & {
791
- readonly label?: string | undefined;
792
496
  readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
793
- readonly error?: string | undefined;
794
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
497
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
795
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;
796
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
499
+ readonly label?: string | undefined;
797
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;
798
503
  readonly for?: string | undefined;
799
504
  } & Partial<vue.ExtractPropTypes<{
800
505
  readonly: {
@@ -810,24 +515,7 @@ declare const ProFormSwitch: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
810
515
  slots: {
811
516
  type: ObjectConstructor;
812
517
  };
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 label?: string | undefined;
823
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
824
- readonly error?: 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, "" | "small" | "default" | "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<{
518
+ }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
831
519
  readonly: {
832
520
  type: BooleanConstructor;
833
521
  default: undefined;
@@ -841,10 +529,7 @@ declare const ProFormSwitch: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
841
529
  slots: {
842
530
  type: ObjectConstructor;
843
531
  };
844
- }>> & Record<string, any>>>, {
845
- [x: string]: any;
846
- }>;
847
- declare const ProFormCascader: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
532
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
848
533
  name: {
849
534
  type: vue.PropType<string | (string | number)[]>;
850
535
  };
@@ -853,13 +538,13 @@ declare const ProFormCascader: vue.DefineComponent<Partial<vue.ExtractPropTypes<
853
538
  readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
854
539
  readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
855
540
  } & {
856
- readonly label?: string | undefined;
857
541
  readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
858
- readonly error?: string | undefined;
859
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
542
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
860
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;
861
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
544
+ readonly label?: string | undefined;
862
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;
863
548
  readonly for?: string | undefined;
864
549
  } & Partial<vue.ExtractPropTypes<{
865
550
  readonly: {
@@ -875,7 +560,24 @@ declare const ProFormCascader: vue.DefineComponent<Partial<vue.ExtractPropTypes<
875
560
  slots: {
876
561
  type: ObjectConstructor;
877
562
  };
878
- }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
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<{
879
581
  name: {
880
582
  type: vue.PropType<string | (string | number)[]>;
881
583
  };
@@ -884,13 +586,13 @@ declare const ProFormCascader: vue.DefineComponent<Partial<vue.ExtractPropTypes<
884
586
  readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
885
587
  readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
886
588
  } & {
887
- readonly label?: string | undefined;
888
589
  readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
889
- readonly error?: string | undefined;
890
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
590
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
891
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;
892
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
592
+ readonly label?: string | undefined;
893
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;
894
596
  readonly for?: string | undefined;
895
597
  } & Partial<vue.ExtractPropTypes<{
896
598
  readonly: {
@@ -906,54 +608,21 @@ declare const ProFormCascader: vue.DefineComponent<Partial<vue.ExtractPropTypes<
906
608
  slots: {
907
609
  type: ObjectConstructor;
908
610
  };
909
- }>> & Record<string, any>>>, {
910
- [x: string]: any;
911
- }>;
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
-
933
- declare const proFormListProps: () => {
934
- addButtonText: {
935
- type: StringConstructor;
936
- default: string;
611
+ }>> & Record<string, any> & Partial<vue.ExtractPropTypes<{
612
+ readonly: {
613
+ type: BooleanConstructor;
614
+ default: undefined;
937
615
  };
938
- addButtonProps: {
939
- type: PropType<ButtonProps$1>;
616
+ fieldProps: {
617
+ type: ObjectConstructor;
940
618
  };
941
- minusButtonText: {
942
- type: StringConstructor;
943
- default: string;
619
+ showProps: {
620
+ type: ObjectConstructor;
944
621
  };
945
- minusButtonProps: {
946
- type: PropType<ButtonProps$1>;
622
+ slots: {
623
+ type: ObjectConstructor;
947
624
  };
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>, {}>;
951
-
952
- declare const createFormItemComponent: ({ InputComp, valueType, name }: {
953
- InputComp: any;
954
- valueType: string;
955
- name?: string | undefined;
956
- }) => vue.DefineComponent<Partial<vue.ExtractPropTypes<{
625
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
957
626
  name: {
958
627
  type: vue.PropType<string | (string | number)[]>;
959
628
  };
@@ -962,13 +631,13 @@ declare const createFormItemComponent: ({ InputComp, valueType, name }: {
962
631
  readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
963
632
  readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
964
633
  } & {
965
- readonly label?: string | undefined;
966
634
  readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
967
- readonly error?: string | undefined;
968
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
635
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
969
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;
970
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
637
+ readonly label?: string | undefined;
971
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;
972
641
  readonly for?: string | undefined;
973
642
  } & Partial<vue.ExtractPropTypes<{
974
643
  readonly: {
@@ -984,7 +653,24 @@ declare const createFormItemComponent: ({ InputComp, valueType, name }: {
984
653
  slots: {
985
654
  type: ObjectConstructor;
986
655
  };
987
- }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
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<{
988
674
  name: {
989
675
  type: vue.PropType<string | (string | number)[]>;
990
676
  };
@@ -993,13 +679,13 @@ declare const createFormItemComponent: ({ InputComp, valueType, name }: {
993
679
  readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
994
680
  readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
995
681
  } & {
996
- readonly label?: string | undefined;
997
682
  readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
998
- readonly error?: string | undefined;
999
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
683
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
1000
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;
1001
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
685
+ readonly label?: string | undefined;
1002
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;
1003
689
  readonly for?: string | undefined;
1004
690
  } & Partial<vue.ExtractPropTypes<{
1005
691
  readonly: {
@@ -1015,75 +701,605 @@ declare const createFormItemComponent: ({ InputComp, valueType, name }: {
1015
701
  slots: {
1016
702
  type: ObjectConstructor;
1017
703
  };
1018
- }>> & Record<string, any>>>, {
1019
- [x: string]: any;
1020
- }>;
1021
-
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>;
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;
951
+ }>;
1034
952
 
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<{}>>, {}>;
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;
1049
+ }>;
1038
1050
 
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;
1051
+ declare type TOption = {
1052
+ label?: string;
1053
+ value: string | number;
1054
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
1055
  };
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<{}>>, {}>;
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
+ }
1118
+
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;
1124
+ }>;
1125
+
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
+ }>>>, {}>;
1076
1214
 
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<{}>>, {}>;
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>, {}>;
1295
+
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
+ }>;
1299
+
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
1304
  declare const proSelectProps: () => {
1089
1305
  options: PropType<TOptions>;
@@ -1098,11 +1314,19 @@ declare const proRadioProps: () => {
1098
1314
  type: PropType<TOptions$1>;
1099
1315
  };
1100
1316
  buttonStyle: {
1101
- type: PropType<"button" | "default">;
1317
+ type: PropType<"default" | "button">;
1102
1318
  default: string;
1103
1319
  };
1104
1320
  };
1105
- declare type ProRadioProps = Partial<ExtractPropTypes<ReturnType<typeof proRadioProps>>> & RadioGroupProps;
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
- export { ButtonProps, DescriptionsProps, FormMethods, ModalProps, PaginationProps, 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 };
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;
1330
+ }>;
1331
+
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 };