@vue-start/element-pro 0.1.1 → 0.2.1

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 +30 -0
  2. package/dist/index.d.ts +879 -585
  3. package/dist/index.es.js +257 -967
  4. package/dist/index.js +258 -973
  5. package/package.json +2 -3
package/dist/index.d.ts CHANGED
@@ -1,249 +1,40 @@
1
1
  import * as vue from 'vue';
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';
2
+ import { VNode, DefineComponent, ExtractPropTypes, PropType, Component } from 'vue';
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';
9
- import * as element_plus_es_components_table_src_table_defaults from 'element-plus/es/components/table/src/table/defaults';
6
+ import { TTableColumn, ProFormProps as ProFormProps$1, ProSearchFormProps as ProSearchFormProps$1, ProFormListProps as ProFormListProps$1, ProTableProps as ProTableProps$1, ProCurdAddOrEditProps, TPageState } 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';
9
+ import * as element_plus_es_utils from 'element-plus/es/utils';
10
10
  import { TableProps } from 'element-plus/es/components/table/src/table/defaults';
11
+ import { Slots } from '@vue/runtime-core';
11
12
 
12
- interface IOperateItem {
13
- value: string | number;
14
- label?: string | VNode;
15
- element?: (record: Record<string, any>, item: IOperateItem) => VNode;
16
- show?: boolean | ((record: Record<string, any>) => boolean);
17
- disabled?: boolean | ((record: Record<string, any>) => boolean);
18
- onClick?: (record: Record<string, any>) => void;
19
- sort?: number;
20
- }
21
- interface ITableOperate {
22
- column?: TableColumnCtx<any>;
23
- items?: IOperateItem[];
24
- itemState?: {
25
- [key: string]: Omit<IOperateItem, "value">;
26
- };
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
- }>;
68
-
69
- interface PaginationProps {
70
- total?: number;
71
- pageSize?: number;
72
- defaultPageSize?: number;
73
- currentPage?: number;
74
- defaultCurrentPage?: number;
75
- pageCount?: number;
76
- pagerCount?: number;
77
- layout?: string;
78
- pageSizes?: number[];
79
- popperClass?: string;
80
- prevText?: string;
81
- nextText?: string;
82
- small?: boolean;
83
- background?: boolean;
84
- disabled?: boolean;
85
- hideOnSinglePage?: boolean;
86
- onSizeChange?: (val: number) => void;
87
- onCurrentChange?: (val: number) => void;
13
+ interface ModalProps {
14
+ appendToBody?: boolean;
15
+ beforeClose?: (done: () => void) => void;
16
+ destroyOnClose?: boolean;
17
+ closeOnClickModal?: boolean;
18
+ closeOnPressEscape?: boolean;
19
+ lockScroll?: boolean;
20
+ modal?: boolean;
21
+ openDelay?: number;
22
+ closeDelay?: number;
23
+ top?: string;
24
+ modelValue?: boolean;
25
+ modalClass?: string;
26
+ width?: string | number;
27
+ zIndex?: number;
28
+ trapFocus?: boolean;
29
+ center?: boolean;
30
+ customClass?: string;
31
+ draggable?: boolean;
32
+ fullscreen?: boolean;
33
+ showClose?: boolean;
34
+ title?: string;
88
35
  }
89
- declare type TPageState = {
90
- page: number;
91
- pageSize: number;
92
- };
93
- declare const defaultPage: TPageState;
94
- declare const proListProps: () => {
95
- /**
96
- * extra 是否放到SearchForm中
97
- */
98
- extraInSearch: {
99
- type: BooleanConstructor;
100
- default: undefined;
101
- };
102
- searchProps: {
103
- type: PropType<ProSearchFormProps>;
104
- };
105
- tableProps: {
106
- type: PropType<Partial<ExtractPropTypes<{
107
- operate: {
108
- type: PropType<ITableOperate>;
109
- };
110
- columnEmptyText: {
111
- type: StringConstructor;
112
- };
113
- column: {
114
- type: PropType<TableColumnCtx<any>>;
115
- };
116
- columns: {
117
- type: PropType<TColumns>;
118
- };
119
- elementMap: {
120
- type: PropType<{
121
- [key: string]: any;
122
- }>;
123
- };
124
- loading: {
125
- type: BooleanConstructor;
126
- default: boolean;
127
- };
128
- }>> & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
129
- tableLayout?: "fixed" | "auto" | undefined;
130
- flexible?: boolean | undefined;
131
- data?: any;
132
- } & {
133
- slots?: Readonly<{
134
- [name: string]: vue.Slot | undefined;
135
- }> | undefined;
136
- }>;
137
- };
138
- paginationProps: {
139
- type: PropType<PaginationProps>;
140
- };
141
- pageState: {
142
- type: PropType<TPageState>;
143
- };
144
- };
145
- declare type ProListProps = Partial<ExtractPropTypes<ReturnType<typeof proListProps>>>;
146
- declare const ProList: vue.DefineComponent<Partial<ExtractPropTypes<{
147
- /**
148
- * extra 是否放到SearchForm中
149
- */
150
- extraInSearch: {
151
- type: BooleanConstructor;
152
- default: undefined;
153
- };
154
- searchProps: {
155
- type: PropType<ProSearchFormProps>;
156
- };
157
- tableProps: {
158
- type: PropType<Partial<ExtractPropTypes<{
159
- operate: {
160
- type: PropType<ITableOperate>;
161
- };
162
- columnEmptyText: {
163
- type: StringConstructor;
164
- };
165
- column: {
166
- type: PropType<TableColumnCtx<any>>;
167
- };
168
- columns: {
169
- type: PropType<TColumns>;
170
- };
171
- elementMap: {
172
- type: PropType<{
173
- [key: string]: any;
174
- }>;
175
- };
176
- loading: {
177
- type: BooleanConstructor;
178
- default: boolean;
179
- };
180
- }>> & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
181
- tableLayout?: "fixed" | "auto" | undefined;
182
- flexible?: boolean | undefined;
183
- data?: any;
184
- } & {
185
- slots?: Readonly<{
186
- [name: string]: vue.Slot | undefined;
187
- }> | undefined;
188
- }>;
189
- };
190
- paginationProps: {
191
- type: PropType<PaginationProps>;
192
- };
193
- pageState: {
194
- type: PropType<TPageState>;
195
- };
196
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
197
- /**
198
- * extra 是否放到SearchForm中
199
- */
200
- extraInSearch: {
201
- type: BooleanConstructor;
202
- default: undefined;
203
- };
204
- searchProps: {
205
- type: PropType<ProSearchFormProps>;
206
- };
207
- tableProps: {
208
- type: PropType<Partial<ExtractPropTypes<{
209
- operate: {
210
- type: PropType<ITableOperate>;
211
- };
212
- columnEmptyText: {
213
- type: StringConstructor;
214
- };
215
- column: {
216
- type: PropType<TableColumnCtx<any>>;
217
- };
218
- columns: {
219
- type: PropType<TColumns>;
220
- };
221
- elementMap: {
222
- type: PropType<{
223
- [key: string]: any;
224
- }>;
225
- };
226
- loading: {
227
- type: BooleanConstructor;
228
- default: boolean;
229
- };
230
- }>> & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
231
- tableLayout?: "fixed" | "auto" | undefined;
232
- flexible?: boolean | undefined;
233
- data?: any;
234
- } & {
235
- slots?: Readonly<{
236
- [name: string]: vue.Slot | undefined;
237
- }> | undefined;
238
- }>;
239
- };
240
- paginationProps: {
241
- type: PropType<PaginationProps>;
242
- };
243
- pageState: {
244
- type: PropType<TPageState>;
245
- };
246
- }>>>, {}>;
36
+ declare const ProCurdModal: vue.DefineComponent<ModalProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ModalProps>, {}>;
37
+ declare const ProCurdModalConnect: vue.DefineComponent<{}, () => JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{}>>, {}>;
247
38
 
