ra-element 0.1.90 → 0.1.92

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 (22) hide show
  1. package/docs/ra-select.md +2 -2
  2. package/docs/ra-tree-select.md +1 -7
  3. package/docs/ra-upload.md +1 -3
  4. package/lib/components/ra-button/index.vue.d.ts +348 -440
  5. package/lib/components/ra-date-picker/index.vue.d.ts +488 -655
  6. package/lib/components/ra-dialog/index.vue.d.ts +516 -764
  7. package/lib/components/ra-form/index.vue.d.ts +523 -0
  8. package/lib/components/ra-input/index.vue.d.ts +544 -790
  9. package/lib/components/ra-select/type.d.ts +5 -0
  10. package/lib/components/ra-table/component/top-module.vue.d.ts +8 -6
  11. package/lib/components/ra-table/index.vue.d.ts +3255 -0
  12. package/lib/components/ra-textarea/index.vue.d.ts +293 -416
  13. package/lib/components/ra-tool-tip/index.vue.d.ts +806 -1152
  14. package/lib/components/ra-tree-select/index.vue.d.ts +517 -278
  15. package/lib/components/ra-tree-select/type.d.ts +5 -0
  16. package/lib/components/ra-upload/index.vue.d.ts +259 -1024
  17. package/lib/ra-element.css +1 -1
  18. package/lib/ra-element.es.js +1287 -1355
  19. package/lib/ra-element.es.js.map +1 -1
  20. package/lib/ra-element.umd.js +1 -1
  21. package/lib/ra-element.umd.js.map +1 -1
  22. package/package.json +1 -1
package/lib/components/ra-upload/index.vue.d.ts CHANGED
@@ -4,565 +4,7 @@ interface UploadFileGroup extends UploadUserFile {
4
4
  fileName?: string;
5
5
  raId?: string;
6
6
  }
