ra-element 0.1.4 → 0.1.6

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 (26) hide show
  1. package/README.md +8 -1
  2. package/docs/ra-select.md +1 -0
  3. package/lib/components/index.d.ts +20 -1
  4. package/lib/components/ra-auto-scroll/index.vue.d.ts +100 -76
  5. package/lib/components/ra-button/index.vue.d.ts +772 -599
  6. package/lib/components/ra-checkbox-group/index.vue.d.ts +442 -329
  7. package/lib/components/ra-date-picker/index.vue.d.ts +1261 -1062
  8. package/lib/components/ra-dialog/index.vue.d.ts +1130 -931
  9. package/lib/components/ra-dialog-select/index.vue.d.ts +81 -57
  10. package/lib/components/ra-help-tip/index.vue.d.ts +65 -41
  11. package/lib/components/ra-input/index.vue.d.ts +1256 -1042
  12. package/lib/components/ra-pagination/index.vue.d.ts +643 -528
  13. package/lib/components/ra-radio-group/index.vue.d.ts +538 -425
  14. package/lib/components/ra-select/index.vue.d.ts +1759 -1647
  15. package/lib/components/ra-svg/index.vue.d.ts +35 -11
  16. package/lib/components/ra-table/component/pagination-group.vue.d.ts +104 -80
  17. package/lib/components/ra-textarea/index.vue.d.ts +55 -31
  18. package/lib/components/ra-tool-tip/index.vue.d.ts +38 -14
  19. package/lib/components/ra-tree-select/index.vue.d.ts +59 -35
  20. package/lib/components/ra-upload/index.vue.d.ts +173 -149
  21. package/lib/index.d.ts +6 -6
  22. package/lib/ra-element.css +1 -1
  23. package/lib/ra-element.es.js +2078 -2072
  24. package/lib/ra-element.umd.js +13 -13
  25. package/package.json +1 -1
  26. package/lib/index-CkAUSFIX.js +0 -4
package/lib/components/ra-button/index.vue.d.ts CHANGED
@@ -11,609 +11,782 @@ declare function __VLS_template(): {
11
11
  rootEl: any;
12
12
  };
13
13
  type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