248
39
  declare type TOption = {
249
40
  label?: string;
@@ -251,15 +42,10 @@ declare type TOption = {
251
42
  disabled?: boolean;
252
43
  };
253
44
  declare type TOptions = TOption[];
254
- declare type TColumn = TableColumnCtx<any> & Omit<TColumn$1, "formItemProps" | "title" | "dataIndex"> & {
45
+ declare type TColumn = TableColumnCtx<any> & Omit<TTableColumn, "formItemProps" | "title" | "dataIndex"> & {
255
46
  formItemProps?: ProFormItemProps;
256
47
  };
257
48
  declare type TColumns = TColumn[];
258
- declare type BooleanRulesObjType = {
259
- [key: string]: (record: any) => boolean;
260
- };
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
49
  interface TableColumnCtx<T> {
264
50
  id?: string;
265
51
  realWidth?: number;
@@ -320,72 +106,133 @@ interface TableColumnCtx<T> {
320
106
  getColumnIndex?: () => number;
321
107
  no?: number;
322
108
  filterOpened?: boolean;
109
+ }
110
+ interface IRow {
111
+ gutter?: number;
112
+ justify?: "start" | "end" | "center" | "space-around" | "space-between" | "space-evenly";
113
+ align?: "top" | "bottom" | "middle";
114
+ tag?: string;
115
+ }
116
+ interface ICol {
117
+ span?: number;
118
+ offset?: number;
119
+ push?: number;
120
+ pull?: number;
121
+ xs?: ColSizeObject | number;
122
+ sm?: ColSizeObject | number;
123
+ md?: ColSizeObject | number;
124
+ lg?: ColSizeObject | number;
125
+ xl?: ColSizeObject | number;
126
+ tag?: string;
323
127
  }
324
128
 
325
- declare const proFormItemProps$1: () => {
326
- name: {
327
- type: PropType<string | (string | number)[]>;
129
+ declare type ProGridProps = {
130
+ row?: IRow;
131
+ col?: ICol;
132
+ items?: {
133
+ vNode: VNode;
134
+ rowKey?: string | number;
135
+ col?: ICol;
136
+ }[];
137
+ };
138
+ declare const ProGrid: DefineComponent<ProGridProps>;
139
+
140
+ declare const createLoadingId: (prefix?: string) => string;
141
+ declare const proLoadingProps: () => {
142
+ loading: {
143
+ type: BooleanConstructor;
144
+ };
145
+ target: {
146
+ type: PropType<string | HTMLElement>;
147
+ };
148
+ body: {
149
+ type: BooleanConstructor;
150
+ };
151
+ fullscreen: {
152
+ type: BooleanConstructor;
153
+ };
154
+ lock: {
155
+ type: BooleanConstructor;
156
+ };
157
+ text: {
158
+ type: StringConstructor;
159
+ };
160
+ spinner: {
161
+ type: StringConstructor;
162
+ };
163
+ background: {
164
+ type: StringConstructor;
165
+ };
166
+ customClass: {
167
+ type: StringConstructor;
328
168
  };
329
169
  };
330
- declare type ProFormItemProps = Partial<ExtractPropTypes<ReturnType<typeof proFormItemProps$1>>> & FormItemProps;
331
- 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
- */
336
- readonly: {
170
+ declare type ProLoadingProps = Partial<ExtractPropTypes<ReturnType<typeof proLoadingProps>>>;
171
+ declare const ProLoading: vue.DefineComponent<Partial<ExtractPropTypes<{
172
+ loading: {
337
173
  type: BooleanConstructor;
338
- default: undefined;
339
174
  };
340
- /**
341
- * FormComponent 根据此项来确定组件是否显示
342
- * rules 根据rules中方法生成showState对象
343
- */
344
- showState: {
345
- type: PropType<{
346
- [x: string]: boolean;
347
- }>;
348
- };
349
- showStateRules: {
350
- type: PropType<BooleanRulesObjType>;
351
- };
352
- /**
353
- * 是否只读
354
- */
355
- readonlyState: {
356
- type: PropType<{
357
- [x: string]: boolean;
358
- }>;
359
- };
360
- readonlyStateRules: {
361
- type: PropType<BooleanRulesObjType>;
362
- };
363
- /**
364
- * 是否disabled
365
- */
366
- disableState: {
367
- type: PropType<{
368
- [x: string]: boolean;
369
- }>;
370
- };
371
- disableStateRules: {
372
- type: PropType<BooleanRulesObjType>;
373
- };
374
- /**
375
- * 展示控件集合，readonly模式下使用这些组件渲染
376
- */
377
- elementMap: {
378
- type: PropType<TElementMap>;
379
- };
380
- /**
381
- * provide传递
382
- */
383
- provideExtra: {
384
- type: PropType<{
385
- [key: string]: any;
386
- }>;
175
+ target: {
176
+ type: PropType<string | HTMLElement>;
177
+ };
178
+ body: {
179
+ type: BooleanConstructor;
180
+ };
181
+ fullscreen: {
182
+ type: BooleanConstructor;
183
+ };
184
+ lock: {
185
+ type: BooleanConstructor;
186
+ };
187
+ text: {
188
+ type: StringConstructor;
189
+ };
190
+ spinner: {
191
+ type: StringConstructor;
192
+ };
193
+ background: {
194
+ type: StringConstructor;
195
+ };
196
+ customClass: {
197
+ type: StringConstructor;
198
+ };
199
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
200
+ loading: {
201
+ type: BooleanConstructor;
202
+ };
203
+ target: {
204
+ type: PropType<string | HTMLElement>;
205
+ };
206
+ body: {
207
+ type: BooleanConstructor;
208
+ };
209
+ fullscreen: {
210
+ type: BooleanConstructor;
211
+ };
212
+ lock: {
213
+ type: BooleanConstructor;
214
+ };
215
+ text: {
216
+ type: StringConstructor;
217
+ };
218
+ spinner: {
219
+ type: StringConstructor;
220
+ };
221
+ background: {
222
+ type: StringConstructor;
223
+ };
224
+ customClass: {
225
+ type: StringConstructor;
226
+ };
227
+ }>>>, {}>;
228
+
229
+ declare const proFormItemProps: () => {
230
+ name: {
231
+ type: PropType<string | (string | number)[]>;
387
232
  };
388
233
  };
234
+ declare type ProFormItemProps = Partial<ExtractPropTypes<ReturnType<typeof proFormItemProps>>> & FormItemProps;
235
+ declare const ProFormItem: DefineComponent<ProFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormItemProps>, {}>;
389
236
  interface FormProps {
390
237
  model?: Record<string, any>;
391
238
  rules?: FormItemRule[];
@@ -402,74 +249,128 @@ interface FormProps {
402
249
  hideRequiredAsterisk?: boolean;
403
250
  scrollToError?: boolean;
404
251
  }
405
- declare type ProFormProps = Partial<ExtractPropTypes<ReturnType<typeof proFormProps>>> & FormProps & {
252
+ declare type ProFormProps = ProFormProps$1 & FormProps & Omit<ProGridProps, "items"> & {
406
253
  onFinish?: (showValues: Record<string, any>, values: Record<string, any>) => void;
407
254
  onFinishFailed?: (invalidFields: Record<string, any>) => void;
408
255
  };
409
- declare const ProForm: vue.DefineComponent<ProFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormProps>, {}>;
256
+ declare const ProForm: DefineComponent<ProFormProps>;
257
+ declare type ProSearchFormProps = ProSearchFormProps$1 & ProFormProps;
258
+ declare const ProSearchForm: DefineComponent<ProSearchFormProps>;
410
259
 
411
- declare const proSchemaFormProps: () => {
412
- columns: {
413
- type: PropType<TColumns>;
260
+ declare const ProFormText: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
261
+ name: {
262
+ type: vue.PropType<string | (string | number)[]>;
263
+ };
264
+ }>> & {
265
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
266
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
267
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
268
+ } & {
269
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
270
+ readonly error?: string | undefined;
271
+ readonly label?: string | undefined;
272
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
273
+ readonly for?: string | undefined;
274
+ 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;
275
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
276
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
277
+ } & Partial<vue.ExtractPropTypes<{
278
+ readonly: {
279
+ type: BooleanConstructor;
280
+ default: undefined;
414
281
  };
415
- /**
416
- * 录入控件集合，通过column->valueType 查找对应的录入组件
417
- */
418
- formElementMap: {
419
- type: PropType<TElementMap>;
282
+ fieldProps: {
283
+ type: ObjectConstructor;
420
284
  };
421
- /**
422
- * 是否启用rules验证
423
- */
424
- needRules: {
425
- type: BooleanConstructor;
426
- default: boolean;
285
+ showProps: {
286
+ type: ObjectConstructor;
427
287
  };
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: {
288
+ slots: {
289
+ type: ObjectConstructor;
290
+ };
291
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
292
+ name: {
293
+ type: vue.PropType<string | (string | number)[]>;
294
+ };
295
+ }>> & {
296
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
297
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
298
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
299
+ } & {
300
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
301
+ readonly error?: string | undefined;
302
+ readonly label?: string | undefined;
303
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
304
+ readonly for?: string | undefined;
305
+ 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;
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 validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
308
+ } & Partial<vue.ExtractPropTypes<{
309
+ readonly: {
444
310
  type: BooleanConstructor;
445
- default: boolean;
311
+ default: undefined;
446
312
  };
447
- /**
448
- * 模式 自动触发或者手动触发 onFinish
449
- */
450
- searchMode: {
451
- type: PropType<"AUTO" | "MANUAL">;
452
- default: SearchMode;
313
+ fieldProps: {
314
+ type: ObjectConstructor;
453
315
  };
454
- /**
455
- * 需要debounce处理的字段
456
- */
457
- debounceKeys: {
458
- type: PropType<string[]>;
316
+ showProps: {
317
+ type: ObjectConstructor;
459
318
  };
460
- debounceTime: {
461
- type: NumberConstructor;
462
- default: number;
319
+ slots: {
320
+ type: ObjectConstructor;
463
321
  };
464
- inline: {
322
+ }>> & Record<string, any>>>, {
323
+ [x: string]: any;
324
+ }>;
325
+ declare const ProFormTextNumber: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
326
+ name: {
327
+ type: vue.PropType<string | (string | number)[]>;
328
+ };
329
+ }>> & {
330
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
331
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
332
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
333
+ } & {
334
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
335
+ readonly error?: string | undefined;
336
+ readonly label?: string | undefined;
337
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
338
+ readonly for?: string | undefined;
339
+ 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;
340
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
341
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
342
+ } & Partial<vue.ExtractPropTypes<{
343
+ readonly: {
465
344
  type: BooleanConstructor;
466
- default: boolean;
345
+ default: undefined;
467
346
  };
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: () => {
347
+ fieldProps: {
348
+ type: ObjectConstructor;
349
+ };
350
+ showProps: {
351
+ type: ObjectConstructor;
352
+ };
353
+ slots: {
354
+ type: ObjectConstructor;
355
+ };
356
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
357
+ name: {
358
+ type: vue.PropType<string | (string | number)[]>;
359
+ };
360
+ }>> & {
361
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
362
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
363
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
364
+ } & {
365
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
366
+ readonly error?: string | undefined;
367
+ readonly label?: string | undefined;
368
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
369
+ readonly for?: string | undefined;
370
+ 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;
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 validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
373
+ } & Partial<vue.ExtractPropTypes<{
473
374
  readonly: {
474
375
  type: BooleanConstructor;
475
376
  default: undefined;
@@ -480,44 +381,530 @@ declare const proFormItemProps: () => {
480
381
  showProps: {
481
382
  type: ObjectConstructor;
482
383
  };
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>>, {
384
+ slots: {
385
+ type: ObjectConstructor;
386
+ };
387
+ }>> & Record<string, any>>>, {
497
388
  [x: string]: any;
498
389
  }>;
499
- declare const ProFormDatePicker: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
390
+ declare const ProFormDatePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
391
+ name: {
392
+ type: vue.PropType<string | (string | number)[]>;
393
+ };
394
+ }>> & {
395
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
396
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
397
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
398
+ } & {
399
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
400
+ readonly error?: string | undefined;
401
+ readonly label?: string | undefined;
402
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
403
+ readonly for?: string | undefined;
404
+ 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;
405
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
406
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
407
+ } & Partial<vue.ExtractPropTypes<{
408
+ readonly: {
409
+ type: BooleanConstructor;
410
+ default: undefined;
411
+ };
412
+ fieldProps: {
413
+ type: ObjectConstructor;
414
+ };
415
+ showProps: {
416
+ type: ObjectConstructor;
417
+ };
418
+ slots: {
419
+ type: ObjectConstructor;
420
+ };
421
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
422
+ name: {
423
+ type: vue.PropType<string | (string | number)[]>;
424
+ };
425
+ }>> & {
426
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
427
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
428
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
429
+ } & {
430
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
431
+ readonly error?: string | undefined;
432
+ readonly label?: string | undefined;
433
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
434
+ readonly for?: string | undefined;
435
+ 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;
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 validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
438
+ } & Partial<vue.ExtractPropTypes<{
439
+ readonly: {
440
+ type: BooleanConstructor;
441
+ default: undefined;
442
+ };
443
+ fieldProps: {
444
+ type: ObjectConstructor;
445
+ };
446
+ showProps: {
447
+ type: ObjectConstructor;
448
+ };
449
+ slots: {
450
+ type: ObjectConstructor;
451
+ };
452
+ }>> & Record<string, any>>>, {
500
453
  [x: string]: any;
501
454
  }>;
502
- declare const ProFormTimePicker: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
455
+ declare const ProFormTimePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
456
+ name: {
457
+ type: vue.PropType<string | (string | number)[]>;
458
+ };
459
+ }>> & {
460
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
461
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
462
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
463
+ } & {
464
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
465
+ readonly error?: string | undefined;
466
+ readonly label?: string | undefined;
467
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
468
+ readonly for?: string | undefined;
469
+ 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;
470
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
471
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
472
+ } & Partial<vue.ExtractPropTypes<{
473
+ readonly: {
474
+ type: BooleanConstructor;
475
+ default: undefined;
476
+ };
477
+ fieldProps: {
478
+ type: ObjectConstructor;
479
+ };
480
+ showProps: {
481
+ type: ObjectConstructor;
482
+ };
483
+ slots: {
484
+ type: ObjectConstructor;
485
+ };
486
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
487
+ name: {
488
+ type: vue.PropType<string | (string | number)[]>;
489
+ };
490
+ }>> & {
491
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
492
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
493
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
494
+ } & {
495
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
496
+ readonly error?: string | undefined;
497
+ readonly label?: string | undefined;
498
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
499
+ readonly for?: string | undefined;
500
+ 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;
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 validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
503
+ } & Partial<vue.ExtractPropTypes<{
504
+ readonly: {
505
+ type: BooleanConstructor;
506
+ default: undefined;
507
+ };
508
+ fieldProps: {
509
+ type: ObjectConstructor;
510
+ };
511
+ showProps: {
512
+ type: ObjectConstructor;
513
+ };
514
+ slots: {
515
+ type: ObjectConstructor;
516
+ };
517
+ }>> & Record<string, any>>>, {
503
518
  [x: string]: any;
504
519
  }>;
505
- declare const ProFormSelect: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
520
+ declare const ProFormSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
521
+ name: {
522
+ type: vue.PropType<string | (string | number)[]>;
523
+ };
524
+ }>> & {
525
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
526
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
527
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
528
+ } & {
529
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
530
+ readonly error?: string | undefined;
531
+ readonly label?: string | undefined;
532
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
533
+ readonly for?: string | undefined;
534
+ 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;
535
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
536
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
537
+ } & Partial<vue.ExtractPropTypes<{
538
+ readonly: {
539
+ type: BooleanConstructor;
540
+ default: undefined;
541
+ };
542
+ fieldProps: {
543
+ type: ObjectConstructor;
544
+ };
545
+ showProps: {
546
+ type: ObjectConstructor;
547
+ };
548
+ slots: {
549
+ type: ObjectConstructor;
550
+ };
551
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
552
+ name: {
553
+ type: vue.PropType<string | (string | number)[]>;
554
+ };
555
+ }>> & {
556
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
557
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
558
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
559
+ } & {
560
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
561
+ readonly error?: string | undefined;
562
+ readonly label?: string | undefined;
563
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
564
+ readonly for?: string | undefined;
565
+ 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;
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 validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
568
+ } & Partial<vue.ExtractPropTypes<{
569
+ readonly: {
570
+ type: BooleanConstructor;
571
+ default: undefined;
572
+ };
573
+ fieldProps: {
574
+ type: ObjectConstructor;
575
+ };
576
+ showProps: {
577
+ type: ObjectConstructor;
578
+ };
579
+ slots: {
580
+ type: ObjectConstructor;
581
+ };
582
+ }>> & Record<string, any>>>, {
506
583
  [x: string]: any;
507
584
  }>;
508
- declare const ProFormTreeSelect: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
585
+ declare const ProFormTreeSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
586
+ name: {
587
+ type: vue.PropType<string | (string | number)[]>;
588
+ };
589
+ }>> & {
590
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
591
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
592
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
593
+ } & {
594
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
595
+ readonly error?: string | undefined;
596
+ readonly label?: string | undefined;
597
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
598
+ readonly for?: string | undefined;
599
+ 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;
600
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
601
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
602
+ } & Partial<vue.ExtractPropTypes<{
603
+ readonly: {
604
+ type: BooleanConstructor;
605
+ default: undefined;
606
+ };
607
+ fieldProps: {
608
+ type: ObjectConstructor;
609
+ };
610
+ showProps: {
611
+ type: ObjectConstructor;
612
+ };
613
+ slots: {
614
+ type: ObjectConstructor;
615
+ };
616
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
617
+ name: {
618
+ type: vue.PropType<string | (string | number)[]>;
619
+ };
620
+ }>> & {
621
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
622
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
623
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
624
+ } & {
625
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
626
+ readonly error?: string | undefined;
627
+ readonly label?: string | undefined;
628
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
629
+ readonly for?: string | undefined;
630
+ 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;
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 validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
633
+ } & Partial<vue.ExtractPropTypes<{
634
+ readonly: {
635
+ type: BooleanConstructor;
636
+ default: undefined;
637
+ };
638
+ fieldProps: {
639
+ type: ObjectConstructor;
640
+ };
641
+ showProps: {
642
+ type: ObjectConstructor;
643
+ };
644
+ slots: {
645
+ type: ObjectConstructor;
646
+ };
647
+ }>> & Record<string, any>>>, {
509
648
  [x: string]: any;
510
649
  }>;
511
- declare const ProFormCheckbox: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
650
+ declare const ProFormCheckbox: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
651
+ name: {
652
+ type: vue.PropType<string | (string | number)[]>;
653
+ };
654
+ }>> & {
655
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
656
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
657
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
658
+ } & {
659
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
660
+ readonly error?: string | undefined;
661
+ readonly label?: string | undefined;
662
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
663
+ readonly for?: string | undefined;
664
+ 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;
665
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
666
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
667
+ } & Partial<vue.ExtractPropTypes<{
668
+ readonly: {
669
+ type: BooleanConstructor;
670
+ default: undefined;
671
+ };
672
+ fieldProps: {
673
+ type: ObjectConstructor;
674
+ };
675
+ showProps: {
676
+ type: ObjectConstructor;
677
+ };
678
+ slots: {
679
+ type: ObjectConstructor;
680
+ };
681
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
682
+ name: {
683
+ type: vue.PropType<string | (string | number)[]>;
684
+ };
685
+ }>> & {
686
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
687
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
688
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
689
+ } & {
690
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
691
+ readonly error?: string | undefined;
692
+ readonly label?: string | undefined;
693
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
694
+ readonly for?: string | undefined;
695
+ 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;
696
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
697
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
698
+ } & Partial<vue.ExtractPropTypes<{
699
+ readonly: {
700
+ type: BooleanConstructor;
701
+ default: undefined;
702
+ };
703
+ fieldProps: {
704
+ type: ObjectConstructor;
705
+ };
706
+ showProps: {
707
+ type: ObjectConstructor;
708
+ };
709
+ slots: {
710
+ type: ObjectConstructor;
711
+ };
712
+ }>> & Record<string, any>>>, {
512
713
  [x: string]: any;
513
714
  }>;
514
- declare const ProFormRadio: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
715
+ declare const ProFormRadio: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
716
+ name: {
717
+ type: vue.PropType<string | (string | number)[]>;
718
+ };
719
+ }>> & {
720
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
721
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
722
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
723
+ } & {
724
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
725
+ readonly error?: string | undefined;
726
+ readonly label?: string | undefined;
727
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
728
+ readonly for?: string | undefined;
729
+ 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;
730
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
731
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
732
+ } & Partial<vue.ExtractPropTypes<{
733
+ readonly: {
734
+ type: BooleanConstructor;
735
+ default: undefined;
736
+ };
737
+ fieldProps: {
738
+ type: ObjectConstructor;
739
+ };
740
+ showProps: {
741
+ type: ObjectConstructor;
742
+ };
743
+ slots: {
744
+ type: ObjectConstructor;
745
+ };
746
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
747
+ name: {
748
+ type: vue.PropType<string | (string | number)[]>;
749
+ };
750
+ }>> & {
751
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
752
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
753
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
754
+ } & {
755
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
756
+ readonly error?: string | undefined;
757
+ readonly label?: string | undefined;
758
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
759
+ readonly for?: string | undefined;
760
+ 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;
761
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
762
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
763
+ } & Partial<vue.ExtractPropTypes<{
764
+ readonly: {
765
+ type: BooleanConstructor;
766
+ default: undefined;
767
+ };
768
+ fieldProps: {
769
+ type: ObjectConstructor;
770
+ };
771
+ showProps: {
772
+ type: ObjectConstructor;
773
+ };
774
+ slots: {
775
+ type: ObjectConstructor;
776
+ };
777
+ }>> & Record<string, any>>>, {
515
778
  [x: string]: any;
516
779
  }>;
517
- declare const ProFormSwitch: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
780
+ declare const ProFormSwitch: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
781
+ name: {
782
+ type: vue.PropType<string | (string | number)[]>;
783
+ };
784
+ }>> & {
785
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
786
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
787
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
788
+ } & {
789
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
790
+ readonly error?: string | undefined;
791
+ readonly label?: string | undefined;
792
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
793
+ readonly for?: string | undefined;
794
+ 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;
795
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
796
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
797
+ } & 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
+ }>> & Record<string, any>, {}, {}, {}, {}, 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 error?: string | undefined;
822
+ readonly label?: string | undefined;
823
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
824
+ readonly for?: string | undefined;
825
+ 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;
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 validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | 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>>>, {
518
843
  [x: string]: any;
519
844
  }>;
520
- declare const ProFormCascader: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
845
+ declare const ProFormCascader: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
846
+ name: {
847
+ type: vue.PropType<string | (string | number)[]>;
848
+ };
849
+ }>> & {
850
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
851
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
852
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
853
+ } & {
854
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
855
+ readonly error?: string | undefined;
856
+ readonly label?: string | undefined;
857
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
858
+ readonly for?: string | undefined;
859
+ 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;
860
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
861
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
862
+ } & Partial<vue.ExtractPropTypes<{
863
+ readonly: {
864
+ type: BooleanConstructor;
865
+ default: undefined;
866
+ };
867
+ fieldProps: {
868
+ type: ObjectConstructor;
869
+ };
870
+ showProps: {
871
+ type: ObjectConstructor;
872
+ };
873
+ slots: {
874
+ type: ObjectConstructor;
875
+ };
876
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
877
+ name: {
878
+ type: vue.PropType<string | (string | number)[]>;
879
+ };
880
+ }>> & {
881
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
882
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
883
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
884
+ } & {
885
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
886
+ readonly error?: string | undefined;
887
+ readonly label?: string | undefined;
888
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
889
+ readonly for?: string | undefined;
890
+ 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;
891
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
892
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
893
+ } & Partial<vue.ExtractPropTypes<{
894
+ readonly: {
895
+ type: BooleanConstructor;
896
+ default: undefined;
897
+ };
898
+ fieldProps: {
899
+ type: ObjectConstructor;
900
+ };
901
+ showProps: {
902
+ type: ObjectConstructor;
903
+ };
904
+ slots: {
905
+ type: ObjectConstructor;
906
+ };
907
+ }>> & Record<string, any>>>, {
521
908
  [x: string]: any;
522
909
  }>;
523
910
  interface ButtonProps {
@@ -549,230 +936,137 @@ declare const proFormListProps: () => {
549
936
  addButtonProps: {
550
937
  type: PropType<ButtonProps$1>;
551
938
  };
552
- rowKey: {
939
+ minusButtonText: {
553
940
  type: StringConstructor;
554
941
  default: string;
555
942
  };
943
+ minusButtonProps: {
944
+ type: PropType<ButtonProps$1>;
945
+ };
556
946
  };
557
- declare type ProFormListProps = Partial<ExtractPropTypes<ReturnType<typeof proFormListProps>>> & ProFormItemProps;
947
+ declare type ProFormListProps = Partial<ExtractPropTypes<ReturnType<typeof proFormListProps>>> & ProFormListProps$1 & ProFormItemProps;
558
948
  declare const ProFormList: vue.DefineComponent<ProFormListProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormListProps>, {}>;
559
949
 
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;
571
- };
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;
580
-
581
- /**
582
- * 添加 和 修改 时候的确定按钮
583
- */
584
- declare const OkButton: vue.DefineComponent<ButtonProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ButtonProps>, {}>;
585
- /**
586
- * 添加 时候的 确定并继续添加按钮
587
- */
588
- declare const ContinueAddButton: vue.DefineComponent<ButtonProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ButtonProps>, {}>;
589
- declare const proOperateButtonProps: () => {
590
- showContinueAdd: {
950
+ declare const createFormItemComponent: ({ InputComp, valueType, name }: {
951
+ InputComp: any;
952
+ valueType: string;
953
+ name?: string | undefined;
954
+ }) => vue.DefineComponent<Partial<vue.ExtractPropTypes<{
955
+ name: {
956
+ type: vue.PropType<string | (string | number)[]>;
957
+ };
958
+ }>> & {
959
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
960
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
961
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
962
+ } & {
963
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
964
+ readonly error?: string | undefined;
965
+ readonly label?: string | undefined;
966
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
967
+ readonly for?: string | undefined;
968
+ 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;
969
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
970
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
971
+ } & Partial<vue.ExtractPropTypes<{
972
+ readonly: {
591
973
  type: BooleanConstructor;
592
- default: boolean;
593
- };
594
- okText: {
595
- type: StringConstructor;
596
- default: string;
974
+ default: undefined;
597
975
  };
598
- okButtonProps: {
599
- type: PropType<ButtonProps>;
976
+ fieldProps: {
977
+ type: ObjectConstructor;
600
978
  };
601
- continueText: {
602
- type: StringConstructor;
603
- default: string;
979
+ showProps: {
980
+ type: ObjectConstructor;
604
981
  };
605
- continueButtonProps: {
606
- type: PropType<ButtonProps>;
982
+ slots: {
983
+ type: ObjectConstructor;
607
984
  };
608
- };
609
- declare type ProOperateButtonProps = Partial<ExtractPropTypes<ReturnType<typeof proOperateButtonProps>>>;
610
- declare const ProOperateButton: vue.DefineComponent<Partial<ExtractPropTypes<{
611
- showContinueAdd: {
985
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
986
+ name: {
987
+ type: vue.PropType<string | (string | number)[]>;
988
+ };
989
+ }>> & {
990
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
991
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
992
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
993
+ } & {
994
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
995
+ readonly error?: string | undefined;
996
+ readonly label?: string | undefined;
997
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
998
+ readonly for?: string | undefined;
999
+ 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;
1000
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
1001
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1002
+ } & Partial<vue.ExtractPropTypes<{
1003
+ readonly: {
612
1004
  type: BooleanConstructor;
613
- default: boolean;
614
- };
615
- okText: {
616
- type: StringConstructor;
617
- default: string;
618
- };
619
- okButtonProps: {
620
- type: PropType<ButtonProps>;
621
- };
622
- continueText: {
623
- type: StringConstructor;
624
- default: string;
625
- };
626
- continueButtonProps: {
627
- type: PropType<ButtonProps>;
1005
+ default: undefined;
628
1006
  };
629
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
630
- showContinueAdd: {
631
- type: BooleanConstructor;
632
- default: boolean;
1007
+ fieldProps: {
1008
+ type: ObjectConstructor;
633
1009
  };
634
- okText: {
635
- type: StringConstructor;
636
- default: string;
1010
+ showProps: {
1011
+ type: ObjectConstructor;
637
1012
  };
638
- okButtonProps: {
639
- type: PropType<ButtonProps>;
1013
+ slots: {
1014
+ type: ObjectConstructor;
640
1015
  };
641
- continueText: {
642
- type: StringConstructor;
643
- default: string;
1016
+ }>> & Record<string, any>>>, {
1017
+ [x: string]: any;
1018
+ }>;
1019
+
1020
+ declare type ProTableProps = Omit<ProTableProps$1, "columns"> & {
1021
+ columns?: TColumns;
1022
+ } & Omit<TableProps<any>, "tableLayout" | "flexible" | "data"> & {
1023
+ tableLayout?: "fixed" | "auto";
1024
+ flexible?: boolean;
1025
+ data?: any;
1026
+ loading?: boolean;
1027
+ };
1028
+ declare const ProTable: DefineComponent<ProTableProps>;
1029
+
1030
+ declare type ProCurdFormProps = ProFormProps & ProCurdAddOrEditProps;
1031
+ declare const ProCurdForm: DefineComponent<ProCurdFormProps>;
1032
+ declare const ProCurdFormConnect: DefineComponent<{}, () => JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{}>>, {}>;
1033
+
1034
+ interface PaginationProps {
1035
+ total?: number;
1036
+ pageSize?: number;
1037
+ defaultPageSize?: number;
1038
+ currentPage?: number;
1039
+ defaultCurrentPage?: number;
1040
+ pageCount?: number;
1041
+ pagerCount?: number;
1042
+ layout?: string;
1043
+ pageSizes?: number[];
1044
+ popperClass?: string;
1045
+ prevText?: string;
1046
+ nextText?: string;
1047
+ small?: boolean;
1048
+ background?: boolean;
1049
+ disabled?: boolean;
1050
+ hideOnSinglePage?: boolean;
1051
+ onSizeChange?: (val: number) => void;
1052
+ onCurrentChange?: (val: number) => void;
1053
+ }
1054
+ declare type ProCurdListProps = {
1055
+ extraInSearch?: boolean;
1056
+ searchProps?: ProSearchFormProps & {
1057
+ slots?: Slots;
644
1058
  };
645
- continueButtonProps: {
646
- type: PropType<ButtonProps>;
647
- };
648
- }>>>, {}>;
649
- declare const proCurdFormProps: () => {
650
- operateButtonProps: {
651
- type: PropType<Partial<ExtractPropTypes<{
652
- showContinueAdd: {
653
- type: BooleanConstructor;
654
- default: boolean;
655
- };
656
- okText: {
657
- type: StringConstructor;
658
- default: string;
659
- };
660
- okButtonProps: {
661
- type: PropType<ButtonProps>;
662
- };
663
- continueText: {
664
- type: StringConstructor;
665
- default: string;
666
- };
667
- continueButtonProps: {
668
- type: PropType<ButtonProps>;
669
- };
670
- }>>>;
1059
+ tableProps?: ProTableProps & {
1060
+ slots?: Slots;
671
1061
  };
1062
+ paginationProps?: PaginationProps;
1063
+ pageState?: TPageState;
672
1064
  };
673
- declare type ProCurdFormProps = Partial<ExtractPropTypes<ReturnType<typeof proCurdFormProps>>> & ProSchemaFormProps;
674
- declare const ProCurdForm: vue.DefineComponent<ProCurdFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProCurdFormProps>, {}>;
675
- declare const ProCurdFormConnect: vue.DefineComponent<{}, () => JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<{}>>, {}>;
676
-
677
1065
  /**
678
1066
  * 组合列表
679
1067
  * SearchForm + Table + Pagination
680
1068
  */
681
- declare const ProCurdList: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
682
- extraInSearch: {
683
- type: BooleanConstructor;
684
- default: undefined;
685
- };
686
- searchProps: {
687
- type: vue.PropType<ProSearchFormProps>;
688
- };
689
- tableProps: {
690
- type: vue.PropType<Partial<vue.ExtractPropTypes<{
691
- operate: {
692
- type: vue.PropType<ITableOperate>;
693
- };
694
- columnEmptyText: {
695
- type: StringConstructor;
696
- };
697
- column: {
698
- type: vue.PropType<TableColumnCtx<any>>;
699
- };
700
- columns: {
701
- type: vue.PropType<TColumns>;
702
- };
703
- elementMap: {
704
- type: vue.PropType<{
705
- [key: string]: any;
706
- }>;
707
- };
708
- loading: {
709
- type: BooleanConstructor;
710
- default: boolean;
711
- };
712
- }>> & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
713
- tableLayout?: "fixed" | "auto" | undefined;
714
- flexible?: boolean | undefined;
715
- data?: any;
716
- } & {
717
- slots?: Readonly<{
718
- [name: string]: vue.Slot | undefined;
719
- }> | undefined;
720
- }>;
721
- };
722
- paginationProps: {
723
- type: vue.PropType<PaginationProps>;
724
- };
725
- pageState: {
726
- type: vue.PropType<TPageState>;
727
- };
728
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<vue.ExtractPropTypes<{
729
- extraInSearch: {
730
- type: BooleanConstructor;
731
- default: undefined;
732
- };
733
- searchProps: {
734
- type: vue.PropType<ProSearchFormProps>;
735
- };
736
- tableProps: {
737
- type: vue.PropType<Partial<vue.ExtractPropTypes<{
738
- operate: {
739
- type: vue.PropType<ITableOperate>;
740
- };
741
- columnEmptyText: {
742
- type: StringConstructor;
743
- };
744
- column: {
745
- type: vue.PropType<TableColumnCtx<any>>;
746
- };
747
- columns: {
748
- type: vue.PropType<TColumns>;
749
- };
750
- elementMap: {
751
- type: vue.PropType<{
752
- [key: string]: any;
753
- }>;
754
- };
755
- loading: {
756
- type: BooleanConstructor;
757
- default: boolean;
758
- };
759
- }>> & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
760
- tableLayout?: "fixed" | "auto" | undefined;
761
- flexible?: boolean | undefined;
762
- data?: any;
763
- } & {
764
- slots?: Readonly<{
765
- [name: string]: vue.Slot | undefined;
766
- }> | undefined;
767
- }>;
768
- };
769
- paginationProps: {
770
- type: vue.PropType<PaginationProps>;
771
- };
772
- pageState: {
773
- type: vue.PropType<TPageState>;
774
- };
775
- }>>>, {}>;
1069
+ declare const ProCurdList: vue.DefineComponent<ProCurdListProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProCurdListProps>, {}>;
776
1070
  declare const ProCurdListConnect: vue.DefineComponent<{}, () => JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{}>>, {}>;
777
1071
 
778
1072
  interface DescriptionsProps {
@@ -783,8 +1077,8 @@ interface DescriptionsProps {
783
1077
  title?: string;
784
1078
  extra?: string;
785
1079
  }
786
- declare const ProCurdDesc: vue.DefineComponent<DescriptionsProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<DescriptionsProps>, {}>;
787
- declare const ProCurdDescConnect: vue.DefineComponent<{}, () => JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{}>>, {}>;
1080
+ declare const ProCurdDesc: DefineComponent<DescriptionsProps>;
1081
+ declare const ProCurdDescConnect: DefineComponent<{}, () => JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{}>>, {}>;
788
1082
 
789
1083
  declare const proSelectProps: () => {
790
1084
  options: PropType<TOptions>;
@@ -794,4 +1088,4 @@ declare const ProSelect: vue.DefineComponent<any, {}, {}, {}, {}, vue.ComponentO
794
1088
  [x: string]: any;
795
1089
  }>;
796
1090
 
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 };
1091
+ export { ButtonProps, DescriptionsProps, 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, ProSearchForm, ProSearchFormProps, ProSelect, ProSelectProps, ProSubmitButton, ProTable, ProTableProps, createFormItemComponent, createLoadingId };