@vue-start/element-pro 0.1.0 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/CHANGELOG.md +34 -0
  2. package/dist/index.d.ts +1341 -794
  3. package/dist/index.es.js +673 -1432
  4. package/dist/index.js +686 -1457
  5. package/package.json +3 -3
package/dist/index.d.ts CHANGED
@@ -1,13 +1,41 @@
1
1
  import * as vue from 'vue';
2
2
  import { VNode, ExtractPropTypes, PropType, Component } from 'vue';
3
- import { FormItemProps, ButtonProps as ButtonProps$1, FormInstance, ElSelect } from 'element-plus';
4
- import { DefineComponent } from '@vue/runtime-core';
5
- import { FilterMethods, Filters } from 'element-plus/es/components/table/src/table-column/defaults';
3
+ import * as element_plus from 'element-plus';
4
+ import { FormItemProps, ButtonProps as ButtonProps$1, ElSelect } from 'element-plus';
6
5
  import { FormItemRule } from 'element-plus/es/tokens/form';
7
- import { Ref, UnwrapNestedRefs } from '@vue/reactivity';
6
+ import * as _vue_start_pro from '@vue-start/pro';
7
+ import { TTableColumn as TTableColumn$1, ProFormProps as ProFormProps$1, ProSearchFormProps as ProSearchFormProps$1, ProFormListProps as ProFormListProps$1, ProTableProps as ProTableProps$1 } from '@vue-start/pro';
8
+ import { FilterMethods, Filters } from 'element-plus/es/components/table/src/table-column/defaults';
9
+ import { ColSizeObject } from 'element-plus/es/components/col/src/col';
10
+ import * as element_plus_es_utils from 'element-plus/es/utils';
8
11
  import * as element_plus_es_components_table_src_table_defaults from 'element-plus/es/components/table/src/table/defaults';
9
12
  import { TableProps } from 'element-plus/es/components/table/src/table/defaults';
10
- import { IRequestActor } from '@vue-start/request';
13
+
14
+ interface ModalProps {
15
+ appendToBody?: boolean;
16
+ beforeClose?: (done: () => void) => void;
17
+ destroyOnClose?: boolean;
18
+ closeOnClickModal?: boolean;
19
+ closeOnPressEscape?: boolean;
20
+ lockScroll?: boolean;
21
+ modal?: boolean;
22
+ openDelay?: number;
23
+ closeDelay?: number;
24
+ top?: string;
25
+ modelValue?: boolean;
26
+ modalClass?: string;
27
+ width?: string | number;
28
+ zIndex?: number;
29
+ trapFocus?: boolean;
30
+ center?: boolean;
31
+ customClass?: string;
32
+ draggable?: boolean;
33
+ fullscreen?: boolean;
34
+ showClose?: boolean;
35
+ title?: string;
36
+ }
37
+ declare const ProCurdModal: vue.DefineComponent<ModalProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ModalProps>, {}>;
38
+ declare const ProCurdModalConnect: vue.DefineComponent<{}, () => JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{}>>, {}>;
11
39
 
