@volverjs/form-vue 1.0.0-beta.1 → 1.0.0-beta.11

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 24/Consulting
+Copyright (c) 2023-present 8 Wave S.r.l. and contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -10,11 +10,11 @@
 
 <br>
 
-#### proudly powered by
+maintained with ❤️ by
 
 <br>
 
-[![24/Consulting](docs/static/24consulting.svg)](https://24consulting.it)
+[![8 Wave](docs/static/8wave.svg)](https://8wave.it)
 
 <br>
 
@@ -56,7 +56,7 @@ const form = createForm({
   schema
   // lazyLoad: boolean - default false
   // updateThrottle: number - default 500
-  // continuosValidation: boolean - default false
+  // continuousValidation: boolean - default false
   // sideEffects?: (data: any) => void
 })
 
@@ -118,7 +118,7 @@ Use the `v-model` directive (or only `:model-value` to set the initial value of
 The form data two way binding is **throttled** by default (500ms) to avoid performance issues. The throttle can be changed with the `updateThrottle` option or prop.
 
 By default form validation **stops** when a **valid state** is reached.
-To activate **continuos validation** use the `continuosValidation` option or prop.
+To activate **continuous validation** use the `continuousValidation` option or prop.
 
 ```vue
 <script lang="ts" setup>
@@ -131,7 +131,7 @@ To activate **continuos validation** use the `continuosValidation` option or pro
 </script>
 
 <template>
-  <VvForm v-model="formData" :update-throttle="1000" continuos-validation>
+  <VvForm v-model="formData" :update-throttle="1000" continuous-validation>
     <!-- ... -->
   </VvForm>
 </template>
@@ -155,7 +155,7 @@ The **default settings** are **inherited** from the plugin (if it's installed).
   const { VvForm, VvFormWrapper, VvFormField } = useForm(schema, {
     // lazyLoad: boolean - default false
     // updateThrottle: number - default 500
-    // continuosValidation: boolean - default false
+    // continuousValidation: boolean - default false
     // sideEffects?: (formData: any) => void
   })
 </script>

package/dist/VvForm.d.ts

@@ -0,0 +1,203 @@
+import { FormStatus } from './enums';
+import { FormComponentOptions, FormSchema, FormTemplate, InjectedFormData } from './types';
+import { z } from 'zod';
+import { IgnoredUpdater } from '@vueuse/core';
+import { Component, InjectionKey, DeepReadonly, Ref, PropType, WatchStopHandle } from 'vue';
+
+export declare const defineForm: <Schema extends FormSchema>(schema: Schema, provideKey: InjectionKey<InjectedFormData<Schema>>, options?: FormComponentOptions<Schema>, VvFormTemplate?: Component) => {
+    errors: Ref<z.inferFormattedError<Schema, string> | undefined>;
+    status: Ref<FormStatus | undefined>;
+    invalid: import('vue').ComputedRef<boolean>;
+    readonly: Ref<boolean>;
+    formData: Ref<Partial<z.TypeOf<Schema> | undefined>>;
+    validate: (value?: Partial<z.TypeOf<Schema> | undefined>) => Promise<boolean>;
+    submit: () => Promise<boolean>;
+    ignoreUpdates: IgnoredUpdater;
+    stopUpdatesWatch: WatchStopHandle;
+    /**
+     * An hack to add types to the default slot
+     */
+    VvForm: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+            continuousValidation: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            modelValue: {
+                type: ObjectConstructor;
+                default: () => {};
+            };
+            readonly: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            tag: {
+                type: StringConstructor;
+                default: string;
+            };
+            template: {
+                type: PropType<FormTemplate<Schema>>;
+                default: undefined;
+            };
+        }>> & {
+            onInvalid?: ((...args: any[]) => any) | undefined;
+            onValid?: ((...args: any[]) => any) | undefined;
+            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+            onSubmit?: ((...args: any[]) => any) | undefined;
+            "onUpdate:readonly"?: ((...args: any[]) => any) | undefined;
+        }, {
+            formData: Ref<Partial<z.TypeOf<Schema> | undefined>>;
+            submit: () => Promise<boolean>;
+            validate: (value?: Partial<z.TypeOf<Schema> | undefined>) => Promise<boolean>;
+            ignoreUpdates: IgnoredUpdater;
+            stopUpdatesWatch: WatchStopHandle;
+            errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>>;
+            status: Readonly<Ref<FormStatus | undefined>>;
+            invalid: import("vue").ComputedRef<boolean>;
+            isReadonly: Ref<boolean>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("invalid" | "valid" | "update:modelValue" | "submit" | "update:readonly")[], import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+            continuousValidation: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            modelValue: {
+                type: ObjectConstructor;
+                default: () => {};
+            };
+            readonly: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            tag: {
+                type: StringConstructor;
+                default: string;
+            };
+            template: {
+                type: PropType<FormTemplate<Schema>>;
+                default: undefined;
+            };
+        }>> & {
+            onInvalid?: ((...args: any[]) => any) | undefined;
+            onValid?: ((...args: any[]) => any) | undefined;
+            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+            onSubmit?: ((...args: any[]) => any) | undefined;
+            "onUpdate:readonly"?: ((...args: any[]) => any) | undefined;
+        }, {
+            readonly: boolean;
+            template: FormTemplate<Schema>;
+            modelValue: Record<string, any>;
+            continuousValidation: boolean;
+            tag: string;
+        }, true, {}, {}, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            continuousValidation: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            modelValue: {
+                type: ObjectConstructor;
+                default: () => {};
+            };
+            readonly: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            tag: {
+                type: StringConstructor;
+                default: string;
+            };
+            template: {
+                type: PropType<FormTemplate<Schema>>;
+                default: undefined;
+            };
+        }>> & {
+            onInvalid?: ((...args: any[]) => any) | undefined;
+            onValid?: ((...args: any[]) => any) | undefined;
+            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+            onSubmit?: ((...args: any[]) => any) | undefined;
+            "onUpdate:readonly"?: ((...args: any[]) => any) | undefined;
+        }, {
+            formData: Ref<Partial<z.TypeOf<Schema> | undefined>>;
+            submit: () => Promise<boolean>;
+            validate: (value?: Partial<z.TypeOf<Schema> | undefined>) => Promise<boolean>;
+            ignoreUpdates: IgnoredUpdater;
+            stopUpdatesWatch: WatchStopHandle;
+            errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>>;
+            status: Readonly<Ref<FormStatus | undefined>>;
+            invalid: import("vue").ComputedRef<boolean>;
+            isReadonly: Ref<boolean>;
+        }, {}, {}, {}, {
+            readonly: boolean;
+            template: FormTemplate<Schema>;
+            modelValue: Record<string, any>;
+            continuousValidation: boolean;
+            tag: string;
+        }>;
+        __isFragment?: undefined;
+        __isTeleport?: undefined;
+        __isSuspense?: undefined;
+    } & import('vue').ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        continuousValidation: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        modelValue: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        readonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        tag: {
+            type: StringConstructor;
+            default: string;
+        };
+        template: {
+            type: PropType<FormTemplate<Schema>>;
+            default: undefined;
+        };
+    }>> & {
+        onInvalid?: ((...args: any[]) => any) | undefined;
+        onValid?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        onSubmit?: ((...args: any[]) => any) | undefined;
+        "onUpdate:readonly"?: ((...args: any[]) => any) | undefined;
+    }, {
+        formData: Ref<Partial<z.TypeOf<Schema> | undefined>>;
+        submit: () => Promise<boolean>;
+        validate: (value?: Partial<z.TypeOf<Schema> | undefined>) => Promise<boolean>;
+        ignoreUpdates: IgnoredUpdater;
+        stopUpdatesWatch: WatchStopHandle;
+        errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>>;
+        status: Readonly<Ref<FormStatus | undefined>>;
+        invalid: import("vue").ComputedRef<boolean>;
+        isReadonly: Ref<boolean>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("invalid" | "valid" | "update:modelValue" | "submit" | "update:readonly")[], "invalid" | "valid" | "update:modelValue" | "submit" | "update:readonly", {
+        readonly: boolean;
+        template: FormTemplate<Schema>;
+        modelValue: Record<string, any>;
+        continuousValidation: boolean;
+        tag: string;
+    }, {}, string, {}> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            default: (_: {
+                formData: unknown extends Partial<z.TypeOf<Schema>> | undefined ? undefined : Partial<z.TypeOf<Schema>> | undefined;
+                submit: () => Promise<boolean>;
+                validate: () => Promise<boolean>;
+                ignoreUpdates: IgnoredUpdater;
+                stopUpdatesWatch: WatchStopHandle;
+                errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema>>>>;
+                status: Ref<DeepReadonly<`${FormStatus}` | undefined>>;
+                invalid: Ref<DeepReadonly<boolean>>;
+                readonly: Ref<boolean>;
+            }) => any;
+        };
+    });
+};

package/dist/{src/VvFormField.d.ts → VvFormField.d.ts}

@@ -1,8 +1,9 @@
-import { type Component, type InjectionKey, type PropType, type Ref, type ConcreteComponent } from 'vue';
-import type { z } from 'zod';
+import { InjectedFormData, InjectedFormWrapperData, InjectedFormFieldData, FormFieldComponentOptions, Path, FormSchema } from './types';
 import { FormFieldType } from './enums';
-import type { InjectedFormData, InjectedFormWrapperData, InjectedFormFieldData, FormFieldComponentOptions, Path, FormSchema } from './types';
-export declare const defineFormField: <Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>, formFieldInjectionKey: InjectionKey<InjectedFormFieldData<Schema>>, options?: FormFieldComponentOptions) => import("vue").DefineComponent<{
+import { z } from 'zod';
+import { Component, InjectionKey, PropType, Ref, ConcreteComponent } from 'vue';
+
+export declare const defineFormField: <Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>, formFieldInjectionKey: InjectionKey<InjectedFormFieldData<Schema>>, options?: FormFieldComponentOptions) => import('vue').DefineComponent<{
     type: {
         type: PropType<"number" | "text" | "email" | "password" | "tel" | "url" | "search" | "date" | "time" | "datetime-local" | "month" | "week" | "color" | "select" | "checkbox" | "radio" | "textarea" | "radioGroup" | "checkboxGroup" | "combobox" | "custom">;
         validator: (value: FormFieldType) => boolean;
@@ -17,7 +18,7 @@ export declare const defineFormField: <Schema extends FormSchema>(formProvideKey
         required: true;
     };
     props: {
-        type: PropType<Partial<z.TypeOf<Schema> | ((formData?: Ref<ObjectConstructor>) => Partial<z.TypeOf<Schema>> | undefined) | undefined>>;
+        type: PropType<Partial<z.TypeOf<Schema> | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined) | undefined>>;
         default: () => {};
     };
     showValid: {
@@ -32,6 +33,10 @@ export declare const defineFormField: <Schema extends FormSchema>(formProvideKey
         type: BooleanConstructor;
         default: boolean;
     };
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
 }, {
     component: import("vue").ComputedRef<{
         new (...args: any[]): any;
@@ -52,10 +57,11 @@ export declare const defineFormField: <Schema extends FormSchema>(formProvideKey
         type: FormFieldType | undefined;
         invalidLabel: any;
         modelValue: any;
+        readonly: {} | undefined;
         'onUpdate:modelValue': (value: unknown) => void;
     }>;
     invalid: import("vue").ComputedRef<boolean>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("invalid" | "valid" | "update:formData" | "update:modelValue")[], "invalid" | "valid" | "update:formData" | "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("invalid" | "valid" | "update:formData" | "update:modelValue")[], "invalid" | "valid" | "update:formData" | "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     type: {
         type: PropType<"number" | "text" | "email" | "password" | "tel" | "url" | "search" | "date" | "time" | "datetime-local" | "month" | "week" | "color" | "select" | "checkbox" | "radio" | "textarea" | "radioGroup" | "checkboxGroup" | "combobox" | "custom">;
         validator: (value: FormFieldType) => boolean;
@@ -70,7 +76,7 @@ export declare const defineFormField: <Schema extends FormSchema>(formProvideKey
         required: true;
     };
     props: {
-        type: PropType<Partial<z.TypeOf<Schema> | ((formData?: Ref<ObjectConstructor>) => Partial<z.TypeOf<Schema>> | undefined) | undefined>>;
+        type: PropType<Partial<z.TypeOf<Schema> | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined) | undefined>>;
         default: () => {};
     };
     showValid: {
@@ -85,6 +91,10 @@ export declare const defineFormField: <Schema extends FormSchema>(formProvideKey
         type: BooleanConstructor;
         default: boolean;
     };
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
 }>> & {
     onInvalid?: ((...args: any[]) => any) | undefined;
     onValid?: ((...args: any[]) => any) | undefined;
@@ -93,14 +103,15 @@ export declare const defineFormField: <Schema extends FormSchema>(formProvideKey
 }, {
     type: "number" | "text" | "email" | "password" | "tel" | "url" | "search" | "date" | "time" | "datetime-local" | "month" | "week" | "color" | "select" | "checkbox" | "radio" | "textarea" | "radioGroup" | "checkboxGroup" | "combobox" | "custom";
     props: [{
-        type: PropType<Partial<z.TypeOf<Schema> | ((formData?: Ref<ObjectConstructor>) => Partial<z.TypeOf<Schema>> | undefined) | undefined>>;
+        type: PropType<Partial<z.TypeOf<Schema> | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined) | undefined>>;
         default: () => {};
     }] extends [import("vue").Prop<infer V, infer D>] ? unknown extends V ? import("@vue/shared").IfAny<V, V, D> : V : {
-        type: PropType<Partial<z.TypeOf<Schema> | ((formData?: Ref<ObjectConstructor>) => Partial<z.TypeOf<Schema>> | undefined) | undefined>>;
+        type: PropType<Partial<z.TypeOf<Schema> | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined) | undefined>>;
         default: () => {};
     };
     is: Component;
     showValid: boolean;
     defaultValue: string | number | boolean | unknown[] | Record<string, any>;
     lazyLoad: boolean;
+    readonly: boolean;
 }, {}>;

package/dist/VvFormTemplate.d.ts

@@ -0,0 +1,83 @@
+import { FormStatus } from './enums';
+import { FormSchema, InjectedFormData, FormTemplate } from './types';
+import { TypeOf, z } from 'zod';
+import { Component, PropType, InjectionKey, DeepReadonly, Ref, VNode } from 'vue';
+
+export declare const defineFormTemplate: <Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, VvFormField: Component) => {
+    new (...args: any[]): import('vue').CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+        schema: {
+            type: PropType<FormTemplate<Schema>>;
+            required: true;
+        };
+        scope: {
+            type: PropType<Record<string, unknown>>;
+            default: () => {};
+        };
+    }>>, (() => (VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[] | undefined)[]) | undefined, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+        schema: {
+            type: PropType<FormTemplate<Schema>>;
+            required: true;
+        };
+        scope: {
+            type: PropType<Record<string, unknown>>;
+            default: () => {};
+        };
+    }>>, {
+        scope: Record<string, unknown>;
+    }, true, {}, {}, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        schema: {
+            type: PropType<FormTemplate<Schema>>;
+            required: true;
+        };
+        scope: {
+            type: PropType<Record<string, unknown>>;
+            default: () => {};
+        };
+    }>>, {} | (() => (VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[] | undefined)[]), {}, {}, {}, {
+        scope: Record<string, unknown>;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & import('vue').ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    schema: {
+        type: PropType<FormTemplate<Schema>>;
+        required: true;
+    };
+    scope: {
+        type: PropType<Record<string, unknown>>;
+        default: () => {};
+    };
+}>>, (() => (VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined)[]) | undefined, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    scope: Record<string, unknown>;
+}, {}, string, {}> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default: (_: {
+            formData: unknown extends Partial<TypeOf<Schema>> | undefined ? undefined : Partial<TypeOf<Schema>> | undefined;
+            submit: () => Promise<boolean>;
+            validate: () => Promise<boolean>;
+            errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema>>>>;
+            status: Ref<DeepReadonly<`${FormStatus}` | undefined>>;
+            invalid: Ref<DeepReadonly<boolean>>;
+        }) => any;
+    };
+});

package/dist/VvFormWrapper.d.ts

@@ -0,0 +1,108 @@
+import { FormSchema, InjectedFormData, InjectedFormWrapperData } from './types';
+import { TypeOf, z } from 'zod';
+import { InjectionKey, Ref, DeepReadonly } from 'vue';
+
+export declare const defineFormWrapper: <Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>) => {
+    new (...args: any[]): import('vue').CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+        name: {
+            type: StringConstructor;
+            required: true;
+        };
+        tag: {
+            type: StringConstructor;
+            default: undefined;
+        };
+    }>> & {
+        onInvalid?: ((...args: any[]) => any) | undefined;
+        onValid?: ((...args: any[]) => any) | undefined;
+    }, {
+        formData: Ref<Partial<TypeOf<Schema>> | undefined> | undefined;
+        errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>> | undefined;
+        submit: (() => Promise<boolean>) | undefined;
+        validate: (() => Promise<boolean>) | undefined;
+        invalid: import("vue").ComputedRef<boolean>;
+        fields: Ref<Set<string> & Omit<Set<string>, keyof Set<any>>>;
+        fieldsErrors: Ref<Map<string, z.inferFormattedError<Schema, string>>>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("invalid" | "valid")[], import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+        name: {
+            type: StringConstructor;
+            required: true;
+        };
+        tag: {
+            type: StringConstructor;
+            default: undefined;
+        };
+    }>> & {
+        onInvalid?: ((...args: any[]) => any) | undefined;
+        onValid?: ((...args: any[]) => any) | undefined;
+    }, {
+        tag: string;
+    }, true, {}, {}, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        name: {
+            type: StringConstructor;
+            required: true;
+        };
+        tag: {
+            type: StringConstructor;
+            default: undefined;
+        };
+    }>> & {
+        onInvalid?: ((...args: any[]) => any) | undefined;
+        onValid?: ((...args: any[]) => any) | undefined;
+    }, {
+        formData: Ref<Partial<TypeOf<Schema>> | undefined> | undefined;
+        errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>> | undefined;
+        submit: (() => Promise<boolean>) | undefined;
+        validate: (() => Promise<boolean>) | undefined;
+        invalid: import("vue").ComputedRef<boolean>;
+        fields: Ref<Set<string> & Omit<Set<string>, keyof Set<any>>>;
+        fieldsErrors: Ref<Map<string, z.inferFormattedError<Schema, string>>>;
+    }, {}, {}, {}, {
+        tag: string;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & import('vue').ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    tag: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & {
+    onInvalid?: ((...args: any[]) => any) | undefined;
+    onValid?: ((...args: any[]) => any) | undefined;
+}, {
+    formData: Ref<Partial<TypeOf<Schema>> | undefined> | undefined;
+    errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>> | undefined;
+    submit: (() => Promise<boolean>) | undefined;
+    validate: (() => Promise<boolean>) | undefined;
+    invalid: import("vue").ComputedRef<boolean>;
+    fields: Ref<Set<string> & Omit<Set<string>, keyof Set<any>>>;
+    fieldsErrors: Ref<Map<string, z.inferFormattedError<Schema, string>>>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("invalid" | "valid")[], "invalid" | "valid", {
+    tag: string;
+}, {}, string, {}> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default: (_: {
+            invalid: boolean;
+            formData: unknown extends Partial<TypeOf<Schema>> | undefined ? undefined : Partial<TypeOf<Schema>> | undefined;
+            submit: () => Promise<boolean>;
+            validate: () => Promise<boolean>;
+            errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema>>>>;
+            fieldsErrors: Map<string, Record<string, {
+                _errors: string[];
+            }>>;
+        }) => any;
+    };
+});

package/dist/{src/enums.d.ts → enums.d.ts}

@@ -23,5 +23,8 @@ export declare enum FormFieldType {
 }
 export declare enum FormStatus {
     invalid = "invalid",
-    valid = "valid"
+    valid = "valid",
+    submitting = "submitting",
+    updated = "updated",
+    unknown = "unknown"
 }