@bobbykim/manguito-theme 0.22.1 → 0.23.1

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.
package/dist/core.d.ts CHANGED
@@ -1,244 +1,550 @@
1
1
  import { ComponentOptionsMixin } from 'vue';
2
+ import { ComponentProvideOptions } from 'vue';
2
3
  import { DefineComponent } from 'vue';
3
4
  import { Directive } from 'vue';
4
- import { ExtractPropTypes } from 'vue';
5
- import { PropType } from 'vue';
6
5
  import { PublicProps } from 'vue';
7
6
  import { Ref } from 'vue';
8
7
  import { RendererElement } from 'vue';
9
8
  import { RendererNode } from 'vue';
10
9
  import { VNode } from 'vue';
11
10
 
12
- declare type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
13
-
14
- declare type __VLS_NonUndefinedable_10<T> = T extends undefined ? never : T;
15
-
16
- declare type __VLS_NonUndefinedable_11<T> = T extends undefined ? never : T;
17
-
18
- declare type __VLS_NonUndefinedable_2<T> = T extends undefined ? never : T;
19
-
20
- declare type __VLS_NonUndefinedable_3<T> = T extends undefined ? never : T;
21
-
22
- declare type __VLS_NonUndefinedable_4<T> = T extends undefined ? never : T;
23
-
24
- declare type __VLS_NonUndefinedable_5<T> = T extends undefined ? never : T;
25
-
26
- declare type __VLS_NonUndefinedable_6<T> = T extends undefined ? never : T;
27
-
28
- declare type __VLS_NonUndefinedable_7<T> = T extends undefined ? never : T;
29
-
30
- declare type __VLS_NonUndefinedable_8<T> = T extends undefined ? never : T;
31
-
32
- declare type __VLS_NonUndefinedable_9<T> = T extends undefined ? never : T;
33
-
34
- declare type __VLS_Prettify<T> = {
35
- [K in keyof T]: T[K];
36
- } & {};
37
-
38
- declare type __VLS_Prettify_10<T> = {
39
- [K in keyof T]: T[K];
40
- } & {};
41
-
42
- declare type __VLS_Prettify_11<T> = {
43
- [K in keyof T]: T[K];
44
- } & {};
45
-
46
- declare type __VLS_Prettify_2<T> = {
47
- [K in keyof T]: T[K];
48
- } & {};
11
+ declare const __VLS_component: DefineComponent< {
12
+ color?: ColorPalette;
13
+ rounded?: boolean;
14
+ shadow?: boolean;
15
+ show?: boolean;
16
+ dismissible?: boolean;
17
+ }, {
18
+ close: () => void;
19
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
20
+ close: (event: Event) => any;
21
+ }, string, PublicProps, Readonly<{
22
+ color?: ColorPalette;
23
+ rounded?: boolean;
24
+ shadow?: boolean;
25
+ show?: boolean;
26
+ dismissible?: boolean;
27
+ }> & Readonly<{
28
+ onClose?: ((event: Event) => any) | undefined;
29
+ }>, {
30
+ color: ColorPalette;
31
+ rounded: boolean;
32
+ shadow: boolean;
33
+ show: boolean;
34
+ dismissible: boolean;
35
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
49
36
 
50
- declare type __VLS_Prettify_3<T> = {
51
- [K in keyof T]: T[K];
52
- } & {};
37
+ declare const __VLS_component_10: DefineComponent< {
38
+ tabNumber: number;
39
+ id: string;
40
+ tabClass?: string | string[];
41
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
42
+ tabNumber: number;
43
+ id: string;
44
+ tabClass?: string | string[];
45
+ }> & Readonly<{}>, {
46
+ tabClass: string | string[];
47
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
48
+
49
+ declare const __VLS_component_11: DefineComponent< {
50
+ bodyClass?: string | string[];
51
+ contentContainerClass?: string | string[];
52
+ controllerTopClass?: string | string[];
53
+ controllerBottomClass?: string | string[];
54
+ loop?: boolean;
55
+ }, {
56
+ numberOfSlides: Ref<number, number>;
57
+ prev: () => void;
58
+ next: () => void;
59
+ setActive: (idx: number) => void;
60
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
61
+ bodyClass?: string | string[];
62
+ contentContainerClass?: string | string[];
63
+ controllerTopClass?: string | string[];
64
+ controllerBottomClass?: string | string[];
65
+ loop?: boolean;
66
+ }> & Readonly<{}>, {
67
+ bodyClass: string | string[];
68
+ contentContainerClass: string | string[];
69
+ controllerTopClass: string | string[];
70
+ controllerBottomClass: string | string[];
71
+ loop: boolean;
72
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
53
73
 
54
- declare type __VLS_Prettify_4<T> = {
55
- [K in keyof T]: T[K];
56
- } & {};
74
+ declare const __VLS_component_12: DefineComponent< {
75
+ slideNumber: number;
76
+ id: string;
77
+ slideClass?: string | string[];
78
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
79
+ slideNumber: number;
80
+ id: string;
81
+ slideClass?: string | string[];
82
+ }> & Readonly<{}>, {
83
+ slideClass: string | string[];
84
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
57
85
 
58
- declare type __VLS_Prettify_5<T> = {
59
- [K in keyof T]: T[K];
60
- } & {};
86
+ declare const __VLS_component_2: DefineComponent< {
87
+ accordion?: string;
88
+ className?: string | string[];
89
+ visible?: boolean;
90
+ }, {
91
+ toggle: () => void;
92
+ close: () => void;
93
+ open: () => void;
94
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
95
+ close: (visible: boolean) => any;
96
+ open: (visible: boolean) => any;
97
+ }, string, PublicProps, Readonly<{
98
+ accordion?: string;
99
+ className?: string | string[];
100
+ visible?: boolean;
101
+ }> & Readonly<{
102
+ onClose?: ((visible: boolean) => any) | undefined;
103
+ onOpen?: ((visible: boolean) => any) | undefined;
104
+ }>, {
105
+ visible: boolean;
106
+ className: string | string[];
107
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
61
108
 
62
- declare type __VLS_Prettify_6<T> = {
63
- [K in keyof T]: T[K];
64
- } & {};
109
+ declare const __VLS_component_3: DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
110
+ toggle: (event: Event) => any;
111
+ "click-outside": (event: Event) => any;
112
+ }, string, PublicProps, Readonly<{}> & Readonly<{
113
+ onToggle?: ((event: Event) => any) | undefined;
114
+ "onClick-outside"?: ((event: Event) => any) | undefined;
115
+ }>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
65
116
 
66
- declare type __VLS_Prettify_7<T> = {
67
- [K in keyof T]: T[K];
68
- } & {};
117
+ declare const __VLS_component_4: DefineComponent< {
118
+ className?: string | string[];
119
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
120
+ className?: string | string[];
121
+ }> & Readonly<{}>, {
122
+ className: string | string[];
123
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
124
+
125
+ declare const __VLS_component_5: DefineComponent< {
126
+ bgColor?: ColorPalette;
127
+ mobileMenuBgColor?: ColorPalette;
128
+ drawerBtnColor?: ColorPalette;
129
+ drawerBtnBorder?: boolean;
130
+ fadeInOnScroll?: boolean;
131
+ scrollDistance?: number;
132
+ sticky?: HeaderStickyOptionType;
133
+ }, {
134
+ headerClose: () => void;
135
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
136
+ "toggle-drawer": (event: Event, open: boolean) => any;
137
+ }, string, PublicProps, Readonly<{
138
+ bgColor?: ColorPalette;
139
+ mobileMenuBgColor?: ColorPalette;
140
+ drawerBtnColor?: ColorPalette;
141
+ drawerBtnBorder?: boolean;
142
+ fadeInOnScroll?: boolean;
143
+ scrollDistance?: number;
144
+ sticky?: HeaderStickyOptionType;
145
+ }> & Readonly<{
146
+ "onToggle-drawer"?: ((event: Event, open: boolean) => any) | undefined;
147
+ }>, {
148
+ bgColor: ColorPalette;
149
+ mobileMenuBgColor: ColorPalette;
150
+ drawerBtnColor: ColorPalette;
151
+ drawerBtnBorder: boolean;
152
+ fadeInOnScroll: boolean;
153
+ scrollDistance: number;
154
+ sticky: HeaderStickyOptionType;
155
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
69
156
 
70
- declare type __VLS_Prettify_8<T> = {
71
- [K in keyof T]: T[K];
72
- } & {};
157
+ declare const __VLS_component_6: DefineComponent< {
158
+ bgColor?: ColorPalette;
159
+ drawerBtnColor?: ColorPalette;
160
+ drawerBtnBorder?: boolean;
161
+ headerWidth?: number;
162
+ }, {
163
+ headerClose: () => void;
164
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
165
+ "toggle-drawer": (event: Event, open: boolean) => any;
166
+ }, string, PublicProps, Readonly<{
167
+ bgColor?: ColorPalette;
168
+ drawerBtnColor?: ColorPalette;
169
+ drawerBtnBorder?: boolean;
170
+ headerWidth?: number;
171
+ }> & Readonly<{
172
+ "onToggle-drawer"?: ((event: Event, open: boolean) => any) | undefined;
173
+ }>, {
174
+ bgColor: ColorPalette;
175
+ drawerBtnColor: ColorPalette;
176
+ drawerBtnBorder: boolean;
177
+ headerWidth: number;
178
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
179
+
180
+ declare const __VLS_component_7: DefineComponent< {
181
+ title?: string;
182
+ titleColor?: ColorPalette;
183
+ className?: string | string[];
184
+ visible?: boolean;
185
+ noBackdrop?: boolean;
186
+ noHeader?: boolean;
187
+ color?: ColorPalette;
188
+ backdropColor?: ColorPalette;
189
+ placement?: VerticalAlignment;
190
+ }, {
191
+ toggle: () => void;
192
+ close: () => void;
193
+ open: () => void;
194
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
195
+ close: (visible: boolean) => any;
196
+ open: (visible: boolean) => any;
197
+ }, string, PublicProps, Readonly<{
198
+ title?: string;
199
+ titleColor?: ColorPalette;
200
+ className?: string | string[];
201
+ visible?: boolean;
202
+ noBackdrop?: boolean;
203
+ noHeader?: boolean;
204
+ color?: ColorPalette;
205
+ backdropColor?: ColorPalette;
206
+ placement?: VerticalAlignment;
207
+ }> & Readonly<{
208
+ onClose?: ((visible: boolean) => any) | undefined;
209
+ onOpen?: ((visible: boolean) => any) | undefined;
210
+ }>, {
211
+ color: ColorPalette;
212
+ visible: boolean;
213
+ className: string | string[];
214
+ titleColor: ColorPalette;
215
+ noBackdrop: boolean;
216
+ noHeader: boolean;
217
+ backdropColor: ColorPalette;
218
+ placement: VerticalAlignment;
219
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
220
+
221
+ declare const __VLS_component_8: DefineComponent< {
222
+ title?: string;
223
+ titleColor?: ColorPalette;
224
+ className?: string | string[];
225
+ visible?: boolean;
226
+ noBackdrop?: boolean;
227
+ noHeader?: boolean;
228
+ color?: ColorPalette;
229
+ backdropColor?: ColorPalette;
230
+ placement?: DirectionX;
231
+ width?: string | number;
232
+ }, {
233
+ toggle: () => void;
234
+ open: () => void;
235
+ close: () => void;
236
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
237
+ close: (visible: boolean) => any;
238
+ open: (visible: boolean) => any;
239
+ }, string, PublicProps, Readonly<{
240
+ title?: string;
241
+ titleColor?: ColorPalette;
242
+ className?: string | string[];
243
+ visible?: boolean;
244
+ noBackdrop?: boolean;
245
+ noHeader?: boolean;
246
+ color?: ColorPalette;
247
+ backdropColor?: ColorPalette;
248
+ placement?: DirectionX;
249
+ width?: string | number;
250
+ }> & Readonly<{
251
+ onClose?: ((visible: boolean) => any) | undefined;
252
+ onOpen?: ((visible: boolean) => any) | undefined;
253
+ }>, {
254
+ color: ColorPalette;
255
+ visible: boolean;
256
+ className: string | string[];
257
+ width: string | number;
258
+ titleColor: ColorPalette;
259
+ noBackdrop: boolean;
260
+ noHeader: boolean;
261
+ backdropColor: ColorPalette;
262
+ placement: DirectionX;
263
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
73
264
 
74
- declare type __VLS_Prettify_9<T> = {
75
- [K in keyof T]: T[K];
76
- } & {};
265
+ declare const __VLS_component_9: DefineComponent< {
266
+ bodyClass?: string | string[];
267
+ btnContainerClass?: string | string[];
268
+ contentContainerClass?: string | string[];
269
+ }, {
270
+ update: (arg: number) => void;
271
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
272
+ bodyClass?: string | string[];
273
+ btnContainerClass?: string | string[];
274
+ contentContainerClass?: string | string[];
275
+ }> & Readonly<{}>, {
276
+ bodyClass: string | string[];
277
+ btnContainerClass: string | string[];
278
+ contentContainerClass: string | string[];
279
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
77
280
 
78
- declare type __VLS_TypePropsToRuntimeProps<T> = {
79
- [K in keyof T]-?: {} extends Pick<T, K> ? {
80
- type: PropType<__VLS_NonUndefinedable<T[K]>>;
81
- } : {
82
- type: PropType<T[K]>;
83
- required: true;
281
+ declare function __VLS_template(): {
282
+ slots: Readonly<{
283
+ default: any;
284
+ }> & {
285
+ default: any;
84
286
  };
287
+ refs: {};
288
+ attrs: Partial<{}>;
85
289
  };
86
290
 
87
- declare type __VLS_TypePropsToRuntimeProps_10<T> = {
88
- [K in keyof T]-?: {} extends Pick<T, K> ? {
89
- type: PropType<__VLS_NonUndefinedable_10<T[K]>>;
90
- } : {
91
- type: PropType<T[K]>;
92
- required: true;
291
+ declare function __VLS_template_10(): {
292
+ slots: {
293
+ default?(_: {}): any;
93
294
  };
94
- };
95
-
96
- declare type __VLS_TypePropsToRuntimeProps_11<T> = {
97
- [K in keyof T]-?: {} extends Pick<T, K> ? {
98
- type: PropType<__VLS_NonUndefinedable_11<T[K]>>;
99
- } : {
100
- type: PropType<T[K]>;
101
- required: true;
295
+ refs: {
296
+ slotRef: HTMLDivElement;
102
297
  };
103
- };
104
-
105
- declare type __VLS_TypePropsToRuntimeProps_2<T> = {
106
- [K in keyof T]-?: {} extends Pick<T, K> ? {
107
- type: PropType<__VLS_NonUndefinedable_2<T[K]>>;
108
- } : {
109
- type: PropType<T[K]>;
110
- required: true;
298
+ attrs: Partial<{}>;
299
+ };
300
+
301
+ declare function __VLS_template_11(): {
302
+ slots: Readonly<{
303
+ content: any;
304
+ 'controller-top'(props: {
305
+ next: () => void;
306
+ prev: () => void;
307
+ setActive: (arg: number) => void;
308
+ numberOfSlides: number;
309
+ activeSlide: number;
310
+ }): any;
311
+ 'controller-bottom'(props: {
312
+ next: () => void;
313
+ prev: () => void;
314
+ setActive: (arg: number) => void;
315
+ numberOfSlides: number;
316
+ activeSlide: number;
317
+ }): any;
318
+ }> & {
319
+ content: any;
320
+ 'controller-top'(props: {
321
+ next: () => void;
322
+ prev: () => void;
323
+ setActive: (arg: number) => void;
324
+ numberOfSlides: number;
325
+ activeSlide: number;
326
+ }): any;
327
+ 'controller-bottom'(props: {
328
+ next: () => void;
329
+ prev: () => void;
330
+ setActive: (arg: number) => void;
331
+ numberOfSlides: number;
332
+ activeSlide: number;
333
+ }): any;
111
334
  };
335
+ refs: {};
336
+ attrs: Partial<{}>;
112
337
  };
113
338
 
114
- declare type __VLS_TypePropsToRuntimeProps_3<T> = {
115
- [K in keyof T]-?: {} extends Pick<T, K> ? {
116
- type: PropType<__VLS_NonUndefinedable_3<T[K]>>;
117
- } : {
118
- type: PropType<T[K]>;
119
- required: true;
339
+ declare function __VLS_template_12(): {
340
+ slots: Readonly<{
341
+ default: any;
342
+ }> & {
343
+ default: any;
120
344
  };
121
- };
122
-
123
- declare type __VLS_TypePropsToRuntimeProps_4<T> = {
124
- [K in keyof T]-?: {} extends Pick<T, K> ? {
125
- type: PropType<__VLS_NonUndefinedable_4<T[K]>>;
126
- } : {
127
- type: PropType<T[K]>;
128
- required: true;
345
+ refs: {
346
+ slideRef: HTMLDivElement;
129
347
  };
348
+ attrs: Partial<{}>;
130
349
  };
131
350
 
132
- declare type __VLS_TypePropsToRuntimeProps_5<T> = {
133
- [K in keyof T]-?: {} extends Pick<T, K> ? {
134
- type: PropType<__VLS_NonUndefinedable_5<T[K]>>;
135
- } : {
136
- type: PropType<T[K]>;
137
- required: true;
351
+ declare function __VLS_template_2(): {
352
+ slots: Readonly<{
353
+ default: any;
354
+ }> & {
355
+ default: any;
138
356
  };
139
- };
140
-
141
- declare type __VLS_TypePropsToRuntimeProps_6<T> = {
142
- [K in keyof T]-?: {} extends Pick<T, K> ? {
143
- type: PropType<__VLS_NonUndefinedable_6<T[K]>>;
144
- } : {
145
- type: PropType<T[K]>;
146
- required: true;
357
+ refs: {
358
+ collapseRef: HTMLDivElement;
147
359
  };
148
- };
149
-
150
- declare type __VLS_TypePropsToRuntimeProps_7<T> = {
151
- [K in keyof T]-?: {} extends Pick<T, K> ? {
152
- type: PropType<__VLS_NonUndefinedable_7<T[K]>>;
153
- } : {
154
- type: PropType<T[K]>;
155
- required: true;
360
+ attrs: Partial<{}>;
361
+ };
362
+
363
+ declare function __VLS_template_3(): {
364
+ slots: Readonly<{
365
+ default: any;
366
+ toggler(props: {
367
+ dropdownState: boolean;
368
+ toggle: (arg: Event) => void;
369
+ }): any;
370
+ }> & {
371
+ default: any;
372
+ toggler(props: {
373
+ dropdownState: boolean;
374
+ toggle: (arg: Event) => void;
375
+ }): any;
156
376
  };
157
- };
158
-
159
- declare type __VLS_TypePropsToRuntimeProps_8<T> = {
160
- [K in keyof T]-?: {} extends Pick<T, K> ? {
161
- type: PropType<__VLS_NonUndefinedable_8<T[K]>>;
162
- } : {
163
- type: PropType<T[K]>;
164
- required: true;
377
+ refs: {
378
+ dropdownTarget: HTMLDivElement;
165
379
  };
166
- };
167
-
168
- declare type __VLS_TypePropsToRuntimeProps_9<T> = {
169
- [K in keyof T]-?: {} extends Pick<T, K> ? {
170
- type: PropType<__VLS_NonUndefinedable_9<T[K]>>;
171
- } : {
172
- type: PropType<T[K]>;
173
- required: true;
380
+ attrs: Partial<{}>;
381
+ };
382
+
383
+ declare function __VLS_template_4(): {
384
+ slots: Readonly<{
385
+ default(props: {
386
+ itemClick: () => void;
387
+ }): any;
388
+ }> & {
389
+ default(props: {
390
+ itemClick: () => void;
391
+ }): any;
392
+ };
393
+ refs: {
394
+ contentRef: HTMLDivElement;
395
+ };
396
+ attrs: Partial<{}>;
397
+ };
398
+
399
+ declare function __VLS_template_5(): {
400
+ slots: Readonly<{
401
+ content: any;
402
+ 'content-right': any;
403
+ 'mobile-content'(props: {
404
+ headerClose: () => void;
405
+ }): any;
406
+ }> & {
407
+ content: any;
408
+ 'content-right': any;
409
+ 'mobile-content'(props: {
410
+ headerClose: () => void;
411
+ }): any;
412
+ };
413
+ refs: {};
414
+ attrs: Partial<{}>;
415
+ };
416
+
417
+ declare function __VLS_template_6(): {
418
+ slots: Readonly<{
419
+ default: any;
420
+ content: any;
421
+ 'content-bottom': any;
422
+ 'mobile-content'(props: {
423
+ headerClose: () => void;
424
+ }): any;
425
+ }> & {
426
+ default: any;
427
+ content: any;
428
+ 'content-bottom': any;
429
+ 'mobile-content'(props: {
430
+ headerClose: () => void;
431
+ }): any;
432
+ };
433
+ refs: {};
434
+ attrs: Partial<{}>;
435
+ };
436
+
437
+ declare function __VLS_template_7(): {
438
+ slots: Readonly<{
439
+ header(props: {
440
+ close: () => void;
441
+ status: boolean;
442
+ }): any;
443
+ body(props: {
444
+ close: () => void;
445
+ status: boolean;
446
+ }): any;
447
+ footer(props: {
448
+ close: () => void;
449
+ status: boolean;
450
+ }): any;
451
+ }> & {
452
+ header(props: {
453
+ close: () => void;
454
+ status: boolean;
455
+ }): any;
456
+ body(props: {
457
+ close: () => void;
458
+ status: boolean;
459
+ }): any;
460
+ footer(props: {
461
+ close: () => void;
462
+ status: boolean;
463
+ }): any;
464
+ };
465
+ refs: {
466
+ modalRef: HTMLDivElement;
467
+ };
468
+ attrs: Partial<{}>;
469
+ };
470
+
471
+ declare function __VLS_template_8(): {
472
+ slots: Readonly<{
473
+ header(props: {
474
+ close: () => void;
475
+ status: boolean;
476
+ }): any;
477
+ body(props: {
478
+ close: () => void;
479
+ status: boolean;
480
+ }): any;
481
+ footer(props: {
482
+ close: () => void;
483
+ status: boolean;
484
+ }): any;
485
+ }> & {
486
+ header(props: {
487
+ close: () => void;
488
+ status: boolean;
489
+ }): any;
490
+ body(props: {
491
+ close: () => void;
492
+ status: boolean;
493
+ }): any;
494
+ footer(props: {
495
+ close: () => void;
496
+ status: boolean;
497
+ }): any;
498
+ };
499
+ refs: {
500
+ sidebarRef: HTMLDivElement;
501
+ headerRef: HTMLDivElement;
502
+ footerRef: HTMLDivElement;
503
+ };
504
+ attrs: Partial<{}>;
505
+ };
506
+
507
+ declare function __VLS_template_9(): {
508
+ slots: Readonly<{
509
+ 'tab-button'(props: {
510
+ update: (num: number) => void;
511
+ activeTab: number;
512
+ }): any;
513
+ 'tab-content': any;
514
+ }> & {
515
+ 'tab-button'(props: {
516
+ update: (num: number) => void;
517
+ activeTab: number;
518
+ }): any;
519
+ 'tab-content': any;
174
520
  };
521
+ refs: {};
522
+ attrs: Partial<{}>;
175
523
  };
176
524
 
177
- declare type __VLS_WithDefaults<P, D> = {
178
- [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
179
- default: D[K];
180
- }> : P[K];
181
- };
525
+ declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
182
526
 
183
- declare type __VLS_WithDefaults_10<P, D> = {
184
- [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_10<P[K] & {
185
- default: D[K];
186
- }> : P[K];
187
- };
527
+ declare type __VLS_TemplateResult_10 = ReturnType<typeof __VLS_template_10>;
188
528
 
189
- declare type __VLS_WithDefaults_11<P, D> = {
190
- [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_11<P[K] & {
191
- default: D[K];
192
- }> : P[K];
193
- };
529
+ declare type __VLS_TemplateResult_11 = ReturnType<typeof __VLS_template_11>;
194
530
 
195
- declare type __VLS_WithDefaults_2<P, D> = {
196
- [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_2<P[K] & {
197
- default: D[K];
198
- }> : P[K];
199
- };
531
+ declare type __VLS_TemplateResult_12 = ReturnType<typeof __VLS_template_12>;
200
532
 
201
- declare type __VLS_WithDefaults_3<P, D> = {
202
- [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_3<P[K] & {
203
- default: D[K];
204
- }> : P[K];
205
- };
533
+ declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;
206
534
 
207
- declare type __VLS_WithDefaults_4<P, D> = {
208
- [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_4<P[K] & {
209
- default: D[K];
210
- }> : P[K];
211
- };
535
+ declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;
212
536
 
213
- declare type __VLS_WithDefaults_5<P, D> = {
214
- [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_5<P[K] & {
215
- default: D[K];
216
- }> : P[K];
217
- };
537
+ declare type __VLS_TemplateResult_4 = ReturnType<typeof __VLS_template_4>;
218
538
 
219
- declare type __VLS_WithDefaults_6<P, D> = {
220
- [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_6<P[K] & {
221
- default: D[K];
222
- }> : P[K];
223
- };
539
+ declare type __VLS_TemplateResult_5 = ReturnType<typeof __VLS_template_5>;
224
540
 
225
- declare type __VLS_WithDefaults_7<P, D> = {
226
- [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_7<P[K] & {
227
- default: D[K];
228
- }> : P[K];
229
- };
541
+ declare type __VLS_TemplateResult_6 = ReturnType<typeof __VLS_template_6>;
230
542
 
231
- declare type __VLS_WithDefaults_8<P, D> = {
232
- [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_8<P[K] & {
233
- default: D[K];
234
- }> : P[K];
235
- };
543
+ declare type __VLS_TemplateResult_7 = ReturnType<typeof __VLS_template_7>;
236
544
 
237
- declare type __VLS_WithDefaults_9<P, D> = {
238
- [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_9<P[K] & {
239
- default: D[K];
240
- }> : P[K];
241
- };
545
+ declare type __VLS_TemplateResult_8 = ReturnType<typeof __VLS_template_8>;
546
+
547
+ declare type __VLS_TemplateResult_9 = ReturnType<typeof __VLS_template_9>;
242
548
 
243
549
  declare type __VLS_WithTemplateSlots<T, S> = T & {
244
550
  new (): {
@@ -312,47 +618,7 @@ declare type __VLS_WithTemplateSlots_9<T, S> = T & {
312
618
  };
313
619
  };
314
620
 
315
- export declare const Alert: __VLS_WithTemplateSlots<DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
316
- color?: ColorPalette | undefined;
317
- rounded?: boolean | undefined;
318
- shadow?: boolean | undefined;
319
- show?: boolean | undefined;
320
- dismissible?: boolean | undefined;
321
- }>, {
322
- color: string;
323
- rounded: boolean;
324
- shadow: boolean;
325
- show: boolean;
326
- dismissible: boolean;
327
- }>, {
328
- close: () => void;
329
- }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
330
- close: (event: Event) => void;
331
- }, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
332
- color?: ColorPalette | undefined;
333
- rounded?: boolean | undefined;
334
- shadow?: boolean | undefined;
335
- show?: boolean | undefined;
336
- dismissible?: boolean | undefined;
337
- }>, {
338
- color: string;
339
- rounded: boolean;
340
- shadow: boolean;
341
- show: boolean;
342
- dismissible: boolean;
343
- }>>> & {
344
- onClose?: ((event: Event) => any) | undefined;
345
- }, {
346
- color: ColorPalette;
347
- shadow: boolean;
348
- rounded: boolean;
349
- show: boolean;
350
- dismissible: boolean;
351
- }, {}>, Readonly<{
352
- default: any;
353
- }> & {
354
- default: any;
355
- }>;
621
+ export declare const Alert: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
356
622
 
357
623
  export declare type Alignment = 'left' | 'center' | 'right';
358
624
 
@@ -364,94 +630,9 @@ declare type BorderWidthClassType = ClassTypesMap['borderWidthType'];
364
630
 
365
631
  export declare type ButtonSize = 'small' | 'medium' | 'large';
366
632
 
367
- export declare const CarouselContainer: __VLS_WithTemplateSlots_11<DefineComponent<__VLS_WithDefaults_10<__VLS_TypePropsToRuntimeProps_10<{
368
- bodyClass?: string | string[] | undefined;
369
- contentContainerClass?: string | string[] | undefined;
370
- controllerTopClass?: string | string[] | undefined;
371
- controllerBottomClass?: string | string[] | undefined;
372
- loop?: boolean | undefined;
373
- }>, {
374
- bodyClass: string;
375
- contentContainerClass: string;
376
- controllerTopClass: string;
377
- controllerBottomClass: string;
378
- loop: boolean;
379
- }>, {
380
- numberOfSlides: Ref<number>;
381
- prev: () => void;
382
- next: () => void;
383
- setActive: (idx: number) => void;
384
- }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_10<__VLS_TypePropsToRuntimeProps_10<{
385
- bodyClass?: string | string[] | undefined;
386
- contentContainerClass?: string | string[] | undefined;
387
- controllerTopClass?: string | string[] | undefined;
388
- controllerBottomClass?: string | string[] | undefined;
389
- loop?: boolean | undefined;
390
- }>, {
391
- bodyClass: string;
392
- contentContainerClass: string;
393
- controllerTopClass: string;
394
- controllerBottomClass: string;
395
- loop: boolean;
396
- }>>>, {
397
- bodyClass: string | string[];
398
- contentContainerClass: string | string[];
399
- controllerTopClass: string | string[];
400
- controllerBottomClass: string | string[];
401
- loop: boolean;
402
- }, {}>, Readonly<{
403
- content: any;
404
- 'controller-top'(props: {
405
- next: () => void;
406
- prev: () => void;
407
- setActive: (arg: number) => void;
408
- numberOfSlides: number;
409
- activeSlide: number;
410
- }): any;
411
- 'controller-bottom'(props: {
412
- next: () => void;
413
- prev: () => void;
414
- setActive: (arg: number) => void;
415
- numberOfSlides: number;
416
- activeSlide: number;
417
- }): any;
418
- }> & {
419
- content: any;
420
- 'controller-top'(props: {
421
- next: () => void;
422
- prev: () => void;
423
- setActive: (arg: number) => void;
424
- numberOfSlides: number;
425
- activeSlide: number;
426
- }): any;
427
- 'controller-bottom'(props: {
428
- next: () => void;
429
- prev: () => void;
430
- setActive: (arg: number) => void;
431
- numberOfSlides: number;
432
- activeSlide: number;
433
- }): any;
434
- }>;
435
-
436
- export declare const CarouselContent: __VLS_WithTemplateSlots_12<DefineComponent<__VLS_WithDefaults_11<__VLS_TypePropsToRuntimeProps_11<{
437
- slideNumber: number;
438
- id: string;
439
- slideClass?: string | string[] | undefined;
440
- }>, {
441
- slideClass: string;
442
- }>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_11<__VLS_TypePropsToRuntimeProps_11<{
443
- slideNumber: number;
444
- id: string;
445
- slideClass?: string | string[] | undefined;
446
- }>, {
447
- slideClass: string;
448
- }>>>, {
449
- slideClass: string | string[];
450
- }, {}>, Readonly<{
451
- default: any;
452
- }> & {
453
- default: any;
454
- }>;
633
+ export declare const CarouselContainer: __VLS_WithTemplateSlots_11<typeof __VLS_component_11, __VLS_TemplateResult_11["slots"]>;
634
+
635
+ export declare const CarouselContent: __VLS_WithTemplateSlots_12<typeof __VLS_component_12, __VLS_TemplateResult_12["slots"]>;
455
636
 
456
637
  declare type ClassType = (typeof allType)[number];
457
638
 
@@ -461,40 +642,9 @@ declare type ClassTypesMap = {
461
642
 
462
643
  export declare const ClientSideRender: DefineComponent< {}, () => VNode<RendererNode, RendererElement, {
463
644
  [key: string]: any;
464
- }>[] | null, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes< {}>>, {}, {}>;
645
+ }>[] | null, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
465
646
 
466
- export declare const Collapse: __VLS_WithTemplateSlots_2<DefineComponent<__VLS_WithDefaults_2<__VLS_TypePropsToRuntimeProps_2<{
467
- accordion?: string | undefined;
468
- className?: string | string[] | undefined;
469
- visible?: boolean | undefined;
470
- }>, {
471
- className: string;
472
- visible: boolean;
473
- }>, {
474
- toggle: () => void;
475
- close: () => void;
476
- open: () => void;
477
- }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
478
- open: (visible: boolean) => void;
479
- close: (visible: boolean) => void;
480
- }, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_2<__VLS_TypePropsToRuntimeProps_2<{
481
- accordion?: string | undefined;
482
- className?: string | string[] | undefined;
483
- visible?: boolean | undefined;
484
- }>, {
485
- className: string;
486
- visible: boolean;
487
- }>>> & {
488
- onOpen?: ((visible: boolean) => any) | undefined;
489
- onClose?: ((visible: boolean) => any) | undefined;
490
- }, {
491
- visible: boolean;
492
- className: string | string[];
493
- }, {}>, Readonly<{
494
- default: any;
495
- }> & {
496
- default: any;
497
- }>;
647
+ export declare const Collapse: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;
498
648
 
499
649
  declare type ColorClassType = ClassTypesMap['colorType'];
500
650
 
@@ -512,163 +662,24 @@ export declare type DirectionX = 'left' | 'right';
512
662
 
513
663
  export declare type DirectionY = 'top' | 'bottom';
514
664
 
515
- export declare const DropdownContainer: __VLS_WithTemplateSlots_3<DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
516
- "click-outside": (event: Event) => void;
517
- toggle: (event: Event) => void;
518
- }, string, PublicProps, Readonly<ExtractPropTypes< {}>> & {
519
- onToggle?: ((event: Event) => any) | undefined;
520
- "onClick-outside"?: ((event: Event) => any) | undefined;
521
- }, {}, {}>, Readonly<{
522
- default: any;
523
- toggler(props: {
524
- dropdownState: boolean;
525
- toggle: (arg: Event) => void;
526
- }): any;
527
- }> & {
528
- default: any;
529
- toggler(props: {
530
- dropdownState: boolean;
531
- toggle: (arg: Event) => void;
532
- }): any;
533
- }>;
534
-
535
- export declare const DropdownContent: __VLS_WithTemplateSlots_4<DefineComponent<__VLS_WithDefaults_3<__VLS_TypePropsToRuntimeProps_3<{
536
- className?: string | string[] | undefined;
537
- }>, {
538
- className: string;
539
- }>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_3<__VLS_TypePropsToRuntimeProps_3<{
540
- className?: string | string[] | undefined;
541
- }>, {
542
- className: string;
543
- }>>>, {
544
- className: string | string[];
545
- }, {}>, Readonly<{
546
- default(props: {
547
- itemClick: () => void;
548
- }): any;
549
- }> & {
550
- default(props: {
551
- itemClick: () => void;
552
- }): any;
553
- }>;
665
+ export declare const DropdownContainer: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;
666
+
667
+ export declare const DropdownContent: __VLS_WithTemplateSlots_4<typeof __VLS_component_4, __VLS_TemplateResult_4["slots"]>;
554
668
 
555
669
  export declare type FontWeight = 'light' | 'normal' | 'bold';
556
670
 
557
671
  declare type FontWeightClassType = ClassTypesMap['fontWeightType'];
558
672
 
559
- declare const generateClass: <T extends "BGCOLOR" | "BEFOREBG" | "AFTERBG" | "HVBGCOLOR" | "FCBGCOLOR" | "ACTIVEBG" | "TEXTCOLOR" | "HVTEXTCOLOR" | "FCTEXTCOLOR" | "DISABLEDTEXTCOLOR" | "SVGFILL" | "RINGCOLOR" | "FOCUSRING" | "ACTIVERING" | "OFFSETRING" | "BTNCOLOR" | "LISTCOLOR" | "BORDER" | "BORDERX" | "BORDERY" | "BORDERT" | "BORDERB" | "BORDERL" | "BORDERR" | "BODYTEXT" | "FONTWEIGHT" | "TEXTALIGN" | "H1" | "H2" | "H3" | "H4" | "BORDERW" | "BORDERXW" | "BORDERYW" | "BORDERTW" | "BORDERBW" | "BORDERLW" | "BORDERRW" | "BGOPACITY" | "OPACITY" | "MARGIN" | "MARGINX" | "MARGINY" | "MARGINT" | "MARGINB" | "MARGINL" | "MARGINR" | "PADDING" | "PADDINGX" | "PADDINGY" | "PADDINGT" | "PADDINGB" | "PADDINGL" | "PADDINGR" | "GAP">(type: T, value: InputType_2<T>) => string;
673
+ declare const generateClass: <T extends ClassType>(type: T, value: InputType_2<T>) => string;
560
674
  export default generateClass;
561
675
 
562
676
  declare type GroupTypes = typeof typeGroup;
563
677
 
564
- export declare const HeaderHorizontal: __VLS_WithTemplateSlots_5<DefineComponent<__VLS_WithDefaults_4<__VLS_TypePropsToRuntimeProps_4<{
565
- bgColor?: ColorPalette | undefined;
566
- mobileMenuBgColor?: ColorPalette | undefined;
567
- drawerBtnColor?: ColorPalette | undefined;
568
- drawerBtnBorder?: boolean | undefined;
569
- fadeInOnScroll?: boolean | undefined;
570
- scrollDistance?: number | undefined;
571
- sticky?: HeaderStickyOptionType | undefined;
572
- }>, {
573
- bgColor: string;
574
- mobileMenuBgColor: string;
575
- drawerBtnColor: string;
576
- drawerBtnBorder: boolean;
577
- fadeInOnScroll: boolean;
578
- scrollDistance: number;
579
- sticky: string;
580
- }>, {
581
- headerClose: () => void;
582
- }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
583
- "toggle-drawer": (event: Event, open: boolean) => void;
584
- }, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_4<__VLS_TypePropsToRuntimeProps_4<{
585
- bgColor?: ColorPalette | undefined;
586
- mobileMenuBgColor?: ColorPalette | undefined;
587
- drawerBtnColor?: ColorPalette | undefined;
588
- drawerBtnBorder?: boolean | undefined;
589
- fadeInOnScroll?: boolean | undefined;
590
- scrollDistance?: number | undefined;
591
- sticky?: HeaderStickyOptionType | undefined;
592
- }>, {
593
- bgColor: string;
594
- mobileMenuBgColor: string;
595
- drawerBtnColor: string;
596
- drawerBtnBorder: boolean;
597
- fadeInOnScroll: boolean;
598
- scrollDistance: number;
599
- sticky: string;
600
- }>>> & {
601
- "onToggle-drawer"?: ((event: Event, open: boolean) => any) | undefined;
602
- }, {
603
- bgColor: ColorPalette;
604
- mobileMenuBgColor: ColorPalette;
605
- drawerBtnColor: ColorPalette;
606
- drawerBtnBorder: boolean;
607
- fadeInOnScroll: boolean;
608
- scrollDistance: number;
609
- sticky: HeaderStickyOptionType;
610
- }, {}>, Readonly<{
611
- content: any;
612
- 'content-right': any;
613
- 'mobile-content'(props: {
614
- headerClose: () => void;
615
- }): any;
616
- }> & {
617
- content: any;
618
- 'content-right': any;
619
- 'mobile-content'(props: {
620
- headerClose: () => void;
621
- }): any;
622
- }>;
678
+ export declare const HeaderHorizontal: __VLS_WithTemplateSlots_5<typeof __VLS_component_5, __VLS_TemplateResult_5["slots"]>;
623
679
 
624
680
  export declare type HeaderStickyOptionType = 'none' | 'tablet' | 'pc' | 'all';
625
681
 
626
- export declare const HeaderVertical: __VLS_WithTemplateSlots_6<DefineComponent<__VLS_WithDefaults_5<__VLS_TypePropsToRuntimeProps_5<{
627
- bgColor?: ColorPalette | undefined;
628
- drawerBtnColor?: ColorPalette | undefined;
629
- drawerBtnBorder?: boolean | undefined;
630
- headerWidth?: number | undefined;
631
- }>, {
632
- bgColor: string;
633
- drawerBtnColor: string;
634
- drawerBtnBorder: boolean;
635
- headerWidth: number;
636
- }>, {
637
- headerClose: () => void;
638
- }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
639
- "toggle-drawer": (event: Event, open: boolean) => void;
640
- }, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_5<__VLS_TypePropsToRuntimeProps_5<{
641
- bgColor?: ColorPalette | undefined;
642
- drawerBtnColor?: ColorPalette | undefined;
643
- drawerBtnBorder?: boolean | undefined;
644
- headerWidth?: number | undefined;
645
- }>, {
646
- bgColor: string;
647
- drawerBtnColor: string;
648
- drawerBtnBorder: boolean;
649
- headerWidth: number;
650
- }>>> & {
651
- "onToggle-drawer"?: ((event: Event, open: boolean) => any) | undefined;
652
- }, {
653
- bgColor: ColorPalette;
654
- drawerBtnColor: ColorPalette;
655
- drawerBtnBorder: boolean;
656
- headerWidth: number;
657
- }, {}>, Readonly<{
658
- default: any;
659
- content: any;
660
- 'content-bottom': any;
661
- 'mobile-content'(props: {
662
- headerClose: () => void;
663
- }): any;
664
- }> & {
665
- default: any;
666
- content: any;
667
- 'content-bottom': any;
668
- 'mobile-content'(props: {
669
- headerClose: () => void;
670
- }): any;
671
- }>;
682
+ export declare const HeaderVertical: __VLS_WithTemplateSlots_6<typeof __VLS_component_6, __VLS_TemplateResult_6["slots"]>;
672
683
 
673
684
  declare type HeadingClassType = ClassTypesMap['headingSizeType'];
674
685
 
@@ -682,90 +693,7 @@ declare type InputType_2<T extends ClassType> = T extends ColorClassType ? Color
682
693
 
683
694
  declare type IntRange<T extends number[], E extends number, R extends number = never> = T['length'] extends E ? R | E : IntRange<[...T, 1], E, R | T['length']>;
684
695
 
685
- export declare const Modal: __VLS_WithTemplateSlots_7<DefineComponent<__VLS_WithDefaults_6<__VLS_TypePropsToRuntimeProps_6<{
686
- title?: string | undefined;
687
- titleColor?: ColorPalette | undefined;
688
- className?: string | string[] | undefined;
689
- visible?: boolean | undefined;
690
- noBackdrop?: boolean | undefined;
691
- noHeader?: boolean | undefined;
692
- color?: ColorPalette | undefined;
693
- backdropColor?: ColorPalette | undefined;
694
- placement?: VerticalAlignment | undefined;
695
- }>, {
696
- titleColor: string;
697
- className: string;
698
- visible: boolean;
699
- noBackdrop: boolean;
700
- noHeader: boolean;
701
- color: string;
702
- backdropColor: string;
703
- placement: string;
704
- }>, {
705
- toggle: () => void;
706
- close: () => void;
707
- open: () => void;
708
- }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
709
- open: (visible: boolean) => void;
710
- close: (visible: boolean) => void;
711
- }, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_6<__VLS_TypePropsToRuntimeProps_6<{
712
- title?: string | undefined;
713
- titleColor?: ColorPalette | undefined;
714
- className?: string | string[] | undefined;
715
- visible?: boolean | undefined;
716
- noBackdrop?: boolean | undefined;
717
- noHeader?: boolean | undefined;
718
- color?: ColorPalette | undefined;
719
- backdropColor?: ColorPalette | undefined;
720
- placement?: VerticalAlignment | undefined;
721
- }>, {
722
- titleColor: string;
723
- className: string;
724
- visible: boolean;
725
- noBackdrop: boolean;
726
- noHeader: boolean;
727
- color: string;
728
- backdropColor: string;
729
- placement: string;
730
- }>>> & {
731
- onOpen?: ((visible: boolean) => any) | undefined;
732
- onClose?: ((visible: boolean) => any) | undefined;
733
- }, {
734
- visible: boolean;
735
- className: string | string[];
736
- color: ColorPalette;
737
- titleColor: ColorPalette;
738
- noBackdrop: boolean;
739
- noHeader: boolean;
740
- backdropColor: ColorPalette;
741
- placement: VerticalAlignment;
742
- }, {}>, Readonly<{
743
- header(props: {
744
- close: () => void;
745
- status: boolean;
746
- }): any;
747
- body(props: {
748
- close: () => void;
749
- status: boolean;
750
- }): any;
751
- footer(props: {
752
- close: () => void;
753
- status: boolean;
754
- }): any;
755
- }> & {
756
- header(props: {
757
- close: () => void;
758
- status: boolean;
759
- }): any;
760
- body(props: {
761
- close: () => void;
762
- status: boolean;
763
- }): any;
764
- footer(props: {
765
- close: () => void;
766
- status: boolean;
767
- }): any;
768
- }>;
696
+ export declare const Modal: __VLS_WithTemplateSlots_7<typeof __VLS_component_7, __VLS_TemplateResult_7["slots"]>;
769
697
 
770
698
  export declare type OpacityRange = 10 | 20 | 30 | 40 | 50 | 60 | 70 | 80 | 90 | 100;
771
699
 
@@ -776,153 +704,15 @@ declare type _RangeArray<T extends number, R extends unknown[] = []> = R['length
776
704
 
777
705
  declare type ScaleClassType = ClassTypesMap['scaleType'];
778
706
 
779
- export declare const Sidebar: __VLS_WithTemplateSlots_8<DefineComponent<__VLS_WithDefaults_7<__VLS_TypePropsToRuntimeProps_7<{
780
- title?: string | undefined;
781
- titleColor?: ColorPalette | undefined;
782
- className?: string | string[] | undefined;
783
- visible?: boolean | undefined;
784
- noBackdrop?: boolean | undefined;
785
- noHeader?: boolean | undefined;
786
- color?: ColorPalette | undefined;
787
- backdropColor?: ColorPalette | undefined;
788
- placement?: DirectionX | undefined;
789
- width?: string | number | undefined;
790
- }>, {
791
- titleColor: string;
792
- className: string;
793
- visible: boolean;
794
- noBackdrop: boolean;
795
- noHeader: boolean;
796
- color: string;
797
- backdropColor: string;
798
- placement: string;
799
- width: number;
800
- }>, {
801
- toggle: () => void;
802
- open: () => void;
803
- close: () => void;
804
- }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
805
- open: (visible: boolean) => void;
806
- close: (visible: boolean) => void;
807
- }, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_7<__VLS_TypePropsToRuntimeProps_7<{
808
- title?: string | undefined;
809
- titleColor?: ColorPalette | undefined;
810
- className?: string | string[] | undefined;
811
- visible?: boolean | undefined;
812
- noBackdrop?: boolean | undefined;
813
- noHeader?: boolean | undefined;
814
- color?: ColorPalette | undefined;
815
- backdropColor?: ColorPalette | undefined;
816
- placement?: DirectionX | undefined;
817
- width?: string | number | undefined;
818
- }>, {
819
- titleColor: string;
820
- className: string;
821
- visible: boolean;
822
- noBackdrop: boolean;
823
- noHeader: boolean;
824
- color: string;
825
- backdropColor: string;
826
- placement: string;
827
- width: number;
828
- }>>> & {
829
- onOpen?: ((visible: boolean) => any) | undefined;
830
- onClose?: ((visible: boolean) => any) | undefined;
831
- }, {
832
- visible: boolean;
833
- className: string | string[];
834
- color: ColorPalette;
835
- width: string | number;
836
- titleColor: ColorPalette;
837
- noBackdrop: boolean;
838
- noHeader: boolean;
839
- backdropColor: ColorPalette;
840
- placement: DirectionX;
841
- }, {}>, Readonly<{
842
- header(props: {
843
- close: () => void;
844
- status: boolean;
845
- }): any;
846
- body(props: {
847
- close: () => void;
848
- status: boolean;
849
- }): any;
850
- footer(props: {
851
- close: () => void;
852
- status: boolean;
853
- }): any;
854
- }> & {
855
- header(props: {
856
- close: () => void;
857
- status: boolean;
858
- }): any;
859
- body(props: {
860
- close: () => void;
861
- status: boolean;
862
- }): any;
863
- footer(props: {
864
- close: () => void;
865
- status: boolean;
866
- }): any;
867
- }>;
707
+ export declare const Sidebar: __VLS_WithTemplateSlots_8<typeof __VLS_component_8, __VLS_TemplateResult_8["slots"]>;
868
708
 
869
709
  declare type SpacingClassType = ClassTypesMap['spacingType'];
870
710
 
871
711
  export declare type SpacingLevel = '0' | '3xs' | '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
872
712
 
873
- export declare const TabContainer: __VLS_WithTemplateSlots_9<DefineComponent<__VLS_WithDefaults_8<__VLS_TypePropsToRuntimeProps_8<{
874
- bodyClass?: string | string[] | undefined;
875
- btnContainerClass?: string | string[] | undefined;
876
- contentContainerClass?: string | string[] | undefined;
877
- }>, {
878
- bodyClass: string;
879
- btnContainerClass: string;
880
- contentContainerClass: string;
881
- }>, {
882
- update: (arg: number) => void;
883
- }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_8<__VLS_TypePropsToRuntimeProps_8<{
884
- bodyClass?: string | string[] | undefined;
885
- btnContainerClass?: string | string[] | undefined;
886
- contentContainerClass?: string | string[] | undefined;
887
- }>, {
888
- bodyClass: string;
889
- btnContainerClass: string;
890
- contentContainerClass: string;
891
- }>>>, {
892
- bodyClass: string | string[];
893
- btnContainerClass: string | string[];
894
- contentContainerClass: string | string[];
895
- }, {}>, Readonly<{
896
- 'tab-button'(props: {
897
- update: (num: number) => void;
898
- activeTab: number;
899
- }): any;
900
- 'tab-content': any;
901
- }> & {
902
- 'tab-button'(props: {
903
- update: (num: number) => void;
904
- activeTab: number;
905
- }): any;
906
- 'tab-content': any;
907
- }>;
908
-
909
- export declare const TabContent: __VLS_WithTemplateSlots_10<DefineComponent<__VLS_WithDefaults_9<__VLS_TypePropsToRuntimeProps_9<{
910
- tabNumber: number;
911
- id: string;
912
- tabClass?: string | string[] | undefined;
913
- }>, {
914
- tabClass: string;
915
- }>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_9<__VLS_TypePropsToRuntimeProps_9<{
916
- tabNumber: number;
917
- id: string;
918
- tabClass?: string | string[] | undefined;
919
- }>, {
920
- tabClass: string;
921
- }>>>, {
922
- tabClass: string | string[];
923
- }, {}>, {
924
- default?(_: {}): any;
925
- }>;
713
+ export declare const TabContainer: __VLS_WithTemplateSlots_9<typeof __VLS_component_9, __VLS_TemplateResult_9["slots"]>;
714
+
715
+ export declare const TabContent: __VLS_WithTemplateSlots_10<typeof __VLS_component_10, __VLS_TemplateResult_10["slots"]>;
926
716
 
927
717
  declare type TextAlignmentClassType = ClassTypesMap['textAlignType'];
928
718