@vue-start/element-pro 0.2.13 → 0.2.14

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 +3264 -521
  2. package/dist/index.es.js +365 -304
  3. package/dist/index.js +1 -1
  4. package/package.json +2 -2
package/dist/index.d.ts CHANGED
@@ -1,250 +1,347 @@
1
- import * as vue from 'vue';
2
- import { ExtractPropTypes, PropType, VNode } from 'vue';
1
+ import * as element_plus_es_components_descriptions_src_descriptions_type from 'element-plus/es/components/descriptions/src/descriptions.type';
3
2
  import * as element_plus from 'element-plus';
4
- import { FormItemProps, DialogProps, IUseCheckboxGroupProps, ISelectProps, MenuProps, UploadProps, UploadFile } from 'element-plus';
3
+ import { DialogProps, IUseCheckboxGroupProps, ISelectProps, MenuProps, UploadProps, UploadFile, FormItemProps } from 'element-plus';
4
+ import * as _vue_shared from '@vue/shared';
5
5
  import * as element_plus_es_utils from 'element-plus/es/utils';
6
- import { FilterMethods, Filters } from 'element-plus/es/components/table/src/table-column/defaults';
6
+ import * as vue from 'vue';
7
+ import { ExtractPropTypes, PropType, VNode } from 'vue';
8
+ import * as _vue_start_pro from '@vue-start/pro';
7
9
  import { TOption, TFile } from '@vue-start/pro';
10
+ import { FilterMethods, Filters } from 'element-plus/es/components/table/src/table-column/defaults';
8
11
 