14
- declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
15
- click: {
16
- type: FunctionConstructor;
17
- default: undefined;
18
- };
19
- cssStyle: {
20
- type: StringConstructor;
21
- default: string;
22
- };
23
- }>, {
24
- component: import('vue').Ref<({
25
- $: import('vue').ComponentInternalInstance;
26
- $data: {};
27
- $props: Partial<{
28
- readonly link: boolean;
29
- readonly circle: boolean;
30
- readonly text: boolean;
31
- readonly disabled: boolean;
32
- readonly round: boolean;
33
- readonly dark: boolean;
34
- readonly type: "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger";
35
- readonly bg: boolean;
36
- readonly loading: boolean;
37
- readonly autofocus: boolean;
38
- readonly tag: string | import('vue').Component;
39
- readonly plain: boolean;
40
- readonly nativeType: "button" | "reset" | "submit";
41
- readonly loadingIcon: string | import('vue').Component;
42
- readonly autoInsertSpace: boolean;
43
- }> & Omit<{
44
- readonly disabled: boolean;
45
- readonly type: "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger";
46
- readonly link: boolean;
47
- readonly circle: boolean;
48
- readonly text: boolean;
49
- readonly nativeType: "button" | "reset" | "submit";
50
- readonly loading: boolean;
51
- readonly bg: boolean;
52
- readonly autofocus: boolean;
53
- readonly dark: boolean;
54
- readonly tag: string | import('vue').Component;
55
- readonly size?: ("" | "default" | "small" | "large") | undefined;
56
- readonly icon?: (string | import('vue').Component) | undefined;
57
- readonly loadingIcon?: (string | import('vue').Component) | undefined;
58
- readonly plain?: boolean | undefined;
59
- readonly round?: boolean | undefined;
60
- readonly color?: string | undefined;
61
- readonly autoInsertSpace?: boolean | undefined;
62
- onClick?: ((evt: MouseEvent) => any) | undefined | undefined;
63
- } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "type" | "link" | "circle" | "text" | "nativeType" | "loading" | "loadingIcon" | "plain" | "bg" | "autofocus" | "round" | "dark" | "autoInsertSpace" | "tag">;
64
- $attrs: {
65
- [x: string]: unknown;
14
+ declare const __VLS_component: import('vue').DefineComponent<
15
+ import('vue').ExtractPropTypes<{
16
+ click: {
17
+ type: FunctionConstructor;
18
+ default: undefined;
66
19
  };
67
- $refs: {
68
- [x: string]: unknown;
20
+ cssStyle: {
21
+ type: StringConstructor;
22
+ default: string;
69
23
  };
70
- $slots: Readonly<{
71
- [name: string]: import('vue').Slot<any> | undefined;
72
- }>;
73
- $root: import('vue').ComponentPublicInstance | null;
74
- $parent: import('vue').ComponentPublicInstance | null;
75
- $host: Element | null;
76
- $emit: (event: "click", evt: MouseEvent) => void;
77
- $el: any;
78
- $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
79
- readonly size: {
80
- readonly type: import('vue').PropType<"" | "default" | "small" | "large">;
81
- readonly required: false;
82
- readonly validator: ((val: unknown) => boolean) | undefined;
83
- __epPropKey: true;
84
- };
85
- readonly disabled: BooleanConstructor;
86
- readonly type: {
87
- readonly type: import('vue').PropType<"" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger">;
88
- readonly required: false;
89
- readonly validator: ((val: unknown) => boolean) | undefined;
90
- __epPropKey: true;
91
- } & {
92
- readonly default: "";
93
- };
94
- readonly icon: {
95
- readonly type: import('vue').PropType<string | import('vue').Component>;
96
- readonly required: false;
97
- readonly validator: ((val: unknown) => boolean) | undefined;
98
- __epPropKey: true;
99
- };
100
- readonly nativeType: {
101
- readonly type: import('vue').PropType<"button" | "reset" | "submit">;
102
- readonly required: false;
103
- readonly validator: ((val: unknown) => boolean) | undefined;
104
- __epPropKey: true;
105
- } & {
106
- readonly default: "button";
107
- };
108
- readonly loading: BooleanConstructor;
109
- readonly loadingIcon: {
110
- readonly type: import('vue').PropType<string | import('vue').Component>;
111
- readonly required: false;
112
- readonly validator: ((val: unknown) => boolean) | undefined;
113
- __epPropKey: true;
114
- } & {
115
- readonly default: () => any;
24
+ }>,
25
+ {
26
+ component: import('vue').Ref<
27
+ | ({
28
+ $: import('vue').ComponentInternalInstance;
29
+ $data: {};
30
+ $props: Partial<{
31
+ readonly link: boolean;
32
+ readonly circle: boolean;
33
+ readonly text: boolean;
34
+ readonly disabled: boolean;
35
+ readonly round: boolean;
36
+ readonly dark: boolean;
37
+ readonly type: '' | 'default' | 'text' | 'primary' | 'success' | 'warning' | 'info' | 'danger';
38
+ readonly bg: boolean;
39
+ readonly loading: boolean;
40
+ readonly autofocus: boolean;
41
+ readonly tag: string | import('vue').Component;
42
+ readonly plain: boolean;
43
+ readonly nativeType: 'button' | 'reset' | 'submit';
44
+ readonly loadingIcon: string | import('vue').Component;
45
+ readonly autoInsertSpace: boolean;
46
+ }> &
47
+ Omit<
48
+ {
49
+ readonly disabled: boolean;
50
+ readonly type: '' | 'default' | 'text' | 'primary' | 'success' | 'warning' | 'info' | 'danger';
51
+ readonly link: boolean;
52
+ readonly circle: boolean;
53
+ readonly text: boolean;
54
+ readonly nativeType: 'button' | 'reset' | 'submit';
55
+ readonly loading: boolean;
56
+ readonly bg: boolean;
57
+ readonly autofocus: boolean;
58
+ readonly dark: boolean;
59
+ readonly tag: string | import('vue').Component;
60
+ readonly size?: ('' | 'default' | 'small' | 'large') | undefined;
61
+ readonly icon?: (string | import('vue').Component) | undefined;
62
+ readonly loadingIcon?: (string | import('vue').Component) | undefined;
63
+ readonly plain?: boolean | undefined;
64
+ readonly round?: boolean | undefined;
65
+ readonly color?: string | undefined;
66
+ readonly autoInsertSpace?: boolean | undefined;
67
+ onClick?: ((evt: MouseEvent) => any) | undefined | undefined;
68
+ } & import('vue').VNodeProps &
69
+ import('vue').AllowedComponentProps &
70
+ import('vue').ComponentCustomProps,
71
+ | 'disabled'
72
+ | 'type'
73
+ | 'link'
74
+ | 'circle'
75
+ | 'text'
76
+ | 'nativeType'
77
+ | 'loading'
78
+ | 'loadingIcon'
79
+ | 'plain'
80
+ | 'bg'
81
+ | 'autofocus'
82
+ | 'round'
83
+ | 'dark'
84
+ | 'autoInsertSpace'
85
+ | 'tag'
86
+ >;
87
+ $attrs: {
88
+ [x: string]: unknown;
89
+ };
90
+ $refs: {
91
+ [x: string]: unknown;
92
+ };
93
+ $slots: Readonly<{
94
+ [name: string]: import('vue').Slot<any> | undefined;
95
+ }>;
96
+ $root: import('vue').ComponentPublicInstance | null;
97
+ $parent: import('vue').ComponentPublicInstance | null;
98
+ $host: Element | null;
99
+ $emit: (event: 'click', evt: MouseEvent) => void;
100
+ $el: any;
101
+ $options: import('vue').ComponentOptionsBase<
102
+ Readonly<
103
+ import('vue').ExtractPropTypes<{
104
+ readonly size: {
105
+ readonly type: import('vue').PropType<'' | 'default' | 'small' | 'large'>;
106
+ readonly required: false;
107
+ readonly validator: ((val: unknown) => boolean) | undefined;
108
+ __epPropKey: true;
109
+ };
110
+ readonly disabled: BooleanConstructor;
111
+ readonly type: {
112
+ readonly type: import('vue').PropType<'' | 'default' | 'text' | 'primary' | 'success' | 'warning' | 'info' | 'danger'>;
113
+ readonly required: false;
114
+ readonly validator: ((val: unknown) => boolean) | undefined;
115
+ __epPropKey: true;
116
+ } & {
117
+ readonly default: '';
118
+ };
119
+ readonly icon: {
120
+ readonly type: import('vue').PropType<string | import('vue').Component>;
121
+ readonly required: false;
122
+ readonly validator: ((val: unknown) => boolean) | undefined;
123
+ __epPropKey: true;
124
+ };
125
+ readonly nativeType: {
126
+ readonly type: import('vue').PropType<'button' | 'reset' | 'submit'>;
127
+ readonly required: false;
128
+ readonly validator: ((val: unknown) => boolean) | undefined;
129
+ __epPropKey: true;
130
+ } & {
131
+ readonly default: 'button';
132
+ };
133
+ readonly loading: BooleanConstructor;
134
+ readonly loadingIcon: {
135
+ readonly type: import('vue').PropType<string | import('vue').Component>;
136
+ readonly required: false;
137
+ readonly validator: ((val: unknown) => boolean) | undefined;
138
+ __epPropKey: true;
139
+ } & {
140
+ readonly default: () => any;
141
+ };
142
+ readonly plain: {
143
+ readonly type: import('vue').PropType<boolean>;
144
+ readonly required: false;
145
+ readonly validator: ((val: unknown) => boolean) | undefined;
146
+ __epPropKey: true;
147
+ } & {
148
+ readonly default: undefined;
149
+ };
150
+ readonly text: BooleanConstructor;
151
+ readonly link: BooleanConstructor;
152
+ readonly bg: BooleanConstructor;
153
+ readonly autofocus: BooleanConstructor;
154
+ readonly round: {
155
+ readonly type: import('vue').PropType<boolean>;
156
+ readonly required: false;
157
+ readonly validator: ((val: unknown) => boolean) | undefined;
158
+ __epPropKey: true;
159
+ } & {
160
+ readonly default: undefined;
161
+ };
162
+ readonly circle: BooleanConstructor;
163
+ readonly color: StringConstructor;
164
+ readonly dark: BooleanConstructor;
165
+ readonly autoInsertSpace: {
166
+ readonly type: import('vue').PropType<boolean>;
167
+ readonly required: false;
168
+ readonly validator: ((val: unknown) => boolean) | undefined;
169
+ __epPropKey: true;
170
+ } & {
171
+ readonly default: undefined;
172
+ };
173
+ readonly tag: {
174
+ readonly type: import('vue').PropType<string | import('vue').Component>;
175
+ readonly required: false;
176
+ readonly validator: ((val: unknown) => boolean) | undefined;
177
+ __epPropKey: true;
178
+ } & {
179
+ readonly default: 'button';
180
+ };
181
+ }>
182
+ > & {
183
+ onClick?: ((evt: MouseEvent) => any) | undefined;
184
+ },
185
+ {
186
+ ref: import('vue').Ref<HTMLButtonElement | undefined>;
187
+ size: import('vue').ComputedRef<'' | 'small' | 'default' | 'large'>;
188
+ type: import('vue').ComputedRef<string>;
189
+ disabled: import('vue').ComputedRef<boolean>;
190
+ shouldAddSpace: import('vue').ComputedRef<boolean>;
191
+ },
192
+ unknown,
193
+ {},
194
+ {},
195
+ import('vue').ComponentOptionsMixin,
196
+ import('vue').ComponentOptionsMixin,
197
+ {
198
+ click: (evt: MouseEvent) => void;
199
+ },
200
+ string,
201
+ {
202
+ readonly link: boolean;
203
+ readonly circle: boolean;
204
+ readonly text: boolean;
205
+ readonly disabled: boolean;
206
+ readonly round: boolean;
207
+ readonly dark: boolean;
208
+ readonly type: '' | 'default' | 'text' | 'primary' | 'success' | 'warning' | 'info' | 'danger';
209
+ readonly bg: boolean;
210
+ readonly loading: boolean;
211
+ readonly autofocus: boolean;
212
+ readonly tag: string | import('vue').Component;
213
+ readonly plain: boolean;
214
+ readonly nativeType: 'button' | 'reset' | 'submit';
215
+ readonly loadingIcon: string | import('vue').Component;
216
+ readonly autoInsertSpace: boolean;
217
+ },
218
+ {},
219
+ string,
220
+ {},
221
+ import('vue').GlobalComponents,
222
+ import('vue').GlobalDirectives,
223
+ string,
224
+ import('vue').ComponentProvideOptions
225
+ > & {
226
+ beforeCreate?: (() => void) | (() => void)[];
227
+ created?: (() => void) | (() => void)[];
228
+ beforeMount?: (() => void) | (() => void)[];
229
+ mounted?: (() => void) | (() => void)[];
230
+ beforeUpdate?: (() => void) | (() => void)[];
231
+ updated?: (() => void) | (() => void)[];
232
+ activated?: (() => void) | (() => void)[];
233
+ deactivated?: (() => void) | (() => void)[];
234
+ beforeDestroy?: (() => void) | (() => void)[];
235
+ beforeUnmount?: (() => void) | (() => void)[];
236
+ destroyed?: (() => void) | (() => void)[];
237
+ unmounted?: (() => void) | (() => void)[];
238
+ renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
239
+ renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
240
+ errorCaptured?:
241
+ | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)
242
+ | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
243
+ };
244
+ $forceUpdate: () => void;
245
+ $nextTick: typeof import('vue').nextTick;
246
+ $watch<T extends string | ((...args: any) => any)>(
247
+ source: T,
248
+ cb: T extends (...args: any) => infer R
249
+ ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any
250
+ : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any,
251
+ options?: import('vue').WatchOptions,
252
+ ): import('vue').WatchStopHandle;
253
+ } & Readonly<{
254
+ readonly link: boolean;
255
+ readonly circle: boolean;
256
+ readonly text: boolean;
257
+ readonly disabled: boolean;
258
+ readonly round: boolean;
259
+ readonly dark: boolean;
260
+ readonly type: '' | 'default' | 'text' | 'primary' | 'success' | 'warning' | 'info' | 'danger';
261
+ readonly bg: boolean;
262
+ readonly loading: boolean;
263
+ readonly autofocus: boolean;
264
+ readonly tag: string | import('vue').Component;
265
+ readonly plain: boolean;
266
+ readonly nativeType: 'button' | 'reset' | 'submit';
267
+ readonly loadingIcon: string | import('vue').Component;
268
+ readonly autoInsertSpace: boolean;
269
+ }> &
270
+ Omit<
271
+ Readonly<
272
+ import('vue').ExtractPropTypes<{
273
+ readonly size: {
274
+ readonly type: import('vue').PropType<'' | 'default' | 'small' | 'large'>;
275
+ readonly required: false;
276
+ readonly validator: ((val: unknown) => boolean) | undefined;
277
+ __epPropKey: true;
278
+ };
279
+ readonly disabled: BooleanConstructor;
280
+ readonly type: {
281
+ readonly type: import('vue').PropType<'' | 'default' | 'text' | 'primary' | 'success' | 'warning' | 'info' | 'danger'>;
282
+ readonly required: false;
283
+ readonly validator: ((val: unknown) => boolean) | undefined;
284
+ __epPropKey: true;
285
+ } & {
286
+ readonly default: '';
287
+ };
288
+ readonly icon: {
289
+ readonly type: import('vue').PropType<string | import('vue').Component>;
290
+ readonly required: false;
291
+ readonly validator: ((val: unknown) => boolean) | undefined;
292
+ __epPropKey: true;
293
+ };
294
+ readonly nativeType: {
295
+ readonly type: import('vue').PropType<'button' | 'reset' | 'submit'>;
296
+ readonly required: false;
297
+ readonly validator: ((val: unknown) => boolean) | undefined;
298
+ __epPropKey: true;
299
+ } & {
300
+ readonly default: 'button';
301
+ };
302
+ readonly loading: BooleanConstructor;
303
+ readonly loadingIcon: {
304
+ readonly type: import('vue').PropType<string | import('vue').Component>;
305
+ readonly required: false;
306
+ readonly validator: ((val: unknown) => boolean) | undefined;
307
+ __epPropKey: true;
308
+ } & {
309
+ readonly default: () => any;
310
+ };
311
+ readonly plain: {
312
+ readonly type: import('vue').PropType<boolean>;
313
+ readonly required: false;
314
+ readonly validator: ((val: unknown) => boolean) | undefined;
315
+ __epPropKey: true;
316
+ } & {
317
+ readonly default: undefined;
318
+ };
319
+ readonly text: BooleanConstructor;
320
+ readonly link: BooleanConstructor;
321
+ readonly bg: BooleanConstructor;
322
+ readonly autofocus: BooleanConstructor;
323
+ readonly round: {
324
+ readonly type: import('vue').PropType<boolean>;
325
+ readonly required: false;
326
+ readonly validator: ((val: unknown) => boolean) | undefined;
327
+ __epPropKey: true;
328
+ } & {
329
+ readonly default: undefined;
330
+ };
331
+ readonly circle: BooleanConstructor;
332
+ readonly color: StringConstructor;
333
+ readonly dark: BooleanConstructor;
334
+ readonly autoInsertSpace: {
335
+ readonly type: import('vue').PropType<boolean>;
336
+ readonly required: false;
337
+ readonly validator: ((val: unknown) => boolean) | undefined;
338
+ __epPropKey: true;
339
+ } & {
340
+ readonly default: undefined;
341
+ };
342
+ readonly tag: {
343
+ readonly type: import('vue').PropType<string | import('vue').Component>;
344
+ readonly required: false;
345
+ readonly validator: ((val: unknown) => boolean) | undefined;
346
+ __epPropKey: true;
347
+ } & {
348
+ readonly default: 'button';
349
+ };
350
+ }>
351
+ > & {
352
+ onClick?: ((evt: MouseEvent) => any) | undefined;
353
+ },
354
+ | 'disabled'
355
+ | 'type'
356
+ | 'link'
357
+ | 'circle'
358
+ | 'text'
359
+ | 'ref'
360
+ | 'size'
361
+ | 'nativeType'
362
+ | 'loading'
363
+ | 'loadingIcon'
364
+ | 'plain'
365
+ | 'bg'
366
+ | 'autofocus'
367
+ | 'round'
368
+ | 'dark'
369
+ | 'autoInsertSpace'
370
+ | 'tag'
371
+ | 'shouldAddSpace'
372
+ > &
373
+ import('vue').ShallowUnwrapRef<{
374
+ ref: import('vue').Ref<HTMLButtonElement | undefined>;
375
+ size: import('vue').ComputedRef<'' | 'small' | 'default' | 'large'>;
376
+ type: import('vue').ComputedRef<string>;
377
+ disabled: import('vue').ComputedRef<boolean>;
378
+ shouldAddSpace: import('vue').ComputedRef<boolean>;
379
+ }> & {} & import('vue').ComponentCustomProperties & {} & {
380
+ $slots: {
381
+ loading?(_: {}): any;
382
+ icon?(_: {}): any;
383
+ default?(_: {}): any;
384
+ };
385
+ })
386
+ | null,
387
+ | ({
388
+ $: import('vue').ComponentInternalInstance;
389
+ $data: {};
390
+ $props: Partial<{
391
+ readonly link: boolean;
392
+ readonly circle: boolean;
393
+ readonly text: boolean;
394
+ readonly disabled: boolean;
395
+ readonly round: boolean;
396
+ readonly dark: boolean;
397
+ readonly type: '' | 'default' | 'text' | 'primary' | 'success' | 'warning' | 'info' | 'danger';
398
+ readonly bg: boolean;
399
+ readonly loading: boolean;
400
+ readonly autofocus: boolean;
401
+ readonly tag: string | import('vue').Component;
402
+ readonly plain: boolean;
403
+ readonly nativeType: 'button' | 'reset' | 'submit';
404
+ readonly loadingIcon: string | import('vue').Component;
405
+ readonly autoInsertSpace: boolean;
406
+ }> &
407
+ Omit<
408
+ {
409
+ readonly disabled: boolean;
410
+ readonly type: '' | 'default' | 'text' | 'primary' | 'success' | 'warning' | 'info' | 'danger';
411
+ readonly link: boolean;
412
+ readonly circle: boolean;
413
+ readonly text: boolean;
414
+ readonly nativeType: 'button' | 'reset' | 'submit';
415
+ readonly loading: boolean;
416
+ readonly bg: boolean;
417
+ readonly autofocus: boolean;
418
+ readonly dark: boolean;
419
+ readonly tag: string | import('vue').Component;
420
+ readonly size?: ('' | 'default' | 'small' | 'large') | undefined;
421
+ readonly icon?: (string | import('vue').Component) | undefined;
422
+ readonly loadingIcon?: (string | import('vue').Component) | undefined;
423
+ readonly plain?: boolean | undefined;
424
+ readonly round?: boolean | undefined;
425
+ readonly color?: string | undefined;
426
+ readonly autoInsertSpace?: boolean | undefined;
427
+ onClick?: ((evt: MouseEvent) => any) | undefined | undefined;
428
+ } & import('vue').VNodeProps &
429
+ import('vue').AllowedComponentProps &
430
+ import('vue').ComponentCustomProps,
431
+ | 'disabled'
432
+ | 'type'
433
+ | 'link'
434
+ | 'circle'
435
+ | 'text'
436
+ | 'nativeType'
437
+ | 'loading'
438
+ | 'loadingIcon'
439
+ | 'plain'
440
+ | 'bg'
441
+ | 'autofocus'
442
+ | 'round'
443
+ | 'dark'
444
+ | 'autoInsertSpace'
445
+ | 'tag'
446
+ >;
447
+ $attrs: {
448
+ [x: string]: unknown;
449
+ };
450
+ $refs: {
451
+ [x: string]: unknown;
452
+ };
453
+ $slots: Readonly<{
454
+ [name: string]: import('vue').Slot<any> | undefined;
455
+ }>;
456
+ $root: import('vue').ComponentPublicInstance | null;
457
+ $parent: import('vue').ComponentPublicInstance | null;
458
+ $host: Element | null;
459
+ $emit: (event: 'click', evt: MouseEvent) => void;
460
+ $el: any;
461
+ $options: import('vue').ComponentOptionsBase<
462
+ Readonly<
463
+ import('vue').ExtractPropTypes<{
464
+ readonly size: {
465
+ readonly type: import('vue').PropType<'' | 'default' | 'small' | 'large'>;
466
+ readonly required: false;
467
+ readonly validator: ((val: unknown) => boolean) | undefined;
468
+ __epPropKey: true;
469
+ };
470
+ readonly disabled: BooleanConstructor;
471
+ readonly type: {
472
+ readonly type: import('vue').PropType<'' | 'default' | 'text' | 'primary' | 'success' | 'warning' | 'info' | 'danger'>;
473
+ readonly required: false;
474
+ readonly validator: ((val: unknown) => boolean) | undefined;
475
+ __epPropKey: true;
476
+ } & {
477
+ readonly default: '';
478
+ };
479
+ readonly icon: {
480
+ readonly type: import('vue').PropType<string | import('vue').Component>;
481
+ readonly required: false;
482
+ readonly validator: ((val: unknown) => boolean) | undefined;
483
+ __epPropKey: true;
484
+ };
485
+ readonly nativeType: {
486
+ readonly type: import('vue').PropType<'button' | 'reset' | 'submit'>;
487
+ readonly required: false;
488
+ readonly validator: ((val: unknown) => boolean) | undefined;
489
+ __epPropKey: true;
490
+ } & {
491
+ readonly default: 'button';
492
+ };
493
+ readonly loading: BooleanConstructor;
494
+ readonly loadingIcon: {
495
+ readonly type: import('vue').PropType<string | import('vue').Component>;
496
+ readonly required: false;
497
+ readonly validator: ((val: unknown) => boolean) | undefined;
498
+ __epPropKey: true;
499
+ } & {
500
+ readonly default: () => any;
501
+ };
502
+ readonly plain: {
503
+ readonly type: import('vue').PropType<boolean>;
504
+ readonly required: false;
505
+ readonly validator: ((val: unknown) => boolean) | undefined;
506
+ __epPropKey: true;
507
+ } & {
508
+ readonly default: undefined;
509
+ };
510
+ readonly text: BooleanConstructor;
511
+ readonly link: BooleanConstructor;
512
+ readonly bg: BooleanConstructor;
513
+ readonly autofocus: BooleanConstructor;
514
+ readonly round: {
515
+ readonly type: import('vue').PropType<boolean>;
516
+ readonly required: false;
517
+ readonly validator: ((val: unknown) => boolean) | undefined;
518
+ __epPropKey: true;
519
+ } & {
520
+ readonly default: undefined;
521
+ };
522
+ readonly circle: BooleanConstructor;
523
+ readonly color: StringConstructor;
524
+ readonly dark: BooleanConstructor;
525
+ readonly autoInsertSpace: {
526
+ readonly type: import('vue').PropType<boolean>;
527
+ readonly required: false;
528
+ readonly validator: ((val: unknown) => boolean) | undefined;
529
+ __epPropKey: true;
530
+ } & {
531
+ readonly default: undefined;
532
+ };
533
+ readonly tag: {
534
+ readonly type: import('vue').PropType<string | import('vue').Component>;
535
+ readonly required: false;
536
+ readonly validator: ((val: unknown) => boolean) | undefined;
537
+ __epPropKey: true;
538
+ } & {
539
+ readonly default: 'button';
540
+ };
541
+ }>
542
+ > & {
543
+ onClick?: ((evt: MouseEvent) => any) | undefined;
544
+ },
545
+ {
546
+ ref: import('vue').Ref<HTMLButtonElement | undefined>;
547
+ size: import('vue').ComputedRef<'' | 'small' | 'default' | 'large'>;
548
+ type: import('vue').ComputedRef<string>;
549
+ disabled: import('vue').ComputedRef<boolean>;
550
+ shouldAddSpace: import('vue').ComputedRef<boolean>;
551
+ },
552
+ unknown,
553
+ {},
554
+ {},
555
+ import('vue').ComponentOptionsMixin,
556
+ import('vue').ComponentOptionsMixin,
557
+ {
558
+ click: (evt: MouseEvent) => void;
559
+ },
560
+ string,
561
+ {
562
+ readonly link: boolean;
563
+ readonly circle: boolean;
564
+ readonly text: boolean;
565
+ readonly disabled: boolean;
566
+ readonly round: boolean;
567
+ readonly dark: boolean;
568
+ readonly type: '' | 'default' | 'text' | 'primary' | 'success' | 'warning' | 'info' | 'danger';
569
+ readonly bg: boolean;
570
+ readonly loading: boolean;
571
+ readonly autofocus: boolean;
572
+ readonly tag: string | import('vue').Component;
573
+ readonly plain: boolean;
574
+ readonly nativeType: 'button' | 'reset' | 'submit';
575
+ readonly loadingIcon: string | import('vue').Component;
576
+ readonly autoInsertSpace: boolean;
577
+ },
578
+ {},
579
+ string,
580
+ {},
581
+ import('vue').GlobalComponents,
582
+ import('vue').GlobalDirectives,
583
+ string,
584
+ import('vue').ComponentProvideOptions
585
+ > & {
586
+ beforeCreate?: (() => void) | (() => void)[];
587
+ created?: (() => void) | (() => void)[];
588
+ beforeMount?: (() => void) | (() => void)[];
589
+ mounted?: (() => void) | (() => void)[];
590
+ beforeUpdate?: (() => void) | (() => void)[];
591
+ updated?: (() => void) | (() => void)[];
592
+ activated?: (() => void) | (() => void)[];
593
+ deactivated?: (() => void) | (() => void)[];
594
+ beforeDestroy?: (() => void) | (() => void)[];
595
+ beforeUnmount?: (() => void) | (() => void)[];
596
+ destroyed?: (() => void) | (() => void)[];
597
+ unmounted?: (() => void) | (() => void)[];
598
+ renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
599
+ renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
600
+ errorCaptured?:
601
+ | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)
602
+ | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
603
+ };
604
+ $forceUpdate: () => void;
605
+ $nextTick: typeof import('vue').nextTick;
606
+ $watch<T extends string | ((...args: any) => any)>(
607
+ source: T,
608
+ cb: T extends (...args: any) => infer R
609
+ ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any
610
+ : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any,
611
+ options?: import('vue').WatchOptions,
612
+ ): import('vue').WatchStopHandle;
613
+ } & Readonly<{
614
+ readonly link: boolean;
615
+ readonly circle: boolean;
616
+ readonly text: boolean;
617
+ readonly disabled: boolean;
618
+ readonly round: boolean;
619
+ readonly dark: boolean;
620
+ readonly type: '' | 'default' | 'text' | 'primary' | 'success' | 'warning' | 'info' | 'danger';
621
+ readonly bg: boolean;
622
+ readonly loading: boolean;
623
+ readonly autofocus: boolean;
624
+ readonly tag: string | import('vue').Component;
625
+ readonly plain: boolean;
626
+ readonly nativeType: 'button' | 'reset' | 'submit';
627
+ readonly loadingIcon: string | import('vue').Component;
628
+ readonly autoInsertSpace: boolean;
629
+ }> &
630
+ Omit<
631
+ Readonly<
632
+ import('vue').ExtractPropTypes<{
633
+ readonly size: {
634
+ readonly type: import('vue').PropType<'' | 'default' | 'small' | 'large'>;
635
+ readonly required: false;
636
+ readonly validator: ((val: unknown) => boolean) | undefined;
637
+ __epPropKey: true;
638
+ };
639
+ readonly disabled: BooleanConstructor;
640
+ readonly type: {
641
+ readonly type: import('vue').PropType<'' | 'default' | 'text' | 'primary' | 'success' | 'warning' | 'info' | 'danger'>;
642
+ readonly required: false;
643
+ readonly validator: ((val: unknown) => boolean) | undefined;
644
+ __epPropKey: true;
645
+ } & {
646
+ readonly default: '';
647
+ };
648
+ readonly icon: {
649
+ readonly type: import('vue').PropType<string | import('vue').Component>;
650
+ readonly required: false;
651
+ readonly validator: ((val: unknown) => boolean) | undefined;
652
+ __epPropKey: true;
653
+ };
654
+ readonly nativeType: {
655
+ readonly type: import('vue').PropType<'button' | 'reset' | 'submit'>;
656
+ readonly required: false;
657
+ readonly validator: ((val: unknown) => boolean) | undefined;
658
+ __epPropKey: true;
659
+ } & {
660
+ readonly default: 'button';
661
+ };
662
+ readonly loading: BooleanConstructor;
663
+ readonly loadingIcon: {
664
+ readonly type: import('vue').PropType<string | import('vue').Component>;
665
+ readonly required: false;
666
+ readonly validator: ((val: unknown) => boolean) | undefined;
667
+ __epPropKey: true;
668
+ } & {
669
+ readonly default: () => any;
670
+ };
671
+ readonly plain: {
672
+ readonly type: import('vue').PropType<boolean>;
673
+ readonly required: false;
674
+ readonly validator: ((val: unknown) => boolean) | undefined;
675
+ __epPropKey: true;
676
+ } & {
677
+ readonly default: undefined;
678
+ };
679
+ readonly text: BooleanConstructor;
680
+ readonly link: BooleanConstructor;
681
+ readonly bg: BooleanConstructor;
682
+ readonly autofocus: BooleanConstructor;
683
+ readonly round: {
684
+ readonly type: import('vue').PropType<boolean>;
685
+ readonly required: false;
686
+ readonly validator: ((val: unknown) => boolean) | undefined;
687
+ __epPropKey: true;
688
+ } & {
689
+ readonly default: undefined;
690
+ };
691
+ readonly circle: BooleanConstructor;
692
+ readonly color: StringConstructor;
693
+ readonly dark: BooleanConstructor;
694
+ readonly autoInsertSpace: {
695
+ readonly type: import('vue').PropType<boolean>;
696
+ readonly required: false;
697
+ readonly validator: ((val: unknown) => boolean) | undefined;
698
+ __epPropKey: true;
699
+ } & {
700
+ readonly default: undefined;
701
+ };
702
+ readonly tag: {
703
+ readonly type: import('vue').PropType<string | import('vue').Component>;
704
+ readonly required: false;
705
+ readonly validator: ((val: unknown) => boolean) | undefined;
706
+ __epPropKey: true;
707
+ } & {
708
+ readonly default: 'button';
709
+ };
710
+ }>
711
+ > & {
712
+ onClick?: ((evt: MouseEvent) => any) | undefined;
713
+ },
714
+ | 'disabled'
715
+ | 'type'
716
+ | 'link'
717
+ | 'circle'
718
+ | 'text'
719
+ | 'ref'
720
+ | 'size'
721
+ | 'nativeType'
722
+ | 'loading'
723
+ | 'loadingIcon'
724
+ | 'plain'
725
+ | 'bg'
726
+ | 'autofocus'
727
+ | 'round'
728
+ | 'dark'
729
+ | 'autoInsertSpace'
730
+ | 'tag'
731
+ | 'shouldAddSpace'
732
+ > &
733
+ import('vue').ShallowUnwrapRef<{
734
+ ref: import('vue').Ref<HTMLButtonElement | undefined>;
735
+ size: import('vue').ComputedRef<'' | 'small' | 'default' | 'large'>;
736
+ type: import('vue').ComputedRef<string>;
737
+ disabled: import('vue').ComputedRef<boolean>;
738
+ shouldAddSpace: import('vue').ComputedRef<boolean>;
739
+ }> & {} & import('vue').ComponentCustomProperties & {} & {
740
+ $slots: {
741
+ loading?(_: {}): any;
742
+ icon?(_: {}): any;
743
+ default?(_: {}): any;
744
+ };
745
+ })
746
+ | null
747
+ >;
748
+ },
749
+ {},
750
+ {},
751
+ {},
752
+ import('vue').ComponentOptionsMixin,
753
+ import('vue').ComponentOptionsMixin,
754
+ {
755
+ click: (...args: any[]) => void;
756
+ },
757
+ string,
758
+ import('vue').PublicProps,
759
+ Readonly<
760
+ import('vue').ExtractPropTypes<{
761
+ click: {
762
+ type: FunctionConstructor;
763
+ default: undefined;
116
764
  };
117
- readonly plain: {
118
- readonly type: import('vue').PropType<boolean>;
119
- readonly required: false;
120
- readonly validator: ((val: unknown) => boolean) | undefined;
121
- __epPropKey: true;
122
- } & {
123
- readonly default: undefined;
124
- };
125
- readonly text: BooleanConstructor;
126
- readonly link: BooleanConstructor;
127
- readonly bg: BooleanConstructor;
128
- readonly autofocus: BooleanConstructor;
129
- readonly round: {
130
- readonly type: import('vue').PropType<boolean>;
131
- readonly required: false;
132
- readonly validator: ((val: unknown) => boolean) | undefined;
133
- __epPropKey: true;
134
- } & {
135
- readonly default: undefined;
136
- };
137
- readonly circle: BooleanConstructor;
138
- readonly color: StringConstructor;
139
- readonly dark: BooleanConstructor;
140
- readonly autoInsertSpace: {
141
- readonly type: import('vue').PropType<boolean>;
142
- readonly required: false;
143
- readonly validator: ((val: unknown) => boolean) | undefined;
144
- __epPropKey: true;
145
- } & {
146
- readonly default: undefined;
147
- };
148
- readonly tag: {
149
- readonly type: import('vue').PropType<string | import('vue').Component>;
150
- readonly required: false;
151
- readonly validator: ((val: unknown) => boolean) | undefined;
152
- __epPropKey: true;
153
- } & {
154
- readonly default: "button";
155
- };
156
- }>> & {
157
- onClick?: ((evt: MouseEvent) => any) | undefined;
158
- }, {
159
- ref: import('vue').Ref<HTMLButtonElement | undefined>;
160
- size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
161
- type: import('vue').ComputedRef<string>;
162
- disabled: import('vue').ComputedRef<boolean>;
163
- shouldAddSpace: import('vue').ComputedRef<boolean>;
164
- }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
165
- click: (evt: MouseEvent) => void;
166
- }, string, {
167
- readonly link: boolean;
168
- readonly circle: boolean;
169
- readonly text: boolean;
170
- readonly disabled: boolean;
171
- readonly round: boolean;
172
- readonly dark: boolean;
173
- readonly type: "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger";
174
- readonly bg: boolean;
175
- readonly loading: boolean;
176
- readonly autofocus: boolean;
177
- readonly tag: string | import('vue').Component;
178
- readonly plain: boolean;
179
- readonly nativeType: "button" | "reset" | "submit";
180
- readonly loadingIcon: string | import('vue').Component;
181
- readonly autoInsertSpace: boolean;
182
- }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
183
- beforeCreate?: (() => void) | (() => void)[];
184
- created?: (() => void) | (() => void)[];
185
- beforeMount?: (() => void) | (() => void)[];
186
- mounted?: (() => void) | (() => void)[];
187
- beforeUpdate?: (() => void) | (() => void)[];
188
- updated?: (() => void) | (() => void)[];
189
- activated?: (() => void) | (() => void)[];
190
- deactivated?: (() => void) | (() => void)[];
191
- beforeDestroy?: (() => void) | (() => void)[];
192
- beforeUnmount?: (() => void) | (() => void)[];
193
- destroyed?: (() => void) | (() => void)[];
194
- unmounted?: (() => void) | (() => void)[];
195
- renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
196
- renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
197
- errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
198
- };
199
- $forceUpdate: () => void;
200
- $nextTick: typeof import('vue').nextTick;
201
- $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;
202
- } & Readonly<{
203
- readonly link: boolean;
204
- readonly circle: boolean;
205
- readonly text: boolean;
206
- readonly disabled: boolean;
207
- readonly round: boolean;
208
- readonly dark: boolean;
209
- readonly type: "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger";
210
- readonly bg: boolean;
211
- readonly loading: boolean;
212
- readonly autofocus: boolean;
213
- readonly tag: string | import('vue').Component;
214
- readonly plain: boolean;
215
- readonly nativeType: "button" | "reset" | "submit";
216
- readonly loadingIcon: string | import('vue').Component;
217
- readonly autoInsertSpace: boolean;
218
- }> & Omit<Readonly<import('vue').ExtractPropTypes<{
219
- readonly size: {
220
- readonly type: import('vue').PropType<"" | "default" | "small" | "large">;
221
- readonly required: false;
222
- readonly validator: ((val: unknown) => boolean) | undefined;
223
- __epPropKey: true;
224
- };
225
- readonly disabled: BooleanConstructor;
226
- readonly type: {
227
- readonly type: import('vue').PropType<"" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger">;
228
- readonly required: false;
229
- readonly validator: ((val: unknown) => boolean) | undefined;
230
- __epPropKey: true;
231
- } & {
232
- readonly default: "";
233
- };
234
- readonly icon: {
235
- readonly type: import('vue').PropType<string | import('vue').Component>;
236
- readonly required: false;
237
- readonly validator: ((val: unknown) => boolean) | undefined;
238
- __epPropKey: true;
239
- };
240
- readonly nativeType: {
241
- readonly type: import('vue').PropType<"button" | "reset" | "submit">;
242
- readonly required: false;
243
- readonly validator: ((val: unknown) => boolean) | undefined;
244
- __epPropKey: true;
245
- } & {
246
- readonly default: "button";
247
- };
248
- readonly loading: BooleanConstructor;
249
- readonly loadingIcon: {
250
- readonly type: import('vue').PropType<string | import('vue').Component>;
251
- readonly required: false;
252
- readonly validator: ((val: unknown) => boolean) | undefined;
253
- __epPropKey: true;
254
- } & {
255
- readonly default: () => any;
256
- };
257
- readonly plain: {
258
- readonly type: import('vue').PropType<boolean>;
259
- readonly required: false;
260
- readonly validator: ((val: unknown) => boolean) | undefined;
261
- __epPropKey: true;
262
- } & {
263
- readonly default: undefined;
264
- };
265
- readonly text: BooleanConstructor;
266
- readonly link: BooleanConstructor;
267
- readonly bg: BooleanConstructor;
268
- readonly autofocus: BooleanConstructor;
269
- readonly round: {
270
- readonly type: import('vue').PropType<boolean>;
271
- readonly required: false;
272
- readonly validator: ((val: unknown) => boolean) | undefined;
273
- __epPropKey: true;
274
- } & {
275
- readonly default: undefined;
276
- };
277
- readonly circle: BooleanConstructor;
278
- readonly color: StringConstructor;
279
- readonly dark: BooleanConstructor;
280
- readonly autoInsertSpace: {
281
- readonly type: import('vue').PropType<boolean>;
282
- readonly required: false;
283
- readonly validator: ((val: unknown) => boolean) | undefined;
284
- __epPropKey: true;
285
- } & {
286
- readonly default: undefined;
287
- };
288
- readonly tag: {
289
- readonly type: import('vue').PropType<string | import('vue').Component>;
290
- readonly required: false;
291
- readonly validator: ((val: unknown) => boolean) | undefined;
292
- __epPropKey: true;
293
- } & {
294
- readonly default: "button";
295
- };
296
- }>> & {
297
- onClick?: ((evt: MouseEvent) => any) | undefined;
298
- }, "disabled" | "type" | "link" | "circle" | "text" | "ref" | "size" | "nativeType" | "loading" | "loadingIcon" | "plain" | "bg" | "autofocus" | "round" | "dark" | "autoInsertSpace" | "tag" | "shouldAddSpace"> & import('vue').ShallowUnwrapRef<{
299
- ref: import('vue').Ref<HTMLButtonElement | undefined>;
300
- size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
301
- type: import('vue').ComputedRef<string>;
302
- disabled: import('vue').ComputedRef<boolean>;
303
- shouldAddSpace: import('vue').ComputedRef<boolean>;
304
- }> & {} & import('vue').ComponentCustomProperties & {} & {
305
- $slots: {
306
- loading?(_: {}): any;
307
- icon?(_: {}): any;
308
- default?(_: {}): any;
309
- };
310
- }) | null, ({
311
- $: import('vue').ComponentInternalInstance;
312
- $data: {};
313
- $props: Partial<{
314
- readonly link: boolean;
315
- readonly circle: boolean;
316
- readonly text: boolean;
317
- readonly disabled: boolean;
318
- readonly round: boolean;
319
- readonly dark: boolean;
320
- readonly type: "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger";
321
- readonly bg: boolean;
322
- readonly loading: boolean;
323
- readonly autofocus: boolean;
324
- readonly tag: string | import('vue').Component;
325
- readonly plain: boolean;
326
- readonly nativeType: "button" | "reset" | "submit";
327
- readonly loadingIcon: string | import('vue').Component;
328
- readonly autoInsertSpace: boolean;
329
- }> & Omit<{
330
- readonly disabled: boolean;
331
- readonly type: "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger";
332
- readonly link: boolean;
333
- readonly circle: boolean;
334
- readonly text: boolean;
335
- readonly nativeType: "button" | "reset" | "submit";
336
- readonly loading: boolean;
337
- readonly bg: boolean;
338
- readonly autofocus: boolean;
339
- readonly dark: boolean;
340
- readonly tag: string | import('vue').Component;
341
- readonly size?: ("" | "default" | "small" | "large") | undefined;
342
- readonly icon?: (string | import('vue').Component) | undefined;
343
- readonly loadingIcon?: (string | import('vue').Component) | undefined;
344
- readonly plain?: boolean | undefined;
345
- readonly round?: boolean | undefined;
346
- readonly color?: string | undefined;
347
- readonly autoInsertSpace?: boolean | undefined;
348
- onClick?: ((evt: MouseEvent) => any) | undefined | undefined;
349
- } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "type" | "link" | "circle" | "text" | "nativeType" | "loading" | "loadingIcon" | "plain" | "bg" | "autofocus" | "round" | "dark" | "autoInsertSpace" | "tag">;
350
- $attrs: {
351
- [x: string]: unknown;
352
- };
353
- $refs: {
354
- [x: string]: unknown;
355
- };
356
- $slots: Readonly<{
357
- [name: string]: import('vue').Slot<any> | undefined;
358
- }>;
359
- $root: import('vue').ComponentPublicInstance | null;
360
- $parent: import('vue').ComponentPublicInstance | null;
361
- $host: Element | null;
362
- $emit: (event: "click", evt: MouseEvent) => void;
363
- $el: any;
364
- $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
365
- readonly size: {
366
- readonly type: import('vue').PropType<"" | "default" | "small" | "large">;
367
- readonly required: false;
368
- readonly validator: ((val: unknown) => boolean) | undefined;
369
- __epPropKey: true;
765
+ cssStyle: {
766
+ type: StringConstructor;
767
+ default: string;
370
768
  };
371
- readonly disabled: BooleanConstructor;
372
- readonly type: {
373
- readonly type: import('vue').PropType<"" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger">;
374
- readonly required: false;
375
- readonly validator: ((val: unknown) => boolean) | undefined;
376
- __epPropKey: true;
377
- } & {
378
- readonly default: "";
379
- };
380
- readonly icon: {
381
- readonly type: import('vue').PropType<string | import('vue').Component>;
382
- readonly required: false;
383
- readonly validator: ((val: unknown) => boolean) | undefined;
384
- __epPropKey: true;
385
- };
386
- readonly nativeType: {
387
- readonly type: import('vue').PropType<"button" | "reset" | "submit">;
388
- readonly required: false;
389
- readonly validator: ((val: unknown) => boolean) | undefined;
390
- __epPropKey: true;
391
- } & {
392
- readonly default: "button";
393
- };
394
- readonly loading: BooleanConstructor;
395
- readonly loadingIcon: {
396
- readonly type: import('vue').PropType<string | import('vue').Component>;
397
- readonly required: false;
398
- readonly validator: ((val: unknown) => boolean) | undefined;
399
- __epPropKey: true;
400
- } & {
401
- readonly default: () => any;
402
- };
403
- readonly plain: {
404
- readonly type: import('vue').PropType<boolean>;
405
- readonly required: false;
406
- readonly validator: ((val: unknown) => boolean) | undefined;
407
- __epPropKey: true;
408
- } & {
409
- readonly default: undefined;
410
- };
411
- readonly text: BooleanConstructor;
412
- readonly link: BooleanConstructor;
413
- readonly bg: BooleanConstructor;
414
- readonly autofocus: BooleanConstructor;
415
- readonly round: {
416
- readonly type: import('vue').PropType<boolean>;
417
- readonly required: false;
418
- readonly validator: ((val: unknown) => boolean) | undefined;
419
- __epPropKey: true;
420
- } & {
421
- readonly default: undefined;
422
- };
423
- readonly circle: BooleanConstructor;
424
- readonly color: StringConstructor;
425
- readonly dark: BooleanConstructor;
426
- readonly autoInsertSpace: {
427
- readonly type: import('vue').PropType<boolean>;
428
- readonly required: false;
429
- readonly validator: ((val: unknown) => boolean) | undefined;
430
- __epPropKey: true;
431
- } & {
432
- readonly default: undefined;
433
- };
434
- readonly tag: {
435
- readonly type: import('vue').PropType<string | import('vue').Component>;
436
- readonly required: false;
437
- readonly validator: ((val: unknown) => boolean) | undefined;
438
- __epPropKey: true;
439
- } & {
440
- readonly default: "button";
441
- };
442
- }>> & {
443
- onClick?: ((evt: MouseEvent) => any) | undefined;
444
- }, {
445
- ref: import('vue').Ref<HTMLButtonElement | undefined>;
446
- size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
447
- type: import('vue').ComputedRef<string>;
448
- disabled: import('vue').ComputedRef<boolean>;
449
- shouldAddSpace: import('vue').ComputedRef<boolean>;
450
- }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
451
- click: (evt: MouseEvent) => void;
452
- }, string, {
453
- readonly link: boolean;
454
- readonly circle: boolean;
455
- readonly text: boolean;
456
- readonly disabled: boolean;
457
- readonly round: boolean;
458
- readonly dark: boolean;
459
- readonly type: "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger";
460
- readonly bg: boolean;
461
- readonly loading: boolean;
462
- readonly autofocus: boolean;
463
- readonly tag: string | import('vue').Component;
464
- readonly plain: boolean;
465
- readonly nativeType: "button" | "reset" | "submit";
466
- readonly loadingIcon: string | import('vue').Component;
467
- readonly autoInsertSpace: boolean;
468
- }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
469
- beforeCreate?: (() => void) | (() => void)[];
470
- created?: (() => void) | (() => void)[];
471
- beforeMount?: (() => void) | (() => void)[];
472
- mounted?: (() => void) | (() => void)[];
473
- beforeUpdate?: (() => void) | (() => void)[];
474
- updated?: (() => void) | (() => void)[];
475
- activated?: (() => void) | (() => void)[];
476
- deactivated?: (() => void) | (() => void)[];
477
- beforeDestroy?: (() => void) | (() => void)[];
478
- beforeUnmount?: (() => void) | (() => void)[];
479
- destroyed?: (() => void) | (() => void)[];
480
- unmounted?: (() => void) | (() => void)[];
481
- renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
482
- renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
483
- errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
484
- };
485
- $forceUpdate: () => void;
486
- $nextTick: typeof import('vue').nextTick;
487
- $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;
488
- } & Readonly<{
489
- readonly link: boolean;
490
- readonly circle: boolean;
491
- readonly text: boolean;
492
- readonly disabled: boolean;
493
- readonly round: boolean;
494
- readonly dark: boolean;
495
- readonly type: "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger";
496
- readonly bg: boolean;
497
- readonly loading: boolean;
498
- readonly autofocus: boolean;
499
- readonly tag: string | import('vue').Component;
500
- readonly plain: boolean;
501
- readonly nativeType: "button" | "reset" | "submit";
502
- readonly loadingIcon: string | import('vue').Component;
503
- readonly autoInsertSpace: boolean;
504
- }> & Omit<Readonly<import('vue').ExtractPropTypes<{
505
- readonly size: {
506
- readonly type: import('vue').PropType<"" | "default" | "small" | "large">;
507
- readonly required: false;
508
- readonly validator: ((val: unknown) => boolean) | undefined;
509
- __epPropKey: true;
510
- };
511
- readonly disabled: BooleanConstructor;
512
- readonly type: {
513
- readonly type: import('vue').PropType<"" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger">;
514
- readonly required: false;
515
- readonly validator: ((val: unknown) => boolean) | undefined;
516
- __epPropKey: true;
517
- } & {
518
- readonly default: "";
519
- };
520
- readonly icon: {
521
- readonly type: import('vue').PropType<string | import('vue').Component>;
522
- readonly required: false;
523
- readonly validator: ((val: unknown) => boolean) | undefined;
524
- __epPropKey: true;
525
- };
526
- readonly nativeType: {
527
- readonly type: import('vue').PropType<"button" | "reset" | "submit">;
528
- readonly required: false;
529
- readonly validator: ((val: unknown) => boolean) | undefined;
530
- __epPropKey: true;
531
- } & {
532
- readonly default: "button";
533
- };
534
- readonly loading: BooleanConstructor;
535
- readonly loadingIcon: {
536
- readonly type: import('vue').PropType<string | import('vue').Component>;
537
- readonly required: false;
538
- readonly validator: ((val: unknown) => boolean) | undefined;
539
- __epPropKey: true;
540
- } & {
541
- readonly default: () => any;
542
- };
543
- readonly plain: {
544
- readonly type: import('vue').PropType<boolean>;
545
- readonly required: false;
546
- readonly validator: ((val: unknown) => boolean) | undefined;
547
- __epPropKey: true;
548
- } & {
549
- readonly default: undefined;
550
- };
551
- readonly text: BooleanConstructor;
552
- readonly link: BooleanConstructor;
553
- readonly bg: BooleanConstructor;
554
- readonly autofocus: BooleanConstructor;
555
- readonly round: {
556
- readonly type: import('vue').PropType<boolean>;
557
- readonly required: false;
558
- readonly validator: ((val: unknown) => boolean) | undefined;
559
- __epPropKey: true;
560
- } & {
561
- readonly default: undefined;
562
- };
563
- readonly circle: BooleanConstructor;
564
- readonly color: StringConstructor;
565
- readonly dark: BooleanConstructor;
566
- readonly autoInsertSpace: {
567
- readonly type: import('vue').PropType<boolean>;
568
- readonly required: false;
569
- readonly validator: ((val: unknown) => boolean) | undefined;
570
- __epPropKey: true;
571
- } & {
572
- readonly default: undefined;
573
- };
574
- readonly tag: {
575
- readonly type: import('vue').PropType<string | import('vue').Component>;
576
- readonly required: false;
577
- readonly validator: ((val: unknown) => boolean) | undefined;
578
- __epPropKey: true;
579
- } & {
580
- readonly default: "button";
581
- };
582
- }>> & {
583
- onClick?: ((evt: MouseEvent) => any) | undefined;
584
- }, "disabled" | "type" | "link" | "circle" | "text" | "ref" | "size" | "nativeType" | "loading" | "loadingIcon" | "plain" | "bg" | "autofocus" | "round" | "dark" | "autoInsertSpace" | "tag" | "shouldAddSpace"> & import('vue').ShallowUnwrapRef<{
585
- ref: import('vue').Ref<HTMLButtonElement | undefined>;
586
- size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
587
- type: import('vue').ComputedRef<string>;
588
- disabled: import('vue').ComputedRef<boolean>;
589
- shouldAddSpace: import('vue').ComputedRef<boolean>;
590
- }> & {} & import('vue').ComponentCustomProperties & {} & {
591
- $slots: {
592
- loading?(_: {}): any;
593
- icon?(_: {}): any;
594
- default?(_: {}): any;
595
- };
596
- }) | null>;
597
- }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
598
- click: (...args: any[]) => void;
599
- }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
600
- click: {
601
- type: FunctionConstructor;
602
- default: undefined;
603
- };
604
- cssStyle: {
605
- type: StringConstructor;
606
- default: string;
607
- };
608
- }>> & Readonly<{
609
- onClick?: ((...args: any[]) => any) | undefined;
610
- }>, {
611
- click: Function;
612
- cssStyle: string;
613
- }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
614
- componentRef: unknown;
615
- }, any>;
616
- declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
769
+ }>
770
+ > &
771
+ Readonly<{
772
+ onClick?: ((...args: any[]) => any) | undefined;
773
+ }>,
774
+ {
775
+ click: Function;
776
+ cssStyle: string;
777
+ },
778
+ {},
779
+ {},
780
+ {},
781
+ string,
782
+ import('vue').ComponentProvideOptions,
783
+ true,
784
+ {
785
+ componentRef: unknown;
786
+ },
787
+ any
788
+ >;
789
+ declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult['slots']>;
617
790
  export default _default;
618
791
  type __VLS_WithTemplateSlots<T, S> = T & {
619
792
  new (): {