12
40
  declare type TOption = {
13
41
  label?: string;
@@ -15,33 +43,10 @@ declare type TOption = {
15
43
  disabled?: boolean;
16
44
  };
17
45
  declare type TOptions = TOption[];
18
- declare type TColumn = TableColumnCtx<any> & {
19
- valueType?: TValueType;
20
- formValueType?: TValueType;
21
- showProps?: Record<string, any>;
46
+ declare type TColumn$1 = TableColumnCtx<any> & Omit<TTableColumn$1, "formItemProps" | "title" | "dataIndex"> & {
22
47
  formItemProps?: ProFormItemProps;
23
- formFieldProps?: Record<string, any>;
24
- search?: boolean;
25
- hideInTable?: boolean;
26
- hideInForm?: boolean;
27
- hideInDetail?: boolean;
28
- searchSort?: boolean;
29
- tableSort?: boolean;
30
- formSort?: boolean;
31
- descSort?: boolean;
32
- extra?: {
33
- desc?: any;
34
- };
35
- };
36
- declare type TColumns = TColumn[];
37
- declare type BooleanObjType = {
38
- [key: string]: boolean;
39
48
  };
40
- declare type BooleanRulesObjType = {
41
- [key: string]: (record: any) => boolean;
42
- };
43
- declare type TDefaultValueType = "text" | "textarea" | "password" | "digit" | "date" | "dateRange" | "time" | "timeRange" | "select" | "treeSelect" | "checkbox" | "radio" | "slider" | "switch" | "rate" | "cascader";
44
- declare type TValueType = TDefaultValueType | string;
49
+ declare type TColumns = TColumn$1[];
45
50
  interface TableColumnCtx<T> {
46
51
  id?: string;
47
52
  realWidth?: number;
@@ -102,356 +107,260 @@ interface TableColumnCtx<T> {
102
107
  getColumnIndex?: () => number;
103
108
  no?: number;
104
109
  filterOpened?: boolean;
110
+ }
111
+ interface IRow {
112
+ gutter?: number;
113
+ justify?: "start" | "end" | "center" | "space-around" | "space-between" | "space-evenly";
114
+ align?: "top" | "bottom" | "middle";
115
+ tag?: string;
116
+ }
117
+ interface ICol {
118
+ span?: number;
119
+ offset?: number;
120
+ push?: number;
121
+ pull?: number;
122
+ xs?: ColSizeObject | number;
123
+ sm?: ColSizeObject | number;
124
+ md?: ColSizeObject | number;
125
+ lg?: ColSizeObject | number;
126
+ xl?: ColSizeObject | number;
127
+ tag?: string;
105
128
  }
106
129
 
107
- declare const proFormItemProps$1: () => {
108
- name: {
109
- type: PropType<string | (string | number)[]>;
130
+ declare type TDefaultValueType = "text" | "textarea" | "password" | "digit" | "date" | "dateRange" | "time" | "timeRange" | "select" | "treeSelect" | "checkbox" | "radio" | "slider" | "switch" | "rate" | "cascader";
131
+ declare type TValueType = TDefaultValueType | string;
132
+ declare type TColumn = {
133
+ title?: string | VNode;
134
+ dataIndex?: string | number;
135
+ valueType?: TValueType;
136
+ formValueType?: TValueType;
137
+ showProps?: Record<string, any>;
138
+ formItemProps?: {
139
+ name?: string;
140
+ label?: string;
141
+ };
142
+ formFieldProps?: Record<string, any>;
143
+ search?: boolean;
144
+ hideInTable?: boolean;
145
+ hideInForm?: boolean;
146
+ hideInDetail?: boolean;
147
+ searchSort?: boolean;
148
+ tableSort?: boolean;
149
+ formSort?: boolean;
150
+ descSort?: boolean;
151
+ extra?: {
152
+ desc?: any;
153
+ };
154
+ };
155
+ /**
156
+ * 组件Map
157
+ */
158
+ declare type TElementMap = Record<string, any>;
159
+
160
+ interface IProTableProvideExtra extends Record<string, any> {
161
+ }
162
+ declare type TTableColumn = {
163
+ customRender?: (opt: {
164
+ value: any;
165
+ text: any;
166
+ record: Record<string, any>;
167
+ index: number;
168
+ column: TTableColumn;
169
+ }) => VNode;
170
+ fixed?: boolean | string;
171
+ } & TColumn;
172
+ declare type TTableColumns = TTableColumn[];
173
+ /**
174
+ * 单个操作描述
175
+ */
176
+ interface IOperateItem {
177
+ value: string | number;
178
+ label?: string | VNode;
179
+ element?: (record: Record<string, any>, item: IOperateItem) => VNode;
180
+ show?: boolean | ((record: Record<string, any>) => boolean);
181
+ disabled?: boolean | ((record: Record<string, any>) => boolean);
182
+ onClick?: (record: Record<string, any>) => void;
183
+ sort?: number;
184
+ }
185
+ /**
186
+ * 整个操作栏描述
187
+ */
188
+ interface ITableOperate {
189
+ column?: TColumn;
190
+ items?: IOperateItem[];
191
+ itemState?: {
192
+ [key: string]: Omit<IOperateItem, "value">;
110
193
  };
194
+ }
195
+
196
+ interface PaginationProps {
197
+ total?: number;
198
+ pageSize?: number;
199
+ defaultPageSize?: number;
200
+ currentPage?: number;
201
+ defaultCurrentPage?: number;
202
+ pageCount?: number;
203
+ pagerCount?: number;
204
+ layout?: string;
205
+ pageSizes?: number[];
206
+ popperClass?: string;
207
+ prevText?: string;
208
+ nextText?: string;
209
+ small?: boolean;
210
+ background?: boolean;
211
+ disabled?: boolean;
212
+ hideOnSinglePage?: boolean;
213
+ onSizeChange?: (val: number) => void;
214
+ onCurrentChange?: (val: number) => void;
215
+ }
216
+ declare type TPageState = {
217
+ page: number;
218
+ pageSize: number;
111
219
  };
112
- declare type ProFormItemProps = Partial<ExtractPropTypes<ReturnType<typeof proFormItemProps$1>>> & FormItemProps;
113
- declare const ProFormItem: DefineComponent<ProFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormItemProps>, {}>;
114
- declare const proFormProps: () => {
220
+ declare const defaultPage: TPageState;
221
+ declare const proListProps: () => {
115
222
  /**
116
- * 子组件是否只读样式
223
+ * extra 是否放到SearchForm中
117
224
  */
118
- readonly: {
225
+ extraInSearch: {
119
226
  type: BooleanConstructor;
120
227
  default: undefined;
121
228
  };
122
- /**
123
- * FormComponent 根据此项来确定组件是否显示
124
- * rules 根据rules中方法生成showState对象
125
- */
126
- showState: {
127
- type: PropType<{
128
- [x: string]: boolean;
129
- }>;
130
- };
131
- showStateRules: {
132
- type: PropType<BooleanRulesObjType>;
229
+ searchProps: {
230
+ type: PropType<ProSearchFormProps>;
133
231
  };
134
- /**
135
- * 是否只读
136
- */
137
- readonlyState: {
138
- type: PropType<{
139
- [x: string]: boolean;
232
+ tableProps: {
233
+ type: PropType<Omit<Partial<ExtractPropTypes<{
234
+ operate: {
235
+ type: PropType<ITableOperate>;
236
+ };
237
+ columnEmptyText: {
238
+ type: StringConstructor;
239
+ };
240
+ column: {
241
+ type: PropType<TTableColumn>;
242
+ };
243
+ columns: {
244
+ type: PropType<TTableColumns>;
245
+ };
246
+ columnState: {
247
+ type: PropType<Record<string, any>>;
248
+ };
249
+ elementMap: {
250
+ type: PropType<TElementMap>;
251
+ };
252
+ loading: {
253
+ type: BooleanConstructor;
254
+ };
255
+ serialNumber: {
256
+ type: BooleanConstructor;
257
+ };
258
+ pagination: {
259
+ type: PropType<{
260
+ page?: number | undefined;
261
+ pageSize?: number | undefined;
262
+ }>;
263
+ };
264
+ provideExtra: {
265
+ type: PropType<IProTableProvideExtra>;
266
+ };
267
+ }>>, "columns"> & {
268
+ columns?: TColumns | undefined;
269
+ } & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
270
+ tableLayout?: "fixed" | "auto" | undefined;
271
+ flexible?: boolean | undefined;
272
+ data?: any;
273
+ } & {
274
+ slots?: Readonly<{
275
+ [name: string]: vue.Slot | undefined;
276
+ }> | undefined;
140
277
  }>;
141
278
  };
142
- readonlyStateRules: {
143
- type: PropType<BooleanRulesObjType>;
144
- };
145
- /**
146
- * 是否disabled
147
- */
148
- disableState: {
149
- type: PropType<{
150
- [x: string]: boolean;
151
- }>;
279
+ paginationProps: {
280
+ type: PropType<PaginationProps>;
152
281
  };
153
- disableStateRules: {
154
- type: PropType<BooleanRulesObjType>;
282
+ pageState: {
283
+ type: PropType<TPageState>;
155
284
  };
285
+ };
286
+ declare type ProListProps = Partial<ExtractPropTypes<ReturnType<typeof proListProps>>>;
287
+ declare const ProList: vue.DefineComponent<Partial<ExtractPropTypes<{
156
288
  /**
157
- * 展示控件集合，readonly模式下使用这些组件渲染
289
+ * extra 是否放到SearchForm中
158
290
  */
159
- elementMap: {
160
- type: PropType<{
161
- [key: string]: DefineComponent<{}, {}, {}, vue.ComputedOptions, vue.MethodOptions, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<{}>>, {}>;
162
- }>;
291
+ extraInSearch: {
292
+ type: BooleanConstructor;
293
+ default: undefined;
163
294
  };
164
- /**
165
- * provide传递
166
- */
167
- provideExtra: {
168
- type: PropType<{
169
- [key: string]: any;
295
+ searchProps: {
296
+ type: PropType<ProSearchFormProps>;
297
+ };
298
+ tableProps: {
299
+ type: PropType<Omit<Partial<ExtractPropTypes<{
300
+ operate: {
301
+ type: PropType<ITableOperate>;
302
+ };
303
+ columnEmptyText: {
304
+ type: StringConstructor;
305
+ };
306
+ column: {
307
+ type: PropType<TTableColumn>;
308
+ };
309
+ columns: {
310
+ type: PropType<TTableColumns>;
311
+ };
312
+ columnState: {
313
+ type: PropType<Record<string, any>>;
314
+ };
315
+ elementMap: {
316
+ type: PropType<TElementMap>;
317
+ };
318
+ loading: {
319
+ type: BooleanConstructor;
320
+ };
321
+ serialNumber: {
322
+ type: BooleanConstructor;
323
+ };
324
+ pagination: {
325
+ type: PropType<{
326
+ page?: number | undefined;
327
+ pageSize?: number | undefined;
328
+ }>;
329
+ };
330
+ provideExtra: {
331
+ type: PropType<IProTableProvideExtra>;
332
+ };
333
+ }>>, "columns"> & {
334
+ columns?: TColumns | undefined;
335
+ } & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
336
+ tableLayout?: "fixed" | "auto" | undefined;
337
+ flexible?: boolean | undefined;
338
+ data?: any;
339
+ } & {
340
+ slots?: Readonly<{
341
+ [name: string]: vue.Slot | undefined;
342
+ }> | undefined;
170
343
  }>;
171
344
  };
172
- };
173
- interface FormProps {
174
- model?: Record<string, any>;
175
- rules?: FormItemRule[];
176
- labelPosition?: "left" | "right" | "top";
177
- labelWidth?: string | number;
178
- labelSuffix?: string;
179
- inline?: boolean;
180
- inlineMessage?: boolean;
181
- statusIcon?: boolean;
182
- showMessage?: boolean;
183
- size?: "large" | "default" | "small";
184
- disabled?: boolean;
185
- validateOnRuleChange?: boolean;
186
- hideRequiredAsterisk?: boolean;
187
- scrollToError?: boolean;
188
- }
189
- declare type ProFormProps = Partial<ExtractPropTypes<ReturnType<typeof proFormProps>>> & FormProps & {
190
- onFinish?: (showValues: Record<string, any>, values: Record<string, any>) => void;
191
- onFinishFailed?: (invalidFields: Record<string, any>) => void;
192
- };
193
- declare const ProForm: DefineComponent<ProFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormProps>, {}>;
194
-
195
- declare const proSchemaFormProps: () => {
196
- columns: {
197
- type: PropType<TColumns>;
345
+ paginationProps: {
346
+ type: PropType<PaginationProps>;
198
347
  };
199
- /**
200
- * 录入控件集合，通过column->valueType 查找对应的录入组件
201
- */
202
- formElementMap: {
203
- type: PropType<{
204
- [key: string]: any;
205
- }>;
348
+ pageState: {
349
+ type: PropType<TPageState>;
206
350
  };
351
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
207
352
  /**
208
- * 是否启用rules验证
353
+ * extra 是否放到SearchForm中
209
354
  */
210
- needRules: {
355
+ extraInSearch: {
211
356
  type: BooleanConstructor;
212
- default: boolean;
213
- };
214
- };
215
- declare type ProSchemaFormProps = Partial<ExtractPropTypes<ReturnType<typeof proSchemaFormProps>>> & ProFormProps;
216
- declare const ProSchemaForm: vue.DefineComponent<any, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<any>, {} | {
217
- [x: string]: any;
218
- }>;
219
-
220
- declare enum SearchMode {
221
- AUTO = "AUTO",
222
- MANUAL = "MANUAL"
223
- }
224
- declare type ISearchMode = keyof typeof SearchMode;
225
- declare const proSearchFormProps: () => {
226
- /**
227
- * 初始化触发 onFinish
228
- */
229
- initEmit: {
230
- type: BooleanConstructor;
231
- default: boolean;
232
- };
233
- /**
234
- * 模式 自动触发或者手动触发 onFinish
235
- */
236
- searchMode: {
237
- type: PropType<"AUTO" | "MANUAL">;
238
- default: SearchMode;
239
- };
240
- /**
241
- * 需要debounce处理的字段
242
- */
243
- debounceKeys: {
244
- type: PropType<string[]>;
245
- };
246
- debounceTime: {
247
- type: NumberConstructor;
248
- default: number;
249
- };
250
- inline: {
251
- type: BooleanConstructor;
252
- default: boolean;
253
- };
254
- };
255
- declare type ProSearchFormProps = Partial<ExtractPropTypes<ReturnType<typeof proSearchFormProps>>> & Omit<ProSchemaFormProps, "inline">;
256
- declare const ProSearchForm: vue.DefineComponent<ProSearchFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProSearchFormProps>, {}>;
257
-
258
- declare const proFormItemProps: () => {
259
- readonly: {
260
- type: BooleanConstructor;
261
- default: undefined;
262
- };
263
- fieldProps: {
264
- type: ObjectConstructor;
265
- };
266
- showProps: {
267
- type: ObjectConstructor;
268
- };
269
- };
270
- declare type ProCreateFormItemProps = Partial<ExtractPropTypes<ReturnType<typeof proFormItemProps>>> & ProFormItemProps & Record<string, any>;
271
- declare const createFormItemComponent: ({ InputComp, valueType, name, }: {
272
- InputComp: any;
273
- valueType: TValueType;
274
- name: string;
275
- }) => vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<ProCreateFormItemProps>>, {
276
- [x: string]: any;
277
- }>;
278
-
279
- declare const ProFormText: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
280
- [x: string]: any;
281
- }>;
282
- declare const ProFormTextNumber: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
283
- [x: string]: any;
284
- }>;
285
- declare const ProFormDatePicker: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
286
- [x: string]: any;
287
- }>;
288
- declare const ProFormTimePicker: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
289
- [x: string]: any;
290
- }>;
291
- declare const ProFormSelect: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
292
- [x: string]: any;
293
- }>;
294
- declare const ProFormTreeSelect: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
295
- [x: string]: any;
296
- }>;
297
- declare const ProFormCheckbox: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
298
- [x: string]: any;
299
- }>;
300
- declare const ProFormRadio: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
301
- [x: string]: any;
302
- }>;
303
- declare const ProFormSwitch: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
304
- [x: string]: any;
305
- }>;
306
- declare const ProFormCascader: vue.DefineComponent<ProCreateFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<ProCreateFormItemProps>>, {
307
- [x: string]: any;
308
- }>;
309
- interface ButtonProps {
310
- size?: "default" | "small" | "large";
311
- disabled?: boolean;
312
- type?: "default" | "primary" | "success" | "warning" | "info" | "danger" | "text";
313
- icon?: string | Component;
314
- nativeType?: "button" | "submit" | "reset";
315
- loading?: boolean;
316
- loadingIcon?: string | Component;
317
- plain?: boolean;
318
- text?: boolean;
319
- link?: boolean;
320
- bg?: boolean;
321
- autofocus?: boolean;
322
- round?: boolean;
323
- circle?: boolean;
324
- color?: string;
325
- dark?: boolean;
326
- autoInsertSpace?: boolean;
327
- }
328
- declare const ProSubmitButton: vue.DefineComponent<ButtonProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ButtonProps>, {}>;
329
-
330
- declare const proFormListProps: () => {
331
- addButtonText: {
332
- type: StringConstructor;
333
- default: string;
334
- };
335
- addButtonProps: {
336
- type: PropType<ButtonProps$1>;
337
- };
338
- rowKey: {
339
- type: StringConstructor;
340
- default: string;
341
- };
342
- };
343
- declare type ProFormListProps = Partial<ExtractPropTypes<ReturnType<typeof proFormListProps>>> & ProFormItemProps;
344
- declare const ProFormList: vue.DefineComponent<ProFormListProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormListProps>, {}>;
345
-
346
- interface IProFormProvide extends Record<string, any> {
347
- formRef: Ref<FormInstance & {
348
- submit: () => void;
349
- }>;
350
- formState: UnwrapNestedRefs<Record<string, any>>;
351
- showState: UnwrapNestedRefs<Record<string, any>>;
352
- readonlyState: UnwrapNestedRefs<Record<string, any>>;
353
- disableState: UnwrapNestedRefs<Record<string, any>>;
354
- readonly: Ref<boolean | undefined>;
355
- elementMap?: {
356
- [key: string]: DefineComponent;
357
- };
358
- }
359
- declare const useProForm: () => IProFormProvide;
360
- declare const provideProForm: (ctx: IProFormProvide) => void;
361
- interface IProFormListProvide {
362
- pathList: (string | number)[];
363
- }
364
- declare const useProFormList: () => IProFormListProvide;
365
- declare const provideProFormList: (ctx: IProFormListProvide) => void;
366
-
367
- interface IOperateItem {
368
- value: string | number;
369
- label?: string | VNode;
370
- element?: (record: Record<string, any>, item: IOperateItem) => VNode;
371
- show?: boolean | ((record: Record<string, any>) => boolean);
372
- disabled?: boolean | ((record: Record<string, any>) => boolean);
373
- onClick?: (record: Record<string, any>) => void;
374
- sort?: number;
375
- }
376
- interface ITableOperate {
377
- column?: TableColumnCtx<any>;
378
- items?: IOperateItem[];
379
- itemState?: {
380
- [key: string]: Omit<IOperateItem, "value">;
381
- };
382
- }
383
- declare const proTableProps: () => {
384
- operate: {
385
- type: PropType<ITableOperate>;
386
- };
387
- columnEmptyText: {
388
- type: StringConstructor;
389
- };
390
- /**
391
- * 公共column，会merge到columns item中
392
- */
393
- column: {
394
- type: PropType<TableColumnCtx<any>>;
395
- };
396
- columns: {
397
- type: PropType<TColumns>;
398
- };
399
- /**
400
- * 展示控件集合，readonly模式下使用这些组件渲染
401
- */
402
- elementMap: {
403
- type: PropType<{
404
- [key: string]: any;
405
- }>;
406
- };
407
- };
408
- declare type ProTableProps = Partial<ExtractPropTypes<ReturnType<typeof proTableProps>>> & Omit<TableProps<any>, "tableLayout" | "flexible" | "data"> & {
409
- tableLayout?: "fixed" | "auto";
410
- flexible?: boolean;
411
- data?: any;
412
- };
413
- declare const ProTable: vue.DefineComponent<ProTableProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProTableProps>, {
414
- data: any;
415
- }>;
416
-
417
- interface PaginationProps {
418
- total?: number;
419
- pageSize?: number;
420
- defaultPageSize?: number;
421
- currentPage?: number;
422
- defaultCurrentPage?: number;
423
- pageCount?: number;
424
- pagerCount?: number;
425
- layout?: string;
426
- pageSizes?: number[];
427
- popperClass?: string;
428
- prevText?: string;
429
- nextText?: string;
430
- small?: boolean;
431
- background?: boolean;
432
- disabled?: boolean;
433
- hideOnSinglePage?: boolean;
434
- onSizeChange?: (val: number) => void;
435
- onCurrentChange?: (val: number) => void;
436
- }
437
- declare type TPageState = {
438
- page: number;
439
- pageSize: number;
440
- };
441
- declare const defaultPage: TPageState;
442
- declare const curdListProps: () => {
443
- /**
444
- * extra 是否放到SearchForm中
445
- */
446
- extraInSearch: {
447
- type: BooleanConstructor;
448
- default: undefined;
357
+ default: undefined;
449
358
  };
450
359
  searchProps: {
451
360
  type: PropType<ProSearchFormProps>;
452
361
  };
453
362
  tableProps: {
454
- type: PropType<Partial<ExtractPropTypes<{
363
+ type: PropType<Omit<Partial<ExtractPropTypes<{
455
364
  operate: {
456
365
  type: PropType<ITableOperate>;
457
366
  };
@@ -459,17 +368,35 @@ declare const curdListProps: () => {
459
368
  type: StringConstructor;
460
369
  };
461
370
  column: {
462
- type: PropType<TableColumnCtx<any>>;
371
+ type: PropType<TTableColumn>;
463
372
  };
464
373
  columns: {
465
- type: PropType<TColumns>;
374
+ type: PropType<TTableColumns>;
375
+ };
376
+ columnState: {
377
+ type: PropType<Record<string, any>>;
466
378
  };
467
379
  elementMap: {
380
+ type: PropType<TElementMap>;
381
+ };
382
+ loading: {
383
+ type: BooleanConstructor;
384
+ };
385
+ serialNumber: {
386
+ type: BooleanConstructor;
387
+ };
388
+ pagination: {
468
389
  type: PropType<{
469
- [key: string]: any;
390
+ page?: number | undefined;
391
+ pageSize?: number | undefined;
470
392
  }>;
471
393
  };
472
- }>> & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
394
+ provideExtra: {
395
+ type: PropType<IProTableProvideExtra>;
396
+ };
397
+ }>>, "columns"> & {
398
+ columns?: TColumns | undefined;
399
+ } & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
473
400
  tableLayout?: "fixed" | "auto" | undefined;
474
401
  flexible?: boolean | undefined;
475
402
  data?: any;
@@ -485,239 +412,977 @@ declare const curdListProps: () => {
485
412
  pageState: {
486
413
  type: PropType<TPageState>;
487
414
  };
488
- };
489
- declare type ProCurdListProps = Partial<ExtractPropTypes<ReturnType<typeof curdListProps>>>;
490
- /**
491
- * 组合列表
492
- * SearchForm + Table + Pagination
493
- */
494
- declare const ProCurdList: vue.DefineComponent<Partial<ExtractPropTypes<{
415
+ }>>>, {}>;
416
+
417
+ declare const proGridProps: () => {
495
418
  /**
496
- * extra 是否放到SearchForm中
419
+ * row属性
497
420
  */
498
- extraInSearch: {
499
- type: BooleanConstructor;
421
+ row: {
422
+ type: PropType<IRow>;
500
423
  default: undefined;
501
424
  };
502
- searchProps: {
503
- type: PropType<ProSearchFormProps>;
425
+ /**
426
+ * 公共col属性
427
+ */
428
+ col: {
429
+ type: PropType<ICol>;
504
430
  };
505
- tableProps: {
506
- type: PropType<Partial<ExtractPropTypes<{
507
- operate: {
508
- type: PropType<ITableOperate>;
509
- };
510
- columnEmptyText: {
511
- type: StringConstructor;
512
- };
513
- column: {
514
- type: PropType<TableColumnCtx<any>>;
515
- };
516
- columns: {
517
- type: PropType<TColumns>;
518
- };
519
- elementMap: {
520
- type: PropType<{
521
- [key: string]: any;
522
- }>;
523
- };
524
- }>> & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
525
- tableLayout?: "fixed" | "auto" | undefined;
526
- flexible?: boolean | undefined;
527
- data?: any;
528
- } & {
529
- slots?: Readonly<{
530
- [name: string]: vue.Slot | undefined;
531
- }> | undefined;
532
- }>;
431
+ /**
432
+ *
433
+ */
434
+ items: {
435
+ type: PropType<{
436
+ vNode: VNode;
437
+ rowKey?: string | number | undefined;
438
+ col?: ICol | undefined;
439
+ }[]>;
533
440
  };
534
- paginationProps: {
535
- type: PropType<PaginationProps>;
441
+ };
442
+ declare type ProGridProps = Partial<ExtractPropTypes<ReturnType<typeof proGridProps>>>;
443
+ declare const ProGrid: vue.DefineComponent<Partial<ExtractPropTypes<{
444
+ /**
445
+ * row属性
446
+ */
447
+ row: {
448
+ type: PropType<IRow>;
449
+ default: undefined;
536
450
  };
537
- pageState: {
538
- type: PropType<TPageState>;
451
+ /**
452
+ * 公共col属性
453
+ */
454
+ col: {
455
+ type: PropType<ICol>;
456
+ };
457
+ /**
458
+ *
459
+ */
460
+ items: {
461
+ type: PropType<{
462
+ vNode: VNode;
463
+ rowKey?: string | number | undefined;
464
+ col?: ICol | undefined;
465
+ }[]>;
539
466
  };
540
467
  }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
541
468
  /**
542
- * extra 是否放到SearchForm中
469
+ * row属性
543
470
  */
544
- extraInSearch: {
545
- type: BooleanConstructor;
471
+ row: {
472
+ type: PropType<IRow>;
546
473
  default: undefined;
547
474
  };
548
- searchProps: {
549
- type: PropType<ProSearchFormProps>;
475
+ /**
476
+ * 公共col属性
477
+ */
478
+ col: {
479
+ type: PropType<ICol>;
550
480
  };
551
- tableProps: {
552
- type: PropType<Partial<ExtractPropTypes<{
553
- operate: {
554
- type: PropType<ITableOperate>;
555
- };
556
- columnEmptyText: {
557
- type: StringConstructor;
558
- };
559
- column: {
560
- type: PropType<TableColumnCtx<any>>;
561
- };
562
- columns: {
563
- type: PropType<TColumns>;
564
- };
565
- elementMap: {
566
- type: PropType<{
567
- [key: string]: any;
568
- }>;
569
- };
570
- }>> & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
571
- tableLayout?: "fixed" | "auto" | undefined;
572
- flexible?: boolean | undefined;
573
- data?: any;
574
- } & {
575
- slots?: Readonly<{
576
- [name: string]: vue.Slot | undefined;
577
- }> | undefined;
578
- }>;
481
+ /**
482
+ *
483
+ */
484
+ items: {
485
+ type: PropType<{
486
+ vNode: VNode;
487
+ rowKey?: string | number | undefined;
488
+ col?: ICol | undefined;
489
+ }[]>;
579
490
  };
580
- paginationProps: {
581
- type: PropType<PaginationProps>;
491
+ }>>>, {}>;
492
+
493
+ declare const createLoadingId: (prefix?: string) => string;
494
+ declare const proLoadingProps: () => {
495
+ loading: {
496
+ type: BooleanConstructor;
582
497
  };
583
- pageState: {
584
- type: PropType<TPageState>;
498
+ target: {
499
+ type: PropType<string | HTMLElement>;
585
500
  };
586
- }>>>, {}>;
587
- declare const ProCurdListConnect: vue.DefineComponent<{}, () => JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<{}>>, {}>;
501
+ body: {
502
+ type: BooleanConstructor;
503
+ };
504
+ fullscreen: {
505
+ type: BooleanConstructor;
506
+ };
507
+ lock: {
508
+ type: BooleanConstructor;
509
+ };
510
+ text: {
511
+ type: StringConstructor;
512
+ };
513
+ spinner: {
514
+ type: StringConstructor;
515
+ };
516
+ background: {
517
+ type: StringConstructor;
518
+ };
519
+ customClass: {
520
+ type: StringConstructor;
521
+ };
522
+ };
523
+ declare type ProLoadingProps = Partial<ExtractPropTypes<ReturnType<typeof proLoadingProps>>>;
524
+ declare const ProLoading: vue.DefineComponent<Partial<ExtractPropTypes<{
525
+ loading: {
526
+ type: BooleanConstructor;
527
+ };
528
+ target: {
529
+ type: PropType<string | HTMLElement>;
530
+ };
531
+ body: {
532
+ type: BooleanConstructor;
533
+ };
534
+ fullscreen: {
535
+ type: BooleanConstructor;
536
+ };
537
+ lock: {
538
+ type: BooleanConstructor;
539
+ };
540
+ text: {
541
+ type: StringConstructor;
542
+ };
543
+ spinner: {
544
+ type: StringConstructor;
545
+ };
546
+ background: {
547
+ type: StringConstructor;
548
+ };
549
+ customClass: {
550
+ type: StringConstructor;
551
+ };
552
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
553
+ loading: {
554
+ type: BooleanConstructor;
555
+ };
556
+ target: {
557
+ type: PropType<string | HTMLElement>;
558
+ };
559
+ body: {
560
+ type: BooleanConstructor;
561
+ };
562
+ fullscreen: {
563
+ type: BooleanConstructor;
564
+ };
565
+ lock: {
566
+ type: BooleanConstructor;
567
+ };
568
+ text: {
569
+ type: StringConstructor;
570
+ };
571
+ spinner: {
572
+ type: StringConstructor;
573
+ };
574
+ background: {
575
+ type: StringConstructor;
576
+ };
577
+ customClass: {
578
+ type: StringConstructor;
579
+ };
580
+ }>>>, {}>;
588
581
 
589
- interface IProModuleProvide {
590
- columns: Ref<TColumns>;
591
- getFormItemVNode: (column: TColumn, needRules: boolean | undefined) => VNode | null;
592
- getItemVNode: (column: TColumn, value: any) => VNode | null;
593
- elementMap: {
594
- [key: string]: any;
582
+ declare const proFormItemProps: () => {
583
+ name: {
584
+ type: PropType<string | (string | number)[]>;
585
+ };
586
+ };
587
+ declare type ProFormItemProps = Partial<ExtractPropTypes<ReturnType<typeof proFormItemProps>>> & FormItemProps;
588
+ declare const ProFormItem: vue.DefineComponent<ProFormItemProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormItemProps>, {}>;
589
+ interface FormProps {
590
+ model?: Record<string, any>;
591
+ rules?: FormItemRule[];
592
+ labelPosition?: "left" | "right" | "top";
593
+ labelWidth?: string | number;
594
+ labelSuffix?: string;
595
+ inline?: boolean;
596
+ inlineMessage?: boolean;
597
+ statusIcon?: boolean;
598
+ showMessage?: boolean;
599
+ size?: "large" | "default" | "small";
600
+ disabled?: boolean;
601
+ validateOnRuleChange?: boolean;
602
+ hideRequiredAsterisk?: boolean;
603
+ scrollToError?: boolean;
604
+ }
605
+ declare type ProFormProps = ProFormProps$1 & FormProps & Omit<ProGridProps, "items"> & {
606
+ onFinish?: (showValues: Record<string, any>, values: Record<string, any>) => void;
607
+ onFinishFailed?: (invalidFields: Record<string, any>) => void;
608
+ };
609
+ declare const ProForm: vue.DefineComponent<ProFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormProps>, {}>;
610
+
611
+ declare type ProSearchFormProps = ProSearchFormProps$1 & Omit<ProFormProps, "inline"> & {
612
+ inline?: boolean;
613
+ };
614
+ declare const ProSearchForm: vue.DefineComponent<ProSearchFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProSearchFormProps>, {}>;
615
+
616
+ declare const ProFormText: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
617
+ name: {
618
+ type: vue.PropType<string | (string | number)[]>;
619
+ };
620
+ }>> & {
621
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
622
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
623
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
624
+ } & {
625
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
626
+ readonly error?: string | undefined;
627
+ readonly label?: string | undefined;
628
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
629
+ readonly for?: string | undefined;
630
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
631
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
632
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
633
+ } & Partial<vue.ExtractPropTypes<{
634
+ readonly: {
635
+ type: BooleanConstructor;
636
+ default: undefined;
637
+ };
638
+ fieldProps: {
639
+ type: ObjectConstructor;
640
+ };
641
+ showProps: {
642
+ type: ObjectConstructor;
643
+ };
644
+ slots: {
645
+ type: ObjectConstructor;
646
+ };
647
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
648
+ name: {
649
+ type: vue.PropType<string | (string | number)[]>;
650
+ };
651
+ }>> & {
652
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
653
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
654
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
655
+ } & {
656
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
657
+ readonly error?: string | undefined;
658
+ readonly label?: string | undefined;
659
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
660
+ readonly for?: string | undefined;
661
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
662
+ 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;
663
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
664
+ } & Partial<vue.ExtractPropTypes<{
665
+ readonly: {
666
+ type: BooleanConstructor;
667
+ default: undefined;
668
+ };
669
+ fieldProps: {
670
+ type: ObjectConstructor;
671
+ };
672
+ showProps: {
673
+ type: ObjectConstructor;
674
+ };
675
+ slots: {
676
+ type: ObjectConstructor;
677
+ };
678
+ }>> & Record<string, any>>>, {
679
+ [x: string]: any;
680
+ }>;
681
+ declare const ProFormTextNumber: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
682
+ name: {
683
+ type: vue.PropType<string | (string | number)[]>;
684
+ };
685
+ }>> & {
686
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
687
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
688
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
689
+ } & {
690
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
691
+ readonly error?: string | undefined;
692
+ readonly label?: string | undefined;
693
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
694
+ readonly for?: string | undefined;
695
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
696
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
697
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
698
+ } & Partial<vue.ExtractPropTypes<{
699
+ readonly: {
700
+ type: BooleanConstructor;
701
+ default: undefined;
702
+ };
703
+ fieldProps: {
704
+ type: ObjectConstructor;
705
+ };
706
+ showProps: {
707
+ type: ObjectConstructor;
708
+ };
709
+ slots: {
710
+ type: ObjectConstructor;
711
+ };
712
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
713
+ name: {
714
+ type: vue.PropType<string | (string | number)[]>;
715
+ };
716
+ }>> & {
717
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
718
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
719
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
720
+ } & {
721
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
722
+ readonly error?: string | undefined;
723
+ readonly label?: string | undefined;
724
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
725
+ readonly for?: string | undefined;
726
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
727
+ 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;
728
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
729
+ } & Partial<vue.ExtractPropTypes<{
730
+ readonly: {
731
+ type: BooleanConstructor;
732
+ default: undefined;
733
+ };
734
+ fieldProps: {
735
+ type: ObjectConstructor;
736
+ };
737
+ showProps: {
738
+ type: ObjectConstructor;
739
+ };
740
+ slots: {
741
+ type: ObjectConstructor;
742
+ };
743
+ }>> & Record<string, any>>>, {
744
+ [x: string]: any;
745
+ }>;
746
+ declare const ProFormDatePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
747
+ name: {
748
+ type: vue.PropType<string | (string | number)[]>;
749
+ };
750
+ }>> & {
751
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
752
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
753
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
754
+ } & {
755
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
756
+ readonly error?: string | undefined;
757
+ readonly label?: string | undefined;
758
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
759
+ readonly for?: string | undefined;
760
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
761
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
762
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
763
+ } & Partial<vue.ExtractPropTypes<{
764
+ readonly: {
765
+ type: BooleanConstructor;
766
+ default: undefined;
767
+ };
768
+ fieldProps: {
769
+ type: ObjectConstructor;
770
+ };
771
+ showProps: {
772
+ type: ObjectConstructor;
773
+ };
774
+ slots: {
775
+ type: ObjectConstructor;
776
+ };
777
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
778
+ name: {
779
+ type: vue.PropType<string | (string | number)[]>;
780
+ };
781
+ }>> & {
782
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
783
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
784
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
785
+ } & {
786
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
787
+ readonly error?: string | undefined;
788
+ readonly label?: string | undefined;
789
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
790
+ readonly for?: string | undefined;
791
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
792
+ 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;
793
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
794
+ } & Partial<vue.ExtractPropTypes<{
795
+ readonly: {
796
+ type: BooleanConstructor;
797
+ default: undefined;
798
+ };
799
+ fieldProps: {
800
+ type: ObjectConstructor;
801
+ };
802
+ showProps: {
803
+ type: ObjectConstructor;
804
+ };
805
+ slots: {
806
+ type: ObjectConstructor;
807
+ };
808
+ }>> & Record<string, any>>>, {
809
+ [x: string]: any;
810
+ }>;
811
+ declare const ProFormTimePicker: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
812
+ name: {
813
+ type: vue.PropType<string | (string | number)[]>;
814
+ };
815
+ }>> & {
816
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
817
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
818
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
819
+ } & {
820
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
821
+ readonly error?: string | undefined;
822
+ readonly label?: string | undefined;
823
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
824
+ readonly for?: string | undefined;
825
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
826
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
827
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
828
+ } & Partial<vue.ExtractPropTypes<{
829
+ readonly: {
830
+ type: BooleanConstructor;
831
+ default: undefined;
832
+ };
833
+ fieldProps: {
834
+ type: ObjectConstructor;
835
+ };
836
+ showProps: {
837
+ type: ObjectConstructor;
838
+ };
839
+ slots: {
840
+ type: ObjectConstructor;
841
+ };
842
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
843
+ name: {
844
+ type: vue.PropType<string | (string | number)[]>;
845
+ };
846
+ }>> & {
847
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
848
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
849
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
850
+ } & {
851
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
852
+ readonly error?: string | undefined;
853
+ readonly label?: string | undefined;
854
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
855
+ readonly for?: string | undefined;
856
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
857
+ 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;
858
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
859
+ } & Partial<vue.ExtractPropTypes<{
860
+ readonly: {
861
+ type: BooleanConstructor;
862
+ default: undefined;
863
+ };
864
+ fieldProps: {
865
+ type: ObjectConstructor;
866
+ };
867
+ showProps: {
868
+ type: ObjectConstructor;
869
+ };
870
+ slots: {
871
+ type: ObjectConstructor;
872
+ };
873
+ }>> & Record<string, any>>>, {
874
+ [x: string]: any;
875
+ }>;
876
+ declare const ProFormSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
877
+ name: {
878
+ type: vue.PropType<string | (string | number)[]>;
879
+ };
880
+ }>> & {
881
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
882
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
883
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
884
+ } & {
885
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
886
+ readonly error?: string | undefined;
887
+ readonly label?: string | undefined;
888
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
889
+ readonly for?: string | undefined;
890
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
891
+ readonly rules?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>) | ((new (...args: any[]) => element_plus.FormItemRule | element_plus.FormItemRule[]) | (() => element_plus_es_utils.Arrayable<element_plus.FormItemRule>))[], unknown, unknown> | undefined;
892
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
893
+ } & Partial<vue.ExtractPropTypes<{
894
+ readonly: {
895
+ type: BooleanConstructor;
896
+ default: undefined;
897
+ };
898
+ fieldProps: {
899
+ type: ObjectConstructor;
900
+ };
901
+ showProps: {
902
+ type: ObjectConstructor;
903
+ };
904
+ slots: {
905
+ type: ObjectConstructor;
906
+ };
907
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
908
+ name: {
909
+ type: vue.PropType<string | (string | number)[]>;
910
+ };
911
+ }>> & {
912
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
913
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
914
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
915
+ } & {
916
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
917
+ readonly error?: string | undefined;
918
+ readonly label?: string | undefined;
919
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
920
+ readonly for?: string | undefined;
921
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
922
+ 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;
923
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
924
+ } & Partial<vue.ExtractPropTypes<{
925
+ readonly: {
926
+ type: BooleanConstructor;
927
+ default: undefined;
928
+ };
929
+ fieldProps: {
930
+ type: ObjectConstructor;
931
+ };
932
+ showProps: {
933
+ type: ObjectConstructor;
934
+ };
935
+ slots: {
936
+ type: ObjectConstructor;
937
+ };
938
+ }>> & Record<string, any>>>, {
939
+ [x: string]: any;
940
+ }>;
941
+ declare const ProFormTreeSelect: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
942
+ name: {
943
+ type: vue.PropType<string | (string | number)[]>;
944
+ };
945
+ }>> & {
946
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
947
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
948
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
949
+ } & {
950
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
951
+ readonly error?: string | undefined;
952
+ readonly label?: string | undefined;
953
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
954
+ readonly for?: string | undefined;
955
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
956
+ 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;
957
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
958
+ } & Partial<vue.ExtractPropTypes<{
959
+ readonly: {
960
+ type: BooleanConstructor;
961
+ default: undefined;
962
+ };
963
+ fieldProps: {
964
+ type: ObjectConstructor;
965
+ };
966
+ showProps: {
967
+ type: ObjectConstructor;
968
+ };
969
+ slots: {
970
+ type: ObjectConstructor;
971
+ };
972
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
973
+ name: {
974
+ type: vue.PropType<string | (string | number)[]>;
975
+ };
976
+ }>> & {
977
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
978
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
979
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
980
+ } & {
981
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
982
+ readonly error?: string | undefined;
983
+ readonly label?: string | undefined;
984
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
985
+ readonly for?: string | undefined;
986
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
987
+ 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;
988
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
989
+ } & Partial<vue.ExtractPropTypes<{
990
+ readonly: {
991
+ type: BooleanConstructor;
992
+ default: undefined;
993
+ };
994
+ fieldProps: {
995
+ type: ObjectConstructor;
996
+ };
997
+ showProps: {
998
+ type: ObjectConstructor;
999
+ };
1000
+ slots: {
1001
+ type: ObjectConstructor;
1002
+ };
1003
+ }>> & Record<string, any>>>, {
1004
+ [x: string]: any;
1005
+ }>;
1006
+ declare const ProFormCheckbox: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1007
+ name: {
1008
+ type: vue.PropType<string | (string | number)[]>;
1009
+ };
1010
+ }>> & {
1011
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1012
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1013
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1014
+ } & {
1015
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1016
+ readonly error?: string | undefined;
1017
+ readonly label?: string | undefined;
1018
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1019
+ readonly for?: string | undefined;
1020
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1021
+ 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;
1022
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1023
+ } & Partial<vue.ExtractPropTypes<{
1024
+ readonly: {
1025
+ type: BooleanConstructor;
1026
+ default: undefined;
1027
+ };
1028
+ fieldProps: {
1029
+ type: ObjectConstructor;
1030
+ };
1031
+ showProps: {
1032
+ type: ObjectConstructor;
1033
+ };
1034
+ slots: {
1035
+ type: ObjectConstructor;
1036
+ };
1037
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
1038
+ name: {
1039
+ type: vue.PropType<string | (string | number)[]>;
1040
+ };
1041
+ }>> & {
1042
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1043
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1044
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1045
+ } & {
1046
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1047
+ readonly error?: string | undefined;
1048
+ readonly label?: string | undefined;
1049
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1050
+ readonly for?: string | undefined;
1051
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1052
+ 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;
1053
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1054
+ } & Partial<vue.ExtractPropTypes<{
1055
+ readonly: {
1056
+ type: BooleanConstructor;
1057
+ default: undefined;
1058
+ };
1059
+ fieldProps: {
1060
+ type: ObjectConstructor;
1061
+ };
1062
+ showProps: {
1063
+ type: ObjectConstructor;
1064
+ };
1065
+ slots: {
1066
+ type: ObjectConstructor;
1067
+ };
1068
+ }>> & Record<string, any>>>, {
1069
+ [x: string]: any;
1070
+ }>;
1071
+ declare const ProFormRadio: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1072
+ name: {
1073
+ type: vue.PropType<string | (string | number)[]>;
1074
+ };
1075
+ }>> & {
1076
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1077
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1078
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1079
+ } & {
1080
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1081
+ readonly error?: string | undefined;
1082
+ readonly label?: string | undefined;
1083
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1084
+ readonly for?: string | undefined;
1085
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1086
+ 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;
1087
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1088
+ } & Partial<vue.ExtractPropTypes<{
1089
+ readonly: {
1090
+ type: BooleanConstructor;
1091
+ default: undefined;
1092
+ };
1093
+ fieldProps: {
1094
+ type: ObjectConstructor;
1095
+ };
1096
+ showProps: {
1097
+ type: ObjectConstructor;
1098
+ };
1099
+ slots: {
1100
+ type: ObjectConstructor;
1101
+ };
1102
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
1103
+ name: {
1104
+ type: vue.PropType<string | (string | number)[]>;
1105
+ };
1106
+ }>> & {
1107
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1108
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1109
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1110
+ } & {
1111
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1112
+ readonly error?: string | undefined;
1113
+ readonly label?: string | undefined;
1114
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1115
+ readonly for?: string | undefined;
1116
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1117
+ 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;
1118
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1119
+ } & Partial<vue.ExtractPropTypes<{
1120
+ readonly: {
1121
+ type: BooleanConstructor;
1122
+ default: undefined;
1123
+ };
1124
+ fieldProps: {
1125
+ type: ObjectConstructor;
1126
+ };
1127
+ showProps: {
1128
+ type: ObjectConstructor;
1129
+ };
1130
+ slots: {
1131
+ type: ObjectConstructor;
1132
+ };
1133
+ }>> & Record<string, any>>>, {
1134
+ [x: string]: any;
1135
+ }>;
1136
+ declare const ProFormSwitch: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1137
+ name: {
1138
+ type: vue.PropType<string | (string | number)[]>;
1139
+ };
1140
+ }>> & {
1141
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1142
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1143
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1144
+ } & {
1145
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1146
+ readonly error?: string | undefined;
1147
+ readonly label?: string | undefined;
1148
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1149
+ readonly for?: string | undefined;
1150
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1151
+ 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;
1152
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1153
+ } & Partial<vue.ExtractPropTypes<{
1154
+ readonly: {
1155
+ type: BooleanConstructor;
1156
+ default: undefined;
1157
+ };
1158
+ fieldProps: {
1159
+ type: ObjectConstructor;
1160
+ };
1161
+ showProps: {
1162
+ type: ObjectConstructor;
1163
+ };
1164
+ slots: {
1165
+ type: ObjectConstructor;
1166
+ };
1167
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
1168
+ name: {
1169
+ type: vue.PropType<string | (string | number)[]>;
1170
+ };
1171
+ }>> & {
1172
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1173
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1174
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1175
+ } & {
1176
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1177
+ readonly error?: string | undefined;
1178
+ readonly label?: string | undefined;
1179
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1180
+ readonly for?: string | undefined;
1181
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1182
+ 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;
1183
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1184
+ } & Partial<vue.ExtractPropTypes<{
1185
+ readonly: {
1186
+ type: BooleanConstructor;
1187
+ default: undefined;
1188
+ };
1189
+ fieldProps: {
1190
+ type: ObjectConstructor;
1191
+ };
1192
+ showProps: {
1193
+ type: ObjectConstructor;
1194
+ };
1195
+ slots: {
1196
+ type: ObjectConstructor;
1197
+ };
1198
+ }>> & Record<string, any>>>, {
1199
+ [x: string]: any;
1200
+ }>;
1201
+ declare const ProFormCascader: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1202
+ name: {
1203
+ type: vue.PropType<string | (string | number)[]>;
1204
+ };
1205
+ }>> & {
1206
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1207
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1208
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1209
+ } & {
1210
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1211
+ readonly error?: string | undefined;
1212
+ readonly label?: string | undefined;
1213
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1214
+ readonly for?: string | undefined;
1215
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1216
+ 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;
1217
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1218
+ } & Partial<vue.ExtractPropTypes<{
1219
+ readonly: {
1220
+ type: BooleanConstructor;
1221
+ default: undefined;
1222
+ };
1223
+ fieldProps: {
1224
+ type: ObjectConstructor;
1225
+ };
1226
+ showProps: {
1227
+ type: ObjectConstructor;
1228
+ };
1229
+ slots: {
1230
+ type: ObjectConstructor;
1231
+ };
1232
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
1233
+ name: {
1234
+ type: vue.PropType<string | (string | number)[]>;
1235
+ };
1236
+ }>> & {
1237
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1238
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1239
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1240
+ } & {
1241
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1242
+ readonly error?: string | undefined;
1243
+ readonly label?: string | undefined;
1244
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1245
+ readonly for?: string | undefined;
1246
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1247
+ 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;
1248
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1249
+ } & Partial<vue.ExtractPropTypes<{
1250
+ readonly: {
1251
+ type: BooleanConstructor;
1252
+ default: undefined;
1253
+ };
1254
+ fieldProps: {
1255
+ type: ObjectConstructor;
1256
+ };
1257
+ showProps: {
1258
+ type: ObjectConstructor;
595
1259
  };
596
- formElementMap: {
597
- [key: string]: any;
1260
+ slots: {
1261
+ type: ObjectConstructor;
598
1262
  };
1263
+ }>> & Record<string, any>>>, {
1264
+ [x: string]: any;
1265
+ }>;
1266
+ interface ButtonProps {
1267
+ size?: "default" | "small" | "large";
1268
+ disabled?: boolean;
1269
+ type?: "default" | "primary" | "success" | "warning" | "info" | "danger" | "text";
1270
+ icon?: string | Component;
1271
+ nativeType?: "button" | "submit" | "reset";
1272
+ loading?: boolean;
1273
+ loadingIcon?: string | Component;
1274
+ plain?: boolean;
1275
+ text?: boolean;
1276
+ link?: boolean;
1277
+ bg?: boolean;
1278
+ autofocus?: boolean;
1279
+ round?: boolean;
1280
+ circle?: boolean;
1281
+ color?: string;
1282
+ dark?: boolean;
1283
+ autoInsertSpace?: boolean;
599
1284
  }
600
- declare const useProModule: () => IProModuleProvide;
601
- declare const provideProModule: (ctx: IProModuleProvide) => void;
1285
+ declare const ProSubmitButton: vue.DefineComponent<ButtonProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ButtonProps>, {}>;
602
1286
 
603
- /**
604
- * 获取Column的valueType，默认"text"
605
- * @param column
606
- */
607
- declare const getColumnValueType: (column: TColumn) => TValueType;
608
- /**
609
- *获取Column的FormItem name
610
- * @param column
611
- */
612
- declare const getColumnFormItemName: (column: TColumn) => string | number | undefined;
613
- /**
614
- * 根据Column生成FormItem VNode
615
- * formFieldProps中的slots参数会以v-slots的形式传递到FormItem的录入组件（子组件）中
616
- * @param formElementMap
617
- * @param column
618
- * @param needRules
619
- */
620
- declare const getFormItemEl: (formElementMap: any, column: TColumn, needRules?: boolean | undefined) => VNode | null;
621
- /**
622
- * 根据Column生成Item VNode
623
- * @param elementMap
624
- * @param column
625
- * @param value
626
- */
627
- declare const getItemEl: (elementMap: any, column: TColumn, value: any) => VNode | null;
628
- declare const proModuleProps: () => {
629
- /**
630
- * 配置（静态）
631
- */
632
- columns: {
633
- type: PropType<TColumns>;
1287
+ declare const proFormListProps: () => {
1288
+ addButtonText: {
1289
+ type: StringConstructor;
1290
+ default: string;
634
1291
  };
635
- /**
636
- * 配置（动态）
637
- * columns动态属性兼容
638
- */
639
- columnState: {
640
- type: PropType<Record<string, any>>;
1292
+ addButtonProps: {
1293
+ type: PropType<ButtonProps$1>;
641
1294
  };
642
- /**
643
- * 展示组件集
644
- */
645
- elementMap: {
646
- type: PropType<{
647
- [key: string]: any;
648
- }>;
1295
+ minusButtonText: {
1296
+ type: StringConstructor;
1297
+ default: string;
649
1298
  };
650
- /**
651
- * 录入组件集
652
- */
653
- formElementMap: {
654
- type: PropType<{
655
- [key: string]: any;
656
- }>;
1299
+ minusButtonProps: {
1300
+ type: PropType<ButtonProps$1>;
657
1301
  };
658
1302
  };
659
- declare type ProModuleProps = Partial<ExtractPropTypes<ReturnType<typeof proModuleProps>>>;
660
- declare const ProModule: vue.DefineComponent<Partial<ExtractPropTypes<{
661
- /**
662
- * 配置（静态）
663
- */
664
- columns: {
665
- type: PropType<TColumns>;
1303
+ declare type ProFormListProps = Partial<ExtractPropTypes<ReturnType<typeof proFormListProps>>> & ProFormListProps$1 & ProFormItemProps;
1304
+ declare const ProFormList: vue.DefineComponent<ProFormListProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormListProps>, {}>;
1305
+
1306
+ declare const createFormItemComponent: ({ InputComp, valueType, name }: {
1307
+ InputComp: any;
1308
+ valueType: string;
1309
+ name?: string | undefined;
1310
+ }) => vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1311
+ name: {
1312
+ type: vue.PropType<string | (string | number)[]>;
1313
+ };
1314
+ }>> & {
1315
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1316
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1317
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1318
+ } & {
1319
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1320
+ readonly error?: string | undefined;
1321
+ readonly label?: string | undefined;
1322
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1323
+ readonly for?: string | undefined;
1324
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1325
+ 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;
1326
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1327
+ } & Partial<vue.ExtractPropTypes<{
1328
+ readonly: {
1329
+ type: BooleanConstructor;
1330
+ default: undefined;
666
1331
  };
667
- /**
668
- * 配置（动态）
669
- * columns动态属性兼容
670
- */
671
- columnState: {
672
- type: PropType<Record<string, any>>;
1332
+ fieldProps: {
1333
+ type: ObjectConstructor;
673
1334
  };
674
- /**
675
- * 展示组件集
676
- */
677
- elementMap: {
678
- type: PropType<{
679
- [key: string]: any;
680
- }>;
1335
+ showProps: {
1336
+ type: ObjectConstructor;
681
1337
  };
682
- /**
683
- * 录入组件集
684
- */
685
- formElementMap: {
686
- type: PropType<{
687
- [key: string]: any;
688
- }>;
1338
+ slots: {
1339
+ type: ObjectConstructor;
689
1340
  };
690
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
691
- /**
692
- * 配置（静态）
693
- */
694
- columns: {
695
- type: PropType<TColumns>;
1341
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<Partial<vue.ExtractPropTypes<{
1342
+ name: {
1343
+ type: vue.PropType<string | (string | number)[]>;
1344
+ };
1345
+ }>> & {
1346
+ readonly labelWidth: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
1347
+ readonly inlineMessage: element_plus_es_utils.EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
1348
+ readonly showMessage: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown>;
1349
+ } & {
1350
+ readonly required?: element_plus_es_utils.EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
1351
+ readonly error?: string | undefined;
1352
+ readonly label?: string | undefined;
1353
+ readonly size?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown> | undefined;
1354
+ readonly for?: string | undefined;
1355
+ readonly prop?: element_plus_es_utils.EpPropMergeType<(new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp) | ((new (...args: any[]) => element_plus.FormItemProp & {}) | (() => element_plus.FormItemProp))[], unknown, unknown> | undefined;
1356
+ 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;
1357
+ readonly validateStatus?: element_plus_es_utils.EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
1358
+ } & Partial<vue.ExtractPropTypes<{
1359
+ readonly: {
1360
+ type: BooleanConstructor;
1361
+ default: undefined;
696
1362
  };
697
- /**
698
- * 配置（动态）
699
- * columns动态属性兼容
700
- */
701
- columnState: {
702
- type: PropType<Record<string, any>>;
1363
+ fieldProps: {
1364
+ type: ObjectConstructor;
703
1365
  };
704
- /**
705
- * 展示组件集
706
- */
707
- elementMap: {
708
- type: PropType<{
709
- [key: string]: any;
710
- }>;
1366
+ showProps: {
1367
+ type: ObjectConstructor;
711
1368
  };
712
- /**
713
- * 录入组件集
714
- */
715
- formElementMap: {
716
- type: PropType<{
717
- [key: string]: any;
718
- }>;
1369
+ slots: {
1370
+ type: ObjectConstructor;
719
1371
  };
720
- }>>>, {}>;
1372
+ }>> & Record<string, any>>>, {
1373
+ [x: string]: any;
1374
+ }>;
1375
+
1376
+ declare type ProTableProps = Omit<ProTableProps$1, "columns"> & {
1377
+ columns?: TColumns;
1378
+ } & Omit<TableProps<any>, "tableLayout" | "flexible" | "data"> & {
1379
+ tableLayout?: "fixed" | "auto";
1380
+ flexible?: boolean;
1381
+ data?: any;
1382
+ };
1383
+ declare const ProTable: vue.DefineComponent<ProTableProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProTableProps>, {
1384
+ data?: any;
1385
+ }>;
721
1386
 
722
1387
  /**
723
1388
  * 添加 和 修改 时候的确定按钮
@@ -815,250 +1480,145 @@ declare type ProCurdFormProps = Partial<ExtractPropTypes<ReturnType<typeof proCu
815
1480
  declare const ProCurdForm: vue.DefineComponent<ProCurdFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProCurdFormProps>, {}>;
816
1481
  declare const ProCurdFormConnect: vue.DefineComponent<{}, () => JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<{}>>, {}>;
817
1482
 
818
- interface ModalProps {
819
- appendToBody?: boolean;
820
- beforeClose?: (done: () => void) => void;
821
- destroyOnClose?: boolean;
822
- closeOnClickModal?: boolean;
823
- closeOnPressEscape?: boolean;
824
- lockScroll?: boolean;
825
- modal?: boolean;
826
- openDelay?: number;
827
- closeDelay?: number;
828
- top?: string;
829
- modelValue?: boolean;
830
- modalClass?: string;
831
- width?: string | number;
832
- zIndex?: number;
833
- trapFocus?: boolean;
834
- center?: boolean;
835
- customClass?: string;
836
- draggable?: boolean;
837
- fullscreen?: boolean;
838
- showClose?: boolean;
839
- title?: string;
840
- }
841
-
842
- interface DescriptionsProps {
843
- border?: boolean;
844
- column?: number;
845
- direction?: "vertical" | "horizontal";
846
- size?: "default" | "small" | "large";
847
- title?: string;
848
- extra?: string;
849
- }
850
- declare const ProCurdDesc: vue.DefineComponent<DescriptionsProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<DescriptionsProps>, {}>;
851
- declare const ProCurdDescConnect: vue.DefineComponent<{}, () => JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{}>>, {}>;
852
-
853
- /**
854
- * curd 操作模式
855
- */
856
- declare enum CurdCurrentMode {
857
- ADD = "ADD",
858
- EDIT = "EDIT",
859
- DETAIL = "DETAIL"
860
- }
861
- declare type ICurdCurrentMode = keyof typeof CurdCurrentMode;
862
- /**
863
- * curd add 模式下 标记 "确定" "确定并继续" 触发
864
- */
865
- declare enum CurdAddAction {
866
- NORMAL = "NORMAL",
867
- CONTINUE = "CONTINUE"
868
- }
869
- declare type ICurdAddAction = keyof typeof CurdAddAction;
870
- interface IListData extends Record<string, any> {
871
- total: number;
872
- dataSource: Record<string, any>[];
873
- }
874
- interface ICurdState extends Record<string, any> {
875
- listLoading?: boolean;
876
- listData?: IListData;
877
- mode?: ICurdCurrentMode;
878
- detailLoading?: boolean;
879
- detailData?: Record<string, any>;
880
- operateLoading?: boolean;
881
- addAction?: ICurdAddAction;
882
- }
883
- declare type BooleanOrFun = boolean | ((record: Record<string, any>) => boolean);
884
1483
  /**
885
- * `on${Action}Bobble`: 冒泡
1484
+ * 组合列表
1485
+ * SearchForm + Table + Pagination
886
1486
  */
887
- interface IOperate {
888
- onList?: (values: Record<string, any>) => void;
889
- detail?: BooleanOrFun;
890
- detailLabel?: string | VNode;
891
- onDetail?: (record: Record<string, any>) => void;
892
- edit?: BooleanOrFun;
893
- editLabel?: string | VNode;
894
- onEdit?: (record: Record<string, any>) => void;
895
- onEditExecute?: (values: Record<string, any>) => void;
896
- add?: BooleanOrFun;
897
- addLabel?: string | VNode;
898
- onAdd?: () => void;
899
- onAddExecute?: (values: Record<string, any>) => void;
900
- delete?: BooleanOrFun;
901
- deleteLabel?: string | VNode;
902
- onDelete?: (record: Record<string, any>) => void;
903
- tableOperate?: ITableOperate;
904
- }
905
- declare const proCurdModuleProps: () => {
906
- /**
907
- * 状态
908
- */
909
- curdState: {
910
- type: PropType<{
911
- [x: string]: any;
912
- listLoading?: boolean | undefined;
913
- listData?: {
914
- [x: string]: any;
915
- total: number;
916
- dataSource: {
917
- [x: string]: any;
918
- }[];
919
- } | undefined;
920
- mode?: "ADD" | "EDIT" | "DETAIL" | undefined;
921
- detailLoading?: boolean | undefined;
922
- detailData?: {
923
- [x: string]: any;
924
- } | undefined;
925
- operateLoading?: boolean | undefined;
926
- addAction?: "NORMAL" | "CONTINUE" | undefined;
1487
+ declare const ProCurdList: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1488
+ extraInSearch: {
1489
+ type: BooleanConstructor;
1490
+ default: undefined;
1491
+ };
1492
+ searchProps: {
1493
+ type: vue.PropType<ProSearchFormProps>;
1494
+ };
1495
+ tableProps: {
1496
+ type: vue.PropType<Omit<Partial<vue.ExtractPropTypes<{
1497
+ operate: {
1498
+ type: vue.PropType<_vue_start_pro.ITableOperate>;
1499
+ };
1500
+ columnEmptyText: {
1501
+ type: StringConstructor;
1502
+ };
1503
+ column: {
1504
+ type: vue.PropType<_vue_start_pro.TTableColumn>;
1505
+ };
1506
+ columns: {
1507
+ type: vue.PropType<_vue_start_pro.TTableColumns>;
1508
+ };
1509
+ columnState: {
1510
+ type: vue.PropType<Record<string, any>>;
1511
+ };
1512
+ elementMap: {
1513
+ type: vue.PropType<_vue_start_pro.TElementMap>;
1514
+ };
1515
+ loading: {
1516
+ type: BooleanConstructor;
1517
+ };
1518
+ serialNumber: {
1519
+ type: BooleanConstructor;
1520
+ };
1521
+ pagination: {
1522
+ type: vue.PropType<{
1523
+ page?: number | undefined;
1524
+ pageSize?: number | undefined;
1525
+ }>;
1526
+ };
1527
+ provideExtra: {
1528
+ type: vue.PropType<_vue_start_pro.IProTableProvideExtra>;
1529
+ };
1530
+ }>>, "columns"> & {
1531
+ columns?: TColumns | undefined;
1532
+ } & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
1533
+ tableLayout?: "fixed" | "auto" | undefined;
1534
+ flexible?: boolean | undefined;
1535
+ data?: any;
1536
+ } & {
1537
+ slots?: Readonly<{
1538
+ [name: string]: vue.Slot | undefined;
1539
+ }> | undefined;
927
1540
  }>;
928
1541
  };
929
- /**
930
- * 操作配置
931
- */
932
- operate: {
933
- type: PropType<IOperate>;
1542
+ paginationProps: {
1543
+ type: vue.PropType<PaginationProps>;
934
1544
  };
935
- /**
936
- * 列表 或 详情 的唯一标识
937
- */
938
- rowKey: {
939
- type: StringConstructor;
940
- default: string;
1545
+ pageState: {
1546
+ type: vue.PropType<TPageState>;
941
1547
  };
942
- /************************* 子组件props *******************************/
943
- listProps: {
944
- type: PropType<Partial<ExtractPropTypes<{
945
- extraInSearch: {
1548
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<vue.ExtractPropTypes<{
1549
+ extraInSearch: {
1550
+ type: BooleanConstructor;
1551
+ default: undefined;
1552
+ };
1553
+ searchProps: {
1554
+ type: vue.PropType<ProSearchFormProps>;
1555
+ };
1556
+ tableProps: {
1557
+ type: vue.PropType<Omit<Partial<vue.ExtractPropTypes<{
1558
+ operate: {
1559
+ type: vue.PropType<_vue_start_pro.ITableOperate>;
1560
+ };
1561
+ columnEmptyText: {
1562
+ type: StringConstructor;
1563
+ };
1564
+ column: {
1565
+ type: vue.PropType<_vue_start_pro.TTableColumn>;
1566
+ };
1567
+ columns: {
1568
+ type: vue.PropType<_vue_start_pro.TTableColumns>;
1569
+ };
1570
+ columnState: {
1571
+ type: vue.PropType<Record<string, any>>;
1572
+ };
1573
+ elementMap: {
1574
+ type: vue.PropType<_vue_start_pro.TElementMap>;
1575
+ };
1576
+ loading: {
946
1577
  type: BooleanConstructor;
947
- default: undefined;
948
1578
  };
949
- searchProps: {
950
- type: PropType<ProSearchFormProps>;
1579
+ serialNumber: {
1580
+ type: BooleanConstructor;
951
1581
  };
952
- tableProps: {
953
- type: PropType<Partial<ExtractPropTypes<{
954
- operate: {
955
- type: PropType<ITableOperate>;
956
- };
957
- columnEmptyText: {
958
- type: StringConstructor;
959
- };
960
- column: {
961
- type: PropType<TableColumnCtx<any>>;
962
- };
963
- columns: {
964
- type: PropType<TColumns>;
965
- };
966
- elementMap: {
967
- type: PropType<{
968
- [key: string]: any;
969
- }>;
970
- };
971
- }>> & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
972
- tableLayout?: "fixed" | "auto" | undefined;
973
- flexible?: boolean | undefined;
974
- data?: any;
975
- } & {
976
- slots?: Readonly<{
977
- [name: string]: vue.Slot | undefined;
978
- }> | undefined;
1582
+ pagination: {
1583
+ type: vue.PropType<{
1584
+ page?: number | undefined;
1585
+ pageSize?: number | undefined;
979
1586
  }>;
980
1587
  };
981
- paginationProps: {
982
- type: PropType<PaginationProps>;
983
- };
984
- pageState: {
985
- type: PropType<TPageState>;
1588
+ provideExtra: {
1589
+ type: vue.PropType<_vue_start_pro.IProTableProvideExtra>;
986
1590
  };
987
- }>>>;
988
- };
989
- formProps: {
990
- type: PropType<ProCurdFormProps>;
1591
+ }>>, "columns"> & {
1592
+ columns?: TColumns | undefined;
1593
+ } & Omit<element_plus_es_components_table_src_table_defaults.TableProps<any>, "data" | "tableLayout" | "flexible"> & {
1594
+ tableLayout?: "fixed" | "auto" | undefined;
1595
+ flexible?: boolean | undefined;
1596
+ data?: any;
1597
+ } & {
1598
+ slots?: Readonly<{
1599
+ [name: string]: vue.Slot | undefined;
1600
+ }> | undefined;
1601
+ }>;
991
1602
  };
992
- descProps: {
993
- type: PropType<DescriptionsProps>;
1603
+ paginationProps: {
1604
+ type: vue.PropType<PaginationProps>;
994
1605
  };
995
- modalProps: {
996
- type: PropType<ModalProps>;
1606
+ pageState: {
1607
+ type: vue.PropType<TPageState>;
997
1608
  };
998
- };
999
- declare type CurdModuleProps = Partial<ExtractPropTypes<ReturnType<typeof proCurdModuleProps>>>;
1000
- declare type ProCurdModuleProps = CurdModuleProps & ProModuleProps;
1001
- declare const ProCurd: vue.DefineComponent<ProCurdModuleProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProCurdModuleProps>, {}>;
1002
-
1003
- interface IProCurdModuleProvide {
1004
- rowKey: string;
1005
- curdState: UnwrapNestedRefs<ICurdState>;
1006
- formColumns: Ref<TColumns>;
1007
- descColumns: Ref<TColumns>;
1008
- tableColumns: Ref<TColumns>;
1009
- searchColumns: Ref<TColumns>;
1010
- operate: IOperate;
1011
- /******************子组件参数*******************/
1012
- listProps?: ProCurdListProps;
1013
- formProps?: ProCurdFormProps;
1014
- descProps?: DescriptionsProps;
1015
- modalProps?: ModalProps;
1016
- }
1017
- declare const useProCurdModule: () => IProCurdModuleProvide;
1018
- declare const provideProCurdModule: (ctx: IProCurdModuleProvide) => void;
1609
+ }>>>, {}>;
1610
+ declare const ProCurdListConnect: vue.DefineComponent<{}, () => JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{}>>, {}>;
1019
1611
 
1020
- interface ICurdNetConvert {
1021
- convertAddParams?: (values: Record<string, any>, record: Record<string, any>) => Record<string, any>;
1022
- convertEditParams?: (values: Record<string, any>, record: Record<string, any>) => Record<string, any>;
1023
- convertListParams?: (values: Record<string, any>) => Record<string, any>;
1024
- convertListData?: (actor: IRequestActor) => IListData;
1025
- convertDetailParams?: (record: Record<string, any>, rowKey: string) => Record<string, any>;
1026
- convertDetailData?: (actor: IRequestActor) => Record<string, any>;
1027
- convertDeleteParams?: (record: Record<string, any>, rowKey: string) => Record<string, any>;
1028
- }
1029
- /**
1030
- * `on{Action}Bubble`
1031
- * 各个回调中都会调用该方法
1032
- * 场景：不改变原有方法逻辑，但是需要在对应的节点添加其他处理
1033
- * 如果直接重写`on{Action}...`，将不会再调用对应的bubble方法
1034
- */
1035
- interface INetOperate extends IOperate {
1036
- onListDone?: (actor: IRequestActor) => void;
1037
- onListFail?: (actor: IRequestActor) => void;
1038
- onListBubble?: (type: "emit" | "done" | "fail", ...rest: any[]) => void;
1039
- onDetailDone?: (actor: IRequestActor) => void;
1040
- onDetailFail?: (actor: IRequestActor) => void;
1041
- onDetailBubble?: (type: "emit" | "done" | "fail", ...rest: any[]) => void;
1042
- onEditDone?: (actor: IRequestActor) => void;
1043
- onEditFail?: (actor: IRequestActor) => void;
1044
- onEditBubble?: (type: "emit" | "execute" | "done" | "fail", ...rest: any[]) => void;
1045
- onAddDone?: (actor: IRequestActor) => void;
1046
- onAddFail?: (actor: IRequestActor) => void;
1047
- onAddBubble?: (type: "emit" | "execute" | "done" | "fail", ...rest: any[]) => void;
1048
- onDeleteDone?: (actor: IRequestActor) => void;
1049
- onDeleteFail?: (actor: IRequestActor) => void;
1050
- onDeleteBubble?: (type: "emit" | "done" | "fail", ...rest: any[]) => void;
1612
+ interface DescriptionsProps {
1613
+ border?: boolean;
1614
+ column?: number;
1615
+ direction?: "vertical" | "horizontal";
1616
+ size?: "default" | "small" | "large";
1617
+ title?: string;
1618
+ extra?: string;
1051
1619
  }
1052
- declare const proCurdNetProps: () => {
1053
- converts: {
1054
- type: PropType<ICurdNetConvert>;
1055
- };
1056
- operate: {
1057
- type: PropType<INetOperate>;
1058
- };
1059
- };
1060
- declare type ProCurdNetProps = Partial<ExtractPropTypes<ReturnType<typeof proCurdNetProps>>> & Omit<ProCurdModuleProps, "operate">;
1061
- declare const ProCurdNet: vue.DefineComponent<ProCurdNetProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProCurdNetProps>, {}>;
1620
+ declare const ProCurdDesc: vue.DefineComponent<DescriptionsProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<DescriptionsProps>, {}>;
1621
+ declare const ProCurdDescConnect: vue.DefineComponent<{}, () => JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{}>>, {}>;
1062
1622
 
1063
1623
  declare const proSelectProps: () => {
1064
1624
  options: PropType<TOptions>;
@@ -1068,17 +1628,4 @@ declare const ProSelect: vue.DefineComponent<any, {}, {}, {}, {}, vue.ComponentO
1068
1628
  [x: string]: any;
1069
1629
  }>;
1070
1630
 
1071
- /**
1072
- * 剔除showState或showStateRules规则为!true的值
1073
- * @param values
1074
- * @param showState
1075
- * @param showStateRules
1076
- */
1077
- declare const getValidValues: (values: Record<string, any>, showState?: BooleanObjType | undefined, showStateRules?: BooleanRulesObjType | undefined) => Record<string, any>;
1078
- /**
1079
- * string类型的path转为arr
1080
- * @param path
1081
- */
1082
- declare const convertPathToList: (path: undefined | string | number | (string | number)[]) => undefined | (string | number)[];
1083
-
1084
- export { ButtonProps, ContinueAddButton, CurdAddAction, CurdCurrentMode, DescriptionsProps, ICurdAddAction, ICurdCurrentMode, ICurdNetConvert, ICurdState, IListData, INetOperate, IOperate, IOperateItem, IProCurdModuleProvide, IProModuleProvide, ISearchMode, ITableOperate, OkButton, PaginationProps, ProCreateFormItemProps, ProCurd, ProCurdDesc, ProCurdDescConnect, ProCurdForm, ProCurdFormConnect, ProCurdFormProps, ProCurdList, ProCurdListConnect, ProCurdListProps, ProCurdModuleProps, ProCurdNet, ProCurdNetProps, ProForm, ProFormCascader, ProFormCheckbox, ProFormDatePicker, ProFormItem, ProFormItemProps, ProFormList, ProFormListProps, ProFormProps, ProFormRadio, ProFormSelect, ProFormSwitch, ProFormText, ProFormTextNumber, ProFormTimePicker, ProFormTreeSelect, ProModule, ProModuleProps, ProOperateButton, ProOperateButtonProps, ProSchemaForm, ProSchemaFormProps, ProSearchForm, ProSearchFormProps, ProSelect, ProSelectProps, ProSubmitButton, ProTable, ProTableProps, SearchMode, TPageState, convertPathToList, createFormItemComponent, defaultPage, getColumnFormItemName, getColumnValueType, getFormItemEl, getItemEl, getValidValues, provideProCurdModule, provideProForm, provideProFormList, provideProModule, useProCurdModule, useProForm, useProFormList, useProModule };
1631
+ export { ButtonProps, ContinueAddButton, DescriptionsProps, ModalProps, OkButton, PaginationProps, ProCurdDesc, ProCurdDescConnect, ProCurdForm, ProCurdFormConnect, ProCurdFormProps, ProCurdList, ProCurdListConnect, ProCurdModal, ProCurdModalConnect, ProForm, ProFormCascader, ProFormCheckbox, ProFormDatePicker, ProFormItem, ProFormItemProps, ProFormList, ProFormListProps, ProFormProps, ProFormRadio, ProFormSelect, ProFormSwitch, ProFormText, ProFormTextNumber, ProFormTimePicker, ProFormTreeSelect, ProGrid, ProGridProps, ProList, ProListProps, ProLoading, ProLoadingProps, ProOperateButton, ProOperateButtonProps, ProSearchForm, ProSearchFormProps, ProSelect, ProSelectProps, ProSubmitButton, ProTable, ProTableProps, TPageState, createFormItemComponent, createLoadingId, defaultPage };