7
- declare function __VLS_template(): {
8
- attrs: Partial<{}>;
9
- slots: {
10
- default?(_: {}): any;
11
- };
12
- refs: {
13
- componentRef: ({
14
- $: import('vue').ComponentInternalInstance;
15
- $data: {};
16
- $props: Partial<{
17
- readonly data: ({
18
- [x: string]: any;
19
- } | Promise<{
20
- [x: string]: any;
21
- }>) | ((rawFile: import('element-plus').UploadRawFile) => {
22
- [x: string]: any;
23
- } | Promise<{
24
- [x: string]: any;
25
- }>);
26
- readonly disabled: boolean;
27
- readonly drag: boolean;
28
- readonly multiple: boolean;
29
- readonly name: string;
30
- readonly onChange: (uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
31
- readonly onError: (error: Error, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
32
- readonly onProgress: (evt: import('element-plus').UploadProgressEvent, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
33
- readonly method: string;
34
- readonly action: string;
35
- readonly accept: string;
36
- readonly withCredentials: boolean;
37
- readonly showFileList: boolean;
38
- readonly fileList: UploadUserFile[];
39
- readonly autoUpload: boolean;
40
- readonly listType: "picture" | "text" | "picture-card";
41
- readonly httpRequest: import('element-plus').UploadRequestHandler;
42
- readonly beforeUpload: (rawFile: import('element-plus').UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob | null | undefined> | null | undefined;
43
- readonly onRemove: (uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
44
- readonly onPreview: (uploadFile: UploadFile) => void;
45
- readonly onSuccess: (response: any, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
46
- readonly onExceed: (files: File[], uploadFiles: UploadUserFile[]) => void;
47
- }> & Omit<{
48
- readonly name: string;
49
- readonly disabled: boolean;
50
- readonly data: ({
51
- [x: string]: any;
52
- } | Promise<{
53
- [x: string]: any;
54
- }>) | ((rawFile: import('element-plus').UploadRawFile) => {
55
- [x: string]: any;
56
- } | Promise<{
57
- [x: string]: any;
58
- }>);
59
- readonly onChange: (uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
60
- readonly onError: (error: Error, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
61
- readonly onProgress: (evt: import('element-plus').UploadProgressEvent, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
62
- readonly drag: boolean;
63
- readonly multiple: boolean;
64
- readonly method: string;
65
- readonly action: string;
66
- readonly accept: string;
67
- readonly listType: "picture" | "text" | "picture-card";
68
- readonly autoUpload: boolean;
69
- readonly showFileList: boolean;
70
- readonly beforeUpload: (rawFile: import('element-plus').UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob | null | undefined> | null | undefined;
71
- readonly onRemove: (uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
72
- readonly onPreview: (uploadFile: UploadFile) => void;
73
- readonly onSuccess: (response: any, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
74
- readonly onExceed: (files: File[], uploadFiles: UploadUserFile[]) => void;
75
- readonly withCredentials: boolean;
76
- readonly fileList: UploadUserFile[];
77
- readonly httpRequest: import('element-plus').UploadRequestHandler;
78
- readonly limit?: number | undefined;
79
- readonly beforeRemove?: ((uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => boolean | Promise<boolean>) | undefined;
80
- readonly crossorigin?: ("" | "anonymous" | "use-credentials") | undefined;
81
- readonly headers?: (Record<string, any> | Headers) | undefined;
82
- } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "name" | "disabled" | "data" | "onChange" | "onError" | "onProgress" | "drag" | "multiple" | "method" | "action" | "accept" | "listType" | "autoUpload" | "showFileList" | "beforeUpload" | "onRemove" | "onPreview" | "onSuccess" | "onExceed" | "withCredentials" | "fileList" | "httpRequest">;
83
- $attrs: {
84
- [x: string]: unknown;
85
- };
86
- $refs: {
87
- [x: string]: unknown;
88
- };
89
- $slots: Readonly<{
90
- [name: string]: import('vue').Slot<any> | undefined;
91
- }>;
92
- $root: import('vue').ComponentPublicInstance | null;
93
- $parent: import('vue').ComponentPublicInstance | null;
94
- $host: Element | null;
95
- $emit: (event: string, ...args: any[]) => void;
96
- $el: any;
97
- $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
98
- readonly beforeUpload: {
99
- readonly type: PropType<(rawFile: import('element-plus').UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob | null | undefined> | null | undefined>;
100
- readonly required: false;
101
- readonly validator: ((val: unknown) => boolean) | undefined;
102
- __epPropKey: true;
103
- } & {
104
- readonly default: () => void;
105
- };
106
- readonly beforeRemove: {
107
- readonly type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => boolean | Promise<boolean>>;
108
- readonly required: false;
109
- readonly validator: ((val: unknown) => boolean) | undefined;
110
- __epPropKey: true;
111
- };
112
- readonly onRemove: {
113
- readonly type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
114
- readonly required: false;
115
- readonly validator: ((val: unknown) => boolean) | undefined;
116
- __epPropKey: true;
117
- } & {
118
- readonly default: () => void;
119
- };
120
- readonly onChange: {
121
- readonly type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
122
- readonly required: false;
123
- readonly validator: ((val: unknown) => boolean) | undefined;
124
- __epPropKey: true;
125
- } & {
126
- readonly default: () => void;
127
- };
128
- readonly onPreview: {
129
- readonly type: PropType<(uploadFile: UploadFile) => void>;
130
- readonly required: false;
131
- readonly validator: ((val: unknown) => boolean) | undefined;
132
- __epPropKey: true;
133
- } & {
134
- readonly default: () => void;
135
- };
136
- readonly onSuccess: {
137
- readonly type: PropType<(response: any, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
138
- readonly required: false;
139
- readonly validator: ((val: unknown) => boolean) | undefined;
140
- __epPropKey: true;
141
- } & {
142
- readonly default: () => void;
143
- };
144
- readonly onProgress: {
145
- readonly type: PropType<(evt: import('element-plus').UploadProgressEvent, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
146
- readonly required: false;
147
- readonly validator: ((val: unknown) => boolean) | undefined;
148
- __epPropKey: true;
149
- } & {
150
- readonly default: () => void;
151
- };
152
- readonly onError: {
153
- readonly type: PropType<(error: Error, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
154
- readonly required: false;
155
- readonly validator: ((val: unknown) => boolean) | undefined;
156
- __epPropKey: true;
157
- } & {
158
- readonly default: () => void;
159
- };
160
- readonly onExceed: {
161
- readonly type: PropType<(files: File[], uploadFiles: UploadUserFile[]) => void>;
162
- readonly required: false;
163
- readonly validator: ((val: unknown) => boolean) | undefined;
164
- __epPropKey: true;
165
- } & {
166
- readonly default: () => void;
167
- };
168
- readonly crossorigin: {
169
- readonly type: PropType<"" | "anonymous" | "use-credentials">;
170
- readonly required: false;
171
- readonly validator: ((val: unknown) => boolean) | undefined;
172
- __epPropKey: true;
173
- };
174
- readonly action: {
175
- readonly type: PropType<string>;
176
- readonly required: false;
177
- readonly validator: ((val: unknown) => boolean) | undefined;
178
- __epPropKey: true;
179
- } & {
180
- readonly default: "#";
181
- };
182
- readonly headers: {
183
- readonly type: PropType<Record<string, any> | Headers>;
184
- readonly required: false;
185
- readonly validator: ((val: unknown) => boolean) | undefined;
186
- __epPropKey: true;
187
- };
188
- readonly method: {
189
- readonly type: PropType<string>;
190
- readonly required: false;
191
- readonly validator: ((val: unknown) => boolean) | undefined;
192
- __epPropKey: true;
193
- } & {
194
- readonly default: "post";
195
- };
196
- readonly data: {
197
- readonly type: PropType<({
198
- [x: string]: any;
199
- } | Promise<{
200
- [x: string]: any;
201
- }>) | ((rawFile: import('element-plus').UploadRawFile) => {
202
- [x: string]: any;
203
- } | Promise<{
204
- [x: string]: any;
205
- }>)>;
206
- readonly required: false;
207
- readonly validator: ((val: unknown) => boolean) | undefined;
208
- __epPropKey: true;
209
- } & {
210
- readonly default: () => {};
211
- };
212
- readonly multiple: BooleanConstructor;
213
- readonly name: {
214
- readonly type: PropType<string>;
215
- readonly required: false;
216
- readonly validator: ((val: unknown) => boolean) | undefined;
217
- __epPropKey: true;
218
- } & {
219
- readonly default: "file";
220
- };
221
- readonly drag: BooleanConstructor;
222
- readonly withCredentials: BooleanConstructor;
223
- readonly showFileList: {
224
- readonly type: PropType<boolean>;
225
- readonly required: false;
226
- readonly validator: ((val: unknown) => boolean) | undefined;
227
- __epPropKey: true;
228
- } & {
229
- readonly default: true;
230
- };
231
- readonly accept: {
232
- readonly type: PropType<string>;
233
- readonly required: false;
234
- readonly validator: ((val: unknown) => boolean) | undefined;
235
- __epPropKey: true;
236
- } & {
237
- readonly default: "";
238
- };
239
- readonly fileList: {
240
- readonly type: PropType<UploadUserFile[]>;
241
- readonly required: false;
242
- readonly validator: ((val: unknown) => boolean) | undefined;
243
- __epPropKey: true;
244
- } & {
245
- readonly default: () => [];
246
- };
247
- readonly autoUpload: {
248
- readonly type: PropType<boolean>;
249
- readonly required: false;
250
- readonly validator: ((val: unknown) => boolean) | undefined;
251
- __epPropKey: true;
252
- } & {
253
- readonly default: true;
254
- };
255
- readonly listType: {
256
- readonly type: PropType<"picture" | "text" | "picture-card">;
257
- readonly required: false;
258
- readonly validator: ((val: unknown) => boolean) | undefined;
259
- __epPropKey: true;
260
- } & {
261
- readonly default: "text";
262
- };
263
- readonly httpRequest: {
264
- readonly type: PropType<import('element-plus').UploadRequestHandler>;
265
- readonly required: false;
266
- readonly validator: ((val: unknown) => boolean) | undefined;
267
- __epPropKey: true;
268
- } & {
269
- readonly default: import('element-plus').UploadRequestHandler;
270
- };
271
- readonly disabled: BooleanConstructor;
272
- readonly limit: NumberConstructor;
273
- }>>, {
274
- abort: (file: UploadFile) => void;
275
- submit: () => void;
276
- clearFiles: (states?: import('element-plus').UploadStatus[]) => void;
277
- handleStart: (rawFile: import('element-plus').UploadRawFile) => void;
278
- handleRemove: (file: UploadFile | import('element-plus').UploadRawFile, rawFile?: import('element-plus').UploadRawFile) => void;
279
- }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
280
- readonly data: ({
281
- [x: string]: any;
282
- } | Promise<{
283
- [x: string]: any;
284
- }>) | ((rawFile: import('element-plus').UploadRawFile) => {
285
- [x: string]: any;
286
- } | Promise<{
287
- [x: string]: any;
288
- }>);
289
- readonly disabled: boolean;
290
- readonly drag: boolean;
291
- readonly multiple: boolean;
292
- readonly name: string;
293
- readonly onChange: (uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
294
- readonly onError: (error: Error, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
295
- readonly onProgress: (evt: import('element-plus').UploadProgressEvent, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
296
- readonly method: string;
297
- readonly action: string;
298
- readonly accept: string;
299
- readonly withCredentials: boolean;
300
- readonly showFileList: boolean;
301
- readonly fileList: UploadUserFile[];
302
- readonly autoUpload: boolean;
303
- readonly listType: "picture" | "text" | "picture-card";
304
- readonly httpRequest: import('element-plus').UploadRequestHandler;
305
- readonly beforeUpload: (rawFile: import('element-plus').UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob | null | undefined> | null | undefined;
306
- readonly onRemove: (uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
307
- readonly onPreview: (uploadFile: UploadFile) => void;
308
- readonly onSuccess: (response: any, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
309
- readonly onExceed: (files: File[], uploadFiles: UploadUserFile[]) => void;
310
- }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
311
- beforeCreate?: (() => void) | (() => void)[];
312
- created?: (() => void) | (() => void)[];
313
- beforeMount?: (() => void) | (() => void)[];
314
- mounted?: (() => void) | (() => void)[];
315
- beforeUpdate?: (() => void) | (() => void)[];
316
- updated?: (() => void) | (() => void)[];
317
- activated?: (() => void) | (() => void)[];
318
- deactivated?: (() => void) | (() => void)[];
319
- beforeDestroy?: (() => void) | (() => void)[];
320
- beforeUnmount?: (() => void) | (() => void)[];
321
- destroyed?: (() => void) | (() => void)[];
322
- unmounted?: (() => void) | (() => void)[];
323
- renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
324
- renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
325
- errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
326
- };
327
- $forceUpdate: () => void;
328
- $nextTick: typeof import('vue').nextTick;
329
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
330
- } & Readonly<{
331
- readonly data: ({
332
- [x: string]: any;
333
- } | Promise<{
334
- [x: string]: any;
335
- }>) | ((rawFile: import('element-plus').UploadRawFile) => {
336
- [x: string]: any;
337
- } | Promise<{
338
- [x: string]: any;
339
- }>);
340
- readonly disabled: boolean;
341
- readonly drag: boolean;
342
- readonly multiple: boolean;
343
- readonly name: string;
344
- readonly onChange: (uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
345
- readonly onError: (error: Error, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
346
- readonly onProgress: (evt: import('element-plus').UploadProgressEvent, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
347
- readonly method: string;
348
- readonly action: string;
349
- readonly accept: string;
350
- readonly withCredentials: boolean;
351
- readonly showFileList: boolean;
352
- readonly fileList: UploadUserFile[];
353
- readonly autoUpload: boolean;
354
- readonly listType: "picture" | "text" | "picture-card";
355
- readonly httpRequest: import('element-plus').UploadRequestHandler;
356
- readonly beforeUpload: (rawFile: import('element-plus').UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob | null | undefined> | null | undefined;
357
- readonly onRemove: (uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
358
- readonly onPreview: (uploadFile: UploadFile) => void;
359
- readonly onSuccess: (response: any, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
360
- readonly onExceed: (files: File[], uploadFiles: UploadUserFile[]) => void;
361
- }> & Omit<Readonly<import('vue').ExtractPropTypes<{
362
- readonly beforeUpload: {
363
- readonly type: PropType<(rawFile: import('element-plus').UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob | null | undefined> | null | undefined>;
364
- readonly required: false;
365
- readonly validator: ((val: unknown) => boolean) | undefined;
366
- __epPropKey: true;
367
- } & {
368
- readonly default: () => void;
369
- };
370
- readonly beforeRemove: {
371
- readonly type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => boolean | Promise<boolean>>;
372
- readonly required: false;
373
- readonly validator: ((val: unknown) => boolean) | undefined;
374
- __epPropKey: true;
375
- };
376
- readonly onRemove: {
377
- readonly type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
378
- readonly required: false;
379
- readonly validator: ((val: unknown) => boolean) | undefined;
380
- __epPropKey: true;
381
- } & {
382
- readonly default: () => void;
383
- };
384
- readonly onChange: {
385
- readonly type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
386
- readonly required: false;
387
- readonly validator: ((val: unknown) => boolean) | undefined;
388
- __epPropKey: true;
389
- } & {
390
- readonly default: () => void;
391
- };
392
- readonly onPreview: {
393
- readonly type: PropType<(uploadFile: UploadFile) => void>;
394
- readonly required: false;
395
- readonly validator: ((val: unknown) => boolean) | undefined;
396
- __epPropKey: true;
397
- } & {
398
- readonly default: () => void;
399
- };
400
- readonly onSuccess: {
401
- readonly type: PropType<(response: any, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
402
- readonly required: false;
403
- readonly validator: ((val: unknown) => boolean) | undefined;
404
- __epPropKey: true;
405
- } & {
406
- readonly default: () => void;
407
- };
408
- readonly onProgress: {
409
- readonly type: PropType<(evt: import('element-plus').UploadProgressEvent, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
410
- readonly required: false;
411
- readonly validator: ((val: unknown) => boolean) | undefined;
412
- __epPropKey: true;
413
- } & {
414
- readonly default: () => void;
415
- };
416
- readonly onError: {
417
- readonly type: PropType<(error: Error, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
418
- readonly required: false;
419
- readonly validator: ((val: unknown) => boolean) | undefined;
420
- __epPropKey: true;
421
- } & {
422
- readonly default: () => void;
423
- };
424
- readonly onExceed: {
425
- readonly type: PropType<(files: File[], uploadFiles: UploadUserFile[]) => void>;
426
- readonly required: false;
427
- readonly validator: ((val: unknown) => boolean) | undefined;
428
- __epPropKey: true;
429
- } & {
430
- readonly default: () => void;
431
- };
432
- readonly crossorigin: {
433
- readonly type: PropType<"" | "anonymous" | "use-credentials">;
434
- readonly required: false;
435
- readonly validator: ((val: unknown) => boolean) | undefined;
436
- __epPropKey: true;
437
- };
438
- readonly action: {
439
- readonly type: PropType<string>;
440
- readonly required: false;
441
- readonly validator: ((val: unknown) => boolean) | undefined;
442
- __epPropKey: true;
443
- } & {
444
- readonly default: "#";
445
- };
446
- readonly headers: {
447
- readonly type: PropType<Record<string, any> | Headers>;
448
- readonly required: false;
449
- readonly validator: ((val: unknown) => boolean) | undefined;
450
- __epPropKey: true;
451
- };
452
- readonly method: {
453
- readonly type: PropType<string>;
454
- readonly required: false;
455
- readonly validator: ((val: unknown) => boolean) | undefined;
456
- __epPropKey: true;
457
- } & {
458
- readonly default: "post";
459
- };
460
- readonly data: {
461
- readonly type: PropType<({
462
- [x: string]: any;
463
- } | Promise<{
464
- [x: string]: any;
465
- }>) | ((rawFile: import('element-plus').UploadRawFile) => {
466
- [x: string]: any;
467
- } | Promise<{
468
- [x: string]: any;
469
- }>)>;
470
- readonly required: false;
471
- readonly validator: ((val: unknown) => boolean) | undefined;
472
- __epPropKey: true;
473
- } & {
474
- readonly default: () => {};
475
- };
476
- readonly multiple: BooleanConstructor;
477
- readonly name: {
478
- readonly type: PropType<string>;
479
- readonly required: false;
480
- readonly validator: ((val: unknown) => boolean) | undefined;
481
- __epPropKey: true;
482
- } & {
483
- readonly default: "file";
484
- };
485
- readonly drag: BooleanConstructor;
486
- readonly withCredentials: BooleanConstructor;
487
- readonly showFileList: {
488
- readonly type: PropType<boolean>;
489
- readonly required: false;
490
- readonly validator: ((val: unknown) => boolean) | undefined;
491
- __epPropKey: true;
492
- } & {
493
- readonly default: true;
494
- };
495
- readonly accept: {
496
- readonly type: PropType<string>;
497
- readonly required: false;
498
- readonly validator: ((val: unknown) => boolean) | undefined;
499
- __epPropKey: true;
500
- } & {
501
- readonly default: "";
502
- };
503
- readonly fileList: {
504
- readonly type: PropType<UploadUserFile[]>;
505
- readonly required: false;
506
- readonly validator: ((val: unknown) => boolean) | undefined;
507
- __epPropKey: true;
508
- } & {
509
- readonly default: () => [];
510
- };
511
- readonly autoUpload: {
512
- readonly type: PropType<boolean>;
513
- readonly required: false;
514
- readonly validator: ((val: unknown) => boolean) | undefined;
515
- __epPropKey: true;
516
- } & {
517
- readonly default: true;
518
- };
519
- readonly listType: {
520
- readonly type: PropType<"picture" | "text" | "picture-card">;
521
- readonly required: false;
522
- readonly validator: ((val: unknown) => boolean) | undefined;
523
- __epPropKey: true;
524
- } & {
525
- readonly default: "text";
526
- };
527
- readonly httpRequest: {
528
- readonly type: PropType<import('element-plus').UploadRequestHandler>;
529
- readonly required: false;
530
- readonly validator: ((val: unknown) => boolean) | undefined;
531
- __epPropKey: true;
532
- } & {
533
- readonly default: import('element-plus').UploadRequestHandler;
534
- };
535
- readonly disabled: BooleanConstructor;
536
- readonly limit: NumberConstructor;
537
- }>>, "name" | "disabled" | "data" | "onChange" | "onError" | "onProgress" | "abort" | "drag" | "submit" | "multiple" | "method" | "action" | "accept" | "listType" | "autoUpload" | "showFileList" | "beforeUpload" | "onRemove" | "onPreview" | "onSuccess" | "onExceed" | "withCredentials" | "fileList" | "httpRequest" | "clearFiles" | "handleStart" | "handleRemove"> & import('vue').ShallowUnwrapRef<{
538
- abort: (file: UploadFile) => void;
539
- submit: () => void;
540
- clearFiles: (states?: import('element-plus').UploadStatus[]) => void;
541
- handleStart: (rawFile: import('element-plus').UploadRawFile) => void;
542
- handleRemove: (file: UploadFile | import('element-plus').UploadRawFile, rawFile?: import('element-plus').UploadRawFile) => void;
543
- }> & {} & import('vue').ComponentCustomProperties & {} & {
544
- $slots: {
545
- file?(_: {
546
- file: UploadFile;
547
- index: number;
548
- }): any;
549
- file?(_: {
550
- file: UploadFile;
551
- index: number;
552
- }): any;
553
- trigger?(_: {}): any;
554
- trigger?(_: {}): any;
555
- default?(_: {}): any;
556
- default?(_: {}): any;
557
- default?(_: {}): any;
558
- tip?(_: {}): any;
559
- };
560
- }) | null;
561
- };
562
- rootEl: HTMLDivElement;
563
- };
564
- type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
565
- declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
7
+ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
566
8
  action: {
567
9
  type: StringConstructor;
568
10
  default: string;
@@ -596,10 +38,6 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
596
38
  default: string;
597
39
  validator: (value: string) => boolean;
598
40
  };
599
- buttonType: {
600
- type: StringConstructor;
601
- default: string;
602
- };
603
41
  buttonText: {
604
42
  type: StringConstructor;
605
43
  default: string;
@@ -620,10 +58,6 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
620
58
  type: BooleanConstructor;
621
59
  default: boolean;
622
60
  };
623
- showMaxSize: {
624
- type: BooleanConstructor;
625
- default: boolean;
626
- };
627
61
  maxSize: {
628
62
  type: NumberConstructor;
629
63
  default: number;
@@ -674,10 +108,6 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
674
108
  default: string;
675
109
  validator: (value: string) => boolean;
676
110
  };
677
- buttonType: {
678
- type: StringConstructor;
679
- default: string;
680
- };
681
111
  buttonText: {
682
112
  type: StringConstructor;
683
113
  default: string;
@@ -698,10 +128,6 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
698
128
  type: BooleanConstructor;
699
129
  default: boolean;
700
130
  };
701
- showMaxSize: {
702
- type: BooleanConstructor;
703
- default: boolean;
704
- };
705
131
  maxSize: {
706
132
  type: NumberConstructor;
707
133
  default: number;
@@ -728,12 +154,10 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
728
154
  limit: number;
729
155
  accept: string;
730
156
  listType: "picture" | "text" | "picture-card";
731
- buttonType: string;
732
157
  buttonText: string;
733
158
  dragText: string;
734
159
  autoUpload: boolean;
735
160
  showFileList: boolean;
736
- showMaxSize: boolean;
737
161
  maxSize: number;
738
162
  showDownload: boolean;
739
163
  }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
@@ -741,72 +165,54 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
741
165
  $: import('vue').ComponentInternalInstance;
742
166
  $data: {};
743
167
  $props: Partial<{
744
- readonly data: ({
745
- [x: string]: any;
746
- } | Promise<{
747
- [x: string]: any;
748
- }>) | ((rawFile: import('element-plus').UploadRawFile) => {
749
- [x: string]: any;
750
- } | Promise<{
751
- [x: string]: any;
752
- }>);
753
- readonly disabled: boolean;
754
- readonly drag: boolean;
755
- readonly multiple: boolean;
756
- readonly name: string;
757
- readonly onChange: (uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
758
- readonly onError: (error: Error, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
759
- readonly onProgress: (evt: import('element-plus').UploadProgressEvent, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
760
- readonly method: string;
761
- readonly action: string;
762
- readonly accept: string;
763
- readonly withCredentials: boolean;
764
- readonly showFileList: boolean;
765
- readonly fileList: UploadUserFile[];
766
- readonly autoUpload: boolean;
767
- readonly listType: "picture" | "text" | "picture-card";
768
- readonly httpRequest: import('element-plus').UploadRequestHandler;
769
- readonly beforeUpload: (rawFile: import('element-plus').UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob | null | undefined> | null | undefined;
770
- readonly onRemove: (uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
771
- readonly onPreview: (uploadFile: UploadFile) => void;
772
- readonly onSuccess: (response: any, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
773
- readonly onExceed: (files: File[], uploadFiles: UploadUserFile[]) => void;
168
+ onChange: import('element-plus').UploadHooks["onChange"];
169
+ disabled: boolean;
170
+ name: string;
171
+ onError: import('element-plus').UploadHooks["onError"];
172
+ onProgress: import('element-plus').UploadHooks["onProgress"];
173
+ data: import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData> | ((rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData>);
174
+ beforeUpload: import('element-plus').UploadHooks["beforeUpload"];
175
+ onRemove: import('element-plus').UploadHooks["onRemove"];
176
+ onPreview: import('element-plus').UploadHooks["onPreview"];
177
+ onSuccess: import('element-plus').UploadHooks["onSuccess"];
178
+ onExceed: import('element-plus').UploadHooks["onExceed"];
179
+ action: string;
180
+ method: string;
181
+ showFileList: boolean;
182
+ accept: string;
183
+ fileList: UploadUserFile[];
184
+ autoUpload: boolean;
185
+ listType: import('element-plus').ListType;
186
+ httpRequest: import('element-plus').UploadRequestHandler;
774
187
  }> & Omit<{
775
188
  readonly name: string;
776
- readonly disabled: boolean;
777
- readonly data: ({
778
- [x: string]: any;
779
- } | Promise<{
780
- [x: string]: any;
781
- }>) | ((rawFile: import('element-plus').UploadRawFile) => {
782
- [x: string]: any;
783
- } | Promise<{
784
- [x: string]: any;
785
- }>);
786
- readonly onChange: (uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
787
- readonly onError: (error: Error, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
788
- readonly onProgress: (evt: import('element-plus').UploadProgressEvent, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
789
- readonly drag: boolean;
790
- readonly multiple: boolean;
791
- readonly method: string;
189
+ readonly data: import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData> | ((rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData>);
190
+ readonly onChange: import('element-plus').UploadHooks["onChange"];
191
+ readonly onError: import('element-plus').UploadHooks["onError"];
192
+ readonly onProgress: import('element-plus').UploadHooks["onProgress"];
792
193
  readonly action: string;
793
194
  readonly accept: string;
794
- readonly listType: "picture" | "text" | "picture-card";
195
+ readonly listType: import('element-plus').ListType;
795
196
  readonly autoUpload: boolean;
796
197
  readonly showFileList: boolean;
797
- readonly beforeUpload: (rawFile: import('element-plus').UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob | null | undefined> | null | undefined;
798
- readonly onRemove: (uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
799
- readonly onPreview: (uploadFile: UploadFile) => void;
800
- readonly onSuccess: (response: any, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
801
- readonly onExceed: (files: File[], uploadFiles: UploadUserFile[]) => void;
802
- readonly withCredentials: boolean;
198
+ readonly onSuccess: import('element-plus').UploadHooks["onSuccess"];
199
+ readonly onRemove: import('element-plus').UploadHooks["onRemove"];
200
+ readonly onExceed: import('element-plus').UploadHooks["onExceed"];
201
+ readonly beforeUpload: import('element-plus').UploadHooks["beforeUpload"];
202
+ readonly onPreview: import('element-plus').UploadHooks["onPreview"];
203
+ readonly method: string;
803
204
  readonly fileList: UploadUserFile[];
804
205
  readonly httpRequest: import('element-plus').UploadRequestHandler;
206
+ readonly disabled?: boolean | undefined;
207
+ readonly drag?: boolean | undefined;
208
+ readonly multiple?: boolean | undefined;
805
209
  readonly limit?: number | undefined;
806
- readonly beforeRemove?: ((uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => boolean | Promise<boolean>) | undefined;
807
- readonly crossorigin?: ("" | "anonymous" | "use-credentials") | undefined;
808
- readonly headers?: (Record<string, any> | Headers) | undefined;
809
- } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "name" | "disabled" | "data" | "onChange" | "onError" | "onProgress" | "drag" | "multiple" | "method" | "action" | "accept" | "listType" | "autoUpload" | "showFileList" | "beforeUpload" | "onRemove" | "onPreview" | "onSuccess" | "onExceed" | "withCredentials" | "fileList" | "httpRequest">;
210
+ readonly beforeRemove?: import('element-plus').UploadHooks["beforeRemove"] | undefined;
211
+ readonly crossorigin?: import('element-plus').Crossorigin | undefined;
212
+ readonly headers?: (Headers | Record<string, any>) | undefined;
213
+ readonly withCredentials?: boolean | undefined;
214
+ readonly directory?: boolean | undefined;
215
+ } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "name" | "disabled" | "data" | "onChange" | "onError" | "onProgress" | "action" | "accept" | "listType" | "autoUpload" | "showFileList" | "onSuccess" | "onRemove" | "onExceed" | "beforeUpload" | "onPreview" | "method" | "fileList" | "httpRequest">;
810
216
  $attrs: {
811
217
  [x: string]: unknown;
812
218
  };
@@ -822,218 +228,132 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
822
228
  $emit: (event: string, ...args: any[]) => void;
823
229
  $el: any;
824
230
  $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
825
- readonly beforeUpload: {
826
- readonly type: PropType<(rawFile: import('element-plus').UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob | null | undefined> | null | undefined>;
827
- readonly required: false;
828
- readonly validator: ((val: unknown) => boolean) | undefined;
829
- __epPropKey: true;
830
- } & {
831
- readonly default: () => void;
231
+ name: {
232
+ type: PropType<string>;
233
+ default: "file";
832
234
  };
833
- readonly beforeRemove: {
834
- readonly type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => boolean | Promise<boolean>>;
835
- readonly required: false;
836
- readonly validator: ((val: unknown) => boolean) | undefined;
837
- __epPropKey: true;
235
+ disabled: {
236
+ type: PropType<boolean>;
237
+ default: undefined;
838
238
  };
839
- readonly onRemove: {
840
- readonly type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
841
- readonly required: false;
842
- readonly validator: ((val: unknown) => boolean) | undefined;
843
- __epPropKey: true;
844
- } & {
845
- readonly default: () => void;
239
+ data: {
240
+ type: PropType<import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus/es/utils/typescript.mjs').Mutable<Record<string, any>>> | ((rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData>)>;
241
+ default: () => import('element-plus/es/utils/typescript.mjs').Mutable<{}>;
846
242
  };
847
- readonly onChange: {
848
- readonly type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
849
- readonly required: false;
850
- readonly validator: ((val: unknown) => boolean) | undefined;
851
- __epPropKey: true;
852
- } & {
853
- readonly default: () => void;
243
+ onChange: {
244
+ type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
245
+ default: () => void;
854
246
  };
855
- readonly onPreview: {
856
- readonly type: PropType<(uploadFile: UploadFile) => void>;
857
- readonly required: false;
858
- readonly validator: ((val: unknown) => boolean) | undefined;
859
- __epPropKey: true;
860
- } & {
861
- readonly default: () => void;
247
+ onError: {
248
+ type: PropType<(error: Error, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
249
+ default: () => void;
862
250
  };
863
- readonly onSuccess: {
864
- readonly type: PropType<(response: any, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
865
- readonly required: false;
866
- readonly validator: ((val: unknown) => boolean) | undefined;
867
- __epPropKey: true;
868
- } & {
869
- readonly default: () => void;
251
+ onProgress: {
252
+ type: PropType<(evt: import('element-plus').UploadProgressEvent, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
253
+ default: () => void;
870
254
  };
871
- readonly onProgress: {
872
- readonly type: PropType<(evt: import('element-plus').UploadProgressEvent, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
873
- readonly required: false;
874
- readonly validator: ((val: unknown) => boolean) | undefined;
875
- __epPropKey: true;
876
- } & {
877
- readonly default: () => void;
255
+ drag: {
256
+ type: PropType<boolean>;
878
257
  };
879
- readonly onError: {
880
- readonly type: PropType<(error: Error, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
881
- readonly required: false;
882
- readonly validator: ((val: unknown) => boolean) | undefined;
883
- __epPropKey: true;
884
- } & {
885
- readonly default: () => void;
258
+ multiple: {
259
+ type: PropType<boolean>;
886
260
  };
887
- readonly onExceed: {
888
- readonly type: PropType<(files: File[], uploadFiles: UploadUserFile[]) => void>;
889
- readonly required: false;
890
- readonly validator: ((val: unknown) => boolean) | undefined;
891
- __epPropKey: true;
892
- } & {
893
- readonly default: () => void;
261
+ action: {
262
+ type: PropType<string>;
263
+ default: "#";
894
264
  };
895
- readonly crossorigin: {
896
- readonly type: PropType<"" | "anonymous" | "use-credentials">;
897
- readonly required: false;
898
- readonly validator: ((val: unknown) => boolean) | undefined;
899
- __epPropKey: true;
265
+ limit: {
266
+ type: PropType<number>;
900
267
  };
901
- readonly action: {
902
- readonly type: PropType<string>;
903
- readonly required: false;
904
- readonly validator: ((val: unknown) => boolean) | undefined;
905
- __epPropKey: true;
906
- } & {
907
- readonly default: "#";
268
+ accept: {
269
+ type: PropType<string>;
270
+ default: "";
908
271
  };
909
- readonly headers: {
910
- readonly type: PropType<Record<string, any> | Headers>;
911
- readonly required: false;
912
- readonly validator: ((val: unknown) => boolean) | undefined;
913
- __epPropKey: true;
272
+ listType: {
273
+ type: PropType<import('element-plus').ListType>;
274
+ default: "text";
914
275
  };
915
- readonly method: {
916
- readonly type: PropType<string>;
917
- readonly required: false;
918
- readonly validator: ((val: unknown) => boolean) | undefined;
919
- __epPropKey: true;
920
- } & {
921
- readonly default: "post";
276
+ autoUpload: {
277
+ type: PropType<boolean>;
278
+ default: true;
922
279
  };
923
- readonly data: {
924
- readonly type: PropType<({
925
- [x: string]: any;
926
- } | Promise<{
927
- [x: string]: any;
928
- }>) | ((rawFile: import('element-plus').UploadRawFile) => {
929
- [x: string]: any;
930
- } | Promise<{
931
- [x: string]: any;
932
- }>)>;
933
- readonly required: false;
934
- readonly validator: ((val: unknown) => boolean) | undefined;
935
- __epPropKey: true;
936
- } & {
937
- readonly default: () => {};
280
+ showFileList: {
281
+ type: PropType<boolean>;
282
+ default: true;
938
283
  };
939
- readonly multiple: BooleanConstructor;
940
- readonly name: {
941
- readonly type: PropType<string>;
942
- readonly required: false;
943
- readonly validator: ((val: unknown) => boolean) | undefined;
944
- __epPropKey: true;
945
- } & {
946
- readonly default: "file";
284
+ onSuccess: {
285
+ type: PropType<(response: any, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
286
+ default: () => void;
947
287
  };
948
- readonly drag: BooleanConstructor;
949
- readonly withCredentials: BooleanConstructor;
950
- readonly showFileList: {
951
- readonly type: PropType<boolean>;
952
- readonly required: false;
953
- readonly validator: ((val: unknown) => boolean) | undefined;
954
- __epPropKey: true;
955
- } & {
956
- readonly default: true;
288
+ onRemove: {
289
+ type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
290
+ default: () => void;
957
291
  };
958
- readonly accept: {
959
- readonly type: PropType<string>;
960
- readonly required: false;
961
- readonly validator: ((val: unknown) => boolean) | undefined;
962
- __epPropKey: true;
963
- } & {
964
- readonly default: "";
292
+ onExceed: {
293
+ type: PropType<(files: File[], uploadFiles: UploadUserFile[]) => void>;
294
+ default: () => void;
965
295
  };
966
- readonly fileList: {
967
- readonly type: PropType<UploadUserFile[]>;
968
- readonly required: false;
969
- readonly validator: ((val: unknown) => boolean) | undefined;
970
- __epPropKey: true;
971
- } & {
972
- readonly default: () => [];
296
+ beforeUpload: {
297
+ type: PropType<(rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<void | undefined | null | boolean | File | Blob>>;
298
+ default: () => void;
973
299
  };
974
- readonly autoUpload: {
975
- readonly type: PropType<boolean>;
976
- readonly required: false;
977
- readonly validator: ((val: unknown) => boolean) | undefined;
978
- __epPropKey: true;
979
- } & {
980
- readonly default: true;
300
+ beforeRemove: {
301
+ type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => import('element-plus/es/utils/typescript.mjs').Awaitable<boolean>>;
981
302
  };
982
- readonly listType: {
983
- readonly type: PropType<"picture" | "text" | "picture-card">;
984
- readonly required: false;
985
- readonly validator: ((val: unknown) => boolean) | undefined;
986
- __epPropKey: true;
987
- } & {
988
- readonly default: "text";
303
+ onPreview: {
304
+ type: PropType<(uploadFile: UploadFile) => void>;
305
+ default: () => void;
989
306
  };
990
- readonly httpRequest: {
991
- readonly type: PropType<import('element-plus').UploadRequestHandler>;
992
- readonly required: false;
993
- readonly validator: ((val: unknown) => boolean) | undefined;
994
- __epPropKey: true;
995
- } & {
996
- readonly default: import('element-plus').UploadRequestHandler;
307
+ crossorigin: {
308
+ type: PropType<import('element-plus').Crossorigin>;
309
+ };
310
+ headers: {
311
+ type: PropType<Record<string, any> | Headers>;
312
+ };
313
+ method: {
314
+ type: PropType<string>;
315
+ default: "post";
316
+ };
317
+ withCredentials: {
318
+ type: PropType<boolean>;
319
+ };
320
+ fileList: {
321
+ type: PropType<UploadUserFile[]>;
322
+ default: () => never[];
323
+ };
324
+ httpRequest: {
325
+ type: PropType<import('element-plus').UploadRequestHandler>;
326
+ default: import('element-plus').UploadRequestHandler;
327
+ };
328
+ directory: {
329
+ type: PropType<boolean>;
997
330
  };
998
- readonly disabled: BooleanConstructor;
999
- readonly limit: NumberConstructor;
1000
331
  }>>, {
1001
- abort: (file: UploadFile) => void;
332
+ abort: (file?: UploadFile) => void;
1002
333
  submit: () => void;
1003
334
  clearFiles: (states?: import('element-plus').UploadStatus[]) => void;
1004
335
  handleStart: (rawFile: import('element-plus').UploadRawFile) => void;
1005
- handleRemove: (file: UploadFile | import('element-plus').UploadRawFile, rawFile?: import('element-plus').UploadRawFile) => void;
1006
- }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
1007
- readonly data: ({
1008
- [x: string]: any;
1009
- } | Promise<{
1010
- [x: string]: any;
1011
- }>) | ((rawFile: import('element-plus').UploadRawFile) => {
1012
- [x: string]: any;
1013
- } | Promise<{
1014
- [x: string]: any;
1015
- }>);
1016
- readonly disabled: boolean;
1017
- readonly drag: boolean;
1018
- readonly multiple: boolean;
1019
- readonly name: string;
1020
- readonly onChange: (uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
1021
- readonly onError: (error: Error, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
1022
- readonly onProgress: (evt: import('element-plus').UploadProgressEvent, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
1023
- readonly method: string;
1024
- readonly action: string;
1025
- readonly accept: string;
1026
- readonly withCredentials: boolean;
1027
- readonly showFileList: boolean;
1028
- readonly fileList: UploadUserFile[];
1029
- readonly autoUpload: boolean;
1030
- readonly listType: "picture" | "text" | "picture-card";
1031
- readonly httpRequest: import('element-plus').UploadRequestHandler;
1032
- readonly beforeUpload: (rawFile: import('element-plus').UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob | null | undefined> | null | undefined;
1033
- readonly onRemove: (uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
1034
- readonly onPreview: (uploadFile: UploadFile) => void;
1035
- readonly onSuccess: (response: any, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
1036
- readonly onExceed: (files: File[], uploadFiles: UploadUserFile[]) => void;
336
+ handleRemove: (file: UploadFile | import('element-plus').UploadRawFile) => void;
337
+ }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
338
+ onChange: import('element-plus').UploadHooks["onChange"];
339
+ disabled: boolean;
340
+ name: string;
341
+ onError: import('element-plus').UploadHooks["onError"];
342
+ onProgress: import('element-plus').UploadHooks["onProgress"];
343
+ data: import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData> | ((rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData>);
344
+ beforeUpload: import('element-plus').UploadHooks["beforeUpload"];
345
+ onRemove: import('element-plus').UploadHooks["onRemove"];
346
+ onPreview: import('element-plus').UploadHooks["onPreview"];
347
+ onSuccess: import('element-plus').UploadHooks["onSuccess"];
348
+ onExceed: import('element-plus').UploadHooks["onExceed"];
349
+ action: string;
350
+ method: string;
351
+ showFileList: boolean;
352
+ accept: string;
353
+ fileList: UploadUserFile[];
354
+ autoUpload: boolean;
355
+ listType: import('element-plus').ListType;
356
+ httpRequest: import('element-plus').UploadRequestHandler;
1037
357
  }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
1038
358
  beforeCreate?: (() => void) | (() => void)[];
1039
359
  created?: (() => void) | (() => void)[];
@@ -1055,241 +375,156 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
1055
375
  $nextTick: typeof import('vue').nextTick;
1056
376
  $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
1057
377
  } & Readonly<{
1058
- readonly data: ({
1059
- [x: string]: any;
1060
- } | Promise<{
1061
- [x: string]: any;
1062
- }>) | ((rawFile: import('element-plus').UploadRawFile) => {
1063
- [x: string]: any;
1064
- } | Promise<{
1065
- [x: string]: any;
1066
- }>);
1067
- readonly disabled: boolean;
1068
- readonly drag: boolean;
1069
- readonly multiple: boolean;
1070
- readonly name: string;
1071
- readonly onChange: (uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
1072
- readonly onError: (error: Error, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
1073
- readonly onProgress: (evt: import('element-plus').UploadProgressEvent, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
1074
- readonly method: string;
1075
- readonly action: string;
1076
- readonly accept: string;
1077
- readonly withCredentials: boolean;
1078
- readonly showFileList: boolean;
1079
- readonly fileList: UploadUserFile[];
1080
- readonly autoUpload: boolean;
1081
- readonly listType: "picture" | "text" | "picture-card";
1082
- readonly httpRequest: import('element-plus').UploadRequestHandler;
1083
- readonly beforeUpload: (rawFile: import('element-plus').UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob | null | undefined> | null | undefined;
1084
- readonly onRemove: (uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
1085
- readonly onPreview: (uploadFile: UploadFile) => void;
1086
- readonly onSuccess: (response: any, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
1087
- readonly onExceed: (files: File[], uploadFiles: UploadUserFile[]) => void;
378
+ onChange: import('element-plus').UploadHooks["onChange"];
379
+ disabled: boolean;
380
+ name: string;
381
+ onError: import('element-plus').UploadHooks["onError"];
382
+ onProgress: import('element-plus').UploadHooks["onProgress"];
383
+ data: import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData> | ((rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData>);
384
+ beforeUpload: import('element-plus').UploadHooks["beforeUpload"];
385
+ onRemove: import('element-plus').UploadHooks["onRemove"];
386
+ onPreview: import('element-plus').UploadHooks["onPreview"];
387
+ onSuccess: import('element-plus').UploadHooks["onSuccess"];
388
+ onExceed: import('element-plus').UploadHooks["onExceed"];
389
+ action: string;
390
+ method: string;
391
+ showFileList: boolean;
392
+ accept: string;
393
+ fileList: UploadUserFile[];
394
+ autoUpload: boolean;
395
+ listType: import('element-plus').ListType;
396
+ httpRequest: import('element-plus').UploadRequestHandler;
1088
397
  }> & Omit<Readonly<import('vue').ExtractPropTypes<{
1089
- readonly beforeUpload: {
1090
- readonly type: PropType<(rawFile: import('element-plus').UploadRawFile) => boolean | void | File | Blob | Promise<boolean | void | File | Blob | null | undefined> | null | undefined>;
1091
- readonly required: false;
1092
- readonly validator: ((val: unknown) => boolean) | undefined;
1093
- __epPropKey: true;
1094
- } & {
1095
- readonly default: () => void;
398
+ name: {
399
+ type: PropType<string>;
400
+ default: "file";
1096
401
  };
1097
- readonly beforeRemove: {
1098
- readonly type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => boolean | Promise<boolean>>;
1099
- readonly required: false;
1100
- readonly validator: ((val: unknown) => boolean) | undefined;
1101
- __epPropKey: true;
402
+ disabled: {
403
+ type: PropType<boolean>;
404
+ default: undefined;
1102
405
  };
1103
- readonly onRemove: {
1104
- readonly type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
1105
- readonly required: false;
1106
- readonly validator: ((val: unknown) => boolean) | undefined;
1107
- __epPropKey: true;
1108
- } & {
1109
- readonly default: () => void;
406
+ data: {
407
+ type: PropType<import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus/es/utils/typescript.mjs').Mutable<Record<string, any>>> | ((rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<import('element-plus').UploadData>)>;
408
+ default: () => import('element-plus/es/utils/typescript.mjs').Mutable<{}>;
1110
409
  };
1111
- readonly onChange: {
1112
- readonly type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
1113
- readonly required: false;
1114
- readonly validator: ((val: unknown) => boolean) | undefined;
1115
- __epPropKey: true;
1116
- } & {
1117
- readonly default: () => void;
410
+ onChange: {
411
+ type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
412
+ default: () => void;
1118
413
  };
1119
- readonly onPreview: {
1120
- readonly type: PropType<(uploadFile: UploadFile) => void>;
1121
- readonly required: false;
1122
- readonly validator: ((val: unknown) => boolean) | undefined;
1123
- __epPropKey: true;
1124
- } & {
1125
- readonly default: () => void;
414
+ onError: {
415
+ type: PropType<(error: Error, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
416
+ default: () => void;
1126
417
  };
1127
- readonly onSuccess: {
1128
- readonly type: PropType<(response: any, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
1129
- readonly required: false;
1130
- readonly validator: ((val: unknown) => boolean) | undefined;
1131
- __epPropKey: true;
1132
- } & {
1133
- readonly default: () => void;
418
+ onProgress: {
419
+ type: PropType<(evt: import('element-plus').UploadProgressEvent, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
420
+ default: () => void;
1134
421
  };
1135
- readonly onProgress: {
1136
- readonly type: PropType<(evt: import('element-plus').UploadProgressEvent, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
1137
- readonly required: false;
1138
- readonly validator: ((val: unknown) => boolean) | undefined;
1139
- __epPropKey: true;
1140
- } & {
1141
- readonly default: () => void;
422
+ drag: {
423
+ type: PropType<boolean>;
1142
424
  };
1143
- readonly onError: {
1144
- readonly type: PropType<(error: Error, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
1145
- readonly required: false;
1146
- readonly validator: ((val: unknown) => boolean) | undefined;
1147
- __epPropKey: true;
1148
- } & {
1149
- readonly default: () => void;
425
+ multiple: {
426
+ type: PropType<boolean>;
1150
427
  };
1151
- readonly onExceed: {
1152
- readonly type: PropType<(files: File[], uploadFiles: UploadUserFile[]) => void>;
1153
- readonly required: false;
1154
- readonly validator: ((val: unknown) => boolean) | undefined;
1155
- __epPropKey: true;
1156
- } & {
1157
- readonly default: () => void;
428
+ action: {
429
+ type: PropType<string>;
430
+ default: "#";
1158
431
  };
1159
- readonly crossorigin: {
1160
- readonly type: PropType<"" | "anonymous" | "use-credentials">;
1161
- readonly required: false;
1162
- readonly validator: ((val: unknown) => boolean) | undefined;
1163
- __epPropKey: true;
432
+ limit: {
433
+ type: PropType<number>;
1164
434
  };
1165
- readonly action: {
1166
- readonly type: PropType<string>;
1167
- readonly required: false;
1168
- readonly validator: ((val: unknown) => boolean) | undefined;
1169
- __epPropKey: true;
1170
- } & {
1171
- readonly default: "#";
435
+ accept: {
436
+ type: PropType<string>;
437
+ default: "";
1172
438
  };
1173
- readonly headers: {
1174
- readonly type: PropType<Record<string, any> | Headers>;
1175
- readonly required: false;
1176
- readonly validator: ((val: unknown) => boolean) | undefined;
1177
- __epPropKey: true;
439
+ listType: {
440
+ type: PropType<import('element-plus').ListType>;
441
+ default: "text";
1178
442
  };
1179
- readonly method: {
1180
- readonly type: PropType<string>;
1181
- readonly required: false;
1182
- readonly validator: ((val: unknown) => boolean) | undefined;
1183
- __epPropKey: true;
1184
- } & {
1185
- readonly default: "post";
443
+ autoUpload: {
444
+ type: PropType<boolean>;
445
+ default: true;
1186
446
  };
1187
- readonly data: {
1188
- readonly type: PropType<({
1189
- [x: string]: any;
1190
- } | Promise<{
1191
- [x: string]: any;
1192
- }>) | ((rawFile: import('element-plus').UploadRawFile) => {
1193
- [x: string]: any;
1194
- } | Promise<{
1195
- [x: string]: any;
1196
- }>)>;
1197
- readonly required: false;
1198
- readonly validator: ((val: unknown) => boolean) | undefined;
1199
- __epPropKey: true;
1200
- } & {
1201
- readonly default: () => {};
447
+ showFileList: {
448
+ type: PropType<boolean>;
449
+ default: true;
1202
450
  };
1203
- readonly multiple: BooleanConstructor;
1204
- readonly name: {
1205
- readonly type: PropType<string>;
1206
- readonly required: false;
1207
- readonly validator: ((val: unknown) => boolean) | undefined;
1208
- __epPropKey: true;
1209
- } & {
1210
- readonly default: "file";
451
+ onSuccess: {
452
+ type: PropType<(response: any, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
453
+ default: () => void;
1211
454
  };
1212
- readonly drag: BooleanConstructor;
1213
- readonly withCredentials: BooleanConstructor;
1214
- readonly showFileList: {
1215
- readonly type: PropType<boolean>;
1216
- readonly required: false;
1217
- readonly validator: ((val: unknown) => boolean) | undefined;
1218
- __epPropKey: true;
1219
- } & {
1220
- readonly default: true;
455
+ onRemove: {
456
+ type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
457
+ default: () => void;
1221
458
  };
1222
- readonly accept: {
1223
- readonly type: PropType<string>;
1224
- readonly required: false;
1225
- readonly validator: ((val: unknown) => boolean) | undefined;
1226
- __epPropKey: true;
1227
- } & {
1228
- readonly default: "";
459
+ onExceed: {
460
+ type: PropType<(files: File[], uploadFiles: UploadUserFile[]) => void>;
461
+ default: () => void;
1229
462
  };
1230
- readonly fileList: {
1231
- readonly type: PropType<UploadUserFile[]>;
1232
- readonly required: false;
1233
- readonly validator: ((val: unknown) => boolean) | undefined;
1234
- __epPropKey: true;
1235
- } & {
1236
- readonly default: () => [];
463
+ beforeUpload: {
464
+ type: PropType<(rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<void | undefined | null | boolean | File | Blob>>;
465
+ default: () => void;
1237
466
  };
1238
- readonly autoUpload: {
1239
- readonly type: PropType<boolean>;
1240
- readonly required: false;
1241
- readonly validator: ((val: unknown) => boolean) | undefined;
1242
- __epPropKey: true;
1243
- } & {
1244
- readonly default: true;
467
+ beforeRemove: {
468
+ type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => import('element-plus/es/utils/typescript.mjs').Awaitable<boolean>>;
1245
469
  };
1246
- readonly listType: {
1247
- readonly type: PropType<"picture" | "text" | "picture-card">;
1248
- readonly required: false;
1249
- readonly validator: ((val: unknown) => boolean) | undefined;
1250
- __epPropKey: true;
1251
- } & {
1252
- readonly default: "text";
470
+ onPreview: {
471
+ type: PropType<(uploadFile: UploadFile) => void>;
472
+ default: () => void;
1253
473
  };
1254
- readonly httpRequest: {
1255
- readonly type: PropType<import('element-plus').UploadRequestHandler>;
1256
- readonly required: false;
1257
- readonly validator: ((val: unknown) => boolean) | undefined;
1258
- __epPropKey: true;
1259
- } & {
1260
- readonly default: import('element-plus').UploadRequestHandler;
474
+ crossorigin: {
475
+ type: PropType<import('element-plus').Crossorigin>;
476
+ };
477
+ headers: {
478
+ type: PropType<Record<string, any> | Headers>;
1261
479
  };
1262
- readonly disabled: BooleanConstructor;
1263
- readonly limit: NumberConstructor;
1264
- }>>, "name" | "disabled" | "data" | "onChange" | "onError" | "onProgress" | "abort" | "drag" | "submit" | "multiple" | "method" | "action" | "accept" | "listType" | "autoUpload" | "showFileList" | "beforeUpload" | "onRemove" | "onPreview" | "onSuccess" | "onExceed" | "withCredentials" | "fileList" | "httpRequest" | "clearFiles" | "handleStart" | "handleRemove"> & import('vue').ShallowUnwrapRef<{
1265
- abort: (file: UploadFile) => void;
480
+ method: {
481
+ type: PropType<string>;
482
+ default: "post";
483
+ };
484
+ withCredentials: {
485
+ type: PropType<boolean>;
486
+ };
487
+ fileList: {
488
+ type: PropType<UploadUserFile[]>;
489
+ default: () => never[];
490
+ };
491
+ httpRequest: {
492
+ type: PropType<import('element-plus').UploadRequestHandler>;
493
+ default: import('element-plus').UploadRequestHandler;
494
+ };
495
+ directory: {
496
+ type: PropType<boolean>;
497
+ };
498
+ }>>, "name" | "disabled" | "data" | "onChange" | "onError" | "onProgress" | "abort" | "submit" | "action" | "accept" | "listType" | "autoUpload" | "showFileList" | "onSuccess" | "onRemove" | "onExceed" | "beforeUpload" | "onPreview" | "method" | "fileList" | "httpRequest" | "clearFiles" | "handleStart" | "handleRemove"> & import('vue').ShallowUnwrapRef<{
499
+ abort: (file?: UploadFile) => void;
1266
500
  submit: () => void;
1267
501
  clearFiles: (states?: import('element-plus').UploadStatus[]) => void;
1268
502
  handleStart: (rawFile: import('element-plus').UploadRawFile) => void;
1269
- handleRemove: (file: UploadFile | import('element-plus').UploadRawFile, rawFile?: import('element-plus').UploadRawFile) => void;
503
+ handleRemove: (file: UploadFile | import('element-plus').UploadRawFile) => void;
1270
504
  }> & {} & import('vue').ComponentCustomProperties & {} & {
1271
505
  $slots: {
1272
- file?(_: {
506
+ file?: (props: {
1273
507
  file: UploadFile;
1274
508
  index: number;
1275
- }): any;
1276
- file?(_: {
509
+ }) => any;
510
+ } & {
511
+ trigger?: (props: {}) => any;
512
+ } & {
513
+ default?: (props: {}) => any;
514
+ } & {
515
+ trigger?: (props: {}) => any;
516
+ } & {
517
+ default?: (props: {}) => any;
518
+ } & {
519
+ default?: (props: {}) => any;
520
+ } & {
521
+ tip?: (props: {}) => any;
522
+ } & {
523
+ file?: (props: {
1277
524
  file: UploadFile;
1278
525
  index: number;
1279
- }): any;
1280
- trigger?(_: {}): any;
1281
- trigger?(_: {}): any;
1282
- default?(_: {}): any;
1283
- default?(_: {}): any;
1284
- default?(_: {}): any;
1285
- tip?(_: {}): any;
526
+ }) => any;
1286
527
  };
1287
528
  }) | null;
1288
529
  }, HTMLDivElement>;
1289
- declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
1290
530
  export default _default;
1291
- type __VLS_WithTemplateSlots<T, S> = T & {
1292
- new (): {
1293
- $slots: S;
1294
- };
1295
- };