9
- declare const proFormItemProps: () => {
10
- name: {
11
- type: PropType<string | (string | number)[]>;
12
- };
13
- };
14
- declare type ProFormItemProps = Partial<ExtractPropTypes<ReturnType<typeof proFormItemProps>>> & FormItemProps;
15
- declare const ProFormItem: vue.DefineComponent<ProFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormItemProps>, {}>;
16
- declare const FormMethods: string[];
17
- declare const ProForm: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
18
- [x: string]: any;
19
- }>;
20
-
21
- declare const ProFormText: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
22
- name: {
23
- type: vue.PropType<string | (string | number)[]>;
24
- };
25
- }>> & {
26
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
27
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
28
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
29
- } & {
30
- readonly error?: string | undefined;
31
- readonly label?: string | undefined;
32
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
33
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
34
- 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;
35
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
36
- 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;
37
- readonly for?: string | undefined;
38
- } & Partial<vue.ExtractPropTypes<{
39
- readonly: {
12
+ declare const createLoadingId: (prefix?: string) => string;
13
+ declare const proLoadingProps: () => {
14
+ loading: {
40
15
  type: BooleanConstructor;
41
- default: undefined;
42
- };
43
- fieldProps: {
44
- type: ObjectConstructor;
45
16
  };
46
- showProps: {
47
- type: ObjectConstructor;
17
+ target: {
18
+ type: PropType<string | HTMLElement>;
48
19
  };
49
- slots: {
50
- type: ObjectConstructor;
20
+ body: {
21
+ type: BooleanConstructor;
51
22
  };
52
- }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
53
- name: {
54
- type: vue.PropType<string | (string | number)[]>;
23
+ fullscreen: {
24
+ type: BooleanConstructor;
55
25
  };
56
- }>> & {
57
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
58
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
59
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
60
- } & {
61
- readonly error?: string | undefined;
62
- readonly label?: string | undefined;
63
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
64
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
65
- 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;
66
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
67
- 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;
68
- readonly for?: string | undefined;
69
- } & Partial<vue.ExtractPropTypes<{
70
- readonly: {
26
+ lock: {
71
27
  type: BooleanConstructor;
72
- default: undefined;
73
28
  };
74
- fieldProps: {
75
- type: ObjectConstructor;
29
+ text: {
30
+ type: StringConstructor;
76
31
  };
77
- showProps: {
78
- type: ObjectConstructor;
32
+ spinner: {
33
+ type: StringConstructor;
79
34
  };
80
- slots: {
81
- type: ObjectConstructor;
35
+ background: {
36
+ type: StringConstructor;
82
37
  };
83
- }>> & Record<string, any>>>, {
84
- [x: string]: any;
85
- }>;
86
- declare const ProFormTextNumber: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
87
- name: {
88
- type: vue.PropType<string | (string | number)[]>;
38
+ customClass: {
39
+ type: StringConstructor;
89
40
  };
90
- }>> & {
91
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
92
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
93
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
94
- } & {
95
- readonly error?: string | undefined;
96
- readonly label?: string | undefined;
97
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
98
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
99
- 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;
100
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
101
- 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;
102
- readonly for?: string | undefined;
103
- } & Partial<vue.ExtractPropTypes<{
104
- readonly: {
41
+ };
42
+ declare type ProLoadingProps = Partial<ExtractPropTypes<ReturnType<typeof proLoadingProps>>>;
43
+ declare const ProLoading: vue.DefineComponent<Partial<ExtractPropTypes<{
44
+ loading: {
105
45
  type: BooleanConstructor;
106
- default: undefined;
107
- };
108
- fieldProps: {
109
- type: ObjectConstructor;
110
46
  };
111
- showProps: {
112
- type: ObjectConstructor;
47
+ target: {
48
+ type: PropType<string | HTMLElement>;
113
49
  };
114
- slots: {
115
- type: ObjectConstructor;
50
+ body: {
51
+ type: BooleanConstructor;
116
52
  };
117
- }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
118
- name: {
119
- type: vue.PropType<string | (string | number)[]>;
53
+ fullscreen: {
54
+ type: BooleanConstructor;
120
55
  };
121
- }>> & {
122
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
123
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
124
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
125
- } & {
126
- readonly error?: string | undefined;
127
- readonly label?: string | undefined;
128
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
129
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
130
- 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;
131
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
132
- 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;
133
- readonly for?: string | undefined;
134
- } & Partial<vue.ExtractPropTypes<{
135
- readonly: {
56
+ lock: {
136
57
  type: BooleanConstructor;
137
- default: undefined;
138
58
  };
139
- fieldProps: {
140
- type: ObjectConstructor;
59
+ text: {
60
+ type: StringConstructor;
141
61
  };
142
- showProps: {
143
- type: ObjectConstructor;
62
+ spinner: {
63
+ type: StringConstructor;
144
64
  };
145
- slots: {
146
- type: ObjectConstructor;
65
+ background: {
66
+ type: StringConstructor;
147
67
  };
148
- }>> & Record<string, any>>>, {
149
- [x: string]: any;
150
- }>;
151
- declare const ProFormDatePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
152
- name: {
153
- type: vue.PropType<string | (string | number)[]>;
68
+ customClass: {
69
+ type: StringConstructor;
154
70
  };
155
- }>> & {
156
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
157
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
158
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
159
- } & {
160
- readonly error?: string | undefined;
161
- readonly label?: string | undefined;
162
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
163
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
164
- 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;
165
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
166
- 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;
167
- readonly for?: string | undefined;
168
- } & Partial<vue.ExtractPropTypes<{
169
- readonly: {
71
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
72
+ loading: {
170
73
  type: BooleanConstructor;
171
- default: undefined;
172
- };
173
- fieldProps: {
174
- type: ObjectConstructor;
175
74
  };
176
- showProps: {
177
- type: ObjectConstructor;
178
- };
179
- slots: {
180
- type: ObjectConstructor;
75
+ target: {
76
+ type: PropType<string | HTMLElement>;
181
77
  };
182
- }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
183
- name: {
184
- type: vue.PropType<string | (string | number)[]>;
78
+ body: {
79
+ type: BooleanConstructor;
185
80
  };
186
- }>> & {
187
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
188
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
189
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
190
- } & {
191
- readonly error?: string | undefined;
192
- readonly label?: string | undefined;
193
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
194
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
195
- 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;
196
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
197
- 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;
198
- readonly for?: string | undefined;
199
- } & Partial<vue.ExtractPropTypes<{
200
- readonly: {
81
+ fullscreen: {
201
82
  type: BooleanConstructor;
202
- default: undefined;
203
83
  };
204
- fieldProps: {
205
- type: ObjectConstructor;
84
+ lock: {
85
+ type: BooleanConstructor;
206
86
  };
207
- showProps: {
208
- type: ObjectConstructor;
87
+ text: {
88
+ type: StringConstructor;
209
89
  };
210
- slots: {
211
- type: ObjectConstructor;
90
+ spinner: {
91
+ type: StringConstructor;
212
92
  };
213
- }>> & Record<string, any>>>, {
214
- [x: string]: any;
215
- }>;
216
- declare const ProFormTimePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
217
- name: {
218
- type: vue.PropType<string | (string | number)[]>;
93
+ background: {
94
+ type: StringConstructor;
219
95
  };
220
- }>> & {
221
- readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
222
- readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
223
- readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
224
- } & {
225
- readonly error?: string | undefined;
226
- readonly label?: string | undefined;
227
- readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
228
- readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
229
- 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;
230
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
231
- 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;
232
- readonly for?: string | undefined;
233
- } & Partial<vue.ExtractPropTypes<{
234
- readonly: {
235
- type: BooleanConstructor;
236
- default: undefined;
96
+ customClass: {
97
+ type: StringConstructor;
237
98
  };
238
- fieldProps: {
239
- type: ObjectConstructor;
99
+ }>>>, {}>;
100
+
101
+ declare const proModalProps: () => {
102
+ /**
103
+ * class名称
104
+ */
105
+ clsName: {
106
+ type: StringConstructor;
107
+ default: string;
240
108
  };
241
- showProps: {
242
- type: ObjectConstructor;
109
+ visible: {
110
+ type: BooleanConstructor;
111
+ default: boolean;
243
112
  };
244
- slots: {
245
- type: ObjectConstructor;
113
+ cancelText: {
114
+ type: StringConstructor;
115
+ default: string;
246
116
  };
247
- }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
117
+ cancelButtonProps: {
118
+ type: PropType<{
119
+ readonly text: boolean;
120
+ readonly link: boolean;
121
+ readonly type: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown>;
122
+ readonly circle: boolean;
123
+ readonly disabled: boolean;
124
+ readonly loading: boolean;
125
+ readonly autofocus: boolean;
126
+ readonly loadingIcon: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown>;
127
+ readonly dark: boolean;
128
+ readonly icon: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown>;
129
+ readonly round: boolean;
130
+ readonly nativeType: element_plus_es_utils.EpPropMergeType<StringConstructor, "reset" | "submit" | "button", unknown>;
131
+ readonly plain: boolean;
132
+ readonly bg: boolean;
133
+ } & {
134
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
135
+ readonly color?: string | undefined;
136
+ readonly autoInsertSpace?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
137
+ } & {
138
+ onClick?: (() => void) | undefined;
139
+ }>;
140
+ };
141
+ okText: {
142
+ type: StringConstructor;
143
+ default: string;
144
+ };
145
+ okButtonProps: {
146
+ type: PropType<{
147
+ readonly text: boolean;
148
+ readonly link: boolean;
149
+ readonly type: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown>;
150
+ readonly circle: boolean;
151
+ readonly disabled: boolean;
152
+ readonly loading: boolean;
153
+ readonly autofocus: boolean;
154
+ readonly loadingIcon: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown>;
155
+ readonly dark: boolean;
156
+ readonly icon: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown>;
157
+ readonly round: boolean;
158
+ readonly nativeType: element_plus_es_utils.EpPropMergeType<StringConstructor, "reset" | "submit" | "button", unknown>;
159
+ readonly plain: boolean;
160
+ readonly bg: boolean;
161
+ } & {
162
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
163
+ readonly color?: string | undefined;
164
+ readonly autoInsertSpace?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
165
+ } & {
166
+ onClick?: (() => void) | undefined;
167
+ }>;
168
+ };
169
+ confirmLoading: BooleanConstructor;
170
+ footer: {
171
+ type: BooleanConstructor;
172
+ default: boolean;
173
+ };
174
+ maskClosable: {
175
+ type: (BooleanConstructor | ObjectConstructor)[];
176
+ default: undefined;
177
+ };
178
+ };
179
+ declare type ProModalProps = Partial<ExtractPropTypes<ReturnType<typeof proModalProps>>> & DialogProps;
180
+ declare const ProModal: vue.DefineComponent<ProModalProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProModalProps>, {}>;
181
+
182
+ declare const ProPagination: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
183
+ [x: string]: any;
184
+ }>;
185
+
186
+ declare const ProPopover: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
187
+ [x: string]: any;
188
+ }>;
189
+
190
+ declare const proCheckboxProps: () => {
191
+ options: PropType<(TOption & {
192
+ disabled: boolean;
193
+ checked: boolean;
194
+ indeterminate: boolean;
195
+ border: boolean;
196
+ validateEvent: boolean;
197
+ } & {
198
+ label?: string | number | boolean | Record<string, any> | undefined;
199
+ name?: string | undefined;
200
+ id?: string | undefined;
201
+ size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
202
+ modelValue?: string | number | boolean | undefined;
203
+ tabindex?: string | number | undefined;
204
+ controls?: string | undefined;
205
+ trueLabel?: string | number | undefined;
206
+ falseLabel?: string | number | undefined;
207
+ })[]>;
208
+ buttonStyle: {
209
+ type: PropType<"default" | "button">;
210
+ default: string;
211
+ };
212
+ optionType: {
213
+ type: PropType<"default" | "button">;
214
+ default: string;
215
+ };
216
+ };
217
+ declare type ProCheckboxProps = Partial<ExtractPropTypes<ReturnType<typeof proCheckboxProps>>> & IUseCheckboxGroupProps;
218
+ declare const ProCheckbox: vue.DefineComponent<ProCheckboxProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProCheckboxProps>, {}>;
219
+
220
+ declare const proRadioProps: () => {
221
+ options: {
222
+ type: PropType<(TOption & {
223
+ readonly label: element_plus_es_utils.EpPropMergeType<(NumberConstructor | StringConstructor | BooleanConstructor)[], unknown, unknown>;
224
+ readonly name: string;
225
+ readonly disabled: boolean;
226
+ readonly modelValue: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>;
227
+ readonly border: boolean;
228
+ } & {
229
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
230
+ } & {
231
+ readonly label: element_plus_es_utils.EpPropMergeType<(NumberConstructor | StringConstructor | BooleanConstructor)[], unknown, unknown>;
232
+ readonly name: string;
233
+ readonly disabled: boolean;
234
+ } & {
235
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
236
+ })[]>;
237
+ };
238
+ buttonStyle: {
239
+ type: PropType<"default" | "button">;
240
+ default: string;
241
+ };
242
+ optionType: {
243
+ type: PropType<"default" | "button">;
244
+ default: string;
245
+ };
246
+ };
247
+ declare type ProRadioProps = Partial<ExtractPropTypes<ReturnType<typeof proRadioProps>>> & Record<string, any>;
248
+ declare const ProRadio: vue.DefineComponent<ProRadioProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<ProRadioProps>>, {
249
+ [x: string]: any;
250
+ }>;
251
+
252
+ declare const proSelectProps: () => {
253
+ options: PropType<(TOption & {
254
+ created: boolean;
255
+ disabled: boolean;
256
+ hovering: boolean;
257
+ selected: boolean;
258
+ } & {
259
+ data?: unknown[] | undefined;
260
+ style?: Record<string, any> | undefined;
261
+ index?: number | undefined;
262
+ item?: Record<string, any> | undefined;
263
+ })[]>;
264
+ };
265
+ declare type ProSelectProps = Partial<ExtractPropTypes<ReturnType<typeof proSelectProps>>> & ISelectProps;
266
+ declare const ProSelect: vue.DefineComponent<ProSelectProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProSelectProps>, {
267
+ modelValue?: any;
268
+ }>;
269
+
270
+ declare const ProTabs: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
271
+ [x: string]: any;
272
+ }>;
273
+
274
+ /******************************* Menus ************************************/
275
+ declare const menuProps: () => {
276
+ convertSubMenuProps: {
277
+ type: FunctionConstructor;
278
+ };
279
+ convertMenuItemProps: {
280
+ type: FunctionConstructor;
281
+ };
282
+ onMenuItemClick: {
283
+ type: FunctionConstructor;
284
+ };
285
+ activeKey: {
286
+ type: StringConstructor;
287
+ };
288
+ options: {
289
+ type: PropType<Record<string, any>[]>;
290
+ };
291
+ fieldNames: {
292
+ type: PropType<{
293
+ children: string;
294
+ value: string;
295
+ label: string;
296
+ }>;
297
+ default: {
298
+ children: string;
299
+ value: string;
300
+ label: string;
301
+ };
302
+ };
303
+ };
304
+ declare type ProMenusProps = Partial<ExtractPropTypes<ReturnType<typeof menuProps>>> & Omit<MenuProps, "defaultActive">;
305
+ declare const ProMenus: vue.DefineComponent<ProMenusProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProMenusProps>, {}>;
306
+
307
+ declare const uploadProps: () => {
308
+ modelValue: {
309
+ type: PropType<TFile[]>;
310
+ default: undefined;
311
+ };
312
+ maxSize: {
313
+ type: NumberConstructor;
314
+ };
315
+ convertResponseData: {
316
+ type: PropType<(res: any) => Record<string, any>>;
317
+ };
318
+ convertItemData: {
319
+ type: PropType<(item: any) => UploadFile>;
320
+ default: (item: any) => any;
321
+ };
322
+ onErrorMsg: PropType<(type: string, msg: string) => void>;
323
+ onStart: PropType<(file: any) => void>;
324
+ beforeUpload: {
325
+ type: FunctionConstructor;
326
+ };
327
+ };
328
+ declare type ProUploadProps = Partial<ExtractPropTypes<ReturnType<typeof uploadProps>>> & Omit<UploadProps, "fileList">;
329
+ declare const UploadMethods: string[];
330
+ declare const ProUploader: vue.DefineComponent<ProUploadProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProUploadProps>, {}>;
331
+
332
+ declare const proFormItemProps: () => {
333
+ name: {
334
+ type: PropType<string | (string | number)[]>;
335
+ };
336
+ };
337
+ declare type ProFormItemProps = Partial<ExtractPropTypes<ReturnType<typeof proFormItemProps>>> & FormItemProps;
338
+ declare const ProFormItem: vue.DefineComponent<ProFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormItemProps>, {}>;
339
+ declare const FormMethods: string[];
340
+ declare const ProForm: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
341
+ [x: string]: any;
342
+ }>;
343
+
344
+ declare const ProFormText: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
248
345
  name: {
249
346
  type: vue.PropType<string | (string | number)[]>;
250
347
  };
@@ -275,10 +372,7 @@ declare const ProFormTimePicker: vue.DefineComponent<Partial<vue.ExtractPropType
275
372
  slots: {
276
373
  type: ObjectConstructor;
277
374
  };
278
- }>> & Record<string, any>>>, {
279
- [x: string]: any;
280
- }>;
281
- declare const ProFormSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
375
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
282
376
  name: {
283
377
  type: vue.PropType<string | (string | number)[]>;
284
378
  };
@@ -309,7 +403,236 @@ declare const ProFormSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
309
403
  slots: {
310
404
  type: ObjectConstructor;
311
405
  };
312
- }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
406
+ }>> & Record<string, any>>>, {
407
+ [x: string]: any;
408
+ }>;
409
+ declare const ProFormTextNumber: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
410
+ name: {
411
+ type: vue.PropType<string | (string | number)[]>;
412
+ };
413
+ }>> & {
414
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
415
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
416
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
417
+ } & {
418
+ readonly error?: string | undefined;
419
+ readonly label?: string | undefined;
420
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
421
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
422
+ 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;
423
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
424
+ 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;
425
+ readonly for?: string | undefined;
426
+ } & Partial<vue.ExtractPropTypes<{
427
+ readonly: {
428
+ type: BooleanConstructor;
429
+ default: undefined;
430
+ };
431
+ fieldProps: {
432
+ type: ObjectConstructor;
433
+ };
434
+ showProps: {
435
+ type: ObjectConstructor;
436
+ };
437
+ slots: {
438
+ type: ObjectConstructor;
439
+ };
440
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
441
+ name: {
442
+ type: vue.PropType<string | (string | number)[]>;
443
+ };
444
+ }>> & {
445
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
446
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
447
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
448
+ } & {
449
+ readonly error?: string | undefined;
450
+ readonly label?: string | undefined;
451
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
452
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
453
+ 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;
454
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
455
+ 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;
456
+ readonly for?: string | undefined;
457
+ } & Partial<vue.ExtractPropTypes<{
458
+ readonly: {
459
+ type: BooleanConstructor;
460
+ default: undefined;
461
+ };
462
+ fieldProps: {
463
+ type: ObjectConstructor;
464
+ };
465
+ showProps: {
466
+ type: ObjectConstructor;
467
+ };
468
+ slots: {
469
+ type: ObjectConstructor;
470
+ };
471
+ }>> & Record<string, any>>>, {
472
+ [x: string]: any;
473
+ }>;
474
+ declare const ProFormDatePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
475
+ name: {
476
+ type: vue.PropType<string | (string | number)[]>;
477
+ };
478
+ }>> & {
479
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
480
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
481
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
482
+ } & {
483
+ readonly error?: string | undefined;
484
+ readonly label?: string | undefined;
485
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
486
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
487
+ 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;
488
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
489
+ 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;
490
+ readonly for?: string | undefined;
491
+ } & Partial<vue.ExtractPropTypes<{
492
+ readonly: {
493
+ type: BooleanConstructor;
494
+ default: undefined;
495
+ };
496
+ fieldProps: {
497
+ type: ObjectConstructor;
498
+ };
499
+ showProps: {
500
+ type: ObjectConstructor;
501
+ };
502
+ slots: {
503
+ type: ObjectConstructor;
504
+ };
505
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
506
+ name: {
507
+ type: vue.PropType<string | (string | number)[]>;
508
+ };
509
+ }>> & {
510
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
511
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
512
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
513
+ } & {
514
+ readonly error?: string | undefined;
515
+ readonly label?: string | undefined;
516
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
517
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
518
+ 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;
519
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
520
+ 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;
521
+ readonly for?: string | undefined;
522
+ } & Partial<vue.ExtractPropTypes<{
523
+ readonly: {
524
+ type: BooleanConstructor;
525
+ default: undefined;
526
+ };
527
+ fieldProps: {
528
+ type: ObjectConstructor;
529
+ };
530
+ showProps: {
531
+ type: ObjectConstructor;
532
+ };
533
+ slots: {
534
+ type: ObjectConstructor;
535
+ };
536
+ }>> & Record<string, any>>>, {
537
+ [x: string]: any;
538
+ }>;
539
+ declare const ProFormTimePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
540
+ name: {
541
+ type: vue.PropType<string | (string | number)[]>;
542
+ };
543
+ }>> & {
544
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
545
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
546
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
547
+ } & {
548
+ readonly error?: string | undefined;
549
+ readonly label?: string | undefined;
550
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
551
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
552
+ 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;
553
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
554
+ 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;
555
+ readonly for?: string | undefined;
556
+ } & Partial<vue.ExtractPropTypes<{
557
+ readonly: {
558
+ type: BooleanConstructor;
559
+ default: undefined;
560
+ };
561
+ fieldProps: {
562
+ type: ObjectConstructor;
563
+ };
564
+ showProps: {
565
+ type: ObjectConstructor;
566
+ };
567
+ slots: {
568
+ type: ObjectConstructor;
569
+ };
570
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
571
+ name: {
572
+ type: vue.PropType<string | (string | number)[]>;
573
+ };
574
+ }>> & {
575
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
576
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
577
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
578
+ } & {
579
+ readonly error?: string | undefined;
580
+ readonly label?: string | undefined;
581
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
582
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
583
+ 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;
584
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
585
+ 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;
586
+ readonly for?: string | undefined;
587
+ } & Partial<vue.ExtractPropTypes<{
588
+ readonly: {
589
+ type: BooleanConstructor;
590
+ default: undefined;
591
+ };
592
+ fieldProps: {
593
+ type: ObjectConstructor;
594
+ };
595
+ showProps: {
596
+ type: ObjectConstructor;
597
+ };
598
+ slots: {
599
+ type: ObjectConstructor;
600
+ };
601
+ }>> & Record<string, any>>>, {
602
+ [x: string]: any;
603
+ }>;
604
+ declare const ProFormSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
605
+ name: {
606
+ type: vue.PropType<string | (string | number)[]>;
607
+ };
608
+ }>> & {
609
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
610
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
611
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
612
+ } & {
613
+ readonly error?: string | undefined;
614
+ readonly label?: string | undefined;
615
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
616
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
617
+ 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;
618
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
619
+ 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;
620
+ readonly for?: string | undefined;
621
+ } & Partial<vue.ExtractPropTypes<{
622
+ readonly: {
623
+ type: BooleanConstructor;
624
+ default: undefined;
625
+ };
626
+ fieldProps: {
627
+ type: ObjectConstructor;
628
+ };
629
+ showProps: {
630
+ type: ObjectConstructor;
631
+ };
632
+ slots: {
633
+ type: ObjectConstructor;
634
+ };
635
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
313
636
  name: {
314
637
  type: vue.PropType<string | (string | number)[]>;
315
638
  };
@@ -739,6 +1062,8 @@ declare const createFormItemComponent: ({ InputComp, valueType, name }: {
739
1062
  [x: string]: any;
740
1063
  }>;
741
1064
 
1065
+ declare type TConvert = (...params: any[]) => any;
1066
+
742
1067
  interface TableColumnCtx<T> {
743
1068
  id?: string;
744
1069
  realWidth?: number;
@@ -807,325 +1132,2743 @@ declare const TableMethods: string[];
807
1132
  declare const ProTable: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
808
1133
  [x: string]: any;
809
1134
  }>;
1135
+ declare const ProTableOperateItem: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
1136
+ [x: string]: any;
1137
+ }>;
810
1138
 
811
- declare const createLoadingId: (prefix?: string) => string;
812
- declare const proLoadingProps: () => {
813
- loading: {
814
- type: BooleanConstructor;
815
- };
816
- target: {
817
- type: PropType<string | HTMLElement>;
818
- };
819
- body: {
820
- type: BooleanConstructor;
821
- };
822
- fullscreen: {
823
- type: BooleanConstructor;
824
- };
825
- lock: {
826
- type: BooleanConstructor;
827
- };
828
- text: {
829
- type: StringConstructor;
830
- };
831
- spinner: {
832
- type: StringConstructor;
833
- };
834
- background: {
835
- type: StringConstructor;
836
- };
837
- customClass: {
838
- type: StringConstructor;
839
- };
840
- };
841
- declare type ProLoadingProps = Partial<ExtractPropTypes<ReturnType<typeof proLoadingProps>>>;
842
- declare const ProLoading: vue.DefineComponent<Partial<ExtractPropTypes<{
843
- loading: {
844
- type: BooleanConstructor;
845
- };
846
- target: {
847
- type: PropType<string | HTMLElement>;
848
- };
849
- body: {
850
- type: BooleanConstructor;
851
- };
852
- fullscreen: {
853
- type: BooleanConstructor;
854
- };
855
- lock: {
856
- type: BooleanConstructor;
857
- };
858
- text: {
859
- type: StringConstructor;
860
- };
861
- spinner: {
862
- type: StringConstructor;
863
- };
864
- background: {
865
- type: StringConstructor;
866
- };
867
- customClass: {
868
- type: StringConstructor;
869
- };
870
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
871
- loading: {
872
- type: BooleanConstructor;
873
- };
874
- target: {
875
- type: PropType<string | HTMLElement>;
876
- };
877
- body: {
878
- type: BooleanConstructor;
879
- };
880
- fullscreen: {
881
- type: BooleanConstructor;
882
- };
883
- lock: {
884
- type: BooleanConstructor;
885
- };
886
- text: {
887
- type: StringConstructor;
888
- };
889
- spinner: {
890
- type: StringConstructor;
891
- };
892
- background: {
893
- type: StringConstructor;
894
- };
895
- customClass: {
896
- type: StringConstructor;
897
- };
898
- }>>>, {}>;
899
-
900
- declare const proModalProps: () => {
901
- /**
902
- * class名称
903
- */
904
- clsName: {
905
- type: StringConstructor;
906
- default: string;
907
- };
908
- visible: {
909
- type: BooleanConstructor;
910
- default: boolean;
911
- };
912
- cancelText: {
913
- type: StringConstructor;
914
- default: string;
915
- };
916
- cancelButtonProps: {
917
- type: PropType<{
918
- readonly text: boolean;
919
- readonly link: boolean;
920
- readonly type: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown>;
921
- readonly circle: boolean;
922
- readonly disabled: boolean;
923
- readonly loading: boolean;
924
- readonly autofocus: boolean;
925
- readonly loadingIcon: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown>;
926
- readonly round: boolean;
927
- readonly dark: boolean;
928
- readonly icon: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown>;
929
- readonly nativeType: element_plus_es_utils.EpPropMergeType<StringConstructor, "reset" | "submit" | "button", unknown>;
930
- readonly plain: boolean;
931
- readonly bg: boolean;
932
- } & {
933
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
934
- readonly color?: string | undefined;
935
- readonly autoInsertSpace?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
936
- } & {
937
- onClick?: (() => void) | undefined;
1139
+ declare const elementMap: {
1140
+ [x: string]: vue.DefineComponent<_vue_start_pro.ProFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<_vue_start_pro.ProFormProps>, {}> | vue.DefineComponent<_vue_start_pro.ProSearchFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<_vue_start_pro.ProSearchFormProps>, {}> | vue.DefineComponent<_vue_start_pro.ProTableProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<_vue_start_pro.ProTableProps>, {}> | vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1141
+ clsName: {
1142
+ type: StringConstructor;
1143
+ default: string;
1144
+ };
1145
+ searchProps: {
1146
+ type: vue.PropType<Record<string, any>>;
1147
+ };
1148
+ searchInTable: {
1149
+ type: BooleanConstructor;
1150
+ default: boolean;
1151
+ };
1152
+ tableProps: {
1153
+ type: vue.PropType<Record<string, any>>;
1154
+ };
1155
+ paginationProps: {
1156
+ type: (vue.PropType<Record<string, any>> | vue.PropType<boolean>)[];
1157
+ default: undefined;
1158
+ };
1159
+ pageState: {
1160
+ type: vue.PropType<_vue_start_pro.TPageState>;
1161
+ };
1162
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<vue.ExtractPropTypes<{
1163
+ clsName: {
1164
+ type: StringConstructor;
1165
+ default: string;
1166
+ };
1167
+ searchProps: {
1168
+ type: vue.PropType<Record<string, any>>;
1169
+ };
1170
+ searchInTable: {
1171
+ type: BooleanConstructor;
1172
+ default: boolean;
1173
+ };
1174
+ tableProps: {
1175
+ type: vue.PropType<Record<string, any>>;
1176
+ };
1177
+ paginationProps: {
1178
+ type: (vue.PropType<Record<string, any>> | vue.PropType<boolean>)[];
1179
+ default: undefined;
1180
+ };
1181
+ pageState: {
1182
+ type: vue.PropType<_vue_start_pro.TPageState>;
1183
+ };
1184
+ }>>>, {}> | vue.DefineComponent<{
1185
+ value: {
1186
+ type: (NumberConstructor | StringConstructor)[];
1187
+ };
1188
+ showProps: {
1189
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1190
+ content: {
1191
+ type: (NumberConstructor | StringConstructor)[];
1192
+ };
1193
+ ellipsis: {
1194
+ type: (BooleanConstructor | vue.PropType<{
1195
+ rows?: number | undefined;
1196
+ num?: number | undefined;
1197
+ }>)[];
1198
+ };
1199
+ popoverProps: ObjectConstructor;
1200
+ }>>>;
1201
+ };
1202
+ convert: {
1203
+ type: vue.PropType<TConvert>;
1204
+ };
1205
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1206
+ value: {
1207
+ type: (NumberConstructor | StringConstructor)[];
1208
+ };
1209
+ showProps: {
1210
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1211
+ content: {
1212
+ type: (NumberConstructor | StringConstructor)[];
1213
+ };
1214
+ ellipsis: {
1215
+ type: (BooleanConstructor | vue.PropType<{
1216
+ rows?: number | undefined;
1217
+ num?: number | undefined;
1218
+ }>)[];
1219
+ };
1220
+ popoverProps: ObjectConstructor;
1221
+ }>>>;
1222
+ };
1223
+ convert: {
1224
+ type: vue.PropType<TConvert>;
1225
+ };
1226
+ }>>, {}> | vue.DefineComponent<{
1227
+ decimalFixed: {
1228
+ type: NumberConstructor;
1229
+ default: number;
1230
+ };
1231
+ thousandDivision: {
1232
+ type: BooleanConstructor;
1233
+ default: boolean;
1234
+ };
1235
+ value: {
1236
+ type: (NumberConstructor | StringConstructor)[];
1237
+ };
1238
+ showProps: {
1239
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1240
+ content: {
1241
+ type: (NumberConstructor | StringConstructor)[];
1242
+ };
1243
+ ellipsis: {
1244
+ type: (BooleanConstructor | vue.PropType<{
1245
+ rows?: number | undefined;
1246
+ num?: number | undefined;
1247
+ }>)[];
1248
+ };
1249
+ popoverProps: ObjectConstructor;
1250
+ }>>>;
1251
+ };
1252
+ convert: {
1253
+ type: vue.PropType<TConvert>;
1254
+ };
1255
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1256
+ decimalFixed: {
1257
+ type: NumberConstructor;
1258
+ default: number;
1259
+ };
1260
+ thousandDivision: {
1261
+ type: BooleanConstructor;
1262
+ default: boolean;
1263
+ };
1264
+ value: {
1265
+ type: (NumberConstructor | StringConstructor)[];
1266
+ };
1267
+ showProps: {
1268
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1269
+ content: {
1270
+ type: (NumberConstructor | StringConstructor)[];
1271
+ };
1272
+ ellipsis: {
1273
+ type: (BooleanConstructor | vue.PropType<{
1274
+ rows?: number | undefined;
1275
+ num?: number | undefined;
1276
+ }>)[];
1277
+ };
1278
+ popoverProps: ObjectConstructor;
1279
+ }>>>;
1280
+ };
1281
+ convert: {
1282
+ type: vue.PropType<TConvert>;
1283
+ };
1284
+ }>>, {
1285
+ decimalFixed: number;
1286
+ thousandDivision: boolean;
1287
+ }> | vue.DefineComponent<{
1288
+ value: {
1289
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
1290
+ };
1291
+ options: vue.PropType<_vue_start_pro.TOptions>;
1292
+ splitStr: {
1293
+ type: StringConstructor;
1294
+ default: string;
1295
+ };
1296
+ colorMap: {
1297
+ type: ObjectConstructor;
1298
+ };
1299
+ showProps: {
1300
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1301
+ content: {
1302
+ type: (NumberConstructor | StringConstructor)[];
1303
+ };
1304
+ ellipsis: {
1305
+ type: (BooleanConstructor | vue.PropType<{
1306
+ rows?: number | undefined;
1307
+ num?: number | undefined;
1308
+ }>)[];
1309
+ };
1310
+ popoverProps: ObjectConstructor;
1311
+ }>>>;
1312
+ };
1313
+ convert: {
1314
+ type: vue.PropType<TConvert>;
1315
+ };
1316
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1317
+ value: {
1318
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
1319
+ };
1320
+ options: vue.PropType<_vue_start_pro.TOptions>;
1321
+ splitStr: {
1322
+ type: StringConstructor;
1323
+ default: string;
1324
+ };
1325
+ colorMap: {
1326
+ type: ObjectConstructor;
1327
+ };
1328
+ showProps: {
1329
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1330
+ content: {
1331
+ type: (NumberConstructor | StringConstructor)[];
1332
+ };
1333
+ ellipsis: {
1334
+ type: (BooleanConstructor | vue.PropType<{
1335
+ rows?: number | undefined;
1336
+ num?: number | undefined;
1337
+ }>)[];
1338
+ };
1339
+ popoverProps: ObjectConstructor;
1340
+ }>>>;
1341
+ };
1342
+ convert: {
1343
+ type: vue.PropType<TConvert>;
1344
+ };
1345
+ }>>, {
1346
+ splitStr: string;
1347
+ }> | vue.DefineComponent<{
1348
+ value: {
1349
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
1350
+ };
1351
+ splitStr: {
1352
+ type: StringConstructor;
1353
+ default: string;
1354
+ };
1355
+ treeData: vue.PropType<Record<string, any>>;
1356
+ data: vue.PropType<Record<string, any>>;
1357
+ options: vue.PropType<Record<string, any>>;
1358
+ fieldNames: ObjectConstructor;
1359
+ props: ObjectConstructor;
1360
+ showProps: {
1361
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1362
+ content: {
1363
+ type: (NumberConstructor | StringConstructor)[];
1364
+ };
1365
+ ellipsis: {
1366
+ type: (BooleanConstructor | vue.PropType<{
1367
+ rows?: number | undefined;
1368
+ num?: number | undefined;
1369
+ }>)[];
1370
+ };
1371
+ popoverProps: ObjectConstructor;
1372
+ }>>>;
1373
+ };
1374
+ convert: {
1375
+ type: vue.PropType<TConvert>;
1376
+ };
1377
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1378
+ value: {
1379
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
1380
+ };
1381
+ splitStr: {
1382
+ type: StringConstructor;
1383
+ default: string;
1384
+ };
1385
+ treeData: vue.PropType<Record<string, any>>;
1386
+ data: vue.PropType<Record<string, any>>;
1387
+ options: vue.PropType<Record<string, any>>;
1388
+ fieldNames: ObjectConstructor;
1389
+ props: ObjectConstructor;
1390
+ showProps: {
1391
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1392
+ content: {
1393
+ type: (NumberConstructor | StringConstructor)[];
1394
+ };
1395
+ ellipsis: {
1396
+ type: (BooleanConstructor | vue.PropType<{
1397
+ rows?: number | undefined;
1398
+ num?: number | undefined;
1399
+ }>)[];
1400
+ };
1401
+ popoverProps: ObjectConstructor;
1402
+ }>>>;
1403
+ };
1404
+ convert: {
1405
+ type: vue.PropType<TConvert>;
1406
+ };
1407
+ }>>, {
1408
+ splitStr: string;
1409
+ }> | vue.DefineComponent<{
1410
+ value: {
1411
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
1412
+ };
1413
+ splitStr: {
1414
+ type: StringConstructor;
1415
+ default: string;
1416
+ };
1417
+ format: {
1418
+ type: StringConstructor;
1419
+ default: string;
1420
+ };
1421
+ isUnix: {
1422
+ type: BooleanConstructor;
1423
+ default: boolean;
1424
+ };
1425
+ showProps: {
1426
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1427
+ content: {
1428
+ type: (NumberConstructor | StringConstructor)[];
1429
+ };
1430
+ ellipsis: {
1431
+ type: (BooleanConstructor | vue.PropType<{
1432
+ rows?: number | undefined;
1433
+ num?: number | undefined;
1434
+ }>)[];
1435
+ };
1436
+ popoverProps: ObjectConstructor;
1437
+ }>>>;
1438
+ };
1439
+ convert: {
1440
+ type: vue.PropType<TConvert>;
1441
+ };
1442
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1443
+ value: {
1444
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
1445
+ };
1446
+ splitStr: {
1447
+ type: StringConstructor;
1448
+ default: string;
1449
+ };
1450
+ format: {
1451
+ type: StringConstructor;
1452
+ default: string;
1453
+ };
1454
+ isUnix: {
1455
+ type: BooleanConstructor;
1456
+ default: boolean;
1457
+ };
1458
+ showProps: {
1459
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
1460
+ content: {
1461
+ type: (NumberConstructor | StringConstructor)[];
1462
+ };
1463
+ ellipsis: {
1464
+ type: (BooleanConstructor | vue.PropType<{
1465
+ rows?: number | undefined;
1466
+ num?: number | undefined;
1467
+ }>)[];
1468
+ };
1469
+ popoverProps: ObjectConstructor;
1470
+ }>>>;
1471
+ };
1472
+ convert: {
1473
+ type: vue.PropType<TConvert>;
1474
+ };
1475
+ }>>, {
1476
+ splitStr: string;
1477
+ format: string;
1478
+ isUnix: boolean;
1479
+ }> | vue.DefineComponent<_vue_start_pro.ProCurdProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<_vue_start_pro.ProCurdProps>, {}> | vue.DefineComponent<ProFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormItemProps>, {}> | vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
1480
+ [x: string]: any;
1481
+ }> | vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1482
+ loading: {
1483
+ type: BooleanConstructor;
1484
+ };
1485
+ target: {
1486
+ type: vue.PropType<string | HTMLElement>;
1487
+ };
1488
+ body: {
1489
+ type: BooleanConstructor;
1490
+ };
1491
+ fullscreen: {
1492
+ type: BooleanConstructor;
1493
+ };
1494
+ lock: {
1495
+ type: BooleanConstructor;
1496
+ };
1497
+ text: {
1498
+ type: StringConstructor;
1499
+ };
1500
+ spinner: {
1501
+ type: StringConstructor;
1502
+ };
1503
+ background: {
1504
+ type: StringConstructor;
1505
+ };
1506
+ customClass: {
1507
+ type: StringConstructor;
1508
+ };
1509
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<vue.ExtractPropTypes<{
1510
+ loading: {
1511
+ type: BooleanConstructor;
1512
+ };
1513
+ target: {
1514
+ type: vue.PropType<string | HTMLElement>;
1515
+ };
1516
+ body: {
1517
+ type: BooleanConstructor;
1518
+ };
1519
+ fullscreen: {
1520
+ type: BooleanConstructor;
1521
+ };
1522
+ lock: {
1523
+ type: BooleanConstructor;
1524
+ };
1525
+ text: {
1526
+ type: StringConstructor;
1527
+ };
1528
+ spinner: {
1529
+ type: StringConstructor;
1530
+ };
1531
+ background: {
1532
+ type: StringConstructor;
1533
+ };
1534
+ customClass: {
1535
+ type: StringConstructor;
1536
+ };
1537
+ }>>>, {}> | vue.DefineComponent<ProModalProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProModalProps>, {}> | (element_plus_es_utils.SFCWithInstall<vue.DefineComponent<{
1538
+ readonly size: {
1539
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1540
+ readonly required: false;
1541
+ readonly validator: ((val: unknown) => boolean) | undefined;
1542
+ __epPropKey: true;
1543
+ };
1544
+ readonly disabled: BooleanConstructor;
1545
+ readonly type: element_plus_es_utils.EpPropFinalized<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown, "", boolean>;
1546
+ readonly icon: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown, "", boolean>;
1547
+ readonly nativeType: element_plus_es_utils.EpPropFinalized<StringConstructor, "reset" | "submit" | "button", unknown, "button", boolean>;
1548
+ readonly loading: BooleanConstructor;
1549
+ readonly loadingIcon: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown, () => vue.DefineComponent<{}, {}, {}, vue.ComputedOptions, vue.MethodOptions, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{}>>, {}>, boolean>;
1550
+ readonly plain: BooleanConstructor;
1551
+ readonly text: BooleanConstructor;
1552
+ readonly link: BooleanConstructor;
1553
+ readonly bg: BooleanConstructor;
1554
+ readonly autofocus: BooleanConstructor;
1555
+ readonly round: BooleanConstructor;
1556
+ readonly circle: BooleanConstructor;
1557
+ readonly color: StringConstructor;
1558
+ readonly dark: BooleanConstructor;
1559
+ readonly autoInsertSpace: element_plus_es_utils.EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
1560
+ }, {
1561
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
1562
+ readonly size: {
1563
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1564
+ readonly required: false;
1565
+ readonly validator: ((val: unknown) => boolean) | undefined;
1566
+ __epPropKey: true;
1567
+ };
1568
+ readonly disabled: BooleanConstructor;
1569
+ readonly type: element_plus_es_utils.EpPropFinalized<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown, "", boolean>;
1570
+ readonly icon: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown, "", boolean>;
1571
+ readonly nativeType: element_plus_es_utils.EpPropFinalized<StringConstructor, "reset" | "submit" | "button", unknown, "button", boolean>;
1572
+ readonly loading: BooleanConstructor;
1573
+ readonly loadingIcon: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown, () => vue.DefineComponent<{}, {}, {}, vue.ComputedOptions, vue.MethodOptions, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{}>>, {}>, boolean>;
1574
+ readonly plain: BooleanConstructor;
1575
+ readonly text: BooleanConstructor;
1576
+ readonly link: BooleanConstructor;
1577
+ readonly bg: BooleanConstructor;
1578
+ readonly autofocus: BooleanConstructor;
1579
+ readonly round: BooleanConstructor;
1580
+ readonly circle: BooleanConstructor;
1581
+ readonly color: StringConstructor;
1582
+ readonly dark: BooleanConstructor;
1583
+ readonly autoInsertSpace: element_plus_es_utils.EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
1584
+ }>> & {
1585
+ onClick?: ((evt: MouseEvent) => any) | undefined;
1586
+ }>>;
1587
+ emit: (event: "click", evt: MouseEvent) => void;
1588
+ slots: Readonly<{
1589
+ [name: string]: vue.Slot | undefined;
938
1590
  }>;
939
- };
940
- okText: {
941
- type: StringConstructor;
942
- default: string;
943
- };
944
- okButtonProps: {
945
- type: PropType<{
946
- readonly text: boolean;
947
- readonly link: boolean;
1591
+ buttonGroupContext: element_plus.ButtonGroupContext | undefined;
1592
+ globalConfig: vue.Ref<element_plus.ButtonConfigContext | undefined>;
1593
+ ns: {
1594
+ namespace: vue.ComputedRef<string>;
1595
+ b: (blockSuffix?: string | undefined) => string;
1596
+ e: (element?: string | undefined) => string;
1597
+ m: (modifier?: string | undefined) => string;
1598
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
1599
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
1600
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
1601
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
1602
+ is: {
1603
+ (name: string, state: boolean | undefined): string;
1604
+ (name: string): string;
1605
+ };
1606
+ cssVar: (object: Record<string, string>) => Record<string, string>;
1607
+ cssVarName: (name: string) => string;
1608
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
1609
+ cssVarBlockName: (name: string) => string;
1610
+ };
1611
+ form: element_plus.FormContext | undefined;
1612
+ _size: vue.ComputedRef<"" | "small" | "default" | "large">;
1613
+ _disabled: vue.ComputedRef<boolean>;
1614
+ _ref: vue.Ref<HTMLButtonElement | undefined>;
1615
+ _type: vue.ComputedRef<"" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info">;
1616
+ autoInsertSpace: vue.ComputedRef<element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>>;
1617
+ shouldAddSpace: vue.ComputedRef<boolean>;
1618
+ buttonStyle: vue.ComputedRef<Record<string, string>>;
1619
+ handleClick: (evt: MouseEvent) => void;
1620
+ ElIcon: element_plus_es_utils.SFCWithInstall<vue.DefineComponent<{
1621
+ readonly size: {
1622
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
1623
+ readonly required: false;
1624
+ readonly validator: ((val: unknown) => boolean) | undefined;
1625
+ __epPropKey: true;
1626
+ };
1627
+ readonly color: {
1628
+ readonly type: vue.PropType<string>;
1629
+ readonly required: false;
1630
+ readonly validator: ((val: unknown) => boolean) | undefined;
1631
+ __epPropKey: true;
1632
+ };
1633
+ }, {
1634
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
1635
+ readonly size: {
1636
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
1637
+ readonly required: false;
1638
+ readonly validator: ((val: unknown) => boolean) | undefined;
1639
+ __epPropKey: true;
1640
+ };
1641
+ readonly color: {
1642
+ readonly type: vue.PropType<string>;
1643
+ readonly required: false;
1644
+ readonly validator: ((val: unknown) => boolean) | undefined;
1645
+ __epPropKey: true;
1646
+ };
1647
+ }>> & {
1648
+ [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
1649
+ }>>;
1650
+ ns: {
1651
+ namespace: vue.ComputedRef<string>;
1652
+ b: (blockSuffix?: string | undefined) => string;
1653
+ e: (element?: string | undefined) => string;
1654
+ m: (modifier?: string | undefined) => string;
1655
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
1656
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
1657
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
1658
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
1659
+ is: {
1660
+ (name: string, state: boolean | undefined): string;
1661
+ (name: string): string;
1662
+ };
1663
+ cssVar: (object: Record<string, string>) => Record<string, string>;
1664
+ cssVarName: (name: string) => string;
1665
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
1666
+ cssVarBlockName: (name: string) => string;
1667
+ };
1668
+ style: vue.ComputedRef<vue.CSSProperties>;
1669
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1670
+ readonly size: {
1671
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
1672
+ readonly required: false;
1673
+ readonly validator: ((val: unknown) => boolean) | undefined;
1674
+ __epPropKey: true;
1675
+ };
1676
+ readonly color: {
1677
+ readonly type: vue.PropType<string>;
1678
+ readonly required: false;
1679
+ readonly validator: ((val: unknown) => boolean) | undefined;
1680
+ __epPropKey: true;
1681
+ };
1682
+ }>>, {}>> & Record<string, any>;
1683
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
1684
+ click: (evt: MouseEvent) => boolean;
1685
+ }, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1686
+ readonly size: {
1687
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1688
+ readonly required: false;
1689
+ readonly validator: ((val: unknown) => boolean) | undefined;
1690
+ __epPropKey: true;
1691
+ };
1692
+ readonly disabled: BooleanConstructor;
1693
+ readonly type: element_plus_es_utils.EpPropFinalized<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown, "", boolean>;
1694
+ readonly icon: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown, "", boolean>;
1695
+ readonly nativeType: element_plus_es_utils.EpPropFinalized<StringConstructor, "reset" | "submit" | "button", unknown, "button", boolean>;
1696
+ readonly loading: BooleanConstructor;
1697
+ readonly loadingIcon: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown, () => vue.DefineComponent<{}, {}, {}, vue.ComputedOptions, vue.MethodOptions, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{}>>, {}>, boolean>;
1698
+ readonly plain: BooleanConstructor;
1699
+ readonly text: BooleanConstructor;
1700
+ readonly link: BooleanConstructor;
1701
+ readonly bg: BooleanConstructor;
1702
+ readonly autofocus: BooleanConstructor;
1703
+ readonly round: BooleanConstructor;
1704
+ readonly circle: BooleanConstructor;
1705
+ readonly color: StringConstructor;
1706
+ readonly dark: BooleanConstructor;
1707
+ readonly autoInsertSpace: element_plus_es_utils.EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
1708
+ }>> & {
1709
+ onClick?: ((evt: MouseEvent) => any) | undefined;
1710
+ }, {
1711
+ readonly type: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown>;
1712
+ readonly text: boolean;
1713
+ readonly icon: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown>;
1714
+ readonly nativeType: element_plus_es_utils.EpPropMergeType<StringConstructor, "reset" | "submit" | "button", unknown>;
1715
+ readonly loadingIcon: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown>;
1716
+ readonly autoInsertSpace: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1717
+ readonly disabled: boolean;
1718
+ readonly loading: boolean;
1719
+ readonly plain: boolean;
1720
+ readonly link: boolean;
1721
+ readonly bg: boolean;
1722
+ readonly autofocus: boolean;
1723
+ readonly round: boolean;
1724
+ readonly circle: boolean;
1725
+ readonly dark: boolean;
1726
+ }>> & {
1727
+ ButtonGroup: vue.DefineComponent<{
1728
+ readonly size: {
1729
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1730
+ readonly required: false;
1731
+ readonly validator: ((val: unknown) => boolean) | undefined;
1732
+ __epPropKey: true;
1733
+ };
1734
+ readonly type: element_plus_es_utils.EpPropFinalized<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown, "", boolean>;
1735
+ }, {
1736
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
1737
+ readonly size: {
1738
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1739
+ readonly required: false;
1740
+ readonly validator: ((val: unknown) => boolean) | undefined;
1741
+ __epPropKey: true;
1742
+ };
1743
+ readonly type: element_plus_es_utils.EpPropFinalized<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown, "", boolean>;
1744
+ }>> & {
1745
+ [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
1746
+ }>>;
1747
+ ns: {
1748
+ namespace: vue.ComputedRef<string>;
1749
+ b: (blockSuffix?: string | undefined) => string;
1750
+ e: (element?: string | undefined) => string;
1751
+ m: (modifier?: string | undefined) => string;
1752
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
1753
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
1754
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
1755
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
1756
+ is: {
1757
+ (name: string, state: boolean | undefined): string;
1758
+ (name: string): string;
1759
+ };
1760
+ cssVar: (object: Record<string, string>) => Record<string, string>;
1761
+ cssVarName: (name: string) => string;
1762
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
1763
+ cssVarBlockName: (name: string) => string;
1764
+ };
1765
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1766
+ readonly size: {
1767
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1768
+ readonly required: false;
1769
+ readonly validator: ((val: unknown) => boolean) | undefined;
1770
+ __epPropKey: true;
1771
+ };
1772
+ readonly type: element_plus_es_utils.EpPropFinalized<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown, "", boolean>;
1773
+ }>>, {
948
1774
  readonly type: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "text" | "default" | "primary" | "success" | "warning" | "danger" | "info", unknown>;
949
- readonly circle: boolean;
950
- readonly disabled: boolean;
951
- readonly loading: boolean;
952
- readonly autofocus: boolean;
953
- readonly loadingIcon: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown>;
954
- readonly round: boolean;
955
- readonly dark: boolean;
956
- readonly icon: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) | ((new (...args: any[]) => (string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>) & {}) | (() => string | vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions>))[], unknown, unknown>;
957
- readonly nativeType: element_plus_es_utils.EpPropMergeType<StringConstructor, "reset" | "submit" | "button", unknown>;
958
- readonly plain: boolean;
959
- readonly bg: boolean;
960
- } & {
961
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
962
- readonly color?: string | undefined;
963
- readonly autoInsertSpace?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
964
- } & {
965
- onClick?: (() => void) | undefined;
966
1775
  }>;
967
- };
968
- confirmLoading: BooleanConstructor;
969
- footer: {
970
- type: BooleanConstructor;
971
- default: boolean;
972
- };
973
- maskClosable: {
974
- type: (BooleanConstructor | ObjectConstructor)[];
975
- default: undefined;
976
- };
977
- };
978
- declare type ProModalProps = Partial<ExtractPropTypes<ReturnType<typeof proModalProps>>> & DialogProps;
979
- declare const ProModal: vue.DefineComponent<ProModalProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProModalProps>, {}>;
980
-
981
- declare const ProPagination: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
982
- [x: string]: any;
983
- }>;
984
-
985
- declare const ProPopover: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
986
- [x: string]: any;
987
- }>;
988
-
989
- declare const proCheckboxProps: () => {
990
- options: PropType<(TOption & {
1776
+ }) | (element_plus_es_utils.SFCWithInstall<vue.DefineComponent<{
1777
+ modelValue: {
1778
+ type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
1779
+ default: () => undefined;
1780
+ };
1781
+ label: {
1782
+ type: (NumberConstructor | StringConstructor | BooleanConstructor | ObjectConstructor)[];
1783
+ };
1784
+ indeterminate: BooleanConstructor;
1785
+ disabled: BooleanConstructor;
1786
+ checked: BooleanConstructor;
1787
+ name: {
1788
+ type: StringConstructor;
1789
+ default: undefined;
1790
+ };
1791
+ trueLabel: {
1792
+ type: (NumberConstructor | StringConstructor)[];
1793
+ default: undefined;
1794
+ };
1795
+ falseLabel: {
1796
+ type: (NumberConstructor | StringConstructor)[];
1797
+ default: undefined;
1798
+ };
1799
+ id: {
1800
+ type: StringConstructor;
1801
+ default: undefined;
1802
+ };
1803
+ controls: {
1804
+ type: StringConstructor;
1805
+ default: undefined;
1806
+ };
1807
+ border: BooleanConstructor;
1808
+ size: {
1809
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1810
+ readonly required: false;
1811
+ readonly validator: ((val: unknown) => boolean) | undefined;
1812
+ __epPropKey: true;
1813
+ };
1814
+ tabindex: (NumberConstructor | StringConstructor)[];
1815
+ validateEvent: {
1816
+ type: BooleanConstructor;
1817
+ default: boolean;
1818
+ };
1819
+ }, {
1820
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
1821
+ modelValue: {
1822
+ type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
1823
+ default: () => undefined;
1824
+ };
1825
+ label: {
1826
+ type: (NumberConstructor | StringConstructor | BooleanConstructor | ObjectConstructor)[];
1827
+ };
1828
+ indeterminate: BooleanConstructor;
1829
+ disabled: BooleanConstructor;
1830
+ checked: BooleanConstructor;
1831
+ name: {
1832
+ type: StringConstructor;
1833
+ default: undefined;
1834
+ };
1835
+ trueLabel: {
1836
+ type: (NumberConstructor | StringConstructor)[];
1837
+ default: undefined;
1838
+ };
1839
+ falseLabel: {
1840
+ type: (NumberConstructor | StringConstructor)[];
1841
+ default: undefined;
1842
+ };
1843
+ id: {
1844
+ type: StringConstructor;
1845
+ default: undefined;
1846
+ };
1847
+ controls: {
1848
+ type: StringConstructor;
1849
+ default: undefined;
1850
+ };
1851
+ border: BooleanConstructor;
1852
+ size: {
1853
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1854
+ readonly required: false;
1855
+ readonly validator: ((val: unknown) => boolean) | undefined;
1856
+ __epPropKey: true;
1857
+ };
1858
+ tabindex: (NumberConstructor | StringConstructor)[];
1859
+ validateEvent: {
1860
+ type: BooleanConstructor;
1861
+ default: boolean;
1862
+ };
1863
+ }>> & {
1864
+ onChange?: ((val: element_plus.CheckboxValueType) => any) | undefined;
1865
+ "onUpdate:modelValue"?: ((val: element_plus.CheckboxValueType) => any) | undefined;
1866
+ }>>;
1867
+ slots: Readonly<{
1868
+ [name: string]: vue.Slot | undefined;
1869
+ }>;
1870
+ inputId: vue.Ref<string | undefined>;
1871
+ isLabeledByFormItem: vue.ComputedRef<boolean>;
1872
+ isChecked: vue.ComputedRef<boolean>;
1873
+ isDisabled: vue.ComputedRef<boolean>;
1874
+ checkboxSize: vue.ComputedRef<"" | "small" | "default" | "large">;
1875
+ hasOwnLabel: vue.ComputedRef<boolean>;
1876
+ model: vue.WritableComputedRef<any>;
1877
+ handleChange: (e: Event) => void;
1878
+ onClickRoot: (e: MouseEvent) => Promise<void>;
1879
+ focus: vue.Ref<boolean>;
1880
+ ns: {
1881
+ namespace: vue.ComputedRef<string>;
1882
+ b: (blockSuffix?: string | undefined) => string;
1883
+ e: (element?: string | undefined) => string;
1884
+ m: (modifier?: string | undefined) => string;
1885
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
1886
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
1887
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
1888
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
1889
+ is: {
1890
+ (name: string, state: boolean | undefined): string;
1891
+ (name: string): string;
1892
+ };
1893
+ cssVar: (object: Record<string, string>) => Record<string, string>;
1894
+ cssVarName: (name: string) => string;
1895
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
1896
+ cssVarBlockName: (name: string) => string;
1897
+ };
1898
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
1899
+ "update:modelValue": (val: element_plus.CheckboxValueType) => boolean;
1900
+ change: (val: element_plus.CheckboxValueType) => boolean;
1901
+ }, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
1902
+ modelValue: {
1903
+ type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
1904
+ default: () => undefined;
1905
+ };
1906
+ label: {
1907
+ type: (NumberConstructor | StringConstructor | BooleanConstructor | ObjectConstructor)[];
1908
+ };
1909
+ indeterminate: BooleanConstructor;
1910
+ disabled: BooleanConstructor;
1911
+ checked: BooleanConstructor;
1912
+ name: {
1913
+ type: StringConstructor;
1914
+ default: undefined;
1915
+ };
1916
+ trueLabel: {
1917
+ type: (NumberConstructor | StringConstructor)[];
1918
+ default: undefined;
1919
+ };
1920
+ falseLabel: {
1921
+ type: (NumberConstructor | StringConstructor)[];
1922
+ default: undefined;
1923
+ };
1924
+ id: {
1925
+ type: StringConstructor;
1926
+ default: undefined;
1927
+ };
1928
+ controls: {
1929
+ type: StringConstructor;
1930
+ default: undefined;
1931
+ };
1932
+ border: BooleanConstructor;
1933
+ size: {
1934
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1935
+ readonly required: false;
1936
+ readonly validator: ((val: unknown) => boolean) | undefined;
1937
+ __epPropKey: true;
1938
+ };
1939
+ tabindex: (NumberConstructor | StringConstructor)[];
1940
+ validateEvent: {
1941
+ type: BooleanConstructor;
1942
+ default: boolean;
1943
+ };
1944
+ }>> & {
1945
+ onChange?: ((val: element_plus.CheckboxValueType) => any) | undefined;
1946
+ "onUpdate:modelValue"?: ((val: element_plus.CheckboxValueType) => any) | undefined;
1947
+ }, {
991
1948
  disabled: boolean;
992
- checked: boolean;
993
- indeterminate: boolean;
994
- border: boolean;
1949
+ name: string;
1950
+ id: string;
1951
+ modelValue: string | number | boolean;
995
1952
  validateEvent: boolean;
996
- } & {
997
- label?: string | number | boolean | Record<string, any> | undefined;
998
- name?: string | undefined;
999
- id?: string | undefined;
1000
- size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
1001
- modelValue?: string | number | boolean | undefined;
1002
- tabindex?: string | number | undefined;
1003
- controls?: string | undefined;
1004
- trueLabel?: string | number | undefined;
1005
- falseLabel?: string | number | undefined;
1006
- })[]>;
1007
- buttonStyle: {
1008
- type: PropType<"default" | "button">;
1009
- default: string;
1010
- };
1011
- optionType: {
1012
- type: PropType<"default" | "button">;
1013
- default: string;
1014
- };
1015
- };
1016
- declare type ProCheckboxProps = Partial<ExtractPropTypes<ReturnType<typeof proCheckboxProps>>> & IUseCheckboxGroupProps;
1017
- declare const ProCheckbox: vue.DefineComponent<ProCheckboxProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProCheckboxProps>, {}>;
1018
-
1019
- declare const proRadioProps: () => {
1020
- options: {
1021
- type: PropType<(TOption & {
1022
- readonly label: element_plus_es_utils.EpPropMergeType<(NumberConstructor | StringConstructor | BooleanConstructor)[], unknown, unknown>;
1023
- readonly name: string;
1024
- readonly disabled: boolean;
1025
- readonly modelValue: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>;
1026
- readonly border: boolean;
1027
- } & {
1028
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
1029
- } & {
1030
- readonly label: element_plus_es_utils.EpPropMergeType<(NumberConstructor | StringConstructor | BooleanConstructor)[], unknown, unknown>;
1031
- readonly name: string;
1032
- readonly disabled: boolean;
1033
- } & {
1034
- readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never> | undefined;
1035
- })[]>;
1036
- };
1037
- buttonStyle: {
1038
- type: PropType<"default" | "button">;
1039
- default: string;
1040
- };
1041
- optionType: {
1042
- type: PropType<"default" | "button">;
1043
- default: string;
1044
- };
1045
- };
1046
- declare type ProRadioProps = Partial<ExtractPropTypes<ReturnType<typeof proRadioProps>>> & Record<string, any>;
1047
- declare const ProRadio: vue.DefineComponent<ProRadioProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<ProRadioProps>>, {
1048
- [x: string]: any;
1049
- }>;
1050
-
1051
- declare const proSelectProps: () => {
1052
- options: PropType<(TOption & {
1053
- created: boolean;
1054
- disabled: boolean;
1055
- hovering: boolean;
1056
- selected: boolean;
1057
- } & {
1058
- data?: unknown[] | undefined;
1059
- style?: Record<string, any> | undefined;
1060
- index?: number | undefined;
1061
- item?: Record<string, any> | undefined;
1062
- })[]>;
1063
- };
1064
- declare type ProSelectProps = Partial<ExtractPropTypes<ReturnType<typeof proSelectProps>>> & ISelectProps;
1065
- declare const ProSelect: vue.DefineComponent<ProSelectProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProSelectProps>, {
1066
- modelValue?: any;
1067
- }>;
1068
-
1069
- declare const ProTabs: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
1070
- [x: string]: any;
1071
- }>;
1072
-
1073
- /******************************* Menus ************************************/
1074
- declare const menuProps: () => {
1075
- convertSubMenuProps: {
1076
- type: FunctionConstructor;
1077
- };
1078
- convertMenuItemProps: {
1079
- type: FunctionConstructor;
1080
- };
1081
- onMenuItemClick: {
1082
- type: FunctionConstructor;
1083
- };
1084
- activeKey: {
1085
- type: StringConstructor;
1086
- };
1087
- options: {
1088
- type: PropType<Record<string, any>[]>;
1089
- };
1090
- fieldNames: {
1091
- type: PropType<{
1092
- children: string;
1093
- value: string;
1953
+ border: boolean;
1954
+ indeterminate: boolean;
1955
+ checked: boolean;
1956
+ trueLabel: string | number;
1957
+ falseLabel: string | number;
1958
+ controls: string;
1959
+ }>> & {
1960
+ CheckboxButton: vue.DefineComponent<{
1961
+ modelValue: {
1962
+ type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
1963
+ default: () => undefined;
1964
+ };
1965
+ label: {
1966
+ type: (NumberConstructor | StringConstructor | BooleanConstructor | ObjectConstructor)[];
1967
+ };
1968
+ indeterminate: BooleanConstructor;
1969
+ disabled: BooleanConstructor;
1970
+ checked: BooleanConstructor;
1971
+ name: {
1972
+ type: StringConstructor;
1973
+ default: undefined;
1974
+ };
1975
+ trueLabel: {
1976
+ type: (NumberConstructor | StringConstructor)[];
1977
+ default: undefined;
1978
+ };
1979
+ falseLabel: {
1980
+ type: (NumberConstructor | StringConstructor)[];
1981
+ default: undefined;
1982
+ };
1983
+ id: {
1984
+ type: StringConstructor;
1985
+ default: undefined;
1986
+ };
1987
+ controls: {
1988
+ type: StringConstructor;
1989
+ default: undefined;
1990
+ };
1991
+ border: BooleanConstructor;
1992
+ size: {
1993
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
1994
+ readonly required: false;
1995
+ readonly validator: ((val: unknown) => boolean) | undefined;
1996
+ __epPropKey: true;
1997
+ };
1998
+ tabindex: (NumberConstructor | StringConstructor)[];
1999
+ validateEvent: {
2000
+ type: BooleanConstructor;
2001
+ default: boolean;
2002
+ };
2003
+ }, {
2004
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
2005
+ modelValue: {
2006
+ type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
2007
+ default: () => undefined;
2008
+ };
2009
+ label: {
2010
+ type: (NumberConstructor | StringConstructor | BooleanConstructor | ObjectConstructor)[];
2011
+ };
2012
+ indeterminate: BooleanConstructor;
2013
+ disabled: BooleanConstructor;
2014
+ checked: BooleanConstructor;
2015
+ name: {
2016
+ type: StringConstructor;
2017
+ default: undefined;
2018
+ };
2019
+ trueLabel: {
2020
+ type: (NumberConstructor | StringConstructor)[];
2021
+ default: undefined;
2022
+ };
2023
+ falseLabel: {
2024
+ type: (NumberConstructor | StringConstructor)[];
2025
+ default: undefined;
2026
+ };
2027
+ id: {
2028
+ type: StringConstructor;
2029
+ default: undefined;
2030
+ };
2031
+ controls: {
2032
+ type: StringConstructor;
2033
+ default: undefined;
2034
+ };
2035
+ border: BooleanConstructor;
2036
+ size: {
2037
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2038
+ readonly required: false;
2039
+ readonly validator: ((val: unknown) => boolean) | undefined;
2040
+ __epPropKey: true;
2041
+ };
2042
+ tabindex: (NumberConstructor | StringConstructor)[];
2043
+ validateEvent: {
2044
+ type: BooleanConstructor;
2045
+ default: boolean;
2046
+ };
2047
+ }>> & {
2048
+ onChange?: ((val: element_plus.CheckboxValueType) => any) | undefined;
2049
+ "onUpdate:modelValue"?: ((val: element_plus.CheckboxValueType) => any) | undefined;
2050
+ }>>;
2051
+ slots: Readonly<{
2052
+ [name: string]: vue.Slot | undefined;
2053
+ }>;
2054
+ focus: vue.Ref<boolean>;
2055
+ isChecked: vue.ComputedRef<boolean>;
2056
+ isDisabled: vue.ComputedRef<boolean>;
2057
+ size: vue.ComputedRef<"" | "small" | "default" | "large">;
2058
+ model: vue.WritableComputedRef<any>;
2059
+ handleChange: (e: Event) => void;
2060
+ checkboxGroup: element_plus.ICheckboxGroupInstance;
2061
+ ns: {
2062
+ namespace: vue.ComputedRef<string>;
2063
+ b: (blockSuffix?: string | undefined) => string;
2064
+ e: (element?: string | undefined) => string;
2065
+ m: (modifier?: string | undefined) => string;
2066
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
2067
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
2068
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
2069
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
2070
+ is: {
2071
+ (name: string, state: boolean | undefined): string;
2072
+ (name: string): string;
2073
+ };
2074
+ cssVar: (object: Record<string, string>) => Record<string, string>;
2075
+ cssVarName: (name: string) => string;
2076
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
2077
+ cssVarBlockName: (name: string) => string;
2078
+ };
2079
+ activeStyle: vue.ComputedRef<vue.CSSProperties>;
2080
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2081
+ "update:modelValue": (val: element_plus.CheckboxValueType) => boolean;
2082
+ change: (val: element_plus.CheckboxValueType) => boolean;
2083
+ }, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2084
+ modelValue: {
2085
+ type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
2086
+ default: () => undefined;
2087
+ };
2088
+ label: {
2089
+ type: (NumberConstructor | StringConstructor | BooleanConstructor | ObjectConstructor)[];
2090
+ };
2091
+ indeterminate: BooleanConstructor;
2092
+ disabled: BooleanConstructor;
2093
+ checked: BooleanConstructor;
2094
+ name: {
2095
+ type: StringConstructor;
2096
+ default: undefined;
2097
+ };
2098
+ trueLabel: {
2099
+ type: (NumberConstructor | StringConstructor)[];
2100
+ default: undefined;
2101
+ };
2102
+ falseLabel: {
2103
+ type: (NumberConstructor | StringConstructor)[];
2104
+ default: undefined;
2105
+ };
2106
+ id: {
2107
+ type: StringConstructor;
2108
+ default: undefined;
2109
+ };
2110
+ controls: {
2111
+ type: StringConstructor;
2112
+ default: undefined;
2113
+ };
2114
+ border: BooleanConstructor;
2115
+ size: {
2116
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2117
+ readonly required: false;
2118
+ readonly validator: ((val: unknown) => boolean) | undefined;
2119
+ __epPropKey: true;
2120
+ };
2121
+ tabindex: (NumberConstructor | StringConstructor)[];
2122
+ validateEvent: {
2123
+ type: BooleanConstructor;
2124
+ default: boolean;
2125
+ };
2126
+ }>> & {
2127
+ onChange?: ((val: element_plus.CheckboxValueType) => any) | undefined;
2128
+ "onUpdate:modelValue"?: ((val: element_plus.CheckboxValueType) => any) | undefined;
2129
+ }, {
2130
+ disabled: boolean;
2131
+ name: string;
2132
+ id: string;
2133
+ modelValue: string | number | boolean;
2134
+ validateEvent: boolean;
2135
+ border: boolean;
2136
+ indeterminate: boolean;
2137
+ checked: boolean;
2138
+ trueLabel: string | number;
2139
+ falseLabel: string | number;
2140
+ controls: string;
2141
+ }>;
2142
+ CheckboxGroup: vue.DefineComponent<{
2143
+ modelValue: {
2144
+ type: vue.PropType<(string | number)[]>;
2145
+ default: () => never[];
2146
+ };
2147
+ disabled: BooleanConstructor;
2148
+ min: {
2149
+ type: NumberConstructor;
2150
+ default: undefined;
2151
+ };
2152
+ max: {
2153
+ type: NumberConstructor;
2154
+ default: undefined;
2155
+ };
2156
+ size: {
2157
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2158
+ readonly required: false;
2159
+ readonly validator: ((val: unknown) => boolean) | undefined;
2160
+ __epPropKey: true;
2161
+ };
2162
+ id: {
2163
+ type: StringConstructor;
2164
+ default: undefined;
2165
+ };
2166
+ label: {
2167
+ type: StringConstructor;
2168
+ default: undefined;
2169
+ };
2170
+ fill: {
2171
+ type: StringConstructor;
2172
+ default: undefined;
2173
+ };
2174
+ textColor: {
2175
+ type: StringConstructor;
2176
+ default: undefined;
2177
+ };
2178
+ tag: {
2179
+ type: StringConstructor;
2180
+ default: string;
2181
+ };
2182
+ validateEvent: {
2183
+ type: BooleanConstructor;
2184
+ default: boolean;
2185
+ };
2186
+ }, {
2187
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
2188
+ modelValue: {
2189
+ type: vue.PropType<(string | number)[]>;
2190
+ default: () => never[];
2191
+ };
2192
+ disabled: BooleanConstructor;
2193
+ min: {
2194
+ type: NumberConstructor;
2195
+ default: undefined;
2196
+ };
2197
+ max: {
2198
+ type: NumberConstructor;
2199
+ default: undefined;
2200
+ };
2201
+ size: {
2202
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2203
+ readonly required: false;
2204
+ readonly validator: ((val: unknown) => boolean) | undefined;
2205
+ __epPropKey: true;
2206
+ };
2207
+ id: {
2208
+ type: StringConstructor;
2209
+ default: undefined;
2210
+ };
2211
+ label: {
2212
+ type: StringConstructor;
2213
+ default: undefined;
2214
+ };
2215
+ fill: {
2216
+ type: StringConstructor;
2217
+ default: undefined;
2218
+ };
2219
+ textColor: {
2220
+ type: StringConstructor;
2221
+ default: undefined;
2222
+ };
2223
+ tag: {
2224
+ type: StringConstructor;
2225
+ default: string;
2226
+ };
2227
+ validateEvent: {
2228
+ type: BooleanConstructor;
2229
+ default: boolean;
2230
+ };
2231
+ }>> & {
2232
+ onChange?: ((val: element_plus.CheckboxValueType[]) => any) | undefined;
2233
+ "onUpdate:modelValue"?: ((val: element_plus.CheckboxValueType[]) => any) | undefined;
2234
+ }>>;
2235
+ emit: ((event: "update:modelValue", val: element_plus.CheckboxValueType[]) => void) & ((event: "change", val: element_plus.CheckboxValueType[]) => void);
2236
+ elFormItem: element_plus.FormItemContext | undefined;
2237
+ groupId: vue.Ref<string | undefined>;
2238
+ isLabeledByFormItem: vue.ComputedRef<boolean>;
2239
+ checkboxGroupSize: vue.ComputedRef<"" | "small" | "default" | "large">;
2240
+ ns: {
2241
+ namespace: vue.ComputedRef<string>;
2242
+ b: (blockSuffix?: string | undefined) => string;
2243
+ e: (element?: string | undefined) => string;
2244
+ m: (modifier?: string | undefined) => string;
2245
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
2246
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
2247
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
2248
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
2249
+ is: {
2250
+ (name: string, state: boolean | undefined): string;
2251
+ (name: string): string;
2252
+ };
2253
+ cssVar: (object: Record<string, string>) => Record<string, string>;
2254
+ cssVarName: (name: string) => string;
2255
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
2256
+ cssVarBlockName: (name: string) => string;
2257
+ };
2258
+ changeEvent: (value: element_plus.CheckboxValueType[]) => void;
2259
+ modelValue: vue.WritableComputedRef<element_plus.CheckboxValueType[]>;
2260
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2261
+ "update:modelValue": (val: element_plus.CheckboxValueType[]) => boolean;
2262
+ change: (val: element_plus.CheckboxValueType[]) => boolean;
2263
+ }, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2264
+ modelValue: {
2265
+ type: vue.PropType<(string | number)[]>;
2266
+ default: () => never[];
2267
+ };
2268
+ disabled: BooleanConstructor;
2269
+ min: {
2270
+ type: NumberConstructor;
2271
+ default: undefined;
2272
+ };
2273
+ max: {
2274
+ type: NumberConstructor;
2275
+ default: undefined;
2276
+ };
2277
+ size: {
2278
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2279
+ readonly required: false;
2280
+ readonly validator: ((val: unknown) => boolean) | undefined;
2281
+ __epPropKey: true;
2282
+ };
2283
+ id: {
2284
+ type: StringConstructor;
2285
+ default: undefined;
2286
+ };
2287
+ label: {
2288
+ type: StringConstructor;
2289
+ default: undefined;
2290
+ };
2291
+ fill: {
2292
+ type: StringConstructor;
2293
+ default: undefined;
2294
+ };
2295
+ textColor: {
2296
+ type: StringConstructor;
2297
+ default: undefined;
2298
+ };
2299
+ tag: {
2300
+ type: StringConstructor;
2301
+ default: string;
2302
+ };
2303
+ validateEvent: {
2304
+ type: BooleanConstructor;
2305
+ default: boolean;
2306
+ };
2307
+ }>> & {
2308
+ onChange?: ((val: element_plus.CheckboxValueType[]) => any) | undefined;
2309
+ "onUpdate:modelValue"?: ((val: element_plus.CheckboxValueType[]) => any) | undefined;
2310
+ }, {
2311
+ disabled: boolean;
1094
2312
  label: string;
2313
+ id: string;
2314
+ modelValue: (string | number)[];
2315
+ fill: string;
2316
+ textColor: string;
2317
+ validateEvent: boolean;
2318
+ min: number;
2319
+ max: number;
2320
+ tag: string;
1095
2321
  }>;
