ra-element 0.1.88 → 0.1.90

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 +7 -1
  3. package/docs/ra-upload.md +3 -1
  4. package/lib/components/ra-button/index.vue.d.ts +440 -348
  5. package/lib/components/ra-date-picker/index.vue.d.ts +647 -483
  6. package/lib/components/ra-dialog/index.vue.d.ts +764 -516
  7. package/lib/components/ra-input/index.vue.d.ts +790 -544
  8. package/lib/components/ra-table/component/top-module.vue.d.ts +6 -8
  9. package/lib/components/ra-textarea/index.vue.d.ts +416 -293
  10. package/lib/components/ra-tool-tip/index.vue.d.ts +1152 -806
  11. package/lib/components/ra-tree-select/index.vue.d.ts +278 -517
  12. package/lib/components/ra-upload/index.vue.d.ts +1024 -259
  13. package/lib/ra-element.css +1 -1
  14. package/lib/ra-element.es.js +1325 -1260
  15. package/lib/ra-element.es.js.map +1 -1
  16. package/lib/ra-element.umd.js +1 -1
  17. package/lib/ra-element.umd.js.map +1 -1
  18. package/package.json +1 -1
  19. package/lib/components/ra-form/index.vue.d.ts +0 -523
  20. package/lib/components/ra-select/type.d.ts +0 -5
  21. package/lib/components/ra-table/index.vue.d.ts +0 -3255
  22. package/lib/components/ra-tree-select/type.d.ts +0 -5
package/lib/components/ra-upload/index.vue.d.ts CHANGED
@@ -4,7 +4,565 @@ interface UploadFileGroup extends UploadUserFile {
4
4
  fileName?: string;
5
5
  raId?: string;
6
6
  }
