@bobbykim/mcl-forms 0.8.2 → 0.9.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.
Files changed (4) hide show
  1. package/dist/index.d.ts +282 -738
  2. package/dist/mcl-forms.js +1458 -373
  3. package/dist/mcl-forms.umd.cjs +2 -2
  4. package/package.json +13 -12
package/dist/index.d.ts CHANGED
@@ -1,52 +1,245 @@
1
1
  import { BodyText } from '@bobbykim/manguito-theme';
2
2
  import { ColorPalette } from '@bobbykim/manguito-theme';
3
3
  import { ComponentOptionsMixin } from 'vue';
4
+ import { ComponentProvideOptions } from 'vue';
5
+ import { ComponentPublicInstance } from 'vue';
4
6
  import { DefineComponent } from 'vue';
5
- import { ExtractPropTypes } from 'vue';
6
7
  import { InputType } from '@bobbykim/manguito-theme';
7
- import { PropType } from 'vue';
8
8
  import { PublicProps } from 'vue';
9
9
 
10
- declare type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
10
+ declare const __VLS_component: DefineComponent< {
11
+ labelFor: string;
12
+ textColor?: ColorPalette;
13
+ textSize?: BodyText;
14
+ textBold?: boolean;
15
+ label?: string;
16
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
17
+ labelFor: string;
18
+ textColor?: ColorPalette;
19
+ textSize?: BodyText;
20
+ textBold?: boolean;
21
+ label?: string;
22
+ }> & Readonly<{}>, {
23
+ textColor: ColorPalette;
24
+ textSize: BodyText;
25
+ textBold: boolean;
26
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
27
+
28
+ declare const __VLS_component_2: DefineComponent<__VLS_PublicProps_3, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
29
+ "update:modelValue": (modelValue: string) => any;
30
+ }, string, PublicProps, Readonly<__VLS_PublicProps_3> & Readonly<{
31
+ "onUpdate:modelValue"?: ((modelValue: string) => any) | undefined;
32
+ }>, {
33
+ type: InputType;
34
+ required: boolean;
35
+ displayBorder: boolean;
36
+ borderColor: ColorPalette;
37
+ rounded: boolean;
38
+ bgColor: ColorPalette;
39
+ displayShadow: boolean;
40
+ displayHighlight: boolean;
41
+ highlightColor: ColorPalette;
42
+ textcolor: ColorPalette;
43
+ placeholder: string;
44
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
45
+
46
+ declare const __VLS_component_3: DefineComponent<__VLS_PublicProps_4, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
47
+ "update:modelValue": (modelValue: string | number | null) => any;
48
+ } & {
49
+ select: (value: string | number) => any;
50
+ clear: () => any;
51
+ open: () => any;
52
+ close: () => any;
53
+ changed: (value: string | number) => any;
54
+ }, string, PublicProps, Readonly<__VLS_PublicProps_4> & Readonly<{
55
+ onSelect?: ((value: string | number) => any) | undefined;
56
+ "onUpdate:modelValue"?: ((modelValue: string | number | null) => any) | undefined;
57
+ onClear?: (() => any) | undefined;
58
+ onOpen?: (() => any) | undefined;
59
+ onClose?: (() => any) | undefined;
60
+ onChanged?: ((value: string | number) => any) | undefined;
61
+ }>, {
62
+ required: boolean;
63
+ displayBorder: boolean;
64
+ borderColor: ColorPalette;
65
+ rounded: boolean;
66
+ bgColor: ColorPalette;
67
+ displayShadow: boolean;
68
+ displayHighlight: boolean;
69
+ highlightColor: ColorPalette;
70
+ textcolor: ColorPalette;
71
+ placeholder: string;
72
+ invalidFeedback: string;
73
+ iconColor: ColorPalette;
74
+ selectColor: ColorPalette;
75
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
11
76
 
12
- declare type __VLS_NonUndefinedable_2<T> = T extends undefined ? never : T;
77
+ declare type __VLS_PublicProps = {
78
+ modelValue?: File | null;
79
+ } & typeof __VLS_typeProps;
13
80
 
14
- declare type __VLS_Prettify<T> = {
15
- [K in keyof T]: T[K];
16
- } & {};
81
+ declare type __VLS_PublicProps_2 = {
82
+ modelValue?: boolean;
83
+ } & typeof __VLS_typeProps_2;
17
84
 
18
- declare type __VLS_Prettify_2<T> = {
19
- [K in keyof T]: T[K];
20
- } & {};
85
+ declare type __VLS_PublicProps_3 = {
86
+ modelValue?: string;
87
+ } & typeof __VLS_typeProps_3;
21
88
 
22
- declare type __VLS_TypePropsToRuntimeProps<T> = {
23
- [K in keyof T]-?: {} extends Pick<T, K> ? {
24
- type: PropType<__VLS_NonUndefinedable<T[K]>>;
25
- } : {
26
- type: PropType<T[K]>;
27
- required: true;
89
+ declare type __VLS_PublicProps_4 = {
90
+ modelValue?: string | number | null;
91
+ } & typeof __VLS_typeProps_4;
92
+
93
+ declare type __VLS_PublicProps_5 = {
94
+ modelValue?: string;
95
+ } & typeof __VLS_typeProps_5;
96
+
97
+ declare type __VLS_PublicProps_6 = {
98
+ modelValue?: boolean;
99
+ } & typeof __VLS_typeProps_6;
100
+
101
+ declare function __VLS_template(): {
102
+ slots: Readonly<{
103
+ default: any;
104
+ label: any;
105
+ }> & {
106
+ default: any;
107
+ label: any;
108
+ };
109
+ refs: {};
110
+ attrs: Partial<{}>;
111
+ };
112
+
113
+ declare function __VLS_template_2(): {
114
+ slots: {
115
+ "invalid-feedback"?(_: {}): any;
28
116
  };
117
+ refs: {};
118
+ attrs: Partial<{}>;
29
119
  };
30
120
 
31
- declare type __VLS_TypePropsToRuntimeProps_2<T> = {
32
- [K in keyof T]-?: {} extends Pick<T, K> ? {
33
- type: PropType<__VLS_NonUndefinedable_2<T[K]>>;
34
- } : {
35
- type: PropType<T[K]>;
36
- required: true;
121
+ declare function __VLS_template_3(): {
122
+ slots: Readonly<{
123
+ dropdown(props: {
124
+ optionClick: (e: Event, option: string | SelectOptionType) => void;
125
+ options: (string | SelectOptionType)[];
126
+ activeIndex: number;
127
+ setRef: (el: Element | ComponentPublicInstance | null, index: number) => void;
128
+ hover: (index: number) => void;
129
+ }): any;
130
+ 'no-match': any;
131
+ }> & {
132
+ dropdown(props: {
133
+ optionClick: (e: Event, option: string | SelectOptionType) => void;
134
+ options: (string | SelectOptionType)[];
135
+ activeIndex: number;
136
+ setRef: (el: Element | ComponentPublicInstance | null, index: number) => void;
137
+ hover: (index: number) => void;
138
+ }): any;
139
+ 'no-match': any;
37
140
  };
141
+ refs: {
142
+ componentRef: HTMLDivElement;
143
+ inputBox: HTMLInputElement;
144
+ dropdownRef: HTMLUListElement;
145
+ };
146
+ attrs: Partial<{}>;
147
+ };
148
+
149
+ declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
150
+
151
+ declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;
152
+
153
+ declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;
154
+
155
+ declare let __VLS_typeProps: {
156
+ id: string;
157
+ displayBorder?: boolean;
158
+ borderColor?: ColorPalette;
159
+ rounded?: boolean;
160
+ bgColor?: ColorPalette;
161
+ buttonText?: string;
162
+ buttonTextColor?: ColorPalette;
163
+ buttonColor?: ColorPalette;
164
+ displayShadow?: boolean;
165
+ textColor?: ColorPalette;
166
+ displayClear?: boolean;
167
+ isRequired?: boolean;
168
+ accept?: string;
169
+ };
170
+
171
+ declare let __VLS_typeProps_2: {
172
+ id: string;
173
+ sliderColor?: ColorPalette;
174
+ onColor?: ColorPalette;
175
+ offColor?: ColorPalette;
176
+ switchSize?: InputSizeType;
177
+ rounded?: boolean;
178
+ };
179
+
180
+ declare let __VLS_typeProps_3: {
181
+ id: string;
182
+ displayBorder?: boolean;
183
+ borderColor?: ColorPalette;
184
+ rounded?: boolean;
185
+ displayHighlight?: boolean;
186
+ highlightColor?: ColorPalette;
187
+ textcolor?: ColorPalette;
188
+ bgColor?: ColorPalette;
189
+ placeholder?: string;
190
+ type?: InputType;
191
+ displayShadow?: boolean;
192
+ required?: boolean;
193
+ invalidFeedback?: string;
194
+ minLength?: number;
195
+ maxLength?: number;
196
+ pattern?: string;
38
197
  };
39
198
 
40
- declare type __VLS_WithDefaults<P, D> = {
41
- [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
42
- default: D[K];
43
- }> : P[K];
199
+ declare let __VLS_typeProps_4: {
200
+ id: string;
201
+ displayBorder?: boolean;
202
+ borderColor?: ColorPalette;
203
+ rounded?: boolean;
204
+ displayHighlight?: boolean;
205
+ highlightColor?: ColorPalette;
206
+ textcolor?: ColorPalette;
207
+ bgColor?: ColorPalette;
208
+ iconColor?: ColorPalette;
209
+ placeholder?: string;
210
+ displayShadow?: boolean;
211
+ required?: boolean;
212
+ options: SelectOptions;
213
+ selectColor?: ColorPalette;
214
+ invalidFeedback?: string;
44
215
  };
45
216
 
46
- declare type __VLS_WithDefaults_2<P, D> = {
47
- [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_2<P[K] & {
48
- default: D[K];
49
- }> : P[K];
217
+ declare let __VLS_typeProps_5: {
218
+ id: string;
219
+ displayBorder?: boolean;
220
+ borderColor?: ColorPalette;
221
+ rounded?: boolean;
222
+ displayHighlight?: boolean;
223
+ highlightColor?: ColorPalette;
224
+ bgColor?: ColorPalette;
225
+ textcolor?: ColorPalette;
226
+ placeholder?: string;
227
+ displayShadow?: boolean;
228
+ required?: boolean;
229
+ rows?: number;
230
+ };
231
+
232
+ declare let __VLS_typeProps_6: {
233
+ id: string;
234
+ inputSize?: InputSizeType;
235
+ bgColor?: ColorPalette;
236
+ checkedBgColor?: ColorPalette;
237
+ checkColor?: ColorPalette;
238
+ borderColor?: ColorPalette;
239
+ displayShadow?: boolean;
240
+ rounded?: boolean;
241
+ value?: string | number;
242
+ checked?: boolean;
50
243
  };
51
244
 
52
245
  declare type __VLS_WithTemplateSlots<T, S> = T & {
@@ -69,756 +262,107 @@ declare type __VLS_WithTemplateSlots_3<T, S> = T & {
69
262
 
70
263
  export declare type InputSizeType = 'sm' | 'md' | 'lg';
71
264
 
72
- export declare const MclCheckbox: DefineComponent< {
73
- modelValue: PropType<boolean>;
74
- rounded: {
75
- type: PropType<boolean>;
76
- default: boolean;
77
- };
78
- id: {
79
- type: PropType<string>;
80
- required: true;
81
- };
82
- inputSize: {
83
- type: PropType<InputSizeType>;
84
- default: string;
85
- };
86
- bgColor: {
87
- type: PropType<ColorPalette>;
88
- default: string;
89
- };
90
- checkedBgColor: {
91
- type: PropType<ColorPalette>;
92
- default: string;
93
- };
94
- checkColor: {
95
- type: PropType<ColorPalette>;
96
- default: string;
97
- };
98
- borderColor: {
99
- type: PropType<ColorPalette>;
100
- default: string;
101
- };
102
- displayShadow: {
103
- type: PropType<boolean>;
104
- default: boolean;
105
- };
106
- value: {
107
- type: PropType<string | number>;
108
- };
109
- checked: {
110
- type: PropType<boolean>;
111
- default: boolean;
112
- };
113
- }, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
114
- "checkbox-click": (event: Event, checked: boolean, value: string | number) => void;
115
- }, string, PublicProps, Readonly<ExtractPropTypes< {
116
- modelValue: PropType<boolean>;
117
- rounded: {
118
- type: PropType<boolean>;
119
- default: boolean;
120
- };
121
- id: {
122
- type: PropType<string>;
123
- required: true;
124
- };
125
- inputSize: {
126
- type: PropType<InputSizeType>;
127
- default: string;
128
- };
129
- bgColor: {
130
- type: PropType<ColorPalette>;
131
- default: string;
132
- };
133
- checkedBgColor: {
134
- type: PropType<ColorPalette>;
135
- default: string;
136
- };
137
- checkColor: {
138
- type: PropType<ColorPalette>;
139
- default: string;
140
- };
141
- borderColor: {
142
- type: PropType<ColorPalette>;
143
- default: string;
144
- };
145
- displayShadow: {
146
- type: PropType<boolean>;
147
- default: boolean;
148
- };
149
- value: {
150
- type: PropType<string | number>;
151
- };
152
- checked: {
153
- type: PropType<boolean>;
154
- default: boolean;
155
- };
156
- }>> & {
265
+ export declare const MclCheckbox: DefineComponent<__VLS_PublicProps_6, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
266
+ "update:modelValue": (modelValue: boolean) => any;
267
+ } & {
268
+ "checkbox-click": (event: Event, checked: boolean, value: string | number) => any;
269
+ }, string, PublicProps, Readonly<__VLS_PublicProps_6> & Readonly<{
270
+ "onUpdate:modelValue"?: ((modelValue: boolean) => any) | undefined;
157
271
  "onCheckbox-click"?: ((event: Event, checked: boolean, value: string | number) => any) | undefined;
158
- }, {
272
+ }>, {
273
+ borderColor: ColorPalette;
159
274
  rounded: boolean;
160
- inputSize: InputSizeType;
161
275
  bgColor: ColorPalette;
162
- checkedBgColor: ColorPalette;
163
- checkColor: ColorPalette;
164
- borderColor: ColorPalette;
165
276
  displayShadow: boolean;
166
277
  checked: boolean;
167
- }, {}>;
278
+ inputSize: InputSizeType;
279
+ checkedBgColor: ColorPalette;
280
+ checkColor: ColorPalette;
281
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
168
282
 
169
- export declare const MclFormGroup: __VLS_WithTemplateSlots<DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
170
- labelFor: string;
171
- textColor?: ColorPalette | undefined;
172
- textSize?: BodyText | undefined;
173
- textBold?: boolean | undefined;
174
- label?: string | undefined;
175
- }>, {
176
- textColor: string;
177
- textSize: string;
178
- textBold: boolean;
179
- }>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
180
- labelFor: string;
181
- textColor?: ColorPalette | undefined;
182
- textSize?: BodyText | undefined;
183
- textBold?: boolean | undefined;
184
- label?: string | undefined;
283
+ export declare const MclFormGroup: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
284
+
285
+ export declare const MclInputFile: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
286
+ "update:modelValue": (modelValue: File | null) => any;
287
+ }, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
288
+ "onUpdate:modelValue"?: ((modelValue: File | null) => any) | undefined;
185
289
  }>, {
186
- textColor: string;
187
- textSize: string;
188
- textBold: boolean;
189
- }>>>, {
190
290
  textColor: ColorPalette;
191
- textSize: BodyText;
192
- textBold: boolean;
193
- }, {}>, Readonly<{
194
- default: any;
195
- label: any;
196
- }> & {
197
- default: any;
198
- label: any;
199
- }>;
200
-
201
- export declare const MclInputFile: DefineComponent< {
202
- modelValue: PropType<File | null>;
203
- rounded: {
204
- type: PropType<boolean>;
205
- default: boolean;
206
- };
207
- id: {
208
- type: PropType<string>;
209
- required: true;
210
- };
211
- bgColor: {
212
- type: PropType<ColorPalette>;
213
- default: string;
214
- };
215
- borderColor: {
216
- type: PropType<ColorPalette>;
217
- default: string;
218
- };
219
- displayShadow: {
220
- type: PropType<boolean>;
221
- default: boolean;
222
- };
223
- textColor: {
224
- type: PropType<ColorPalette>;
225
- default: string;
226
- };
227
- displayBorder: {
228
- type: PropType<boolean>;
229
- default: boolean;
230
- };
231
- buttonText: {
232
- type: PropType<string>;
233
- default: string;
234
- };
235
- buttonTextColor: {
236
- type: PropType<ColorPalette>;
237
- default: string;
238
- };
239
- buttonColor: {
240
- type: PropType<ColorPalette>;
241
- default: string;
242
- };
243
- displayClear: {
244
- type: PropType<boolean>;
245
- default: boolean;
246
- };
247
- isRequired: {
248
- type: PropType<boolean>;
249
- default: boolean;
250
- };
251
- accept: {
252
- type: PropType<string>;
253
- default: string;
254
- };
255
- }, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes< {
256
- modelValue: PropType<File | null>;
257
- rounded: {
258
- type: PropType<boolean>;
259
- default: boolean;
260
- };
261
- id: {
262
- type: PropType<string>;
263
- required: true;
264
- };
265
- bgColor: {
266
- type: PropType<ColorPalette>;
267
- default: string;
268
- };
269
- borderColor: {
270
- type: PropType<ColorPalette>;
271
- default: string;
272
- };
273
- displayShadow: {
274
- type: PropType<boolean>;
275
- default: boolean;
276
- };
277
- textColor: {
278
- type: PropType<ColorPalette>;
279
- default: string;
280
- };
281
- displayBorder: {
282
- type: PropType<boolean>;
283
- default: boolean;
284
- };
285
- buttonText: {
286
- type: PropType<string>;
287
- default: string;
288
- };
289
- buttonTextColor: {
290
- type: PropType<ColorPalette>;
291
- default: string;
292
- };
293
- buttonColor: {
294
- type: PropType<ColorPalette>;
295
- default: string;
296
- };
297
- displayClear: {
298
- type: PropType<boolean>;
299
- default: boolean;
300
- };
301
- isRequired: {
302
- type: PropType<boolean>;
303
- default: boolean;
304
- };
305
- accept: {
306
- type: PropType<string>;
307
- default: string;
308
- };
309
- }>>, {
291
+ displayBorder: boolean;
292
+ borderColor: ColorPalette;
310
293
  rounded: boolean;
311
294
  bgColor: ColorPalette;
312
- borderColor: ColorPalette;
313
- displayShadow: boolean;
314
- textColor: ColorPalette;
315
- displayBorder: boolean;
316
295
  buttonText: string;
317
296
  buttonTextColor: ColorPalette;
318
297
  buttonColor: ColorPalette;
298
+ displayShadow: boolean;
319
299
  displayClear: boolean;
320
300
  isRequired: boolean;
321
301
  accept: string;
322
- }, {}>;
302
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
323
303
 
324
- export declare const MclInputRadio: DefineComponent<__VLS_WithDefaults_2<__VLS_TypePropsToRuntimeProps_2<{
304
+ export declare const MclInputRadio: DefineComponent< {
325
305
  id: string;
326
- radioSize?: InputSizeType | undefined;
327
- bgColor?: ColorPalette | undefined;
328
- checkedColor?: ColorPalette | undefined;
329
- displayShadow?: boolean | undefined;
330
- value?: string | number | undefined;
331
- checked?: boolean | undefined;
332
- }>, {
333
- radioSize: string;
334
- bgColor: string;
335
- checkedColor: string;
336
- displayShadow: boolean;
337
- value: string;
338
- checked: boolean;
339
- }>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
340
- change: (event: Event, value: string | number) => void;
341
- }, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_2<__VLS_TypePropsToRuntimeProps_2<{
306
+ radioSize?: InputSizeType;
307
+ bgColor?: ColorPalette;
308
+ checkedColor?: ColorPalette;
309
+ displayShadow?: boolean;
310
+ value?: string | number;
311
+ checked?: boolean;
312
+ }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
313
+ change: (event: Event, value: string | number) => any;
314
+ }, string, PublicProps, Readonly<{
342
315
  id: string;
343
- radioSize?: InputSizeType | undefined;
344
- bgColor?: ColorPalette | undefined;
345
- checkedColor?: ColorPalette | undefined;
346
- displayShadow?: boolean | undefined;
347
- value?: string | number | undefined;
348
- checked?: boolean | undefined;
349
- }>, {
350
- radioSize: string;
351
- bgColor: string;
352
- checkedColor: string;
353
- displayShadow: boolean;
354
- value: string;
355
- checked: boolean;
356
- }>>> & {
316
+ radioSize?: InputSizeType;
317
+ bgColor?: ColorPalette;
318
+ checkedColor?: ColorPalette;
319
+ displayShadow?: boolean;
320
+ value?: string | number;
321
+ checked?: boolean;
322
+ }> & Readonly<{
357
323
  onChange?: ((event: Event, value: string | number) => any) | undefined;
358
- }, {
324
+ }>, {
359
325
  bgColor: ColorPalette;
360
326
  displayShadow: boolean;
361
- value: string | number;
362
- checked: boolean;
363
327
  radioSize: InputSizeType;
364
328
  checkedColor: ColorPalette;
365
- }, {}>;
329
+ value: string | number;
330
+ checked: boolean;
331
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
366
332
 
367
- export declare const MclInputSwitch: DefineComponent< {
368
- modelValue: PropType<boolean>;
369
- rounded: {
370
- type: PropType<boolean>;
371
- default: boolean;
372
- };
373
- id: {
374
- type: PropType<string>;
375
- required: true;
376
- };
377
- sliderColor: {
378
- type: PropType<ColorPalette>;
379
- default: string;
380
- };
381
- onColor: {
382
- type: PropType<ColorPalette>;
383
- default: string;
384
- };
385
- offColor: {
386
- type: PropType<ColorPalette>;
387
- default: string;
388
- };
389
- switchSize: {
390
- type: PropType<InputSizeType>;
391
- default: string;
392
- };
393
- }, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes< {
394
- modelValue: PropType<boolean>;
395
- rounded: {
396
- type: PropType<boolean>;
397
- default: boolean;
398
- };
399
- id: {
400
- type: PropType<string>;
401
- required: true;
402
- };
403
- sliderColor: {
404
- type: PropType<ColorPalette>;
405
- default: string;
406
- };
407
- onColor: {
408
- type: PropType<ColorPalette>;
409
- default: string;
410
- };
411
- offColor: {
412
- type: PropType<ColorPalette>;
413
- default: string;
414
- };
415
- switchSize: {
416
- type: PropType<InputSizeType>;
417
- default: string;
418
- };
419
- }>>, {
333
+ export declare const MclInputSwitch: DefineComponent<__VLS_PublicProps_2, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
334
+ "update:modelValue": (modelValue: boolean) => any;
335
+ }, string, PublicProps, Readonly<__VLS_PublicProps_2> & Readonly<{
336
+ "onUpdate:modelValue"?: ((modelValue: boolean) => any) | undefined;
337
+ }>, {
420
338
  rounded: boolean;
421
339
  sliderColor: ColorPalette;
422
340
  onColor: ColorPalette;
423
341
  offColor: ColorPalette;
424
342
  switchSize: InputSizeType;
425
- }, {}>;
343
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
426
344
 
427
- export declare const MclInputText: __VLS_WithTemplateSlots_2<DefineComponent< {
428
- modelValue: PropType<string>;
429
- pattern: {
430
- type: PropType<string>;
431
- };
432
- rounded: {
433
- type: PropType<boolean>;
434
- default: boolean;
435
- };
436
- type: {
437
- type: PropType<InputType>;
438
- default: string;
439
- };
440
- id: {
441
- type: PropType<string>;
442
- required: true;
443
- };
444
- bgColor: {
445
- type: PropType<ColorPalette>;
446
- default: string;
447
- };
448
- borderColor: {
449
- type: PropType<ColorPalette>;
450
- default: string;
451
- };
452
- displayShadow: {
453
- type: PropType<boolean>;
454
- default: boolean;
455
- };
456
- required: {
457
- type: PropType<boolean>;
458
- default: boolean;
459
- };
460
- displayBorder: {
461
- type: PropType<boolean>;
462
- default: boolean;
463
- };
464
- displayHighlight: {
465
- type: PropType<boolean>;
466
- default: boolean;
467
- };
468
- highlightColor: {
469
- type: PropType<ColorPalette>;
470
- default: string;
471
- };
472
- textcolor: {
473
- type: PropType<ColorPalette>;
474
- default: string;
475
- };
476
- placeholder: {
477
- type: PropType<string>;
478
- default: string;
479
- };
480
- invalidFeedback: {
481
- type: PropType<string>;
482
- };
483
- minLength: {
484
- type: PropType<number>;
485
- };
486
- maxLength: {
487
- type: PropType<number>;
488
- };
489
- }, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes< {
490
- modelValue: PropType<string>;
491
- pattern: {
492
- type: PropType<string>;
493
- };
494
- rounded: {
495
- type: PropType<boolean>;
496
- default: boolean;
497
- };
498
- type: {
499
- type: PropType<InputType>;
500
- default: string;
501
- };
502
- id: {
503
- type: PropType<string>;
504
- required: true;
505
- };
506
- bgColor: {
507
- type: PropType<ColorPalette>;
508
- default: string;
509
- };
510
- borderColor: {
511
- type: PropType<ColorPalette>;
512
- default: string;
513
- };
514
- displayShadow: {
515
- type: PropType<boolean>;
516
- default: boolean;
517
- };
518
- required: {
519
- type: PropType<boolean>;
520
- default: boolean;
521
- };
522
- displayBorder: {
523
- type: PropType<boolean>;
524
- default: boolean;
525
- };
526
- displayHighlight: {
527
- type: PropType<boolean>;
528
- default: boolean;
529
- };
530
- highlightColor: {
531
- type: PropType<ColorPalette>;
532
- default: string;
533
- };
534
- textcolor: {
535
- type: PropType<ColorPalette>;
536
- default: string;
537
- };
538
- placeholder: {
539
- type: PropType<string>;
540
- default: string;
541
- };
542
- invalidFeedback: {
543
- type: PropType<string>;
544
- };
545
- minLength: {
546
- type: PropType<number>;
547
- };
548
- maxLength: {
549
- type: PropType<number>;
550
- };
551
- }>>, {
552
- rounded: boolean;
553
- type: InputType;
554
- bgColor: ColorPalette;
555
- borderColor: ColorPalette;
556
- displayShadow: boolean;
345
+ export declare const MclInputText: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;
346
+
347
+ export declare const MclSelect: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;
348
+
349
+ export declare const MclTextArea: DefineComponent<__VLS_PublicProps_5, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
350
+ "update:modelValue": (modelValue: string) => any;
351
+ }, string, PublicProps, Readonly<__VLS_PublicProps_5> & Readonly<{
352
+ "onUpdate:modelValue"?: ((modelValue: string) => any) | undefined;
353
+ }>, {
557
354
  required: boolean;
558
355
  displayBorder: boolean;
559
- displayHighlight: boolean;
560
- highlightColor: ColorPalette;
561
- textcolor: ColorPalette;
562
- placeholder: string;
563
- }, {}>, {
564
- "invalid-feedback"?(_: {}): any;
565
- }>;
566
-
567
- export declare const MclSelect: __VLS_WithTemplateSlots_3<DefineComponent< {
568
- modelValue: PropType<string | number>;
569
- rounded: {
570
- type: PropType<boolean>;
571
- default: boolean;
572
- };
573
- id: {
574
- type: PropType<string>;
575
- required: true;
576
- };
577
- bgColor: {
578
- type: PropType<ColorPalette>;
579
- default: string;
580
- };
581
- borderColor: {
582
- type: PropType<ColorPalette>;
583
- default: string;
584
- };
585
- displayShadow: {
586
- type: PropType<boolean>;
587
- default: boolean;
588
- };
589
- required: {
590
- type: PropType<boolean>;
591
- default: boolean;
592
- };
593
- displayBorder: {
594
- type: PropType<boolean>;
595
- default: boolean;
596
- };
597
- displayHighlight: {
598
- type: PropType<boolean>;
599
- default: boolean;
600
- };
601
- highlightColor: {
602
- type: PropType<ColorPalette>;
603
- default: string;
604
- };
605
- textcolor: {
606
- type: PropType<ColorPalette>;
607
- default: string;
608
- };
609
- placeholder: {
610
- type: PropType<string>;
611
- default: string;
612
- };
613
- invalidFeedback: {
614
- type: PropType<string>;
615
- default: string;
616
- };
617
- iconColor: {
618
- type: PropType<ColorPalette>;
619
- default: string;
620
- };
621
- options: {
622
- type: PropType<SelectOptions>;
623
- required: true;
624
- };
625
- selectColor: {
626
- type: PropType<ColorPalette>;
627
- default: string;
628
- };
629
- }, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes< {
630
- modelValue: PropType<string | number>;
631
- rounded: {
632
- type: PropType<boolean>;
633
- default: boolean;
634
- };
635
- id: {
636
- type: PropType<string>;
637
- required: true;
638
- };
639
- bgColor: {
640
- type: PropType<ColorPalette>;
641
- default: string;
642
- };
643
- borderColor: {
644
- type: PropType<ColorPalette>;
645
- default: string;
646
- };
647
- displayShadow: {
648
- type: PropType<boolean>;
649
- default: boolean;
650
- };
651
- required: {
652
- type: PropType<boolean>;
653
- default: boolean;
654
- };
655
- displayBorder: {
656
- type: PropType<boolean>;
657
- default: boolean;
658
- };
659
- displayHighlight: {
660
- type: PropType<boolean>;
661
- default: boolean;
662
- };
663
- highlightColor: {
664
- type: PropType<ColorPalette>;
665
- default: string;
666
- };
667
- textcolor: {
668
- type: PropType<ColorPalette>;
669
- default: string;
670
- };
671
- placeholder: {
672
- type: PropType<string>;
673
- default: string;
674
- };
675
- invalidFeedback: {
676
- type: PropType<string>;
677
- default: string;
678
- };
679
- iconColor: {
680
- type: PropType<ColorPalette>;
681
- default: string;
682
- };
683
- options: {
684
- type: PropType<SelectOptions>;
685
- required: true;
686
- };
687
- selectColor: {
688
- type: PropType<ColorPalette>;
689
- default: string;
690
- };
691
- }>>, {
692
- rounded: boolean;
693
- bgColor: ColorPalette;
694
356
  borderColor: ColorPalette;
695
- displayShadow: boolean;
696
- required: boolean;
697
- displayBorder: boolean;
698
- displayHighlight: boolean;
699
- highlightColor: ColorPalette;
700
- textcolor: ColorPalette;
701
- placeholder: string;
702
- invalidFeedback: string;
703
- iconColor: ColorPalette;
704
- selectColor: ColorPalette;
705
- }, {}>, {
706
- "no-match"?(_: {}): any;
707
- }>;
708
-
709
- export declare const MclTextArea: DefineComponent< {
710
- modelValue: PropType<string>;
711
- rounded: {
712
- type: PropType<boolean>;
713
- default: boolean;
714
- };
715
- id: {
716
- type: PropType<string>;
717
- required: true;
718
- };
719
- bgColor: {
720
- type: PropType<ColorPalette>;
721
- default: string;
722
- };
723
- borderColor: {
724
- type: PropType<ColorPalette>;
725
- default: string;
726
- };
727
- displayShadow: {
728
- type: PropType<boolean>;
729
- default: boolean;
730
- };
731
- required: {
732
- type: PropType<boolean>;
733
- default: boolean;
734
- };
735
- displayBorder: {
736
- type: PropType<boolean>;
737
- default: boolean;
738
- };
739
- displayHighlight: {
740
- type: PropType<boolean>;
741
- default: boolean;
742
- };
743
- highlightColor: {
744
- type: PropType<ColorPalette>;
745
- default: string;
746
- };
747
- textcolor: {
748
- type: PropType<ColorPalette>;
749
- default: string;
750
- };
751
- placeholder: {
752
- type: PropType<string>;
753
- default: string;
754
- };
755
- rows: {
756
- type: PropType<number>;
757
- default: number;
758
- };
759
- }, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes< {
760
- modelValue: PropType<string>;
761
- rounded: {
762
- type: PropType<boolean>;
763
- default: boolean;
764
- };
765
- id: {
766
- type: PropType<string>;
767
- required: true;
768
- };
769
- bgColor: {
770
- type: PropType<ColorPalette>;
771
- default: string;
772
- };
773
- borderColor: {
774
- type: PropType<ColorPalette>;
775
- default: string;
776
- };
777
- displayShadow: {
778
- type: PropType<boolean>;
779
- default: boolean;
780
- };
781
- required: {
782
- type: PropType<boolean>;
783
- default: boolean;
784
- };
785
- displayBorder: {
786
- type: PropType<boolean>;
787
- default: boolean;
788
- };
789
- displayHighlight: {
790
- type: PropType<boolean>;
791
- default: boolean;
792
- };
793
- highlightColor: {
794
- type: PropType<ColorPalette>;
795
- default: string;
796
- };
797
- textcolor: {
798
- type: PropType<ColorPalette>;
799
- default: string;
800
- };
801
- placeholder: {
802
- type: PropType<string>;
803
- default: string;
804
- };
805
- rows: {
806
- type: PropType<number>;
807
- default: number;
808
- };
809
- }>>, {
810
357
  rounded: boolean;
811
358
  bgColor: ColorPalette;
812
- borderColor: ColorPalette;
813
359
  displayShadow: boolean;
814
- required: boolean;
815
- displayBorder: boolean;
816
360
  displayHighlight: boolean;
817
361
  highlightColor: ColorPalette;
818
362
  textcolor: ColorPalette;
819
363
  placeholder: string;
820
364
  rows: number;
821
- }, {}>;
365
+ }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
822
366
 
823
367
  export declare type SelectOptions = SelectOptionType[] | string[];
824
368