1096
- default: {
1097
- children: string;
1098
- value: string;
2322
+ }) | vue.DefineComponent<ProMenusProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProMenusProps>, {}> | vue.DefineComponent<ProUploadProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProUploadProps>, {}> | (element_plus_es_utils.SFCWithInstall<vue.DefineComponent<{
2323
+ readonly border: element_plus_es_utils.EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
2324
+ readonly column: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 3, boolean>;
2325
+ readonly direction: element_plus_es_utils.EpPropFinalized<StringConstructor, "vertical" | "horizontal", unknown, "horizontal", boolean>;
2326
+ readonly size: {
2327
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2328
+ readonly required: false;
2329
+ readonly validator: ((val: unknown) => boolean) | undefined;
2330
+ __epPropKey: true;
2331
+ };
2332
+ readonly title: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
2333
+ readonly extra: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
2334
+ }, {
2335
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
2336
+ readonly border: element_plus_es_utils.EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
2337
+ readonly column: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 3, boolean>;
2338
+ readonly direction: element_plus_es_utils.EpPropFinalized<StringConstructor, "vertical" | "horizontal", unknown, "horizontal", boolean>;
2339
+ readonly size: {
2340
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2341
+ readonly required: false;
2342
+ readonly validator: ((val: unknown) => boolean) | undefined;
2343
+ __epPropKey: true;
2344
+ };
2345
+ readonly title: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
2346
+ readonly extra: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
2347
+ }>> & {
2348
+ [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
2349
+ }>>;
2350
+ ns: {
2351
+ namespace: vue.ComputedRef<string>;
2352
+ b: (blockSuffix?: string | undefined) => string;
2353
+ e: (element?: string | undefined) => string;
2354
+ m: (modifier?: string | undefined) => string;
2355
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
2356
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
2357
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
2358
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
2359
+ is: {
2360
+ (name: string, state: boolean | undefined): string;
2361
+ (name: string): string;
2362
+ };
2363
+ cssVar: (object: Record<string, string>) => Record<string, string>;
2364
+ cssVarName: (name: string) => string;
2365
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
2366
+ cssVarBlockName: (name: string) => string;
2367
+ };
2368
+ descriptionsSize: vue.ComputedRef<"" | "small" | "default" | "large">;
2369
+ slots: Readonly<{
2370
+ [name: string]: vue.Slot | undefined;
2371
+ }>;
2372
+ descriptionKls: vue.ComputedRef<string[]>;
2373
+ flattedChildren: (children: any) => never[];
2374
+ filledNode: (node: any, span: any, count: any, isLast?: boolean | undefined) => any;
2375
+ getRows: () => never[];
2376
+ ElDescriptionsRow: vue.DefineComponent<{
2377
+ readonly row: element_plus_es_utils.EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
2378
+ }, {
2379
+ descriptions: element_plus_es_components_descriptions_src_descriptions_type.IDescriptionsInject;
2380
+ ElDescriptionsCell: vue.DefineComponent<{
2381
+ cell: {
2382
+ type: ObjectConstructor;
2383
+ };
2384
+ tag: {
2385
+ type: StringConstructor;
2386
+ };
2387
+ type: {
2388
+ type: StringConstructor;
2389
+ };
2390
+ }, {
2391
+ descriptions: element_plus_es_components_descriptions_src_descriptions_type.IDescriptionsInject;
2392
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2393
+ cell: {
2394
+ type: ObjectConstructor;
2395
+ };
2396
+ tag: {
2397
+ type: StringConstructor;
2398
+ };
2399
+ type: {
2400
+ type: StringConstructor;
2401
+ };
2402
+ }>>, {}>;
2403
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2404
+ readonly row: element_plus_es_utils.EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
2405
+ }>>, {
2406
+ readonly row: unknown[];
2407
+ }>;
2408
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2409
+ readonly border: element_plus_es_utils.EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
2410
+ readonly column: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 3, boolean>;
2411
+ readonly direction: element_plus_es_utils.EpPropFinalized<StringConstructor, "vertical" | "horizontal", unknown, "horizontal", boolean>;
2412
+ readonly size: {
2413
+ readonly type: vue.PropType<element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
2414
+ readonly required: false;
2415
+ readonly validator: ((val: unknown) => boolean) | undefined;
2416
+ __epPropKey: true;
2417
+ };
2418
+ readonly title: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
2419
+ readonly extra: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
2420
+ }>>, {
2421
+ readonly title: string;
2422
+ readonly column: number;
2423
+ readonly border: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
2424
+ readonly direction: element_plus_es_utils.EpPropMergeType<StringConstructor, "vertical" | "horizontal", unknown>;
2425
+ readonly extra: string;
2426
+ }>> & {
2427
+ DescriptionsItem: vue.DefineComponent<{
2428
+ label: {
2429
+ type: StringConstructor;
2430
+ default: string;
2431
+ };
2432
+ span: {
2433
+ type: NumberConstructor;
2434
+ default: number;
2435
+ };
2436
+ width: {
2437
+ type: (NumberConstructor | StringConstructor)[];
2438
+ default: string;
2439
+ };
2440
+ minWidth: {
2441
+ type: (NumberConstructor | StringConstructor)[];
2442
+ default: string;
2443
+ };
2444
+ align: {
2445
+ type: StringConstructor;
2446
+ default: string;
2447
+ };
2448
+ labelAlign: {
2449
+ type: StringConstructor;
2450
+ default: string;
2451
+ };
2452
+ className: {
2453
+ type: StringConstructor;
2454
+ default: string;
2455
+ };
2456
+ labelClassName: {
2457
+ type: StringConstructor;
2458
+ default: string;
2459
+ };
2460
+ }, unknown, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2461
+ label: {
2462
+ type: StringConstructor;
2463
+ default: string;
2464
+ };
2465
+ span: {
2466
+ type: NumberConstructor;
2467
+ default: number;
2468
+ };
2469
+ width: {
2470
+ type: (NumberConstructor | StringConstructor)[];
2471
+ default: string;
2472
+ };
2473
+ minWidth: {
2474
+ type: (NumberConstructor | StringConstructor)[];
2475
+ default: string;
2476
+ };
2477
+ align: {
2478
+ type: StringConstructor;
2479
+ default: string;
2480
+ };
2481
+ labelAlign: {
2482
+ type: StringConstructor;
2483
+ default: string;
2484
+ };
2485
+ className: {
2486
+ type: StringConstructor;
2487
+ default: string;
2488
+ };
2489
+ labelClassName: {
2490
+ type: StringConstructor;
2491
+ default: string;
2492
+ };
2493
+ }>>, {
1099
2494
  label: string;
2495
+ width: string | number;
2496
+ className: string;
2497
+ minWidth: string | number;
2498
+ span: number;
2499
+ align: string;
2500
+ labelAlign: string;
2501
+ labelClassName: string;
2502
+ }>;
2503
+ }) | (element_plus_es_utils.SFCWithInstall<vue.DefineComponent<{
2504
+ readonly tag: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
2505
+ readonly gutter: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2506
+ readonly justify: element_plus_es_utils.EpPropFinalized<StringConstructor, "start" | "end" | "space-around" | "space-between" | "center" | "space-evenly", unknown, "start", boolean>;
2507
+ readonly align: element_plus_es_utils.EpPropFinalized<StringConstructor, "middle" | "top" | "bottom", unknown, "top", boolean>;
2508
+ }, {
2509
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
2510
+ readonly tag: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
2511
+ readonly gutter: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2512
+ readonly justify: element_plus_es_utils.EpPropFinalized<StringConstructor, "start" | "end" | "space-around" | "space-between" | "center" | "space-evenly", unknown, "start", boolean>;
2513
+ readonly align: element_plus_es_utils.EpPropFinalized<StringConstructor, "middle" | "top" | "bottom", unknown, "top", boolean>;
2514
+ }>> & {
2515
+ [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
2516
+ }>>;
2517
+ ns: {
2518
+ namespace: vue.ComputedRef<string>;
2519
+ b: (blockSuffix?: string | undefined) => string;
2520
+ e: (element?: string | undefined) => string;
2521
+ m: (modifier?: string | undefined) => string;
2522
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
2523
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
2524
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
2525
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
2526
+ is: {
2527
+ (name: string, state: boolean | undefined): string;
2528
+ (name: string): string;
2529
+ };
2530
+ cssVar: (object: Record<string, string>) => Record<string, string>;
2531
+ cssVarName: (name: string) => string;
2532
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
2533
+ cssVarBlockName: (name: string) => string;
1100
2534
  };
1101
- };
2535
+ gutter: vue.ComputedRef<number>;
2536
+ style: vue.ComputedRef<vue.CSSProperties>;
2537
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2538
+ readonly tag: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
2539
+ readonly gutter: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2540
+ readonly justify: element_plus_es_utils.EpPropFinalized<StringConstructor, "start" | "end" | "space-around" | "space-between" | "center" | "space-evenly", unknown, "start", boolean>;
2541
+ readonly align: element_plus_es_utils.EpPropFinalized<StringConstructor, "middle" | "top" | "bottom", unknown, "top", boolean>;
2542
+ }>>, {
2543
+ readonly justify: element_plus_es_utils.EpPropMergeType<StringConstructor, "start" | "end" | "space-around" | "space-between" | "center" | "space-evenly", unknown>;
2544
+ readonly tag: string;
2545
+ readonly gutter: number;
2546
+ readonly align: element_plus_es_utils.EpPropMergeType<StringConstructor, "middle" | "top" | "bottom", unknown>;
2547
+ }>> & Record<string, any>) | (element_plus_es_utils.SFCWithInstall<vue.DefineComponent<{
2548
+ readonly tag: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
2549
+ readonly span: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 24, boolean>;
2550
+ readonly offset: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2551
+ readonly pull: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2552
+ readonly push: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2553
+ readonly xs: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2554
+ readonly sm: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2555
+ readonly md: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2556
+ readonly lg: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2557
+ readonly xl: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2558
+ }, {
2559
+ props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
2560
+ readonly tag: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
2561
+ readonly span: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 24, boolean>;
2562
+ readonly offset: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2563
+ readonly pull: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2564
+ readonly push: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2565
+ readonly xs: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2566
+ readonly sm: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2567
+ readonly md: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2568
+ readonly lg: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2569
+ readonly xl: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2570
+ }>> & {
2571
+ [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
2572
+ }>>;
2573
+ gutter: vue.ComputedRef<number>;
2574
+ ns: {
2575
+ namespace: vue.ComputedRef<string>;
2576
+ b: (blockSuffix?: string | undefined) => string;
2577
+ e: (element?: string | undefined) => string;
2578
+ m: (modifier?: string | undefined) => string;
2579
+ be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
2580
+ em: (element?: string | undefined, modifier?: string | undefined) => string;
2581
+ bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
2582
+ bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
2583
+ is: {
2584
+ (name: string, state: boolean | undefined): string;
2585
+ (name: string): string;
2586
+ };
2587
+ cssVar: (object: Record<string, string>) => Record<string, string>;
2588
+ cssVarName: (name: string) => string;
2589
+ cssVarBlock: (object: Record<string, string>) => Record<string, string>;
2590
+ cssVarBlockName: (name: string) => string;
2591
+ };
2592
+ style: vue.ComputedRef<vue.CSSProperties>;
2593
+ classes: vue.ComputedRef<string[]>;
2594
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2595
+ readonly tag: element_plus_es_utils.EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
2596
+ readonly span: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 24, boolean>;
2597
+ readonly offset: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2598
+ readonly pull: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2599
+ readonly push: element_plus_es_utils.EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
2600
+ readonly xs: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2601
+ readonly sm: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2602
+ readonly md: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2603
+ readonly lg: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2604
+ readonly xl: element_plus_es_utils.EpPropFinalized<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown, () => element_plus_es_utils.Mutable<{}>, boolean>;
2605
+ }>>, {
2606
+ readonly offset: number;
2607
+ readonly push: number;
2608
+ readonly tag: string;
2609
+ readonly span: number;
2610
+ readonly pull: number;
2611
+ readonly xs: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown>;
2612
+ readonly sm: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown>;
2613
+ readonly md: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown>;
2614
+ readonly lg: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown>;
2615
+ readonly xl: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize) | ((new (...args: any[]) => number | element_plus.ColSizeObject) | (() => element_plus.ColSize))[], unknown, unknown>;
2616
+ }>> & Record<string, any>) | element_plus_es_utils.SFCWithInstall<vue.DefineComponent<{
2617
+ label: {
2618
+ type: StringConstructor;
2619
+ default: string;
2620
+ };
2621
+ span: {
2622
+ type: NumberConstructor;
2623
+ default: number;
2624
+ };
2625
+ width: {
2626
+ type: (NumberConstructor | StringConstructor)[];
2627
+ default: string;
2628
+ };
2629
+ minWidth: {
2630
+ type: (NumberConstructor | StringConstructor)[];
2631
+ default: string;
2632
+ };
2633
+ align: {
2634
+ type: StringConstructor;
2635
+ default: string;
2636
+ };
2637
+ labelAlign: {
2638
+ type: StringConstructor;
2639
+ default: string;
2640
+ };
2641
+ className: {
2642
+ type: StringConstructor;
2643
+ default: string;
2644
+ };
2645
+ labelClassName: {
2646
+ type: StringConstructor;
2647
+ default: string;
2648
+ };
2649
+ }, unknown, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2650
+ label: {
2651
+ type: StringConstructor;
2652
+ default: string;
2653
+ };
2654
+ span: {
2655
+ type: NumberConstructor;
2656
+ default: number;
2657
+ };
2658
+ width: {
2659
+ type: (NumberConstructor | StringConstructor)[];
2660
+ default: string;
2661
+ };
2662
+ minWidth: {
2663
+ type: (NumberConstructor | StringConstructor)[];
2664
+ default: string;
2665
+ };
2666
+ align: {
2667
+ type: StringConstructor;
2668
+ default: string;
2669
+ };
2670
+ labelAlign: {
2671
+ type: StringConstructor;
2672
+ default: string;
2673
+ };
2674
+ className: {
2675
+ type: StringConstructor;
2676
+ default: string;
2677
+ };
2678
+ labelClassName: {
2679
+ type: StringConstructor;
2680
+ default: string;
2681
+ };
2682
+ }>>, {
2683
+ label: string;
2684
+ width: string | number;
2685
+ className: string;
2686
+ minWidth: string | number;
2687
+ span: number;
2688
+ align: string;
2689
+ labelAlign: string;
2690
+ labelClassName: string;
2691
+ }>>;
2692
+ text: vue.DefineComponent<{
2693
+ value: {
2694
+ type: (NumberConstructor | StringConstructor)[];
2695
+ };
2696
+ showProps: {
2697
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2698
+ content: {
2699
+ type: (NumberConstructor | StringConstructor)[];
2700
+ };
2701
+ ellipsis: {
2702
+ type: (BooleanConstructor | vue.PropType<{
2703
+ rows?: number | undefined;
2704
+ num?: number | undefined;
2705
+ }>)[];
2706
+ };
2707
+ popoverProps: ObjectConstructor;
2708
+ }>>>;
2709
+ };
2710
+ convert: {
2711
+ type: vue.PropType<TConvert>;
2712
+ };
2713
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2714
+ value: {
2715
+ type: (NumberConstructor | StringConstructor)[];
2716
+ };
2717
+ showProps: {
2718
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2719
+ content: {
2720
+ type: (NumberConstructor | StringConstructor)[];
2721
+ };
2722
+ ellipsis: {
2723
+ type: (BooleanConstructor | vue.PropType<{
2724
+ rows?: number | undefined;
2725
+ num?: number | undefined;
2726
+ }>)[];
2727
+ };
2728
+ popoverProps: ObjectConstructor;
2729
+ }>>>;
2730
+ };
2731
+ convert: {
2732
+ type: vue.PropType<TConvert>;
2733
+ };
2734
+ }>>, {}>;
2735
+ digit: vue.DefineComponent<{
2736
+ decimalFixed: {
2737
+ type: NumberConstructor;
2738
+ default: number;
2739
+ };
2740
+ thousandDivision: {
2741
+ type: BooleanConstructor;
2742
+ default: boolean;
2743
+ };
2744
+ value: {
2745
+ type: (NumberConstructor | StringConstructor)[];
2746
+ };
2747
+ showProps: {
2748
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2749
+ content: {
2750
+ type: (NumberConstructor | StringConstructor)[];
2751
+ };
2752
+ ellipsis: {
2753
+ type: (BooleanConstructor | vue.PropType<{
2754
+ rows?: number | undefined;
2755
+ num?: number | undefined;
2756
+ }>)[];
2757
+ };
2758
+ popoverProps: ObjectConstructor;
2759
+ }>>>;
2760
+ };
2761
+ convert: {
2762
+ type: vue.PropType<TConvert>;
2763
+ };
2764
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2765
+ decimalFixed: {
2766
+ type: NumberConstructor;
2767
+ default: number;
2768
+ };
2769
+ thousandDivision: {
2770
+ type: BooleanConstructor;
2771
+ default: boolean;
2772
+ };
2773
+ value: {
2774
+ type: (NumberConstructor | StringConstructor)[];
2775
+ };
2776
+ showProps: {
2777
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2778
+ content: {
2779
+ type: (NumberConstructor | StringConstructor)[];
2780
+ };
2781
+ ellipsis: {
2782
+ type: (BooleanConstructor | vue.PropType<{
2783
+ rows?: number | undefined;
2784
+ num?: number | undefined;
2785
+ }>)[];
2786
+ };
2787
+ popoverProps: ObjectConstructor;
2788
+ }>>>;
2789
+ };
2790
+ convert: {
2791
+ type: vue.PropType<TConvert>;
2792
+ };
2793
+ }>>, {
2794
+ decimalFixed: number;
2795
+ thousandDivision: boolean;
2796
+ }>;
2797
+ date: vue.DefineComponent<{
2798
+ value: {
2799
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
2800
+ };
2801
+ splitStr: {
2802
+ type: StringConstructor;
2803
+ default: string;
2804
+ };
2805
+ format: {
2806
+ type: StringConstructor;
2807
+ default: string;
2808
+ };
2809
+ isUnix: {
2810
+ type: BooleanConstructor;
2811
+ default: boolean;
2812
+ };
2813
+ showProps: {
2814
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2815
+ content: {
2816
+ type: (NumberConstructor | StringConstructor)[];
2817
+ };
2818
+ ellipsis: {
2819
+ type: (BooleanConstructor | vue.PropType<{
2820
+ rows?: number | undefined;
2821
+ num?: number | undefined;
2822
+ }>)[];
2823
+ };
2824
+ popoverProps: ObjectConstructor;
2825
+ }>>>;
2826
+ };
2827
+ convert: {
2828
+ type: vue.PropType<TConvert>;
2829
+ };
2830
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2831
+ value: {
2832
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
2833
+ };
2834
+ splitStr: {
2835
+ type: StringConstructor;
2836
+ default: string;
2837
+ };
2838
+ format: {
2839
+ type: StringConstructor;
2840
+ default: string;
2841
+ };
2842
+ isUnix: {
2843
+ type: BooleanConstructor;
2844
+ default: boolean;
2845
+ };
2846
+ showProps: {
2847
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2848
+ content: {
2849
+ type: (NumberConstructor | StringConstructor)[];
2850
+ };
2851
+ ellipsis: {
2852
+ type: (BooleanConstructor | vue.PropType<{
2853
+ rows?: number | undefined;
2854
+ num?: number | undefined;
2855
+ }>)[];
2856
+ };
2857
+ popoverProps: ObjectConstructor;
2858
+ }>>>;
2859
+ };
2860
+ convert: {
2861
+ type: vue.PropType<TConvert>;
2862
+ };
2863
+ }>>, {
2864
+ splitStr: string;
2865
+ format: string;
2866
+ isUnix: boolean;
2867
+ }>;
2868
+ time: vue.DefineComponent<{
2869
+ value: {
2870
+ type: (NumberConstructor | StringConstructor)[];
2871
+ };
2872
+ showProps: {
2873
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2874
+ content: {
2875
+ type: (NumberConstructor | StringConstructor)[];
2876
+ };
2877
+ ellipsis: {
2878
+ type: (BooleanConstructor | vue.PropType<{
2879
+ rows?: number | undefined;
2880
+ num?: number | undefined;
2881
+ }>)[];
2882
+ };
2883
+ popoverProps: ObjectConstructor;
2884
+ }>>>;
2885
+ };
2886
+ convert: {
2887
+ type: vue.PropType<TConvert>;
2888
+ };
2889
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2890
+ value: {
2891
+ type: (NumberConstructor | StringConstructor)[];
2892
+ };
2893
+ showProps: {
2894
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2895
+ content: {
2896
+ type: (NumberConstructor | StringConstructor)[];
2897
+ };
2898
+ ellipsis: {
2899
+ type: (BooleanConstructor | vue.PropType<{
2900
+ rows?: number | undefined;
2901
+ num?: number | undefined;
2902
+ }>)[];
2903
+ };
2904
+ popoverProps: ObjectConstructor;
2905
+ }>>>;
2906
+ };
2907
+ convert: {
2908
+ type: vue.PropType<TConvert>;
2909
+ };
2910
+ }>>, {}>;
2911
+ select: vue.DefineComponent<{
2912
+ value: {
2913
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
2914
+ };
2915
+ options: vue.PropType<_vue_start_pro.TOptions>;
2916
+ splitStr: {
2917
+ type: StringConstructor;
2918
+ default: string;
2919
+ };
2920
+ colorMap: {
2921
+ type: ObjectConstructor;
2922
+ };
2923
+ showProps: {
2924
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2925
+ content: {
2926
+ type: (NumberConstructor | StringConstructor)[];
2927
+ };
2928
+ ellipsis: {
2929
+ type: (BooleanConstructor | vue.PropType<{
2930
+ rows?: number | undefined;
2931
+ num?: number | undefined;
2932
+ }>)[];
2933
+ };
2934
+ popoverProps: ObjectConstructor;
2935
+ }>>>;
2936
+ };
2937
+ convert: {
2938
+ type: vue.PropType<TConvert>;
2939
+ };
2940
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
2941
+ value: {
2942
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
2943
+ };
2944
+ options: vue.PropType<_vue_start_pro.TOptions>;
2945
+ splitStr: {
2946
+ type: StringConstructor;
2947
+ default: string;
2948
+ };
2949
+ colorMap: {
2950
+ type: ObjectConstructor;
2951
+ };
2952
+ showProps: {
2953
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2954
+ content: {
2955
+ type: (NumberConstructor | StringConstructor)[];
2956
+ };
2957
+ ellipsis: {
2958
+ type: (BooleanConstructor | vue.PropType<{
2959
+ rows?: number | undefined;
2960
+ num?: number | undefined;
2961
+ }>)[];
2962
+ };
2963
+ popoverProps: ObjectConstructor;
2964
+ }>>>;
2965
+ };
2966
+ convert: {
2967
+ type: vue.PropType<TConvert>;
2968
+ };
2969
+ }>>, {
2970
+ splitStr: string;
2971
+ }>;
2972
+ radio: vue.DefineComponent<{
2973
+ value: {
2974
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
2975
+ };
2976
+ options: vue.PropType<_vue_start_pro.TOptions>;
2977
+ splitStr: {
2978
+ type: StringConstructor;
2979
+ default: string;
2980
+ };
2981
+ colorMap: {
2982
+ type: ObjectConstructor;
2983
+ };
2984
+ showProps: {
2985
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
2986
+ content: {
2987
+ type: (NumberConstructor | StringConstructor)[];
2988
+ };
2989
+ ellipsis: {
2990
+ type: (BooleanConstructor | vue.PropType<{
2991
+ rows?: number | undefined;
2992
+ num?: number | undefined;
2993
+ }>)[];
2994
+ };
2995
+ popoverProps: ObjectConstructor;
2996
+ }>>>;
2997
+ };
2998
+ convert: {
2999
+ type: vue.PropType<TConvert>;
3000
+ };
3001
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
3002
+ value: {
3003
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3004
+ };
3005
+ options: vue.PropType<_vue_start_pro.TOptions>;
3006
+ splitStr: {
3007
+ type: StringConstructor;
3008
+ default: string;
3009
+ };
3010
+ colorMap: {
3011
+ type: ObjectConstructor;
3012
+ };
3013
+ showProps: {
3014
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3015
+ content: {
3016
+ type: (NumberConstructor | StringConstructor)[];
3017
+ };
3018
+ ellipsis: {
3019
+ type: (BooleanConstructor | vue.PropType<{
3020
+ rows?: number | undefined;
3021
+ num?: number | undefined;
3022
+ }>)[];
3023
+ };
3024
+ popoverProps: ObjectConstructor;
3025
+ }>>>;
3026
+ };
3027
+ convert: {
3028
+ type: vue.PropType<TConvert>;
3029
+ };
3030
+ }>>, {
3031
+ splitStr: string;
3032
+ }>;
3033
+ checkbox: vue.DefineComponent<{
3034
+ value: {
3035
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3036
+ };
3037
+ options: vue.PropType<_vue_start_pro.TOptions>;
3038
+ splitStr: {
3039
+ type: StringConstructor;
3040
+ default: string;
3041
+ };
3042
+ colorMap: {
3043
+ type: ObjectConstructor;
3044
+ };
3045
+ showProps: {
3046
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3047
+ content: {
3048
+ type: (NumberConstructor | StringConstructor)[];
3049
+ };
3050
+ ellipsis: {
3051
+ type: (BooleanConstructor | vue.PropType<{
3052
+ rows?: number | undefined;
3053
+ num?: number | undefined;
3054
+ }>)[];
3055
+ };
3056
+ popoverProps: ObjectConstructor;
3057
+ }>>>;
3058
+ };
3059
+ convert: {
3060
+ type: vue.PropType<TConvert>;
3061
+ };
3062
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
3063
+ value: {
3064
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3065
+ };
3066
+ options: vue.PropType<_vue_start_pro.TOptions>;
3067
+ splitStr: {
3068
+ type: StringConstructor;
3069
+ default: string;
3070
+ };
3071
+ colorMap: {
3072
+ type: ObjectConstructor;
3073
+ };
3074
+ showProps: {
3075
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3076
+ content: {
3077
+ type: (NumberConstructor | StringConstructor)[];
3078
+ };
3079
+ ellipsis: {
3080
+ type: (BooleanConstructor | vue.PropType<{
3081
+ rows?: number | undefined;
3082
+ num?: number | undefined;
3083
+ }>)[];
3084
+ };
3085
+ popoverProps: ObjectConstructor;
3086
+ }>>>;
3087
+ };
3088
+ convert: {
3089
+ type: vue.PropType<TConvert>;
3090
+ };
3091
+ }>>, {
3092
+ splitStr: string;
3093
+ }>;
3094
+ treeSelect: vue.DefineComponent<{
3095
+ value: {
3096
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3097
+ };
3098
+ splitStr: {
3099
+ type: StringConstructor;
3100
+ default: string;
3101
+ };
3102
+ treeData: vue.PropType<Record<string, any>>;
3103
+ data: vue.PropType<Record<string, any>>;
3104
+ options: vue.PropType<Record<string, any>>;
3105
+ fieldNames: ObjectConstructor;
3106
+ props: ObjectConstructor;
3107
+ showProps: {
3108
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3109
+ content: {
3110
+ type: (NumberConstructor | StringConstructor)[];
3111
+ };
3112
+ ellipsis: {
3113
+ type: (BooleanConstructor | vue.PropType<{
3114
+ rows?: number | undefined;
3115
+ num?: number | undefined;
3116
+ }>)[];
3117
+ };
3118
+ popoverProps: ObjectConstructor;
3119
+ }>>>;
3120
+ };
3121
+ convert: {
3122
+ type: vue.PropType<TConvert>;
3123
+ };
3124
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
3125
+ value: {
3126
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3127
+ };
3128
+ splitStr: {
3129
+ type: StringConstructor;
3130
+ default: string;
3131
+ };
3132
+ treeData: vue.PropType<Record<string, any>>;
3133
+ data: vue.PropType<Record<string, any>>;
3134
+ options: vue.PropType<Record<string, any>>;
3135
+ fieldNames: ObjectConstructor;
3136
+ props: ObjectConstructor;
3137
+ showProps: {
3138
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3139
+ content: {
3140
+ type: (NumberConstructor | StringConstructor)[];
3141
+ };
3142
+ ellipsis: {
3143
+ type: (BooleanConstructor | vue.PropType<{
3144
+ rows?: number | undefined;
3145
+ num?: number | undefined;
3146
+ }>)[];
3147
+ };
3148
+ popoverProps: ObjectConstructor;
3149
+ }>>>;
3150
+ };
3151
+ convert: {
3152
+ type: vue.PropType<TConvert>;
3153
+ };
3154
+ }>>, {
3155
+ splitStr: string;
3156
+ }>;
3157
+ cascader: vue.DefineComponent<{
3158
+ value: {
3159
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3160
+ };
3161
+ splitStr: {
3162
+ type: StringConstructor;
3163
+ default: string;
3164
+ };
3165
+ treeData: vue.PropType<Record<string, any>>;
3166
+ data: vue.PropType<Record<string, any>>;
3167
+ options: vue.PropType<Record<string, any>>;
3168
+ fieldNames: ObjectConstructor;
3169
+ props: ObjectConstructor;
3170
+ showProps: {
3171
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3172
+ content: {
3173
+ type: (NumberConstructor | StringConstructor)[];
3174
+ };
3175
+ ellipsis: {
3176
+ type: (BooleanConstructor | vue.PropType<{
3177
+ rows?: number | undefined;
3178
+ num?: number | undefined;
3179
+ }>)[];
3180
+ };
3181
+ popoverProps: ObjectConstructor;
3182
+ }>>>;
3183
+ };
3184
+ convert: {
3185
+ type: vue.PropType<TConvert>;
3186
+ };
3187
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
3188
+ value: {
3189
+ type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
3190
+ };
3191
+ splitStr: {
3192
+ type: StringConstructor;
3193
+ default: string;
3194
+ };
3195
+ treeData: vue.PropType<Record<string, any>>;
3196
+ data: vue.PropType<Record<string, any>>;
3197
+ options: vue.PropType<Record<string, any>>;
3198
+ fieldNames: ObjectConstructor;
3199
+ props: ObjectConstructor;
3200
+ showProps: {
3201
+ type: vue.PropType<Partial<vue.ExtractPropTypes<{
3202
+ content: {
3203
+ type: (NumberConstructor | StringConstructor)[];
3204
+ };
3205
+ ellipsis: {
3206
+ type: (BooleanConstructor | vue.PropType<{
3207
+ rows?: number | undefined;
3208
+ num?: number | undefined;
3209
+ }>)[];
3210
+ };
3211
+ popoverProps: ObjectConstructor;
3212
+ }>>>;
3213
+ };
3214
+ convert: {
3215
+ type: vue.PropType<TConvert>;
3216
+ };
3217
+ }>>, {
3218
+ splitStr: string;
3219
+ }>;
1102
3220
  };
