@vue-start/element-pro 0.2.5 → 0.2.7

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