@vue-start/element-pro 0.1.1 → 0.1.2

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 (5) hide show
  1. package/CHANGELOG.md +9 -0
  2. package/dist/index.d.ts +1028 -343
  3. package/dist/index.es.js +404 -714
  4. package/dist/index.js +403 -715
  5. package/package.json +2 -2
package/dist/index.d.ts CHANGED
@@ -1,14 +1,178 @@
1
1
  import * as vue from 'vue';
2
2
  import { VNode, ExtractPropTypes, PropType, Component } from 'vue';
3
- import { FormItemProps, ButtonProps as ButtonProps$1, FormInstance, ElSelect } from 'element-plus';
4
- import { FilterMethods, Filters } from 'element-plus/es/components/table/src/table-column/defaults';
5
- import { TColumn as TColumn$1, TElementMap } from '@vue-start/pro';
3
+ import * as element_plus from 'element-plus';
4
+ import { FormItemProps, ButtonProps as ButtonProps$1, ElSelect } from 'element-plus';
6
5
  import { FormItemRule } from 'element-plus/es/tokens/form';
7
- import { Ref, UnwrapNestedRefs } from '@vue/reactivity';
8
- import { DefineComponent } from '@vue/runtime-core';
6
+ import * as _vue_start_pro from '@vue-start/pro';
7
+ import { TTableColumn as TTableColumn$1, ProFormProps as ProFormProps$1, ProSearchFormProps as ProSearchFormProps$1, ProFormListProps as ProFormListProps$1, ProTableProps as ProTableProps$1 } from '@vue-start/pro';
8
+ import { FilterMethods, Filters } from 'element-plus/es/components/table/src/table-column/defaults';
9
+ import { ColSizeObject } from 'element-plus/es/components/col/src/col';
10
+ import * as element_plus_es_utils from 'element-plus/es/utils';
9
11
  import * as element_plus_es_components_table_src_table_defaults from 'element-plus/es/components/table/src/table/defaults';
10
12
  import { TableProps } from 'element-plus/es/components/table/src/table/defaults';
11
13
 
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$1 = TableColumnCtx<any> & Omit<TTableColumn$1, "formItemProps" | "title" | "dataIndex"> & {
47
+ formItemProps?: ProFormItemProps;
48
+ };
49
+ declare type TColumns = TColumn$1[];
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 TDefaultValueType = "text" | "textarea" | "password" | "digit" | "date" | "dateRange" | "time" | "timeRange" | "select" | "treeSelect" | "checkbox" | "radio" | "slider" | "switch" | "rate" | "cascader";
131
+ declare type TValueType = TDefaultValueType | string;
132
+ declare type TColumn = {
133
+ title?: string | VNode;
134
+ dataIndex?: string | number;
135
+ valueType?: TValueType;
136
+ formValueType?: TValueType;
137
+ showProps?: Record<string, any>;
138
+ formItemProps?: {
139
+ name?: string;
140
+ label?: string;
141
+ };
142
+ formFieldProps?: Record<string, any>;
143
+ search?: boolean;
144
+ hideInTable?: boolean;
145
+ hideInForm?: boolean;
146
+ hideInDetail?: boolean;
147
+ searchSort?: boolean;
148
+ tableSort?: boolean;
149
+ formSort?: boolean;
150
+ descSort?: boolean;
151
+ extra?: {
152
+ desc?: any;
153
+ };
154
+ };
155
+ /**
156
+ * 组件Map
157
+ */
158
+ declare type TElementMap = Record<string, any>;
159
+
160
+ interface IProTableProvideExtra extends Record<string, any> {
161
+ }
162
+ declare type TTableColumn = {
163
+ customRender?: (opt: {
164
+ value: any;
165
+ text: any;
166
+ record: Record<string, any>;
167
+ index: number;
168
+ column: TTableColumn;
169
+ }) => VNode;
170
+ fixed?: boolean | string;
171
+ } & TColumn;
172
+ declare type TTableColumns = TTableColumn[];
173
+ /**
174
+ * 单个操作描述
175
+ */
12
176
  interface IOperateItem {
13
177
  value: string | number;
14
178
  label?: string | VNode;
@@ -18,53 +182,16 @@ interface IOperateItem {
18
182
  onClick?: (record: Record<string, any>) => void;
19
183
  sort?: number;
20
184
  }
185
+ /**
186
+ * 整个操作栏描述
187
+ */
21
188
  interface ITableOperate {
22
- column?: TableColumnCtx<any>;
189
+ column?: TColumn;
23
190
  items?: IOperateItem[];
24
191
  itemState?: {
25
192
  [key: string]: Omit<IOperateItem, "value">;
26
193
  };
27
- }
28
- declare const proTableProps: () => {
29
- operate: {
30
- type: PropType<ITableOperate>;
31
- };
32
- columnEmptyText: {
33
- type: StringConstructor;
34
- };
35
- /**
36
- * 公共column，会merge到columns item中
37
- */
38
- column: {
39
- type: PropType<TableColumnCtx<any>>;
40
- };
41
- columns: {
42
- type: PropType<TColumns>;
43
- };
44
- /**
45
- * 展示控件集合，readonly模式下使用这些组件渲染
46
- */
47
- elementMap: {
48
- type: PropType<{
49
- [key: string]: any;
50
- }>;
51
- };
52
- /**
53
- * loading
54
- */
55
- loading: {
56
- type: BooleanConstructor;
57
- default: boolean;
58
- };
59
- };
60
- declare type ProTableProps = Partial<ExtractPropTypes<ReturnType<typeof proTableProps>>> & Omit<TableProps<any>, "tableLayout" | "flexible" | "data"> & {
61
- tableLayout?: "fixed" | "auto";
62
- flexible?: boolean;
63
- data?: any;
64
- };
65
- declare const ProTable: vue.DefineComponent<ProTableProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProTableProps>, {
66
- data: any;
67
- }>;
194
+ }
68
195
 