1103
- declare type ProMenusProps = Partial<ExtractPropTypes<ReturnType<typeof menuProps>>> & Omit<MenuProps, "defaultActive">;
1104
- declare const ProMenus: vue.DefineComponent<ProMenusProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProMenusProps>, {}>;
1105
-
1106
- declare const uploadProps: () => {
1107
- modelValue: {
1108
- type: PropType<TFile[]>;
1109
- default: undefined;
1110
- };
1111
- maxSize: {
1112
- type: NumberConstructor;
1113
- };
1114
- convertResponseData: {
1115
- type: PropType<(res: any) => Record<string, any>>;
1116
- };
1117
- convertItemData: {
1118
- type: PropType<(item: any) => UploadFile>;
1119
- default: (item: any) => any;
1120
- };
1121
- onErrorMsg: PropType<(type: string, msg: string) => void>;
1122
- onStart: PropType<(file: any) => void>;
1123
- beforeUpload: {
1124
- type: FunctionConstructor;
1125
- };
3221
+ declare const formElementMap: {
3222
+ text: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3223
+ name: {
3224
+ type: vue.PropType<string | (string | number)[]>;
3225
+ };
3226
+ }>> & {
3227
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3228
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3229
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3230
+ } & {
3231
+ readonly error?: string | undefined;
3232
+ readonly label?: string | undefined;
3233
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3234
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3235
+ 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;
3236
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3237
+ 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;
3238
+ readonly for?: string | undefined;
3239
+ } & Partial<vue.ExtractPropTypes<{
3240
+ readonly: {
3241
+ type: BooleanConstructor;
3242
+ default: undefined;
3243
+ };
3244
+ fieldProps: {
3245
+ type: ObjectConstructor;
3246
+ };
3247
+ showProps: {
3248
+ type: ObjectConstructor;
3249
+ };
3250
+ slots: {
3251
+ type: ObjectConstructor;
3252
+ };
3253
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3254
+ name: {
3255
+ type: vue.PropType<string | (string | number)[]>;
3256
+ };
3257
+ }>> & {
3258
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3259
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3260
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3261
+ } & {
3262
+ readonly error?: string | undefined;
3263
+ readonly label?: string | undefined;
3264
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3265
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3266
+ 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;
3267
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3268
+ 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;
3269
+ readonly for?: string | undefined;
3270
+ } & Partial<vue.ExtractPropTypes<{
3271
+ readonly: {
3272
+ type: BooleanConstructor;
3273
+ default: undefined;
3274
+ };
3275
+ fieldProps: {
3276
+ type: ObjectConstructor;
3277
+ };
3278
+ showProps: {
3279
+ type: ObjectConstructor;
3280
+ };
3281
+ slots: {
3282
+ type: ObjectConstructor;
3283
+ };
3284
+ }>> & Record<string, any>>>, {
3285
+ [x: string]: any;
3286
+ }>;
3287
+ digit: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3288
+ name: {
3289
+ type: vue.PropType<string | (string | number)[]>;
3290
+ };
3291
+ }>> & {
3292
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3293
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3294
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3295
+ } & {
3296
+ readonly error?: string | undefined;
3297
+ readonly label?: string | undefined;
3298
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3299
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3300
+ 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;
3301
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3302
+ 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;
3303
+ readonly for?: string | undefined;
3304
+ } & Partial<vue.ExtractPropTypes<{
3305
+ readonly: {
3306
+ type: BooleanConstructor;
3307
+ default: undefined;
3308
+ };
3309
+ fieldProps: {
3310
+ type: ObjectConstructor;
3311
+ };
3312
+ showProps: {
3313
+ type: ObjectConstructor;
3314
+ };
3315
+ slots: {
3316
+ type: ObjectConstructor;
3317
+ };
3318
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3319
+ name: {
3320
+ type: vue.PropType<string | (string | number)[]>;
3321
+ };
3322
+ }>> & {
3323
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3324
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3325
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3326
+ } & {
3327
+ readonly error?: string | undefined;
3328
+ readonly label?: string | undefined;
3329
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3330
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3331
+ 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;
3332
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3333
+ 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;
3334
+ readonly for?: string | undefined;
3335
+ } & Partial<vue.ExtractPropTypes<{
3336
+ readonly: {
3337
+ type: BooleanConstructor;
3338
+ default: undefined;
3339
+ };
3340
+ fieldProps: {
3341
+ type: ObjectConstructor;
3342
+ };
3343
+ showProps: {
3344
+ type: ObjectConstructor;
3345
+ };
3346
+ slots: {
3347
+ type: ObjectConstructor;
3348
+ };
3349
+ }>> & Record<string, any>>>, {
3350
+ [x: string]: any;
3351
+ }>;
3352
+ date: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3353
+ name: {
3354
+ type: vue.PropType<string | (string | number)[]>;
3355
+ };
3356
+ }>> & {
3357
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3358
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3359
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3360
+ } & {
3361
+ readonly error?: string | undefined;
3362
+ readonly label?: string | undefined;
3363
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3364
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3365
+ 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;
3366
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3367
+ 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;
3368
+ readonly for?: string | undefined;
3369
+ } & Partial<vue.ExtractPropTypes<{
3370
+ readonly: {
3371
+ type: BooleanConstructor;
3372
+ default: undefined;
3373
+ };
3374
+ fieldProps: {
3375
+ type: ObjectConstructor;
3376
+ };
3377
+ showProps: {
3378
+ type: ObjectConstructor;
3379
+ };
3380
+ slots: {
3381
+ type: ObjectConstructor;
3382
+ };
3383
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3384
+ name: {
3385
+ type: vue.PropType<string | (string | number)[]>;
3386
+ };
3387
+ }>> & {
3388
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3389
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3390
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3391
+ } & {
3392
+ readonly error?: string | undefined;
3393
+ readonly label?: string | undefined;
3394
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3395
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3396
+ 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;
3397
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3398
+ 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;
3399
+ readonly for?: string | undefined;
3400
+ } & Partial<vue.ExtractPropTypes<{
3401
+ readonly: {
3402
+ type: BooleanConstructor;
3403
+ default: undefined;
3404
+ };
3405
+ fieldProps: {
3406
+ type: ObjectConstructor;
3407
+ };
3408
+ showProps: {
3409
+ type: ObjectConstructor;
3410
+ };
3411
+ slots: {
3412
+ type: ObjectConstructor;
3413
+ };
3414
+ }>> & Record<string, any>>>, {
3415
+ [x: string]: any;
3416
+ }>;
3417
+ time: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3418
+ name: {
3419
+ type: vue.PropType<string | (string | number)[]>;
3420
+ };
3421
+ }>> & {
3422
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3423
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3424
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3425
+ } & {
3426
+ readonly error?: string | undefined;
3427
+ readonly label?: string | undefined;
3428
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3429
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3430
+ 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;
3431
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3432
+ 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;
3433
+ readonly for?: string | undefined;
3434
+ } & Partial<vue.ExtractPropTypes<{
3435
+ readonly: {
3436
+ type: BooleanConstructor;
3437
+ default: undefined;
3438
+ };
3439
+ fieldProps: {
3440
+ type: ObjectConstructor;
3441
+ };
3442
+ showProps: {
3443
+ type: ObjectConstructor;
3444
+ };
3445
+ slots: {
3446
+ type: ObjectConstructor;
3447
+ };
3448
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3449
+ name: {
3450
+ type: vue.PropType<string | (string | number)[]>;
3451
+ };
3452
+ }>> & {
3453
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3454
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3455
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3456
+ } & {
3457
+ readonly error?: string | undefined;
3458
+ readonly label?: string | undefined;
3459
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3460
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3461
+ 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;
3462
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3463
+ 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;
3464
+ readonly for?: string | undefined;
3465
+ } & Partial<vue.ExtractPropTypes<{
3466
+ readonly: {
3467
+ type: BooleanConstructor;
3468
+ default: undefined;
3469
+ };
3470
+ fieldProps: {
3471
+ type: ObjectConstructor;
3472
+ };
3473
+ showProps: {
3474
+ type: ObjectConstructor;
3475
+ };
3476
+ slots: {
3477
+ type: ObjectConstructor;
3478
+ };
3479
+ }>> & Record<string, any>>>, {
3480
+ [x: string]: any;
3481
+ }>;
3482
+ select: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3483
+ name: {
3484
+ type: vue.PropType<string | (string | number)[]>;
3485
+ };
3486
+ }>> & {
3487
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3488
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3489
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3490
+ } & {
3491
+ readonly error?: string | undefined;
3492
+ readonly label?: string | undefined;
3493
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3494
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3495
+ 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;
3496
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3497
+ 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;
3498
+ readonly for?: string | undefined;
3499
+ } & Partial<vue.ExtractPropTypes<{
3500
+ readonly: {
3501
+ type: BooleanConstructor;
3502
+ default: undefined;
3503
+ };
3504
+ fieldProps: {
3505
+ type: ObjectConstructor;
3506
+ };
3507
+ showProps: {
3508
+ type: ObjectConstructor;
3509
+ };
3510
+ slots: {
3511
+ type: ObjectConstructor;
3512
+ };
3513
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3514
+ name: {
3515
+ type: vue.PropType<string | (string | number)[]>;
3516
+ };
3517
+ }>> & {
3518
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3519
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3520
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3521
+ } & {
3522
+ readonly error?: string | undefined;
3523
+ readonly label?: string | undefined;
3524
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3525
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3526
+ 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;
3527
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3528
+ 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;
3529
+ readonly for?: string | undefined;
3530
+ } & Partial<vue.ExtractPropTypes<{
3531
+ readonly: {
3532
+ type: BooleanConstructor;
3533
+ default: undefined;
3534
+ };
3535
+ fieldProps: {
3536
+ type: ObjectConstructor;
3537
+ };
3538
+ showProps: {
3539
+ type: ObjectConstructor;
3540
+ };
3541
+ slots: {
3542
+ type: ObjectConstructor;
3543
+ };
3544
+ }>> & Record<string, any>>>, {
3545
+ [x: string]: any;
3546
+ }>;
3547
+ treeSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3548
+ name: {
3549
+ type: vue.PropType<string | (string | number)[]>;
3550
+ };
3551
+ }>> & {
3552
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3553
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3554
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3555
+ } & {
3556
+ readonly error?: string | undefined;
3557
+ readonly label?: string | undefined;
3558
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3559
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3560
+ 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;
3561
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3562
+ 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;
3563
+ readonly for?: string | undefined;
3564
+ } & Partial<vue.ExtractPropTypes<{
3565
+ readonly: {
3566
+ type: BooleanConstructor;
3567
+ default: undefined;
3568
+ };
3569
+ fieldProps: {
3570
+ type: ObjectConstructor;
3571
+ };
3572
+ showProps: {
3573
+ type: ObjectConstructor;
3574
+ };
3575
+ slots: {
3576
+ type: ObjectConstructor;
3577
+ };
3578
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3579
+ name: {
3580
+ type: vue.PropType<string | (string | number)[]>;
3581
+ };
3582
+ }>> & {
3583
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3584
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3585
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3586
+ } & {
3587
+ readonly error?: string | undefined;
3588
+ readonly label?: string | undefined;
3589
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3590
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3591
+ 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;
3592
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3593
+ 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;
3594
+ readonly for?: string | undefined;
3595
+ } & Partial<vue.ExtractPropTypes<{
3596
+ readonly: {
3597
+ type: BooleanConstructor;
3598
+ default: undefined;
3599
+ };
3600
+ fieldProps: {
3601
+ type: ObjectConstructor;
3602
+ };
3603
+ showProps: {
3604
+ type: ObjectConstructor;
3605
+ };
3606
+ slots: {
3607
+ type: ObjectConstructor;
3608
+ };
3609
+ }>> & Record<string, any>>>, {
3610
+ [x: string]: any;
3611
+ }>;
3612
+ checkbox: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3613
+ name: {
3614
+ type: vue.PropType<string | (string | number)[]>;
3615
+ };
3616
+ }>> & {
3617
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3618
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3619
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3620
+ } & {
3621
+ readonly error?: string | undefined;
3622
+ readonly label?: string | undefined;
3623
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3624
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3625
+ 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;
3626
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3627
+ 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;
3628
+ readonly for?: string | undefined;
3629
+ } & Partial<vue.ExtractPropTypes<{
3630
+ readonly: {
3631
+ type: BooleanConstructor;
3632
+ default: undefined;
3633
+ };
3634
+ fieldProps: {
3635
+ type: ObjectConstructor;
3636
+ };
3637
+ showProps: {
3638
+ type: ObjectConstructor;
3639
+ };
3640
+ slots: {
3641
+ type: ObjectConstructor;
3642
+ };
3643
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3644
+ name: {
3645
+ type: vue.PropType<string | (string | number)[]>;
3646
+ };
3647
+ }>> & {
3648
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3649
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3650
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3651
+ } & {
3652
+ readonly error?: string | undefined;
3653
+ readonly label?: string | undefined;
3654
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3655
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3656
+ 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;
3657
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3658
+ 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;
3659
+ readonly for?: string | undefined;
3660
+ } & Partial<vue.ExtractPropTypes<{
3661
+ readonly: {
3662
+ type: BooleanConstructor;
3663
+ default: undefined;
3664
+ };
3665
+ fieldProps: {
3666
+ type: ObjectConstructor;
3667
+ };
3668
+ showProps: {
3669
+ type: ObjectConstructor;
3670
+ };
3671
+ slots: {
3672
+ type: ObjectConstructor;
3673
+ };
3674
+ }>> & Record<string, any>>>, {
3675
+ [x: string]: any;
3676
+ }>;
3677
+ radio: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3678
+ name: {
3679
+ type: vue.PropType<string | (string | number)[]>;
3680
+ };
3681
+ }>> & {
3682
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3683
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3684
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3685
+ } & {
3686
+ readonly error?: string | undefined;
3687
+ readonly label?: string | undefined;
3688
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3689
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3690
+ 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;
3691
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3692
+ 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;
3693
+ readonly for?: string | undefined;
3694
+ } & Partial<vue.ExtractPropTypes<{
3695
+ readonly: {
3696
+ type: BooleanConstructor;
3697
+ default: undefined;
3698
+ };
3699
+ fieldProps: {
3700
+ type: ObjectConstructor;
3701
+ };
3702
+ showProps: {
3703
+ type: ObjectConstructor;
3704
+ };
3705
+ slots: {
3706
+ type: ObjectConstructor;
3707
+ };
3708
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3709
+ name: {
3710
+ type: vue.PropType<string | (string | number)[]>;
3711
+ };
3712
+ }>> & {
3713
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3714
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3715
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3716
+ } & {
3717
+ readonly error?: string | undefined;
3718
+ readonly label?: string | undefined;
3719
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3720
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3721
+ 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;
3722
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3723
+ 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;
3724
+ readonly for?: string | undefined;
3725
+ } & Partial<vue.ExtractPropTypes<{
3726
+ readonly: {
3727
+ type: BooleanConstructor;
3728
+ default: undefined;
3729
+ };
3730
+ fieldProps: {
3731
+ type: ObjectConstructor;
3732
+ };
3733
+ showProps: {
3734
+ type: ObjectConstructor;
3735
+ };
3736
+ slots: {
3737
+ type: ObjectConstructor;
3738
+ };
3739
+ }>> & Record<string, any>>>, {
3740
+ [x: string]: any;
3741
+ }>;
3742
+ switch: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3743
+ name: {
3744
+ type: vue.PropType<string | (string | number)[]>;
3745
+ };
3746
+ }>> & {
3747
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3748
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3749
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3750
+ } & {
3751
+ readonly error?: string | undefined;
3752
+ readonly label?: string | undefined;
3753
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3754
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3755
+ 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;
3756
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3757
+ 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;
3758
+ readonly for?: string | undefined;
3759
+ } & Partial<vue.ExtractPropTypes<{
3760
+ readonly: {
3761
+ type: BooleanConstructor;
3762
+ default: undefined;
3763
+ };
3764
+ fieldProps: {
3765
+ type: ObjectConstructor;
3766
+ };
3767
+ showProps: {
3768
+ type: ObjectConstructor;
3769
+ };
3770
+ slots: {
3771
+ type: ObjectConstructor;
3772
+ };
3773
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3774
+ name: {
3775
+ type: vue.PropType<string | (string | number)[]>;
3776
+ };
3777
+ }>> & {
3778
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3779
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3780
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3781
+ } & {
3782
+ readonly error?: string | undefined;
3783
+ readonly label?: string | undefined;
3784
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3785
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3786
+ 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;
3787
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3788
+ 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;
3789
+ readonly for?: string | undefined;
3790
+ } & Partial<vue.ExtractPropTypes<{
3791
+ readonly: {
3792
+ type: BooleanConstructor;
3793
+ default: undefined;
3794
+ };
3795
+ fieldProps: {
3796
+ type: ObjectConstructor;
3797
+ };
3798
+ showProps: {
3799
+ type: ObjectConstructor;
3800
+ };
3801
+ slots: {
3802
+ type: ObjectConstructor;
3803
+ };
3804
+ }>> & Record<string, any>>>, {
3805
+ [x: string]: any;
3806
+ }>;
3807
+ cascader: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
3808
+ name: {
3809
+ type: vue.PropType<string | (string | number)[]>;
3810
+ };
3811
+ }>> & {
3812
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3813
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3814
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3815
+ } & {
3816
+ readonly error?: string | undefined;
3817
+ readonly label?: string | undefined;
3818
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3819
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3820
+ 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;
3821
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3822
+ 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;
3823
+ readonly for?: string | undefined;
3824
+ } & Partial<vue.ExtractPropTypes<{
3825
+ readonly: {
3826
+ type: BooleanConstructor;
3827
+ default: undefined;
3828
+ };
3829
+ fieldProps: {
3830
+ type: ObjectConstructor;
3831
+ };
3832
+ showProps: {
3833
+ type: ObjectConstructor;
3834
+ };
3835
+ slots: {
3836
+ type: ObjectConstructor;
3837
+ };
3838
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
3839
+ name: {
3840
+ type: vue.PropType<string | (string | number)[]>;
3841
+ };
3842
+ }>> & {
3843
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
3844
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
3845
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
3846
+ } & {
3847
+ readonly error?: string | undefined;
3848
+ readonly label?: string | undefined;
3849
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "validating" | "success", unknown> | undefined;
3850
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
3851
+ 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;
3852
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
3853
+ 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;
3854
+ readonly for?: string | undefined;
3855
+ } & Partial<vue.ExtractPropTypes<{
3856
+ readonly: {
3857
+ type: BooleanConstructor;
3858
+ default: undefined;
3859
+ };
3860
+ fieldProps: {
3861
+ type: ObjectConstructor;
3862
+ };
3863
+ showProps: {
3864
+ type: ObjectConstructor;
3865
+ };
3866
+ slots: {
3867
+ type: ObjectConstructor;
3868
+ };
3869
+ }>> & Record<string, any>>>, {
3870
+ [x: string]: any;
3871
+ }>;
1126
3872
  };
