@volverjs/form-vue 1.1.2 → 1.1.4

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 (17) hide show
  1. package/dist/index.d.ts +973 -2
  2. package/dist/index.es.js +150 -71
  3. package/dist/index.umd.js +1 -1
  4. package/package.json +18 -18
  5. package/src/VvForm.ts +1 -3
  6. package/src/index.ts +3 -3
  7. package/src/shims.d.ts +8 -0
  8. package/src/utils.ts +127 -164
  9. package/dist/src/index.d.ts +0 -972
  10. /package/dist/{src/VvForm.d.ts → VvForm.d.ts} +0 -0
  11. /package/dist/{src/VvFormField.d.ts → VvFormField.d.ts} +0 -0
  12. /package/dist/{src/VvFormFieldsGroup.d.ts → VvFormFieldsGroup.d.ts} +0 -0
  13. /package/dist/{src/VvFormTemplate.d.ts → VvFormTemplate.d.ts} +0 -0
  14. /package/dist/{src/VvFormWrapper.d.ts → VvFormWrapper.d.ts} +0 -0
  15. /package/dist/{src/enums.d.ts → enums.d.ts} +0 -0
  16. /package/dist/{src/types.d.ts → types.d.ts} +0 -0
  17. /package/dist/{src/utils.d.ts → utils.d.ts} +0 -0