69
196
  interface PaginationProps {
70
197
  total?: number;
@@ -103,29 +230,31 @@ declare const proListProps: () => {
103
230
  type: PropType<ProSearchFormProps>;
104
231
  };
105
232
  tableProps: {
106
- type: PropType<Partial<ExtractPropTypes<{
233
+ type: PropType<Omit<Partial<ExtractPropTypes<{
107
234
  operate: {
108
- type: PropType<ITableOperate>;
235
+ type: PropType<ITableOperate>; /******************* search pagination ********************/
109
236
  };
110
237
  columnEmptyText: {
111
238
  type: StringConstructor;
112
239
  };
113
240
  column: {
114
- type: PropType<TableColumnCtx<any>>;
241
+ type: PropType<TTableColumn>;
115
242
  };
116
243
  columns: {
117
- type: PropType<TColumns>;
244
+ type: PropType<TTableColumns>;
118
245
  };
119
246
  elementMap: {
120
- type: PropType<{
121
- [key: string]: any;
122
- }>;
247
+ type: PropType<TElementMap>;
123
248
  };
124
249
  loading: {
125
250
  type: BooleanConstructor;
126
- default: boolean;
127
251
  };
128
- }>> & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
252
+ provideExtra: {
253
+ type: PropType<IProTableProvideExtra>;
254
+ };
255
+ }>>, "columns"> & {
256
+ columns?: TColumns | undefined;
257
+ } & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
129
258
  tableLayout?: "fixed" | "auto" | undefined;
130
259
  flexible?: boolean | undefined;
131
260
  data?: any;
@@ -155,29 +284,31 @@ declare const ProList: vue.DefineComponent<Partial<ExtractPropTypes<{
155
284
  type: PropType<ProSearchFormProps>;
156
285
  };
157
286
  tableProps: {
158
- type: PropType<Partial<ExtractPropTypes<{
287
+ type: PropType<Omit<Partial<ExtractPropTypes<{
159
288
  operate: {
160
- type: PropType<ITableOperate>;
289
+ type: PropType<ITableOperate>; /******************* search pagination ********************/
161
290
  };
162
291
  columnEmptyText: {
163
292
  type: StringConstructor;
164
293
  };
165
294
  column: {
166
- type: PropType<TableColumnCtx<any>>;
295
+ type: PropType<TTableColumn>;
167
296
  };
168
297
  columns: {
169
- type: PropType<TColumns>;
298
+ type: PropType<TTableColumns>;
170
299
  };
171
300
  elementMap: {
172
- type: PropType<{
173
- [key: string]: any;
174
- }>;
301
+ type: PropType<TElementMap>;
175
302
  };
176
303
  loading: {
177
304
  type: BooleanConstructor;
178
- default: boolean;
179
305
  };
180
- }>> & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
306
+ provideExtra: {
307
+ type: PropType<IProTableProvideExtra>;
308
+ };
309
+ }>>, "columns"> & {
310
+ columns?: TColumns | undefined;
311
+ } & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
181
312
  tableLayout?: "fixed" | "auto" | undefined;
182
313
  flexible?: boolean | undefined;
183
314
  data?: any;
@@ -205,29 +336,31 @@ declare const ProList: vue.DefineComponent<Partial<ExtractPropTypes<{
205
336
  type: PropType<ProSearchFormProps>;
206
337
  };
207
338
  tableProps: {
208
- type: PropType<Partial<ExtractPropTypes<{
339
+ type: PropType<Omit<Partial<ExtractPropTypes<{
209
340
  operate: {
210
- type: PropType<ITableOperate>;
341
+ type: PropType<ITableOperate>; /******************* search pagination ********************/
211
342
  };
212
343
  columnEmptyText: {
213
344
  type: StringConstructor;
214
345
  };
215
346
  column: {
216
- type: PropType<TableColumnCtx<any>>;
347
+ type: PropType<TTableColumn>;
217
348
  };
218
349
  columns: {
219
- type: PropType<TColumns>;
350
+ type: PropType<TTableColumns>;
220
351
  };
221
352
  elementMap: {
222
- type: PropType<{
223
- [key: string]: any;
224
- }>;
353
+ type: PropType<TElementMap>;
225
354
  };
226
355
  loading: {
227
356
  type: BooleanConstructor;
228
- default: boolean;
229
357
  };
230
- }>> & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
358
+ provideExtra: {
359
+ type: PropType<IProTableProvideExtra>;
360
+ };
361
+ }>>, "columns"> & {
362
+ columns?: TColumns | undefined;
363
+ } & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
231
364
  tableLayout?: "fixed" | "auto" | undefined;
232
365
  flexible?: boolean | undefined;
233
366
  data?: any;
@@ -245,231 +378,555 @@ declare const ProList: vue.DefineComponent<Partial<ExtractPropTypes<{
245
378
  };
246
379
  }>>>, {}>;
247
380
 
248
- declare type TOption = {
249
- label?: string;
250
- value: string | number;
251
- disabled?: boolean;
252
- };
253
- declare type TOptions = TOption[];
254
- declare type TColumn = TableColumnCtx<any> & Omit<TColumn$1, "formItemProps" | "title" | "dataIndex"> & {
255
- formItemProps?: ProFormItemProps;
256
- };
257
- declare type TColumns = TColumn[];
258
- declare type BooleanRulesObjType = {
259
- [key: string]: (record: any) => boolean;
381
+ declare const proGridProps: () => {
382
+ /**
383
+ * row属性
384
+ */
385
+ row: {
386
+ type: PropType<IRow>;
387
+ default: undefined;
388
+ };
389
+ /**
390
+ * 公共col属性
391
+ */
392
+ col: {
393
+ type: PropType<ICol>;
394
+ };
395
+ /**
396
+ *
397
+ */
398
+ items: {
399
+ type: PropType<{
400
+ vNode: VNode;
401
+ rowKey?: string | number | undefined;
402
+ col?: ICol | undefined;
403
+ }[]>;
404
+ };
260
405
  };
261
- declare type TDefaultValueType = "text" | "textarea" | "password" | "digit" | "date" | "dateRange" | "time" | "timeRange" | "select" | "treeSelect" | "checkbox" | "radio" | "slider" | "switch" | "rate" | "cascader";
262
- declare type TValueType = TDefaultValueType | string;
263
- interface TableColumnCtx<T> {
264
- id?: string;
265
- realWidth?: number;
266
- type?: string;
267
- /********* title兼容 ********/
268
- label?: string;
269
- renderHeader?: (data: {
270
- column: TableColumnCtx<T>;
271
- $index: number;
272
- }) => VNode;
273
- title?: string | VNode;
274
- /********* dataIndex兼容 ********/
275
- prop?: string;
276
- dataIndex?: string | number;
277
- className?: string;
278
- labelClassName?: string;
279
- property?: string;
280
- width?: string | number;
281
- minWidth?: string | number;
282
- sortable?: boolean | string;
283
- sortMethod?: (a: T, b: T) => number;
284
- sortBy?: string | ((row: T, index: number) => string) | string[];
285
- resizable?: boolean;
286
- columnKey?: string;
287
- rawColumnKey?: string;
288
- align?: string;
289
- headerAlign?: string;
290
- showTooltipWhenOverflow?: boolean;
291
- showOverflowTooltip?: boolean;
292
- fixed?: boolean | string;
293
- formatter?: (row: T, column: TableColumnCtx<T>, cellValue: any, index: number) => VNode | string;
294
- customRender?: (opt: {
295
- value: any;
296
- text: any;
297
- record: T;
298
- index: number;
299
- column: TableColumnCtx<T>;
300
- }) => VNode | string | null;
301
- selectable?: (row: T, index: number) => boolean;
302
- reserveSelection?: boolean;
303
- filterMethod?: FilterMethods<T>;
304
- filteredValue?: string[];
305
- filters?: Filters;
306
- filterPlacement?: string;
307
- filterMultiple?: boolean;
308
- index?: number | ((index: number) => number);
309
- sortOrders?: ("ascending" | "descending" | null)[];
310
- renderCell?: (data: any) => void;
311
- colSpan?: number;
312
- rowSpan?: number;
313
- children?: TableColumnCtx<T>[];
314
- level?: number;
315
- filterable?: boolean | FilterMethods<T> | Filters;
316
- order?: string;
317
- isColumnGroup?: boolean;
318
- isSubColumn?: boolean;
319
- columns?: TableColumnCtx<T>[];
320
- getColumnIndex?: () => number;
321
- no?: number;
322
- filterOpened?: boolean;
323
- }
406
+ declare type ProGridProps = Partial<ExtractPropTypes<ReturnType<typeof proGridProps>>>;
407
+ declare const ProGrid: vue.DefineComponent<Partial<ExtractPropTypes<{
408
+ /**
409
+ * row属性
410
+ */
411
+ row: {
412
+ type: PropType<IRow>;
413
+ default: undefined;
414
+ };
415
+ /**
416
+ * 公共col属性
417
+ */
418
+ col: {
419
+ type: PropType<ICol>;
420
+ };
421
+ /**
422
+ *
423
+ */
424
+ items: {
425
+ type: PropType<{
426
+ vNode: VNode;
427
+ rowKey?: string | number | undefined;
428
+ col?: ICol | undefined;
429
+ }[]>;
430
+ };
431
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
432
+ /**
433
+ * row属性
434
+ */
435
+ row: {
436
+ type: PropType<IRow>;
437
+ default: undefined;
438
+ };
439
+ /**
440
+ * 公共col属性
441
+ */
442
+ col: {
443
+ type: PropType<ICol>;
444
+ };
445
+ /**
446
+ *
447
+ */
448
+ items: {
449
+ type: PropType<{
450
+ vNode: VNode;
451
+ rowKey?: string | number | undefined;
452
+ col?: ICol | undefined;
453
+ }[]>;
454
+ };
455
+ }>>>, {}>;
324
456
 
325
- declare const proFormItemProps$1: () => {
457
+ declare const proFormItemProps: () => {
326
458
  name: {
327
459
  type: PropType<string | (string | number)[]>;
328
460
  };
329
461
  };
330
- declare type ProFormItemProps = Partial<ExtractPropTypes<ReturnType<typeof proFormItemProps$1>>> & FormItemProps;
462
+ declare type ProFormItemProps = Partial<ExtractPropTypes<ReturnType<typeof proFormItemProps>>> & FormItemProps;
331
463
  declare const ProFormItem: vue.DefineComponent<ProFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormItemProps>, {}>;
332
- declare const proFormProps: () => {
333
- /**
334
- * 子组件是否只读样式
335
- */
464
+ interface FormProps {
465
+ model?: Record<string, any>;
466
+ rules?: FormItemRule[];
467
+ labelPosition?: "left" | "right" | "top";
468
+ labelWidth?: string | number;
469
+ labelSuffix?: string;
470
+ inline?: boolean;
471
+ inlineMessage?: boolean;
472
+ statusIcon?: boolean;
473
+ showMessage?: boolean;
474
+ size?: "large" | "default" | "small";
475
+ disabled?: boolean;
476
+ validateOnRuleChange?: boolean;
477
+ hideRequiredAsterisk?: boolean;
478
+ scrollToError?: boolean;
479
+ }
480
+ declare type ProFormProps = ProFormProps$1 & FormProps & Omit<ProGridProps, "items"> & {
481
+ onFinish?: (showValues: Record<string, any>, values: Record<string, any>) => void;
482
+ onFinishFailed?: (invalidFields: Record<string, any>) => void;
483
+ };
484
+ declare const ProForm: vue.DefineComponent<ProFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormProps>, {}>;
485
+
486
+ declare type ProSearchFormProps = ProSearchFormProps$1 & Omit<ProFormProps, "inline"> & {
487
+ inline?: boolean;
488
+ };
489
+ declare const ProSearchForm: vue.DefineComponent<ProSearchFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProSearchFormProps>, {}>;
490
+
491
+ declare const ProFormText: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
492
+ name: {
493
+ type: vue.PropType<string | (string | number)[]>;
494
+ };
495
+ }>> & {
496
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
497
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
498
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
499
+ } & {
500
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
501
+ readonly error?: string | undefined;
502
+ readonly label?: string | undefined;
503
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
504
+ readonly for?: string | undefined;
505
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
506
+ 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;
507
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
508
+ } & Partial<vue.ExtractPropTypes<{
509
+ readonly: {
510
+ type: BooleanConstructor;
511
+ default: undefined;
512
+ };
513
+ fieldProps: {
514
+ type: ObjectConstructor;
515
+ };
516
+ showProps: {
517
+ type: ObjectConstructor;
518
+ };
519
+ slots: {
520
+ type: ObjectConstructor;
521
+ };
522
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
523
+ name: {
524
+ type: vue.PropType<string | (string | number)[]>;
525
+ };
526
+ }>> & {
527
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
528
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
529
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
530
+ } & {
531
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
532
+ readonly error?: string | undefined;
533
+ readonly label?: string | undefined;
534
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
535
+ readonly for?: string | undefined;
536
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
537
+ 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;
538
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
539
+ } & Partial<vue.ExtractPropTypes<{
540
+ readonly: {
541
+ type: BooleanConstructor;
542
+ default: undefined;
543
+ };
544
+ fieldProps: {
545
+ type: ObjectConstructor;
546
+ };
547
+ showProps: {
548
+ type: ObjectConstructor;
549
+ };
550
+ slots: {
551
+ type: ObjectConstructor;
552
+ };
553
+ }>> & Record<string, any>>>, {
554
+ [x: string]: any;
555
+ }>;
556
+ declare const ProFormTextNumber: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
557
+ name: {
558
+ type: vue.PropType<string | (string | number)[]>;
559
+ };
560
+ }>> & {
561
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
562
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
563
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
564
+ } & {
565
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
566
+ readonly error?: string | undefined;
567
+ readonly label?: string | undefined;
568
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
569
+ readonly for?: string | undefined;
570
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
571
+ 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;
572
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
573
+ } & Partial<vue.ExtractPropTypes<{
574
+ readonly: {
575
+ type: BooleanConstructor;
576
+ default: undefined;
577
+ };
578
+ fieldProps: {
579
+ type: ObjectConstructor;
580
+ };
581
+ showProps: {
582
+ type: ObjectConstructor;
583
+ };
584
+ slots: {
585
+ type: ObjectConstructor;
586
+ };
587
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
588
+ name: {
589
+ type: vue.PropType<string | (string | number)[]>;
590
+ };
591
+ }>> & {
592
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
593
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
594
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
595
+ } & {
596
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
597
+ readonly error?: string | undefined;
598
+ readonly label?: string | undefined;
599
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
600
+ readonly for?: string | undefined;
601
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
602
+ 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;
603
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
604
+ } & Partial<vue.ExtractPropTypes<{
605
+ readonly: {
606
+ type: BooleanConstructor;
607
+ default: undefined;
608
+ };
609
+ fieldProps: {
610
+ type: ObjectConstructor;
611
+ };
612
+ showProps: {
613
+ type: ObjectConstructor;
614
+ };
615
+ slots: {
616
+ type: ObjectConstructor;
617
+ };
618
+ }>> & Record<string, any>>>, {
619
+ [x: string]: any;
620
+ }>;
621
+ declare const ProFormDatePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
622
+ name: {
623
+ type: vue.PropType<string | (string | number)[]>;
624
+ };
625
+ }>> & {
626
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
627
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
628
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
629
+ } & {
630
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
631
+ readonly error?: string | undefined;
632
+ readonly label?: string | undefined;
633
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
634
+ readonly for?: string | undefined;
635
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
636
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
637
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
638
+ } & Partial<vue.ExtractPropTypes<{
639
+ readonly: {
640
+ type: BooleanConstructor;
641
+ default: undefined;
642
+ };
643
+ fieldProps: {
644
+ type: ObjectConstructor;
645
+ };
646
+ showProps: {
647
+ type: ObjectConstructor;
648
+ };
649
+ slots: {
650
+ type: ObjectConstructor;
651
+ };
652
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
653
+ name: {
654
+ type: vue.PropType<string | (string | number)[]>;
655
+ };
656
+ }>> & {
657
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
658
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
659
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
660
+ } & {
661
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
662
+ readonly error?: string | undefined;
663
+ readonly label?: string | undefined;
664
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
665
+ readonly for?: string | undefined;
666
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
667
+ 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;
668
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
669
+ } & Partial<vue.ExtractPropTypes<{
670
+ readonly: {
671
+ type: BooleanConstructor;
672
+ default: undefined;
673
+ };
674
+ fieldProps: {
675
+ type: ObjectConstructor;
676
+ };
677
+ showProps: {
678
+ type: ObjectConstructor;
679
+ };
680
+ slots: {
681
+ type: ObjectConstructor;
682
+ };
683
+ }>> & Record<string, any>>>, {
684
+ [x: string]: any;
685
+ }>;
686
+ declare const ProFormTimePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
687
+ name: {
688
+ type: vue.PropType<string | (string | number)[]>;
689
+ };
690
+ }>> & {
691
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
692
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
693
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
694
+ } & {
695
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
696
+ readonly error?: string | undefined;
697
+ readonly label?: string | undefined;
698
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
699
+ readonly for?: string | undefined;
700
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
701
+ 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;
702
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
703
+ } & Partial<vue.ExtractPropTypes<{
704
+ readonly: {
705
+ type: BooleanConstructor;
706
+ default: undefined;
707
+ };
708
+ fieldProps: {
709
+ type: ObjectConstructor;
710
+ };
711
+ showProps: {
712
+ type: ObjectConstructor;
713
+ };
714
+ slots: {
715
+ type: ObjectConstructor;
716
+ };
717
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
718
+ name: {
719
+ type: vue.PropType<string | (string | number)[]>;
720
+ };
721
+ }>> & {
722
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
723
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
724
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
725
+ } & {
726
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
727
+ readonly error?: string | undefined;
728
+ readonly label?: string | undefined;
729
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
730
+ readonly for?: string | undefined;
731
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
732
+ 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;
733
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
734
+ } & Partial<vue.ExtractPropTypes<{
735
+ readonly: {
736
+ type: BooleanConstructor;
737
+ default: undefined;
738
+ };
739
+ fieldProps: {
740
+ type: ObjectConstructor;
741
+ };
742
+ showProps: {
743
+ type: ObjectConstructor;
744
+ };
745
+ slots: {
746
+ type: ObjectConstructor;
747
+ };
748
+ }>> & Record<string, any>>>, {
749
+ [x: string]: any;
750
+ }>;
751
+ declare const ProFormSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
752
+ name: {
753
+ type: vue.PropType<string | (string | number)[]>;
754
+ };
755
+ }>> & {
756
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
757
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
758
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
759
+ } & {
760
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
761
+ readonly error?: string | undefined;
762
+ readonly label?: string | undefined;
763
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
764
+ readonly for?: string | undefined;
765
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
766
+ 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;
767
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
768
+ } & Partial<vue.ExtractPropTypes<{
336
769
  readonly: {
337
770
  type: BooleanConstructor;
338
771
  default: undefined;
339
772
  };
340
- /**
341
- * FormComponent 根据此项来确定组件是否显示
342
- * rules 根据rules中方法生成showState对象
343
- */
344
- showState: {
345
- type: PropType<{
346
- [x: string]: boolean;
347
- }>;
773
+ fieldProps: {
774
+ type: ObjectConstructor;
348
775
  };
349
- showStateRules: {
350
- type: PropType<BooleanRulesObjType>;
776
+ showProps: {
777
+ type: ObjectConstructor;
351
778
  };
352
- /**
353
- * 是否只读
354
- */
355
- readonlyState: {
356
- type: PropType<{
357
- [x: string]: boolean;
358
- }>;
779
+ slots: {
780
+ type: ObjectConstructor;
359
781
  };
360
- readonlyStateRules: {
361
- type: PropType<BooleanRulesObjType>;
782
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
783
+ name: {
784
+ type: vue.PropType<string | (string | number)[]>;
785
+ };
786
+ }>> & {
787
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
788
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
789
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
790
+ } & {
791
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
792
+ readonly error?: string | undefined;
793
+ readonly label?: string | undefined;
794
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
795
+ readonly for?: string | undefined;
796
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
797
+ 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;
798
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
799
+ } & Partial<vue.ExtractPropTypes<{
800
+ readonly: {
801
+ type: BooleanConstructor;
802
+ default: undefined;
362
803
  };
363
- /**
364
- * 是否disabled
365
- */
366
- disableState: {
367
- type: PropType<{
368
- [x: string]: boolean;
369
- }>;
804
+ fieldProps: {
805
+ type: ObjectConstructor;
370
806
  };
371
- disableStateRules: {
372
- type: PropType<BooleanRulesObjType>;
807
+ showProps: {
808
+ type: ObjectConstructor;
373
809
  };
374
- /**
375
- * 展示控件集合，readonly模式下使用这些组件渲染
376
- */
377
- elementMap: {
378
- type: PropType<TElementMap>;
810
+ slots: {
811
+ type: ObjectConstructor;
379
812
  };
380
- /**
381
- * provide传递
382
- */
383
- provideExtra: {
384
- type: PropType<{
385
- [key: string]: any;
386
- }>;
813
+ }>> & Record<string, any>>>, {
814
+ [x: string]: any;
815
+ }>;
816
+ declare const ProFormTreeSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
817
+ name: {
818
+ type: vue.PropType<string | (string | number)[]>;
819
+ };
820
+ }>> & {
821
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
822
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
823
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
824
+ } & {
825
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
826
+ readonly error?: string | undefined;
827
+ readonly label?: string | undefined;
828
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
829
+ readonly for?: string | undefined;
830
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
831
+ 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;
832
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
833
+ } & Partial<vue.ExtractPropTypes<{
834
+ readonly: {
835
+ type: BooleanConstructor;
836
+ default: undefined;
387
837
  };
388
- };
389
- interface FormProps {
390
- model?: Record<string, any>;
391
- rules?: FormItemRule[];
392
- labelPosition?: "left" | "right" | "top";
393
- labelWidth?: string | number;
394
- labelSuffix?: string;
395
- inline?: boolean;
396
- inlineMessage?: boolean;
397
- statusIcon?: boolean;
398
- showMessage?: boolean;
399
- size?: "large" | "default" | "small";
400
- disabled?: boolean;
401
- validateOnRuleChange?: boolean;
402
- hideRequiredAsterisk?: boolean;
403
- scrollToError?: boolean;
404
- }
405
- declare type ProFormProps = Partial<ExtractPropTypes<ReturnType<typeof proFormProps>>> & FormProps & {
406
- onFinish?: (showValues: Record<string, any>, values: Record<string, any>) => void;
407
- onFinishFailed?: (invalidFields: Record<string, any>) => void;
408
- };
409
- declare const ProForm: vue.DefineComponent<ProFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormProps>, {}>;
410
-
411
- declare const proSchemaFormProps: () => {
412
- columns: {
413
- type: PropType<TColumns>;
838
+ fieldProps: {
839
+ type: ObjectConstructor;
414
840
  };
415
- /**
416
- * 录入控件集合，通过column->valueType 查找对应的录入组件
417
- */
418
- formElementMap: {
419
- type: PropType<TElementMap>;
841
+ showProps: {
842
+ type: ObjectConstructor;
420
843
  };
421
- /**
422
- * 是否启用rules验证
423
- */
424
- needRules: {
425
- type: BooleanConstructor;
426
- default: boolean;
844
+ slots: {
845
+ type: ObjectConstructor;
427
846
  };
428
- };
429
- declare type ProSchemaFormProps = Partial<ExtractPropTypes<ReturnType<typeof proSchemaFormProps>>> & ProFormProps;
430
- declare const ProSchemaForm: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
431
- [x: string]: any;
432
- }>;
433
-
434
- declare enum SearchMode {
435
- AUTO = "AUTO",
436
- MANUAL = "MANUAL"
437
- }
438
- declare type ISearchMode = keyof typeof SearchMode;
439
- declare const proSearchFormProps: () => {
440
- /**
441
- * 初始化触发 onFinish
442
- */
443
- initEmit: {
847
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
848
+ name: {
849
+ type: vue.PropType<string | (string | number)[]>;
850
+ };
851
+ }>> & {
852
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
853
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
854
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
855
+ } & {
856
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
857
+ readonly error?: string | undefined;
858
+ readonly label?: string | undefined;
859
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
860
+ readonly for?: string | undefined;
861
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
862
+ 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;
863
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
864
+ } & Partial<vue.ExtractPropTypes<{
865
+ readonly: {
444
866
  type: BooleanConstructor;
445
- default: boolean;
867
+ default: undefined;
446
868
  };
447
- /**
448
- * 模式 自动触发或者手动触发 onFinish
449
- */
450
- searchMode: {
451
- type: PropType<"AUTO" | "MANUAL">;
452
- default: SearchMode;
869
+ fieldProps: {
870
+ type: ObjectConstructor;
453
871
  };
454
- /**
455
- * 需要debounce处理的字段
456
- */
457
- debounceKeys: {
458
- type: PropType<string[]>;
872
+ showProps: {
873
+ type: ObjectConstructor;
459
874
  };
460
- debounceTime: {
461
- type: NumberConstructor;
462
- default: number;
875
+ slots: {
876
+ type: ObjectConstructor;
463
877
  };
464
- inline: {
878
+ }>> & Record<string, any>>>, {
879
+ [x: string]: any;
880
+ }>;
881
+ declare const ProFormCheckbox: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
882
+ name: {
883
+ type: vue.PropType<string | (string | number)[]>;
884
+ };
885
+ }>> & {
886
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
887
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
888
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
889
+ } & {
890
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
891
+ readonly error?: string | undefined;
892
+ readonly label?: string | undefined;
893
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
894
+ readonly for?: string | undefined;
895
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
896
+ 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;
897
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
898
+ } & Partial<vue.ExtractPropTypes<{
899
+ readonly: {
465
900
  type: BooleanConstructor;
466
- default: boolean;
901
+ default: undefined;
467
902
  };
468
- };
469
- declare type ProSearchFormProps = Partial<ExtractPropTypes<ReturnType<typeof proSearchFormProps>>> & Omit<ProSchemaFormProps, "inline">;
470
- declare const ProSearchForm: vue.DefineComponent<ProSearchFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProSearchFormProps>, {}>;
471
-
472
- declare const proFormItemProps: () => {
903
+ fieldProps: {
904
+ type: ObjectConstructor;
905
+ };
906
+ showProps: {
907
+ type: ObjectConstructor;
908
+ };
909
+ slots: {
910
+ type: ObjectConstructor;
911
+ };
912
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
913
+ name: {
914
+ type: vue.PropType<string | (string | number)[]>;
915
+ };
916
+ }>> & {
917
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
918
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
919
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
920
+ } & {
921
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
922
+ readonly error?: string | undefined;
923
+ readonly label?: string | undefined;
924
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
925
+ readonly for?: string | undefined;
926
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
927
+ 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;
928
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
929
+ } & Partial<vue.ExtractPropTypes<{
473
930
  readonly: {
474
931
  type: BooleanConstructor;
475
932
  default: undefined;
@@ -480,44 +937,205 @@ declare const proFormItemProps: () => {
480
937
  showProps: {
481
938
  type: ObjectConstructor;
482
939
  };
483
- };
484
- declare type ProCreateFormItemProps = Partial<ExtractPropTypes<ReturnType<typeof proFormItemProps>>> & ProFormItemProps & Record<string, any>;
485
- declare const createFormItemComponent: ({ InputComp, valueType, name, }: {
486
- InputComp: any;
487
- valueType: TValueType;
488
- name: string;
489
- }) => vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<ProCreateFormItemProps>>, {
490
- [x: string]: any;
491
- }>;
492
-
493
- declare const ProFormText: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
494
- [x: string]: any;
495
- }>;
496
- declare const ProFormTextNumber: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
497
- [x: string]: any;
498
- }>;
499
- declare const ProFormDatePicker: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
500
- [x: string]: any;
501
- }>;
502
- declare const ProFormTimePicker: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
503
- [x: string]: any;
504
- }>;
505
- declare const ProFormSelect: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
506
- [x: string]: any;
507
- }>;
508
- declare const ProFormTreeSelect: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
509
- [x: string]: any;
510
- }>;
511
- declare const ProFormCheckbox: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
940
+ slots: {
941
+ type: ObjectConstructor;
942
+ };
943
+ }>> & Record<string, any>>>, {
512
944
  [x: string]: any;
513
945
  }>;
514
- declare const ProFormRadio: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
946
+ declare const ProFormRadio: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
947
+ name: {
948
+ type: vue.PropType<string | (string | number)[]>;
949
+ };
950
+ }>> & {
951
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
952
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
953
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
954
+ } & {
955
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
956
+ readonly error?: string | undefined;
957
+ readonly label?: string | undefined;
958
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
959
+ readonly for?: string | undefined;
960
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
961
+ 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;
962
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
963
+ } & Partial<vue.ExtractPropTypes<{
964
+ readonly: {
965
+ type: BooleanConstructor;
966
+ default: undefined;
967
+ };
968
+ fieldProps: {
969
+ type: ObjectConstructor;
970
+ };
971
+ showProps: {
972
+ type: ObjectConstructor;
973
+ };
974
+ slots: {
975
+ type: ObjectConstructor;
976
+ };
977
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
978
+ name: {
979
+ type: vue.PropType<string | (string | number)[]>;
980
+ };
981
+ }>> & {
982
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
983
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
984
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
985
+ } & {
986
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
987
+ readonly error?: string | undefined;
988
+ readonly label?: string | undefined;
989
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
990
+ readonly for?: string | undefined;
991
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
992
+ 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;
993
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
994
+ } & Partial<vue.ExtractPropTypes<{
995
+ readonly: {
996
+ type: BooleanConstructor;
997
+ default: undefined;
998
+ };
999
+ fieldProps: {
1000
+ type: ObjectConstructor;
1001
+ };
1002
+ showProps: {
1003
+ type: ObjectConstructor;
1004
+ };
1005
+ slots: {
1006
+ type: ObjectConstructor;
1007
+ };
1008
+ }>> & Record<string, any>>>, {
515
1009
  [x: string]: any;
516
1010
  }>;
517
- declare const ProFormSwitch: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
1011
+ declare const ProFormSwitch: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1012
+ name: {
1013
+ type: vue.PropType<string | (string | number)[]>;
1014
+ };
1015
+ }>> & {
1016
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1017
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1018
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1019
+ } & {
1020
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1021
+ readonly error?: string | undefined;
1022
+ readonly label?: string | undefined;
1023
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1024
+ readonly for?: string | undefined;
1025
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1026
+ 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;
1027
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1028
+ } & Partial<vue.ExtractPropTypes<{
1029
+ readonly: {
1030
+ type: BooleanConstructor;
1031
+ default: undefined;
1032
+ };
1033
+ fieldProps: {
1034
+ type: ObjectConstructor;
1035
+ };
1036
+ showProps: {
1037
+ type: ObjectConstructor;
1038
+ };
1039
+ slots: {
1040
+ type: ObjectConstructor;
1041
+ };
1042
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
1043
+ name: {
1044
+ type: vue.PropType<string | (string | number)[]>;
1045
+ };
1046
+ }>> & {
1047
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1048
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1049
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1050
+ } & {
1051
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1052
+ readonly error?: string | undefined;
1053
+ readonly label?: string | undefined;
1054
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1055
+ readonly for?: string | undefined;
1056
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1057
+ 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;
1058
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1059
+ } & Partial<vue.ExtractPropTypes<{
1060
+ readonly: {
1061
+ type: BooleanConstructor;
1062
+ default: undefined;
1063
+ };
1064
+ fieldProps: {
1065
+ type: ObjectConstructor;
1066
+ };
1067
+ showProps: {
1068
+ type: ObjectConstructor;
1069
+ };
1070
+ slots: {
1071
+ type: ObjectConstructor;
1072
+ };
1073
+ }>> & Record<string, any>>>, {
518
1074
  [x: string]: any;
519
1075
  }>;
520
- declare const ProFormCascader: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
1076
+ declare const ProFormCascader: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1077
+ name: {
1078
+ type: vue.PropType<string | (string | number)[]>;
1079
+ };
1080
+ }>> & {
1081
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1082
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1083
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1084
+ } & {
1085
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1086
+ readonly error?: string | undefined;
1087
+ readonly label?: string | undefined;
1088
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1089
+ readonly for?: string | undefined;
1090
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1091
+ 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;
1092
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1093
+ } & Partial<vue.ExtractPropTypes<{
1094
+ readonly: {
1095
+ type: BooleanConstructor;
1096
+ default: undefined;
1097
+ };
1098
+ fieldProps: {
1099
+ type: ObjectConstructor;
1100
+ };
1101
+ showProps: {
1102
+ type: ObjectConstructor;
1103
+ };
1104
+ slots: {
1105
+ type: ObjectConstructor;
1106
+ };
1107
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
1108
+ name: {
1109
+ type: vue.PropType<string | (string | number)[]>;
1110
+ };
1111
+ }>> & {
1112
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1113
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1114
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1115
+ } & {
1116
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1117
+ readonly error?: string | undefined;
1118
+ readonly label?: string | undefined;
1119
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1120
+ readonly for?: string | undefined;
1121
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1122
+ 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;
1123
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1124
+ } & Partial<vue.ExtractPropTypes<{
1125
+ readonly: {
1126
+ type: BooleanConstructor;
1127
+ default: undefined;
1128
+ };
1129
+ fieldProps: {
1130
+ type: ObjectConstructor;
1131
+ };
1132
+ showProps: {
1133
+ type: ObjectConstructor;
1134
+ };
1135
+ slots: {
1136
+ type: ObjectConstructor;
1137
+ };
1138
+ }>> & Record<string, any>>>, {
521
1139
  [x: string]: any;
522
1140
  }>;
523
1141
  interface ButtonProps {
@@ -549,34 +1167,97 @@ declare const proFormListProps: () => {
549
1167
  addButtonProps: {
550
1168
  type: PropType<ButtonProps$1>;
551
1169
  };
552
- rowKey: {
1170
+ minusButtonText: {
553
1171
  type: StringConstructor;
554
1172
  default: string;
555
1173
  };
1174
+ minusButtonProps: {
1175
+ type: PropType<ButtonProps$1>;
1176
+ };
556
1177
  };
557
- declare type ProFormListProps = Partial<ExtractPropTypes<ReturnType<typeof proFormListProps>>> & ProFormItemProps;
1178
+ declare type ProFormListProps = Partial<ExtractPropTypes<ReturnType<typeof proFormListProps>>> & ProFormListProps$1 & ProFormItemProps;
558
1179
  declare const ProFormList: vue.DefineComponent<ProFormListProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormListProps>, {}>;
559
1180
 
560
- interface IProFormProvide extends Record<string, any> {
561
- formRef: Ref<FormInstance & {
562
- submit: () => void;
563
- }>;
564
- formState: UnwrapNestedRefs<Record<string, any>>;
565
- showState: UnwrapNestedRefs<Record<string, any>>;
566
- readonlyState: UnwrapNestedRefs<Record<string, any>>;
567
- disableState: UnwrapNestedRefs<Record<string, any>>;
568
- readonly: Ref<boolean | undefined>;
569
- elementMap?: {
570
- [key: string]: DefineComponent;
1181
+ declare const createFormItemComponent: ({ InputComp, valueType, name }: {
1182
+ InputComp: any;
1183
+ valueType: string;
1184
+ name?: string | undefined;
1185
+ }) => vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1186
+ name: {
1187
+ type: vue.PropType<string | (string | number)[]>;
1188
+ };
1189
+ }>> & {
1190
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1191
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1192
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1193
+ } & {
1194
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1195
+ readonly error?: string | undefined;
1196
+ readonly label?: string | undefined;
1197
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1198
+ readonly for?: string | undefined;
1199
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1200
+ 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;
1201
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1202
+ } & Partial<vue.ExtractPropTypes<{
1203
+ readonly: {
1204
+ type: BooleanConstructor;
1205
+ default: undefined;
571
1206
  };
572
- }
573
- declare const useProForm: () => IProFormProvide;
574
- declare const provideProForm: (ctx: IProFormProvide) => void;
575
- interface IProFormListProvide {
576
- pathList: (string | number)[];
577
- }
578
- declare const useProFormList: () => IProFormListProvide;
579
- declare const provideProFormList: (ctx: IProFormListProvide) => void;
1207
+ fieldProps: {
1208
+ type: ObjectConstructor;
1209
+ };
1210
+ showProps: {
1211
+ type: ObjectConstructor;
1212
+ };
1213
+ slots: {
1214
+ type: ObjectConstructor;
1215
+ };
1216
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
1217
+ name: {
1218
+ type: vue.PropType<string | (string | number)[]>;
1219
+ };
1220
+ }>> & {
1221
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1222
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1223
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1224
+ } & {
1225
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1226
+ readonly error?: string | undefined;
1227
+ readonly label?: string | undefined;
1228
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1229
+ readonly for?: string | undefined;
1230
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1231
+ 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;
1232
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1233
+ } & Partial<vue.ExtractPropTypes<{
1234
+ readonly: {
1235
+ type: BooleanConstructor;
1236
+ default: undefined;
1237
+ };
1238
+ fieldProps: {
1239
+ type: ObjectConstructor;
1240
+ };
1241
+ showProps: {
1242
+ type: ObjectConstructor;
1243
+ };
1244
+ slots: {
1245
+ type: ObjectConstructor;
1246
+ };
1247
+ }>> & Record<string, any>>>, {
1248
+ [x: string]: any;
1249
+ }>;
1250
+
1251
+ declare type ProTableProps = Omit<ProTableProps$1, "columns"> & {
1252
+ columns?: TColumns;
1253
+ } & Omit<TableProps<any>, "tableLayout" | "flexible" | "data"> & {
1254
+ tableLayout?: "fixed" | "auto";
1255
+ flexible?: boolean;
1256
+ data?: any;
1257
+ };
1258
+ declare const ProTable: vue.DefineComponent<ProTableProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProTableProps>, {
1259
+ data?: any;
1260
+ }>;
580
1261
 
581
1262
  /**
582
1263
  * 添加 和 修改 时候的确定按钮
@@ -670,7 +1351,7 @@ declare const proCurdFormProps: () => {
670
1351
  }>>>;
671
1352
  };
672
1353
  };
673
- declare type ProCurdFormProps = Partial<ExtractPropTypes<ReturnType<typeof proCurdFormProps>>> & ProSchemaFormProps;
1354
+ declare type ProCurdFormProps = Partial<ExtractPropTypes<ReturnType<typeof proCurdFormProps>>> & ProFormProps;
674
1355
  declare const ProCurdForm: vue.DefineComponent<ProCurdFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProCurdFormProps>, {}>;
675
1356
  declare const ProCurdFormConnect: vue.DefineComponent<{}, () => JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<{}>>, {}>;
676
1357
 
@@ -687,29 +1368,31 @@ declare const ProCurdList: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
687
1368
  type: vue.PropType<ProSearchFormProps>;
688
1369
  };
689
1370
  tableProps: {
690
- type: vue.PropType<Partial<vue.ExtractPropTypes<{
1371
+ type: vue.PropType<Omit<Partial<vue.ExtractPropTypes<{
691
1372
  operate: {
692
- type: vue.PropType<ITableOperate>;
1373
+ type: vue.PropType<_vue_start_pro.ITableOperate>;
693
1374
  };
694
1375
  columnEmptyText: {
695
1376
  type: StringConstructor;
696
1377
  };
697
1378
  column: {
698
- type: vue.PropType<TableColumnCtx<any>>;
1379
+ type: vue.PropType<_vue_start_pro.TTableColumn>;
699
1380
  };
700
1381
  columns: {
701
- type: vue.PropType<TColumns>;
1382
+ type: vue.PropType<_vue_start_pro.TTableColumns>;
702
1383
  };
703
1384
  elementMap: {
704
- type: vue.PropType<{
705
- [key: string]: any;
706
- }>;
1385
+ type: vue.PropType<_vue_start_pro.TElementMap>;
707
1386
  };
708
1387
  loading: {
709
1388
  type: BooleanConstructor;
710
- default: boolean;
711
1389
  };
712
- }>> & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
1390
+ provideExtra: {
1391
+ type: vue.PropType<_vue_start_pro.IProTableProvideExtra>;
1392
+ };
1393
+ }>>, "columns"> & {
1394
+ columns?: TColumns | undefined;
1395
+ } & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
713
1396
  tableLayout?: "fixed" | "auto" | undefined;
714
1397
  flexible?: boolean | undefined;
715
1398
  data?: any;
@@ -734,29 +1417,31 @@ declare const ProCurdList: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
734
1417
  type: vue.PropType<ProSearchFormProps>;
735
1418
  };
736
1419
  tableProps: {
737
- type: vue.PropType<Partial<vue.ExtractPropTypes<{
1420
+ type: vue.PropType<Omit<Partial<vue.ExtractPropTypes<{
738
1421
  operate: {
739
- type: vue.PropType<ITableOperate>;
1422
+ type: vue.PropType<_vue_start_pro.ITableOperate>;
740
1423
  };
741
1424
  columnEmptyText: {
742
1425
  type: StringConstructor;
743
1426
  };
744
1427
  column: {
745
- type: vue.PropType<TableColumnCtx<any>>;
1428
+ type: vue.PropType<_vue_start_pro.TTableColumn>;
746
1429
  };
747
1430
  columns: {
748
- type: vue.PropType<TColumns>;
1431
+ type: vue.PropType<_vue_start_pro.TTableColumns>;
749
1432
  };
750
1433
  elementMap: {
751
- type: vue.PropType<{
752
- [key: string]: any;
753
- }>;
1434
+ type: vue.PropType<_vue_start_pro.TElementMap>;
754
1435
  };
755
1436
  loading: {
756
1437
  type: BooleanConstructor;
757
- default: boolean;
758
1438
  };
759
- }>> & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
1439
+ provideExtra: {
1440
+ type: vue.PropType<_vue_start_pro.IProTableProvideExtra>;
1441
+ };
1442
+ }>>, "columns"> & {
1443
+ columns?: TColumns | undefined;
1444
+ } & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
760
1445
  tableLayout?: "fixed" | "auto" | undefined;
761
1446
  flexible?: boolean | undefined;
762
1447
  data?: any;
@@ -794,4 +1479,4 @@ declare const ProSelect: vue.DefineComponent<any, {}, {}, {}, {}, vue.ComponentO
794
1479
  [x: string]: any;
795
1480
  }>;
796
1481
 
797
- export { ButtonProps, ContinueAddButton, DescriptionsProps, IOperateItem, ISearchMode, ITableOperate, OkButton, PaginationProps, ProCreateFormItemProps, ProCurdDesc, ProCurdDescConnect, ProCurdForm, ProCurdFormConnect, ProCurdFormProps, ProCurdList, ProCurdListConnect, ProForm, ProFormCascader, ProFormCheckbox, ProFormDatePicker, ProFormItem, ProFormItemProps, ProFormList, ProFormListProps, ProFormProps, ProFormRadio, ProFormSelect, ProFormSwitch, ProFormText, ProFormTextNumber, ProFormTimePicker, ProFormTreeSelect, ProList, ProListProps, ProOperateButton, ProOperateButtonProps, ProSchemaForm, ProSchemaFormProps, ProSearchForm, ProSearchFormProps, ProSelect, ProSelectProps, ProSubmitButton, ProTable, ProTableProps, SearchMode, TPageState, createFormItemComponent, defaultPage, provideProForm, provideProFormList, useProForm, useProFormList };
1482
+ export { ButtonProps, ContinueAddButton, DescriptionsProps, ModalProps, OkButton, PaginationProps, ProCurdDesc, ProCurdDescConnect, ProCurdForm, ProCurdFormConnect, ProCurdFormProps, ProCurdList, ProCurdListConnect, ProCurdModal, ProCurdModalConnect, ProForm, ProFormCascader, ProFormCheckbox, ProFormDatePicker, ProFormItem, ProFormItemProps, ProFormList, ProFormListProps, ProFormProps, ProFormRadio, ProFormSelect, ProFormSwitch, ProFormText, ProFormTextNumber, ProFormTimePicker, ProFormTreeSelect, ProGrid, ProGridProps, ProList, ProListProps, ProOperateButton, ProOperateButtonProps, ProSearchForm, ProSearchFormProps, ProSelect, ProSelectProps, ProSubmitButton, ProTable, ProTableProps, TPageState, createFormItemComponent, defaultPage };