1127
- declare type ProUploadProps = Partial<ExtractPropTypes<ReturnType<typeof uploadProps>>> & Omit<UploadProps, "fileList">;
1128
- declare const UploadMethods: string[];
1129
- declare const ProUploader: vue.DefineComponent<ProUploadProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProUploadProps>, {}>;
1130
3873
 
1131
- export { FormMethods, ProCheckbox, ProCheckboxProps, ProForm, ProFormCascader, ProFormCheckbox, ProFormDatePicker, ProFormItem, ProFormItemProps, ProFormRadio, ProFormSelect, ProFormSwitch, ProFormText, ProFormTextNumber, ProFormTimePicker, ProFormTreeSelect, ProLoading, ProLoadingProps, ProMenus, ProMenusProps, ProModal, ProModalProps, ProPagination, ProPopover, ProRadio, ProRadioProps, ProSelect, ProSelectProps, ProTable, ProTableColumn, ProTableColumnProps, ProTabs, ProUploadProps, ProUploader, TableMethods, UploadMethods, createFormItemComponent, createLoadingId };
3874
+ export { FormMethods, ProCheckbox, ProCheckboxProps, ProForm, ProFormCascader, ProFormCheckbox, ProFormDatePicker, ProFormItem, ProFormItemProps, ProFormRadio, ProFormSelect, ProFormSwitch, ProFormText, ProFormTextNumber, ProFormTimePicker, ProFormTreeSelect, ProLoading, ProLoadingProps, ProMenus, ProMenusProps, ProModal, ProModalProps, ProPagination, ProPopover, ProRadio, ProRadioProps, ProSelect, ProSelectProps, ProTable, ProTableColumn, ProTableColumnProps, ProTableOperateItem, ProTabs, ProUploadProps, ProUploader, TableMethods, UploadMethods, createFormItemComponent, createLoadingId, elementMap, formElementMap };