7
- declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
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<{
8
566
  action: {
9
567
  type: StringConstructor;
10
568
  default: string;
@@ -38,6 +596,10 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
38
596
  default: string;
39
597
  validator: (value: string) => boolean;
40
598
  };
599
+ buttonType: {
600
+ type: StringConstructor;
601
+ default: string;
602
+ };
41
603
  buttonText: {
42
604
  type: StringConstructor;
43
605
  default: string;
@@ -58,6 +620,10 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
58
620
  type: BooleanConstructor;
59
621
  default: boolean;
60
622
  };
623
+ showMaxSize: {
624
+ type: BooleanConstructor;
625
+ default: boolean;
626
+ };
61
627
  maxSize: {
62
628
  type: NumberConstructor;
63
629
  default: number;
@@ -108,6 +674,10 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
108
674
  default: string;
109
675
  validator: (value: string) => boolean;
110
676
  };
677
+ buttonType: {
678
+ type: StringConstructor;
679
+ default: string;
680
+ };
111
681
  buttonText: {
112
682
  type: StringConstructor;
113
683
  default: string;
@@ -128,6 +698,10 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
128
698
  type: BooleanConstructor;
129
699
  default: boolean;
130
700
  };
701
+ showMaxSize: {
702
+ type: BooleanConstructor;
703
+ default: boolean;
704
+ };
131
705
  maxSize: {
132
706
  type: NumberConstructor;
133
707
  default: number;
@@ -154,10 +728,12 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
154
728
  limit: number;
155
729
  accept: string;
156
730
  listType: "picture" | "text" | "picture-card";
731
+ buttonType: string;
157
732
  buttonText: string;
158
733
  dragText: string;
159
734
  autoUpload: boolean;
160
735
  showFileList: boolean;
736
+ showMaxSize: boolean;
161
737
  maxSize: number;
162
738
  showDownload: boolean;
163
739
  }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
@@ -165,54 +741,72 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
165
741
  $: import('vue').ComponentInternalInstance;
166
742
  $data: {};
167
743
  $props: Partial<{
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;
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;
187
774
  }> & Omit<{
188
775
  readonly name: 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"];
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;
193
792
  readonly action: string;
194
793
  readonly accept: string;
195
- readonly listType: import('element-plus').ListType;
794
+ readonly listType: "picture" | "text" | "picture-card";
196
795
  readonly autoUpload: boolean;
197
796
  readonly showFileList: 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;
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;
204
803
  readonly fileList: UploadUserFile[];
205
804
  readonly httpRequest: import('element-plus').UploadRequestHandler;
206
- readonly disabled?: boolean | undefined;
207
- readonly drag?: boolean | undefined;
208
- readonly multiple?: boolean | undefined;
209
805
  readonly limit?: number | undefined;
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">;
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">;
216
810
  $attrs: {
217
811
  [x: string]: unknown;
218
812
  };
@@ -228,132 +822,218 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
228
822
  $emit: (event: string, ...args: any[]) => void;
229
823
  $el: any;
230
824
  $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
231
- name: {
232
- type: PropType<string>;
233
- default: "file";
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;
234
832
  };
235
- disabled: {
236
- type: PropType<boolean>;
237
- default: undefined;
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;
238
838
  };
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<{}>;
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;
242
846
  };
243
- onChange: {
244
- type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
245
- default: () => void;
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;
246
854
  };
247
- onError: {
248
- type: PropType<(error: Error, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
249
- default: () => void;
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;
250
862
  };
251
- onProgress: {
252
- type: PropType<(evt: import('element-plus').UploadProgressEvent, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
253
- default: () => void;
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;
254
870
  };
255
- drag: {
256
- type: PropType<boolean>;
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;
257
878
  };
258
- multiple: {
259
- type: PropType<boolean>;
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;
260
886
  };
261
- action: {
262
- type: PropType<string>;
263
- default: "#";
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;
264
894
  };
265
- limit: {
266
- type: PropType<number>;
895
+ readonly crossorigin: {
896
+ readonly type: PropType<"" | "anonymous" | "use-credentials">;
897
+ readonly required: false;
898
+ readonly validator: ((val: unknown) => boolean) | undefined;
899
+ __epPropKey: true;
267
900
  };
268
- accept: {
269
- type: PropType<string>;
270
- default: "";
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: "#";
271
908
  };
272
- listType: {
273
- type: PropType<import('element-plus').ListType>;
274
- default: "text";
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;
275
914
  };
276
- autoUpload: {
277
- type: PropType<boolean>;
278
- default: true;
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";
279
922
  };
280
- showFileList: {
281
- type: PropType<boolean>;
282
- default: true;
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: () => {};
283
938
  };
284
- onSuccess: {
285
- type: PropType<(response: any, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
286
- default: () => void;
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";
287
947
  };
288
- onRemove: {
289
- type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
290
- default: () => void;
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;
291
957
  };
292
- onExceed: {
293
- type: PropType<(files: File[], uploadFiles: UploadUserFile[]) => void>;
294
- default: () => void;
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: "";
295
965
  };
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;
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: () => [];
299
973
  };
300
- beforeRemove: {
301
- type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => import('element-plus/es/utils/typescript.mjs').Awaitable<boolean>>;
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;
302
981
  };
303
- onPreview: {
304
- type: PropType<(uploadFile: UploadFile) => void>;
305
- default: () => void;
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";
306
989
  };
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>;
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;
330
997
  };
998
+ readonly disabled: BooleanConstructor;
999
+ readonly limit: NumberConstructor;
331
1000
  }>>, {
332
- abort: (file?: UploadFile) => void;
1001
+ abort: (file: UploadFile) => void;
333
1002
  submit: () => void;
334
1003
  clearFiles: (states?: import('element-plus').UploadStatus[]) => void;
335
1004
  handleStart: (rawFile: import('element-plus').UploadRawFile) => 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;
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;
357
1037
  }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
358
1038
  beforeCreate?: (() => void) | (() => void)[];
359
1039
  created?: (() => void) | (() => void)[];
@@ -375,156 +1055,241 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
375
1055
  $nextTick: typeof import('vue').nextTick;
376
1056
  $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;
377
1057
  } & Readonly<{
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;
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;
397
1088
  }> & Omit<Readonly<import('vue').ExtractPropTypes<{
398
- name: {
399
- type: PropType<string>;
400
- default: "file";
401
- };
402
- disabled: {
403
- type: PropType<boolean>;
404
- default: undefined;
405
- };
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<{}>;
409
- };
410
- onChange: {
411
- type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
412
- default: () => void;
413
- };
414
- onError: {
415
- type: PropType<(error: Error, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
416
- default: () => void;
417
- };
418
- onProgress: {
419
- type: PropType<(evt: import('element-plus').UploadProgressEvent, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
420
- default: () => void;
421
- };
422
- drag: {
423
- type: PropType<boolean>;
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;
424
1096
  };
425
- multiple: {
426
- type: PropType<boolean>;
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;
427
1102
  };
428
- action: {
429
- type: PropType<string>;
430
- default: "#";
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;
431
1110
  };
432
- limit: {
433
- type: PropType<number>;
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;
434
1118
  };
435
- accept: {
436
- type: PropType<string>;
437
- default: "";
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;
438
1126
  };
439
- listType: {
440
- type: PropType<import('element-plus').ListType>;
441
- default: "text";
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;
442
1134
  };
443
- autoUpload: {
444
- type: PropType<boolean>;
445
- default: true;
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;
446
1142
  };
447
- showFileList: {
448
- type: PropType<boolean>;
449
- default: true;
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;
450
1150
  };
451
- onSuccess: {
452
- type: PropType<(response: any, uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
453
- default: () => void;
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;
454
1158
  };
455
- onRemove: {
456
- type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
457
- default: () => void;
1159
+ readonly crossorigin: {
1160
+ readonly type: PropType<"" | "anonymous" | "use-credentials">;
1161
+ readonly required: false;
1162
+ readonly validator: ((val: unknown) => boolean) | undefined;
1163
+ __epPropKey: true;
458
1164
  };
459
- onExceed: {
460
- type: PropType<(files: File[], uploadFiles: UploadUserFile[]) => void>;
461
- default: () => void;
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: "#";
462
1172
  };
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;
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;
466
1178
  };
467
- beforeRemove: {
468
- type: PropType<(uploadFile: UploadFile, uploadFiles: import('element-plus').UploadFiles) => import('element-plus/es/utils/typescript.mjs').Awaitable<boolean>>;
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";
469
1186
  };
470
- onPreview: {
471
- type: PropType<(uploadFile: UploadFile) => void>;
472
- default: () => void;
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: () => {};
473
1202
  };
474
- crossorigin: {
475
- type: PropType<import('element-plus').Crossorigin>;
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";
476
1211
  };
477
- headers: {
478
- type: PropType<Record<string, any> | Headers>;
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;
479
1221
  };
480
- method: {
481
- type: PropType<string>;
482
- default: "post";
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: "";
483
1229
  };
484
- withCredentials: {
485
- type: PropType<boolean>;
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: () => [];
486
1237
  };
487
- fileList: {
488
- type: PropType<UploadUserFile[]>;
489
- default: () => never[];
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;
490
1245
  };
491
- httpRequest: {
492
- type: PropType<import('element-plus').UploadRequestHandler>;
493
- default: import('element-plus').UploadRequestHandler;
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";
494
1253
  };
495
- directory: {
496
- type: PropType<boolean>;
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;
497
1261
  };
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;
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;
500
1266
  submit: () => void;
501
1267
  clearFiles: (states?: import('element-plus').UploadStatus[]) => void;
502
1268
  handleStart: (rawFile: import('element-plus').UploadRawFile) => void;
503
- handleRemove: (file: UploadFile | import('element-plus').UploadRawFile) => void;
1269
+ handleRemove: (file: UploadFile | import('element-plus').UploadRawFile, rawFile?: import('element-plus').UploadRawFile) => void;
504
1270
  }> & {} & import('vue').ComponentCustomProperties & {} & {
505
1271
  $slots: {
506
- file?: (props: {
1272
+ file?(_: {
507
1273
  file: UploadFile;
508
1274
  index: number;
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: {
1275
+ }): any;
1276
+ file?(_: {
524
1277
  file: UploadFile;
525
1278
  index: number;
526
- }) => any;
1279
+ }): any;
1280
+ trigger?(_: {}): any;
1281
+ trigger?(_: {}): any;
1282
+ default?(_: {}): any;
1283
+ default?(_: {}): any;
1284
+ default?(_: {}): any;
1285
+ tip?(_: {}): any;
527
1286
  };
528
1287
  }) | null;
529
1288
  }, HTMLDivElement>;
1289
+ declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
530
1290
  export default _default;
1291
+ type __VLS_WithTemplateSlots<T, S> = T & {
1292
+ new (): {
1293
+ $slots: S;
1294
+ };
1295
+ };