@volverjs/form-vue 1.1.1 → 1.1.2-beta.3

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