package/dist/index.d.ts CHANGED
@@ -1,2 +1,973 @@
1
- export * from './src/index'
2
- export {}
1
+ import { InjectionKey, Plugin } from 'vue';
2
+ import { defineForm } from './VvForm';
3
+ import { defineFormField } from './VvFormField';
4
+ import { defineFormFieldsGroup } from './VvFormFieldsGroup';
5
+ import { defineFormWrapper } from './VvFormWrapper';
6
+ import { defineFormTemplate } from './VvFormTemplate';
7
+ import { InjectedFormData, InjectedFormWrapperData, InjectedFormFieldData, FormComposableOptions, FormPluginOptions, FormTemplateItem, Path, PathValue, FormSchema, FormTemplate } from './types';
8
+ declare function _formType<Schema extends FormSchema, Type>(schema: Schema, options?: FormComposableOptions<Schema, Type>): {
9
+ clear: () => void;
10
+ errors: import('vue').Ref<import('./types').InferFormattedError<Schema> | undefined, import('./types').InferFormattedError<Schema> | undefined>;
11
+ formData: import('vue').Ref<(undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined>;
12
+ formFieldInjectionKey: InjectionKey<InjectedFormFieldData<Schema>>;
13
+ formInjectionKey: InjectionKey<InjectedFormData<Schema, Type>>;
14
+ formWrapperInjectionKey: InjectionKey<InjectedFormWrapperData<Schema>>;
15
+ ignoreUpdates: import('@vueuse/core').IgnoredUpdater;
16
+ invalid: import('vue').ComputedRef<boolean>;
17
+ readonly: import('vue').Ref<boolean, boolean>;
18
+ reset: () => void;
19
+ status: import('vue').Ref<import('./enums').FormStatus | undefined, import('./enums').FormStatus | undefined>;
20
+ stopUpdatesWatch: import('vue').WatchStopHandle;
21
+ submit: (options?: {
22
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
23
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
24
+ } | undefined) => Promise<boolean>;
25
+ validate: (value?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
26
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
27
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
28
+ } | undefined) => Promise<boolean>;
29
+ wrappers: Map<string, InjectedFormWrapperData<Schema>>;
30
+ VvForm: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
31
+ continuousValidation: {
32
+ type: BooleanConstructor;
33
+ default: boolean;
34
+ };
35
+ modelValue: {
36
+ type: ObjectConstructor;
37
+ default: () => {};
38
+ };
39
+ readonly: {
40
+ type: BooleanConstructor;
41
+ default: boolean | undefined;
42
+ };
43
+ tag: {
44
+ type: StringConstructor;
45
+ default: string;
46
+ };
47
+ template: {
48
+ type: import('vue').PropType<FormTemplate<Schema, Type>>;
49
+ default: undefined;
50
+ };
51
+ superRefine: {
52
+ type: import('vue').PropType<(arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>>;
53
+ default: undefined;
54
+ };
55
+ validateFields: {
56
+ type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>[]>;
57
+ default: undefined;
58
+ };
59
+ }>, {
60
+ clear: () => void;
61
+ errors: Readonly<import('vue').Ref<import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined, import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined>>;
62
+ formData: import('vue').Ref<(undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined>;
63
+ ignoreUpdates: import('@vueuse/core').IgnoredUpdater;
64
+ invalid: import('vue').ComputedRef<boolean>;
65
+ isReadonly: import('vue').Ref<boolean, boolean>;
66
+ reset: () => void;
67
+ status: Readonly<import('vue').Ref<import('./enums').FormStatus | undefined, import('./enums').FormStatus | undefined>>;
68
+ stopUpdatesWatch: import('vue').WatchStopHandle;
69
+ submit: () => Promise<boolean>;
70
+ validate: (value?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
71
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
72
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
73
+ } | undefined) => Promise<boolean>;
74
+ wrappers: Map<string, InjectedFormWrapperData<Schema>>;
75
+ }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "reset" | "submit" | "update:modelValue" | "update:readonly")[], "invalid" | "valid" | "reset" | "submit" | "update:modelValue" | "update:readonly", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
76
+ continuousValidation: {
77
+ type: BooleanConstructor;
78
+ default: boolean;
79
+ };
80
+ modelValue: {
81
+ type: ObjectConstructor;
82
+ default: () => {};
83
+ };
84
+ readonly: {
85
+ type: BooleanConstructor;
86
+ default: boolean | undefined;
87
+ };
88
+ tag: {
89
+ type: StringConstructor;
90
+ default: string;
91
+ };
92
+ template: {
93
+ type: import('vue').PropType<FormTemplate<Schema, Type>>;
94
+ default: undefined;
95
+ };
96
+ superRefine: {
97
+ type: import('vue').PropType<(arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>>;
98
+ default: undefined;
99
+ };
100
+ validateFields: {
101
+ type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>[]>;
102
+ default: undefined;
103
+ };
104
+ }>> & Readonly<{
105
+ onInvalid?: ((...args: any[]) => any) | undefined;
106
+ onValid?: ((...args: any[]) => any) | undefined;
107
+ onReset?: ((...args: any[]) => any) | undefined;
108
+ onSubmit?: ((...args: any[]) => any) | undefined;
109
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
110
+ "onUpdate:readonly"?: ((...args: any[]) => any) | undefined;
111
+ }>, {
112
+ readonly: boolean;
113
+ superRefine: (arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>;
114
+ tag: string;
115
+ template: FormTemplate<Schema, Type>;
116
+ continuousValidation: boolean;
117
+ modelValue: Record<string, any>;
118
+ validateFields: Path<import('./types').InferSchema<Schema>>[];
119
+ }, import('vue').SlotsType<{
120
+ default: {
121
+ errors: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
122
+ formData: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
123
+ invalid: import('vue').UnwrapRef<import('vue').ComputedRef<boolean>>;
124
+ readonly: import('vue').UnwrapRef<import('vue').Ref<boolean, boolean>>;
125
+ status: import('vue').UnwrapRef<Readonly<import('vue').Ref<import('./enums').FormStatus | undefined, import('./enums').FormStatus | undefined>>>;
126
+ wrappers: Map<string, InjectedFormWrapperData<Schema>>;
127
+ clear: () => void;
128
+ ignoreUpdates: import('@vueuse/core').IgnoredUpdater;
129
+ reset: () => void;
130
+ stopUpdatesWatch: import('vue').WatchStopHandle;
131
+ submit: (options?: {
132
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
133
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
134
+ } | undefined) => Promise<boolean>;
135
+ validate: (value?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
136
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
137
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
138
+ } | undefined) => Promise<boolean>;
139
+ };
140
+ }>, {}, {}, "invalid" | "valid" | "reset" | "status" | "readonly" | "clear" | "errors" | "validate" | "submit" | "tag" | "template", import('vue').ComponentProvideOptions, true, {}, any>;
141
+ VvFormField: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
142
+ type: {
143
+ type: import('vue').PropType<`${import('./enums').FormFieldType}`>;
144
+ validator: (value: import('./enums').FormFieldType) => boolean;
145
+ default: import('./enums').FormFieldType;
146
+ };
147
+ is: {
148
+ type: import('vue').PropType<import('vue').Component | string>;
149
+ default: undefined;
150
+ };
151
+ name: {
152
+ type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>>;
153
+ required: true;
154
+ };
155
+ props: {
156
+ type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
157
+ default: () => {};
158
+ };
159
+ showValid: {
160
+ type: BooleanConstructor;
161
+ default: boolean;
162
+ };
163
+ defaultValue: {
164
+ type: (ArrayConstructor | NumberConstructor | ObjectConstructor | BooleanConstructor | StringConstructor)[];
165
+ default: undefined;
166
+ };
167
+ lazyLoad: {
168
+ type: BooleanConstructor;
169
+ default: boolean;
170
+ };
171
+ readonly: {
172
+ type: BooleanConstructor;
173
+ default: undefined;
174
+ };
175
+ }>, {
176
+ component: import('vue').ComputedRef<{
177
+ new (...args: any[]): any;
178
+ __isFragment?: never;
179
+ __isTeleport?: never;
180
+ __isSuspense?: never;
181
+ } | import('vue').ConcreteComponent>;
182
+ hasProps: import('vue').ComputedRef<{
183
+ name: {} | ([{
184
+ type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>>;
185
+ required: true;
186
+ }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('../node_modules/@vue/shared').IfAny<V, V, D> : V : V : {
187
+ type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>>;
188
+ required: true;
189
+ });
190
+ invalid: boolean;
191
+ valid: boolean | undefined;
192
+ type: import('./enums').FormFieldType | undefined;
193
+ invalidLabel: string[] | undefined;
194
+ modelValue: unknown;
195
+ readonly: boolean;
196
+ 'onUpdate:modelValue': (value: unknown) => void;
197
+ }>;
198
+ invalid: import('vue').ComputedRef<boolean>;
199
+ }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "update:modelValue" | "update:formData")[], "invalid" | "valid" | "update:modelValue" | "update:formData", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
200
+ type: {
201
+ type: import('vue').PropType<`${import('./enums').FormFieldType}`>;
202
+ validator: (value: import('./enums').FormFieldType) => boolean;
203
+ default: import('./enums').FormFieldType;
204
+ };
205
+ is: {
206
+ type: import('vue').PropType<import('vue').Component | string>;
207
+ default: undefined;
208
+ };
209
+ name: {
210
+ type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>>;
211
+ required: true;
212
+ };
213
+ props: {
214
+ type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
215
+ default: () => {};
216
+ };
217
+ showValid: {
218
+ type: BooleanConstructor;
219
+ default: boolean;
220
+ };
221
+ defaultValue: {
222
+ type: (ArrayConstructor | NumberConstructor | ObjectConstructor | BooleanConstructor | StringConstructor)[];
223
+ default: undefined;
224
+ };
225
+ lazyLoad: {
226
+ type: BooleanConstructor;
227
+ default: boolean;
228
+ };
229
+ readonly: {
230
+ type: BooleanConstructor;
231
+ default: undefined;
232
+ };
233
+ }>> & Readonly<{
234
+ onInvalid?: ((...args: any[]) => any) | undefined;
235
+ onValid?: ((...args: any[]) => any) | undefined;
236
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
237
+ "onUpdate:formData"?: ((...args: any[]) => any) | undefined;
238
+ }>, {
239
+ type: "number" | "text" | "email" | "password" | "tel" | "url" | "search" | "date" | "time" | "datetime-local" | "month" | "week" | "color" | "select" | "checkbox" | "radio" | "textarea" | "radioGroup" | "checkboxGroup" | "combobox" | "custom";
240
+ readonly: boolean;
241
+ props: [{
242
+ type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
243
+ default: () => {};
244
+ }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('../node_modules/@vue/shared').IfAny<V, V, D> : V : V : {
245
+ type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
246
+ default: () => {};
247
+ };
248
+ is: string | import('vue').Component;
249
+ showValid: boolean;
250
+ defaultValue: string | number | boolean | unknown[] | Record<string, any>;
251
+ lazyLoad: boolean;
252
+ }, import('vue').SlotsType<{
253
+ [key: string]: any;
254
+ default: {
255
+ errors: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema> | undefined>;
256
+ formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
257
+ formErrors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
258
+ invalid: boolean;
259
+ invalidLabel?: string[];
260
+ modelValue: any;
261
+ readonly: boolean;
262
+ onUpdate: (value: unknown) => void;
263
+ submit?: InjectedFormData<Schema_1, Type_1>["submit"];
264
+ validate?: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
265
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
266
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
267
+ } | undefined) => Promise<boolean>) | undefined;
268
+ };
269
+ }>, {}, {}, "invalid" | "type" | "errors" | "component" | "hasProps" | "invalidLabel" | "is", import('vue').ComponentProvideOptions, true, {}, any>;
270
+ VvFormFieldsGroup: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
271
+ is: {
272
+ type: import('vue').PropType<import('vue').Component | string>;
273
+ default: undefined;
274
+ };
275
+ names: {
276
+ type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>[] | Record<string, Path<import('./types').InferSchema<Schema>>>>;
277
+ required: true;
278
+ };
279
+ props: {
280
+ type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
281
+ default: () => {};
282
+ };
283
+ showValid: {
284
+ type: BooleanConstructor;
285
+ default: boolean;
286
+ };
287
+ defaultValues: {
288
+ type: import('vue').PropType<Record<Path<import('./types').InferSchema<Schema>>, any>>;
289
+ default: undefined;
290
+ };
291
+ readonly: {
292
+ type: BooleanConstructor;
293
+ default: undefined;
294
+ };
295
+ }>, {
296
+ component: import('vue').ComputedRef<{
297
+ render(): import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
298
+ [key: string]: any;
299
+ }>[];
300
+ }>;
301
+ hasProps: import('vue').ComputedRef<{
302
+ modelValue: Record<string, any>;
303
+ names: {};
304
+ invalid: boolean;
305
+ invalids: Record<string, boolean>;
306
+ valid: boolean | undefined;
307
+ invalidLabels: Record<string, string[]> | undefined;
308
+ readonly: boolean;
309
+ }>;
310
+ invalid: import('vue').ComputedRef<boolean>;
311
+ }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "update:modelValue" | "update:formData")[], "invalid" | "valid" | "update:modelValue" | "update:formData", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
312
+ is: {
313
+ type: import('vue').PropType<import('vue').Component | string>;
314
+ default: undefined;
315
+ };
316
+ names: {
317
+ type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>[] | Record<string, Path<import('./types').InferSchema<Schema>>>>;
318
+ required: true;
319
+ };
320
+ props: {
321
+ type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
322
+ default: () => {};
323
+ };
324
+ showValid: {
325
+ type: BooleanConstructor;
326
+ default: boolean;
327
+ };
328
+ defaultValues: {
329
+ type: import('vue').PropType<Record<Path<import('./types').InferSchema<Schema>>, any>>;
330
+ default: undefined;
331
+ };
332
+ readonly: {
333
+ type: BooleanConstructor;
334
+ default: undefined;
335
+ };
336
+ }>> & Readonly<{
337
+ onInvalid?: ((...args: any[]) => any) | undefined;
338
+ onValid?: ((...args: any[]) => any) | undefined;
339
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
340
+ "onUpdate:formData"?: ((...args: any[]) => any) | undefined;
341
+ }>, {
342
+ readonly: boolean;
343
+ props: [{
344
+ type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
345
+ default: () => {};
346
+ }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('../node_modules/@vue/shared').IfAny<V, V, D> : V : V : {
347
+ type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
348
+ default: () => {};
349
+ };
350
+ is: string | import('vue').Component;
351
+ showValid: boolean;
352
+ defaultValues: [{
353
+ type: import('vue').PropType<Record<Path<import('./types').InferSchema<Schema>>, any>>;
354
+ default: undefined;
355
+ }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('../node_modules/@vue/shared').IfAny<V, V, D> : V : V : {
356
+ type: import('vue').PropType<Record<Path<import('./types').InferSchema<Schema>>, any>>;
357
+ default: undefined;
358
+ };
359
+ }, import('vue').SlotsType<{
360
+ [key: string]: any;
361
+ default: {
362
+ errors?: Record<Path<import('./types').InferSchema<Schema>>, import('./types').InferFormattedError<Schema>> | undefined;
363
+ formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
364
+ formErrors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
365
+ invalid: boolean;
366
+ invalids: Record<string, boolean>;
367
+ invalidLabels?: Record<string, string[]>;
368
+ modelValue: Record<string, any>;
369
+ onUpdate: (value: Record<string, any>) => void;
370
+ onUpdateField: (name: string, value: any) => void;
371
+ readonly: boolean;
372
+ submit?: InjectedFormData<Schema_2, Type_2>["submit"];
373
+ validate?: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
374
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
375
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
376
+ } | undefined) => Promise<boolean>) | undefined;
377
+ };
378
+ }>, {}, {}, "invalid" | "errors" | "component" | "hasProps" | "is" | "invalidLabels", import('vue').ComponentProvideOptions, true, {}, any>;
379
+ VvFormTemplate: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
380
+ schema: {
381
+ type: import('vue').PropType<FormTemplate<Schema, Type>>;
382
+ required: true;
383
+ };
384
+ scope: {
385
+ type: import('vue').PropType<Record<string, unknown>>;
386
+ default: () => {};
387
+ };
388
+ }>, (() => (import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
389
+ [key: string]: any;
390
+ }> | import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
391
+ [key: string]: any;
392
+ }>[] | undefined)[]) | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
393
+ schema: {
394
+ type: import('vue').PropType<FormTemplate<Schema, Type>>;
395
+ required: true;
396
+ };
397
+ scope: {
398
+ type: import('vue').PropType<Record<string, unknown>>;
399
+ default: () => {};
400
+ };
401
+ }>> & Readonly<{}>, {
402
+ scope: Record<string, unknown>;
403
+ }, import('vue').SlotsType<{
404
+ default: {
405
+ errors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
406
+ formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
407
+ invalid: boolean;
408
+ status?: import('./enums').FormStatus;
409
+ submit?: InjectedFormData<Schema_3, Type_3>["submit"];
410
+ validate?: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
411
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
412
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
413
+ } | undefined) => Promise<boolean>) | undefined;
414
+ clear?: InjectedFormData<Schema_3, Type_3>["clear"];
415
+ reset?: InjectedFormData<Schema_3, Type_3>["reset"];
416
+ };
417
+ }>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
418
+ VvFormWrapper: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
419
+ name: {
420
+ type: StringConstructor;
421
+ required: true;
422
+ };
423
+ tag: {
424
+ type: StringConstructor;
425
+ default: undefined;
426
+ };
427
+ readonly: {
428
+ type: BooleanConstructor;
429
+ default: boolean;
430
+ };
431
+ }>, {
432
+ errors: Readonly<import('vue').Ref<import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined, import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined>> | undefined;
433
+ fields: import('vue').Ref<Map<string, Path<import('./types').InferSchema<Schema>>>, Map<string, Path<import('./types').InferSchema<Schema>>>>;
434
+ fieldsErrors: import('vue').Ref<Map<string, import('./types').InferFormattedError<Schema>>, Map<string, import('./types').InferFormattedError<Schema>>>;
435
+ formData: import('vue').Ref<(undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined> | undefined;
436
+ invalid: import('vue').ComputedRef<boolean>;
437
+ readonly: import('vue').ComputedRef<boolean>;
438
+ clear: (() => void) | undefined;
439
+ reset: (() => void) | undefined;
440
+ submit: (() => Promise<boolean>) | undefined;
441
+ validate: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
442
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
443
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
444
+ } | undefined) => Promise<boolean>) | undefined;
445
+ validateWrapper: () => Promise<boolean>;
446
+ }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid")[], "invalid" | "valid", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
447
+ name: {
448
+ type: StringConstructor;
449
+ required: true;
450
+ };
451
+ tag: {
452
+ type: StringConstructor;
453
+ default: undefined;
454
+ };
455
+ readonly: {
456
+ type: BooleanConstructor;
457
+ default: boolean;
458
+ };
459
+ }>> & Readonly<{
460
+ onInvalid?: ((...args: any[]) => any) | undefined;
461
+ onValid?: ((...args: any[]) => any) | undefined;
462
+ }>, {
463
+ readonly: boolean;
464
+ tag: string;
465
+ }, import('vue').SlotsType<{
466
+ default: {
467
+ errors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
468
+ fieldsErrors: Map<string, import('./types').InferFormattedError<Schema>>;
469
+ formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
470
+ formErrors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
471
+ invalid: boolean;
472
+ readonly: boolean;
473
+ clear?: InjectedFormData<Schema_4, Type_4>["clear"];
474
+ reset?: InjectedFormData<Schema_4, Type_4>["reset"];
475
+ submit?: InjectedFormData<Schema_4, Type_4>["submit"];
476
+ validate?: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
477
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
478
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
479
+ } | undefined) => Promise<boolean>) | undefined;
480
+ validateWrapper?: (() => Promise<boolean>) | undefined;
481
+ };
482
+ }>, {}, {}, "invalid" | "reset" | "readonly" | "clear" | "errors" | "validate" | "submit" | "tag" | "formData" | "fields" | "fieldsErrors" | "validateWrapper", import('vue').ComponentProvideOptions, true, {}, any>;
483
+ };
484
+ export declare const pluginInjectionKey: InjectionKey<FormPluginOptions>;
485
+ export declare function createForm(options: FormPluginOptions): Plugin & Partial<ReturnType<typeof useForm>>;
486
+ export declare function useForm<Schema extends FormSchema, Type>(schema: Schema, options?: FormComposableOptions<Schema, Type>): ReturnType<typeof _formType<Schema, Type>>;
487
+ export { FormFieldType } from './enums';
488
+ export { defaultObjectByJSONSchema, defaultObjectBySchema } from './utils';
489
+ type FormComponent = ReturnType<typeof defineForm>;
490
+ type FormWrapperComponent = ReturnType<typeof defineFormWrapper>;
491
+ type FormFieldComponent = ReturnType<typeof defineFormField>;
492
+ type FormFieldsGroupComponent = ReturnType<typeof defineFormFieldsGroup>;
493
+ type FormTemplateComponent = ReturnType<typeof defineFormTemplate>;
494
+ export type { FormComponent, FormComposableOptions, FormFieldComponent, FormFieldsGroupComponent, FormPluginOptions, FormSchema, FormTemplate, FormTemplateComponent, FormTemplateItem, FormWrapperComponent, InjectedFormData, InjectedFormFieldData, InjectedFormWrapperData, Path, PathValue, };
495
+ /**
496
+ * @deprecated Use `useForm()` instead
497
+ */
498
+ export declare function formType<Schema extends FormSchema, Type>(schema: Schema, options?: FormComposableOptions<Schema, Type>): {
499
+ clear: () => void;
500
+ errors: import('vue').Ref<import('./types').InferFormattedError<Schema> | undefined, import('./types').InferFormattedError<Schema> | undefined>;
501
+ formData: import('vue').Ref<(undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined>;
502
+ formFieldInjectionKey: InjectionKey<InjectedFormFieldData<Schema>>;
503
+ formInjectionKey: InjectionKey<InjectedFormData<Schema, Type>>;
504
+ formWrapperInjectionKey: InjectionKey<InjectedFormWrapperData<Schema>>;
505
+ ignoreUpdates: import('@vueuse/core').IgnoredUpdater;
506
+ invalid: import('vue').ComputedRef<boolean>;
507
+ readonly: import('vue').Ref<boolean, boolean>;
508
+ reset: () => void;
509
+ status: import('vue').Ref<import('./enums').FormStatus | undefined, import('./enums').FormStatus | undefined>;
510
+ stopUpdatesWatch: import('vue').WatchStopHandle;
511
+ submit: (options?: {
512
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
513
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
514
+ } | undefined) => Promise<boolean>;
515
+ validate: (value?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
516
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
517
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
518
+ } | undefined) => Promise<boolean>;
519
+ wrappers: Map<string, InjectedFormWrapperData<Schema>>;
520
+ VvForm: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
521
+ continuousValidation: {
522
+ type: BooleanConstructor;
523
+ default: boolean;
524
+ };
525
+ modelValue: {
526
+ type: ObjectConstructor;
527
+ default: () => {};
528
+ };
529
+ readonly: {
530
+ type: BooleanConstructor;
531
+ default: boolean | undefined;
532
+ };
533
+ tag: {
534
+ type: StringConstructor;
535
+ default: string;
536
+ };
537
+ template: {
538
+ type: import('vue').PropType<FormTemplate<Schema, Type>>;
539
+ default: undefined;
540
+ };
541
+ superRefine: {
542
+ type: import('vue').PropType<(arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>>;
543
+ default: undefined;
544
+ };
545
+ validateFields: {
546
+ type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>[]>;
547
+ default: undefined;
548
+ };
549
+ }>, {
550
+ clear: () => void;
551
+ errors: Readonly<import('vue').Ref<import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined, import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined>>;
552
+ formData: import('vue').Ref<(undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined>;
553
+ ignoreUpdates: import('@vueuse/core').IgnoredUpdater;
554
+ invalid: import('vue').ComputedRef<boolean>;
555
+ isReadonly: import('vue').Ref<boolean, boolean>;
556
+ reset: () => void;
557
+ status: Readonly<import('vue').Ref<import('./enums').FormStatus | undefined, import('./enums').FormStatus | undefined>>;
558
+ stopUpdatesWatch: import('vue').WatchStopHandle;
559
+ submit: () => Promise<boolean>;
560
+ validate: (value?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
561
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
562
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
563
+ } | undefined) => Promise<boolean>;
564
+ wrappers: Map<string, InjectedFormWrapperData<Schema>>;
565
+ }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "reset" | "submit" | "update:modelValue" | "update:readonly")[], "invalid" | "valid" | "reset" | "submit" | "update:modelValue" | "update:readonly", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
566
+ continuousValidation: {
567
+ type: BooleanConstructor;
568
+ default: boolean;
569
+ };
570
+ modelValue: {
571
+ type: ObjectConstructor;
572
+ default: () => {};
573
+ };
574
+ readonly: {
575
+ type: BooleanConstructor;
576
+ default: boolean | undefined;
577
+ };
578
+ tag: {
579
+ type: StringConstructor;
580
+ default: string;
581
+ };
582
+ template: {
583
+ type: import('vue').PropType<FormTemplate<Schema, Type>>;
584
+ default: undefined;
585
+ };
586
+ superRefine: {
587
+ type: import('vue').PropType<(arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>>;
588
+ default: undefined;
589
+ };
590
+ validateFields: {
591
+ type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>[]>;
592
+ default: undefined;
593
+ };
594
+ }>> & Readonly<{
595
+ onInvalid?: ((...args: any[]) => any) | undefined;
596
+ onValid?: ((...args: any[]) => any) | undefined;
597
+ onReset?: ((...args: any[]) => any) | undefined;
598
+ onSubmit?: ((...args: any[]) => any) | undefined;
599
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
600
+ "onUpdate:readonly"?: ((...args: any[]) => any) | undefined;
601
+ }>, {
602
+ readonly: boolean;
603
+ superRefine: (arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>;
604
+ tag: string;
605
+ template: FormTemplate<Schema, Type>;
606
+ continuousValidation: boolean;
607
+ modelValue: Record<string, any>;
608
+ validateFields: Path<import('./types').InferSchema<Schema>>[];
609
+ }, import('vue').SlotsType<{
610
+ default: {
611
+ errors: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
612
+ formData: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
613
+ invalid: import('vue').UnwrapRef<import('vue').ComputedRef<boolean>>;
614
+ readonly: import('vue').UnwrapRef<import('vue').Ref<boolean, boolean>>;
615
+ status: import('vue').UnwrapRef<Readonly<import('vue').Ref<import('./enums').FormStatus | undefined, import('./enums').FormStatus | undefined>>>;
616
+ wrappers: Map<string, InjectedFormWrapperData<Schema>>;
617
+ clear: () => void;
618
+ ignoreUpdates: import('@vueuse/core').IgnoredUpdater;
619
+ reset: () => void;
620
+ stopUpdatesWatch: import('vue').WatchStopHandle;
621
+ submit: (options?: {
622
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
623
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
624
+ } | undefined) => Promise<boolean>;
625
+ validate: (value?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
626
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
627
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
628
+ } | undefined) => Promise<boolean>;
629
+ };
630
+ }>, {}, {}, "invalid" | "valid" | "reset" | "status" | "readonly" | "clear" | "errors" | "validate" | "submit" | "tag" | "template", import('vue').ComponentProvideOptions, true, {}, any>;
631
+ VvFormField: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
632
+ type: {
633
+ type: import('vue').PropType<`${import('./enums').FormFieldType}`>;
634
+ validator: (value: import('./enums').FormFieldType) => boolean;
635
+ default: import('./enums').FormFieldType;
636
+ };
637
+ is: {
638
+ type: import('vue').PropType<import('vue').Component | string>;
639
+ default: undefined;
640
+ };
641
+ name: {
642
+ type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>>;
643
+ required: true;
644
+ };
645
+ props: {
646
+ type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
647
+ default: () => {};
648
+ };
649
+ showValid: {
650
+ type: BooleanConstructor;
651
+ default: boolean;
652
+ };
653
+ defaultValue: {
654
+ type: (ArrayConstructor | NumberConstructor | ObjectConstructor | BooleanConstructor | StringConstructor)[];
655
+ default: undefined;
656
+ };
657
+ lazyLoad: {
658
+ type: BooleanConstructor;
659
+ default: boolean;
660
+ };
661
+ readonly: {
662
+ type: BooleanConstructor;
663
+ default: undefined;
664
+ };
665
+ }>, {
666
+ component: import('vue').ComputedRef<{
667
+ new (...args: any[]): any;
668
+ __isFragment?: never;
669
+ __isTeleport?: never;
670
+ __isSuspense?: never;
671
+ } | import('vue').ConcreteComponent>;
672
+ hasProps: import('vue').ComputedRef<{
673
+ name: {} | ([{
674
+ type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>>;
675
+ required: true;
676
+ }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('../node_modules/@vue/shared').IfAny<V, V, D> : V : V : {
677
+ type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>>;
678
+ required: true;
679
+ });
680
+ invalid: boolean;
681
+ valid: boolean | undefined;
682
+ type: import('./enums').FormFieldType | undefined;
683
+ invalidLabel: string[] | undefined;
684
+ modelValue: unknown;
685
+ readonly: boolean;
686
+ 'onUpdate:modelValue': (value: unknown) => void;
687
+ }>;
688
+ invalid: import('vue').ComputedRef<boolean>;
689
+ }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "update:modelValue" | "update:formData")[], "invalid" | "valid" | "update:modelValue" | "update:formData", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
690
+ type: {
691
+ type: import('vue').PropType<`${import('./enums').FormFieldType}`>;
692
+ validator: (value: import('./enums').FormFieldType) => boolean;
693
+ default: import('./enums').FormFieldType;
694
+ };
695
+ is: {
696
+ type: import('vue').PropType<import('vue').Component | string>;
697
+ default: undefined;
698
+ };
699
+ name: {
700
+ type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>>;
701
+ required: true;
702
+ };
703
+ props: {
704
+ type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
705
+ default: () => {};
706
+ };
707
+ showValid: {
708
+ type: BooleanConstructor;
709
+ default: boolean;
710
+ };
711
+ defaultValue: {
712
+ type: (ArrayConstructor | NumberConstructor | ObjectConstructor | BooleanConstructor | StringConstructor)[];
713
+ default: undefined;
714
+ };
715
+ lazyLoad: {
716
+ type: BooleanConstructor;
717
+ default: boolean;
718
+ };
719
+ readonly: {
720
+ type: BooleanConstructor;
721
+ default: undefined;
722
+ };
723
+ }>> & Readonly<{
724
+ onInvalid?: ((...args: any[]) => any) | undefined;
725
+ onValid?: ((...args: any[]) => any) | undefined;
726
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
727
+ "onUpdate:formData"?: ((...args: any[]) => any) | undefined;
728
+ }>, {
729
+ type: "number" | "text" | "email" | "password" | "tel" | "url" | "search" | "date" | "time" | "datetime-local" | "month" | "week" | "color" | "select" | "checkbox" | "radio" | "textarea" | "radioGroup" | "checkboxGroup" | "combobox" | "custom";
730
+ readonly: boolean;
731
+ props: [{
732
+ type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
733
+ default: () => {};
734
+ }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('../node_modules/@vue/shared').IfAny<V, V, D> : V : V : {
735
+ type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
736
+ default: () => {};
737
+ };
738
+ is: string | import('vue').Component;
739
+ showValid: boolean;
740
+ defaultValue: string | number | boolean | unknown[] | Record<string, any>;
741
+ lazyLoad: boolean;
742
+ }, import('vue').SlotsType<{
743
+ [key: string]: any;
744
+ default: {
745
+ errors: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema> | undefined>;
746
+ formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
747
+ formErrors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
748
+ invalid: boolean;
749
+ invalidLabel?: string[];
750
+ modelValue: any;
751
+ readonly: boolean;
752
+ onUpdate: (value: unknown) => void;
753
+ submit?: InjectedFormData<Schema_1, Type_1>["submit"];
754
+ validate?: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
755
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
756
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
757
+ } | undefined) => Promise<boolean>) | undefined;
758
+ };
759
+ }>, {}, {}, "invalid" | "type" | "errors" | "component" | "hasProps" | "invalidLabel" | "is", import('vue').ComponentProvideOptions, true, {}, any>;
760
+ VvFormFieldsGroup: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
761
+ is: {
762
+ type: import('vue').PropType<import('vue').Component | string>;
763
+ default: undefined;
764
+ };
765
+ names: {
766
+ type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>[] | Record<string, Path<import('./types').InferSchema<Schema>>>>;
767
+ required: true;
768
+ };
769
+ props: {
770
+ type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
771
+ default: () => {};
772
+ };
773
+ showValid: {
774
+ type: BooleanConstructor;
775
+ default: boolean;
776
+ };
777
+ defaultValues: {
778
+ type: import('vue').PropType<Record<Path<import('./types').InferSchema<Schema>>, any>>;
779
+ default: undefined;
780
+ };
781
+ readonly: {
782
+ type: BooleanConstructor;
783
+ default: undefined;
784
+ };
785
+ }>, {
786
+ component: import('vue').ComputedRef<{
787
+ render(): import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
788
+ [key: string]: any;
789
+ }>[];
790
+ }>;
791
+ hasProps: import('vue').ComputedRef<{
792
+ modelValue: Record<string, any>;
793
+ names: {};
794
+ invalid: boolean;
795
+ invalids: Record<string, boolean>;
796
+ valid: boolean | undefined;
797
+ invalidLabels: Record<string, string[]> | undefined;
798
+ readonly: boolean;
799
+ }>;
800
+ invalid: import('vue').ComputedRef<boolean>;
801
+ }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "update:modelValue" | "update:formData")[], "invalid" | "valid" | "update:modelValue" | "update:formData", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
802
+ is: {
803
+ type: import('vue').PropType<import('vue').Component | string>;
804
+ default: undefined;
805
+ };
806
+ names: {
807
+ type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>[] | Record<string, Path<import('./types').InferSchema<Schema>>>>;
808
+ required: true;
809
+ };
810
+ props: {
811
+ type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
812
+ default: () => {};
813
+ };
814
+ showValid: {
815
+ type: BooleanConstructor;
816
+ default: boolean;
817
+ };
818
+ defaultValues: {
819
+ type: import('vue').PropType<Record<Path<import('./types').InferSchema<Schema>>, any>>;
820
+ default: undefined;
821
+ };
822
+ readonly: {
823
+ type: BooleanConstructor;
824
+ default: undefined;
825
+ };
826
+ }>> & Readonly<{
827
+ onInvalid?: ((...args: any[]) => any) | undefined;
828
+ onValid?: ((...args: any[]) => any) | undefined;
829
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
830
+ "onUpdate:formData"?: ((...args: any[]) => any) | undefined;
831
+ }>, {
832
+ readonly: boolean;
833
+ props: [{
834
+ type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
835
+ default: () => {};
836
+ }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('../node_modules/@vue/shared').IfAny<V, V, D> : V : V : {
837
+ type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
838
+ default: () => {};
839
+ };
840
+ is: string | import('vue').Component;
841
+ showValid: boolean;
842
+ defaultValues: [{
843
+ type: import('vue').PropType<Record<Path<import('./types').InferSchema<Schema>>, any>>;
844
+ default: undefined;
845
+ }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('../node_modules/@vue/shared').IfAny<V, V, D> : V : V : {
846
+ type: import('vue').PropType<Record<Path<import('./types').InferSchema<Schema>>, any>>;
847
+ default: undefined;
848
+ };
849
+ }, import('vue').SlotsType<{
850
+ [key: string]: any;
851
+ default: {
852
+ errors?: Record<Path<import('./types').InferSchema<Schema>>, import('./types').InferFormattedError<Schema>> | undefined;
853
+ formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
854
+ formErrors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
855
+ invalid: boolean;
856
+ invalids: Record<string, boolean>;
857
+ invalidLabels?: Record<string, string[]>;
858
+ modelValue: Record<string, any>;
859
+ onUpdate: (value: Record<string, any>) => void;
860
+ onUpdateField: (name: string, value: any) => void;
861
+ readonly: boolean;
862
+ submit?: InjectedFormData<Schema_2, Type_2>["submit"];
863
+ validate?: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
864
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
865
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
866
+ } | undefined) => Promise<boolean>) | undefined;
867
+ };
868
+ }>, {}, {}, "invalid" | "errors" | "component" | "hasProps" | "is" | "invalidLabels", import('vue').ComponentProvideOptions, true, {}, any>;
869
+ VvFormTemplate: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
870
+ schema: {
871
+ type: import('vue').PropType<FormTemplate<Schema, Type>>;
872
+ required: true;
873
+ };
874
+ scope: {
875
+ type: import('vue').PropType<Record<string, unknown>>;
876
+ default: () => {};
877
+ };
878
+ }>, (() => (import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
879
+ [key: string]: any;
880
+ }> | import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
881
+ [key: string]: any;
882
+ }>[] | undefined)[]) | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
883
+ schema: {
884
+ type: import('vue').PropType<FormTemplate<Schema, Type>>;
885
+ required: true;
886
+ };
887
+ scope: {
888
+ type: import('vue').PropType<Record<string, unknown>>;
889
+ default: () => {};
890
+ };
891
+ }>> & Readonly<{}>, {
892
+ scope: Record<string, unknown>;
893
+ }, import('vue').SlotsType<{
894
+ default: {
895
+ errors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
896
+ formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
897
+ invalid: boolean;
898
+ status?: import('./enums').FormStatus;
899
+ submit?: InjectedFormData<Schema_3, Type_3>["submit"];
900
+ validate?: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
901
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
902
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
903
+ } | undefined) => Promise<boolean>) | undefined;
904
+ clear?: InjectedFormData<Schema_3, Type_3>["clear"];
905
+ reset?: InjectedFormData<Schema_3, Type_3>["reset"];
906
+ };
907
+ }>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
908
+ VvFormWrapper: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
909
+ name: {
910
+ type: StringConstructor;
911
+ required: true;
912
+ };
913
+ tag: {
914
+ type: StringConstructor;
915
+ default: undefined;
916
+ };
917
+ readonly: {
918
+ type: BooleanConstructor;
919
+ default: boolean;
920
+ };
921
+ }>, {
922
+ errors: Readonly<import('vue').Ref<import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined, import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined>> | undefined;
923
+ fields: import('vue').Ref<Map<string, Path<import('./types').InferSchema<Schema>>>, Map<string, Path<import('./types').InferSchema<Schema>>>>;
924
+ fieldsErrors: import('vue').Ref<Map<string, import('./types').InferFormattedError<Schema>>, Map<string, import('./types').InferFormattedError<Schema>>>;
925
+ formData: import('vue').Ref<(undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined> | undefined;
926
+ invalid: import('vue').ComputedRef<boolean>;
927
+ readonly: import('vue').ComputedRef<boolean>;
928
+ clear: (() => void) | undefined;
929
+ reset: (() => void) | undefined;
930
+ submit: (() => Promise<boolean>) | undefined;
931
+ validate: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
932
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
933
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
934
+ } | undefined) => Promise<boolean>) | undefined;
935
+ validateWrapper: () => Promise<boolean>;
936
+ }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid")[], "invalid" | "valid", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
937
+ name: {
938
+ type: StringConstructor;
939
+ required: true;
940
+ };
941
+ tag: {
942
+ type: StringConstructor;
943
+ default: undefined;
944
+ };
945
+ readonly: {
946
+ type: BooleanConstructor;
947
+ default: boolean;
948
+ };
949
+ }>> & Readonly<{
950
+ onInvalid?: ((...args: any[]) => any) | undefined;
951
+ onValid?: ((...args: any[]) => any) | undefined;
952
+ }>, {
953
+ readonly: boolean;
954
+ tag: string;
955
+ }, import('vue').SlotsType<{
956
+ default: {
957
+ errors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
958
+ fieldsErrors: Map<string, import('./types').InferFormattedError<Schema>>;
959
+ formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
960
+ formErrors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
961
+ invalid: boolean;
962
+ readonly: boolean;
963
+ clear?: InjectedFormData<Schema_4, Type_4>["clear"];
964
+ reset?: InjectedFormData<Schema_4, Type_4>["reset"];
965
+ submit?: InjectedFormData<Schema_4, Type_4>["submit"];
966
+ validate?: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
967
+ fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
968
+ superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
969
+ } | undefined) => Promise<boolean>) | undefined;
970
+ validateWrapper?: (() => Promise<boolean>) | undefined;
971
+ };
972
+ }>, {}, {}, "invalid" | "reset" | "readonly" | "clear" | "errors" | "validate" | "submit" | "tag" | "formData" | "fields" | "fieldsErrors" | "validateWrapper", import('vue').ComponentProvideOptions, true, {}, any>;
973
+ };