@volverjs/form-vue 1.0.0-beta.9 → 1.0.0

package/dist/VvForm.d.ts

@@ -0,0 +1,135 @@
+import { Component, InjectionKey, PropType, SlotsType, UnwrapRef } from 'vue';
+import { RefinementCtx, z } from 'zod';
+import { FormComponentOptions, FormSchema, FormTemplate, InjectedFormData, InjectedFormWrapperData, Path } from './types';
+import { FormStatus } from './enums';
+export declare function defineForm<Schema extends FormSchema, Type, FormTemplateComponent extends Component>(schema: Schema, provideKey: InjectionKey<InjectedFormData<Schema, Type>>, options: FormComponentOptions<Schema, Type>, VvFormTemplate: FormTemplateComponent, wrappers: Map<string, InjectedFormWrapperData<Schema>>): {
+    clear: () => void;
+    errors: import('vue').Ref<z.inferFormattedError<Schema, string> | undefined, z.inferFormattedError<Schema, string> | undefined>;
+    formData: import('vue').Ref<(undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined, (undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined>;
+    ignoreUpdates: import('@vueuse/core').IgnoredUpdater;
+    invalid: import('vue').ComputedRef<boolean>;
+    readonly: import('vue').Ref<boolean, boolean>;
+    reset: () => void;
+    status: import('vue').Ref<FormStatus | undefined, FormStatus | undefined>;
+    wrappers: Map<string, InjectedFormWrapperData<Schema>>;
+    stopUpdatesWatch: import('vue').WatchStopHandle;
+    submit: (options?: {
+        fields?: Set<Path<z.infer<Schema>>>;
+        superRefine?: (arg: z.infer<Schema>, ctx: RefinementCtx) => void | Promise<void>;
+    }) => Promise<boolean>;
+    validate: (value?: (undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined, options?: {
+        fields?: Set<Path<z.infer<Schema>>>;
+        superRefine?: (arg: z.infer<Schema>, ctx: RefinementCtx) => void | Promise<void>;
+    }) => Promise<boolean>;
+    VvForm: import('vue').DefineComponent<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, Type>>;
+            default: undefined;
+        };
+        superRefine: {
+            type: PropType<(arg: z.infer<Schema>, ctx: RefinementCtx) => void | Promise<void>>;
+            default: undefined;
+        };
+        validateFields: {
+            type: PropType<Path<z.infer<Schema>>[]>;
+            default: undefined;
+        };
+    }>, {
+        clear: () => void;
+        errors: Readonly<import('vue').Ref<import('vue').DeepReadonly<z.inferFormattedError<Schema, string>> | undefined, import('vue').DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>>;
+        formData: import('vue').Ref<(undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined, (undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined>;
+        ignoreUpdates: import('@vueuse/core').IgnoredUpdater;
+        invalid: import('vue').ComputedRef<boolean>;
+        isReadonly: import('vue').Ref<boolean, boolean>;
+        reset: () => void;
+        status: Readonly<import('vue').Ref<FormStatus | undefined, FormStatus | undefined>>;
+        stopUpdatesWatch: import('vue').WatchStopHandle;
+        submit: () => Promise<boolean>;
+        validate: (value?: (undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined, options?: {
+            fields?: Set<Path<z.infer<Schema>>>;
+            superRefine?: (arg: z.infer<Schema>, ctx: RefinementCtx) => void | Promise<void>;
+        }) => Promise<boolean>;
+        wrappers: Map<string, InjectedFormWrapperData<Schema>>;
+    }, {}, {}, {}, 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<{
+        continuousValidation: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        modelValue: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        readonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        tag: {
+            type: StringConstructor;
+            default: string;
+        };
+        template: {
+            type: PropType<FormTemplate<Schema, Type>>;
+            default: undefined;
+        };
+        superRefine: {
+            type: PropType<(arg: z.infer<Schema>, ctx: RefinementCtx) => void | Promise<void>>;
+            default: undefined;
+        };
+        validateFields: {
+            type: PropType<Path<z.infer<Schema>>[]>;
+            default: undefined;
+        };
+    }>> & Readonly<{
+        onInvalid?: ((...args: any[]) => any) | undefined;
+        onValid?: ((...args: any[]) => any) | undefined;
+        onReset?: ((...args: any[]) => any) | undefined;
+        onSubmit?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        "onUpdate:readonly"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        superRefine: (arg: z.infer<Schema>, ctx: RefinementCtx) => void | Promise<void>;
+        readonly: boolean;
+        tag: string;
+        template: FormTemplate<Schema, Type>;
+        continuousValidation: boolean;
+        modelValue: Record<string, any>;
+        validateFields: Path<z.TypeOf<Schema>>[];
+    }, SlotsType<{
+        default: {
+            errors: UnwrapRef<Readonly<import('vue').Ref<import('vue').DeepReadonly<z.inferFormattedError<Schema, string>> | undefined, import('vue').DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>>>;
+            formData: UnwrapRef<import('vue').Ref<(undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined, (undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined>>;
+            invalid: UnwrapRef<import('vue').ComputedRef<boolean>>;
+            readonly: UnwrapRef<import('vue').Ref<boolean, boolean>>;
+            status: UnwrapRef<Readonly<import('vue').Ref<FormStatus | undefined, FormStatus | undefined>>>;
+            wrappers: typeof wrappers;
+            clear: () => void;
+            ignoreUpdates: import('@vueuse/core').IgnoredUpdater;
+            reset: () => void;
+            stopUpdatesWatch: import('vue').WatchStopHandle;
+            submit: (options?: {
+                fields?: Set<Path<z.infer<Schema>>>;
+                superRefine?: (arg: z.infer<Schema>, ctx: RefinementCtx) => void | Promise<void>;
+            }) => Promise<boolean>;
+            validate: (value?: (undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined, options?: {
+                fields?: Set<Path<z.infer<Schema>>>;
+                superRefine?: (arg: z.infer<Schema>, ctx: RefinementCtx) => void | Promise<void>;
+            }) => Promise<boolean>;
+        };
+    }>, {}, {}, "invalid" | "valid" | "reset" | "status" | "readonly" | "clear" | "submit" | "errors" | "tag" | "template" | "validate", import('vue').ComponentProvideOptions, true, {}, any>;
+};

package/dist/VvFormField.d.ts

@@ -0,0 +1,130 @@
+import { Component, ConcreteComponent, DeepReadonly, InjectionKey, PropType, Ref, SlotsType } from 'vue';
+import { z } from 'zod';
+import { FormFieldComponentOptions, FormSchema, InjectedFormData, InjectedFormFieldData, InjectedFormWrapperData, Path } from './types';
+import { FormFieldType } from './enums';
+export declare function defineFormField<Schema extends FormSchema, Type = undefined>(formProvideKey: InjectionKey<InjectedFormData<Schema, Type>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>, formFieldInjectionKey: InjectionKey<InjectedFormFieldData<Schema>>, options?: FormFieldComponentOptions): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    type: {
+        type: PropType<`${FormFieldType}`>;
+        validator: (value: FormFieldType) => boolean;
+        default: FormFieldType;
+    };
+    is: {
+        type: PropType<Component | string>;
+        default: undefined;
+    };
+    name: {
+        type: PropType<Path<z.infer<Schema>>>;
+        required: true;
+    };
+    props: {
+        type: PropType<Partial<z.infer<Schema> | undefined | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined)>>;
+        default: () => {};
+    };
+    showValid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    defaultValue: {
+        type: (ObjectConstructor | ArrayConstructor | BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    lazyLoad: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>, {
+    component: import('vue').ComputedRef<{
+        new (...args: any[]): any;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } | ConcreteComponent>;
+    hasProps: import('vue').ComputedRef<{
+        name: {} | ([{
+            type: PropType<Path<z.infer<Schema>>>;
+            required: true;
+        }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('@vue/shared').IfAny<V, V, D> : V : V : {
+            type: PropType<Path<z.infer<Schema>>>;
+            required: true;
+        });
+        invalid: boolean;
+        valid: boolean | undefined;
+        type: FormFieldType | undefined;
+        invalidLabel: any;
+        modelValue: any;
+        readonly: boolean;
+        'onUpdate:modelValue': (value: unknown) => void;
+    }>;
+    invalid: import('vue').ComputedRef<boolean>;
+}, {}, {}, {}, 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<{
+    type: {
+        type: PropType<`${FormFieldType}`>;
+        validator: (value: FormFieldType) => boolean;
+        default: FormFieldType;
+    };
+    is: {
+        type: PropType<Component | string>;
+        default: undefined;
+    };
+    name: {
+        type: PropType<Path<z.infer<Schema>>>;
+        required: true;
+    };
+    props: {
+        type: PropType<Partial<z.infer<Schema> | undefined | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined)>>;
+        default: () => {};
+    };
+    showValid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    defaultValue: {
+        type: (ObjectConstructor | ArrayConstructor | BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    lazyLoad: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onInvalid?: ((...args: any[]) => any) | undefined;
+    onValid?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:formData"?: ((...args: any[]) => any) | undefined;
+}>, {
+    type: "number" | "text" | "email" | "password" | "tel" | "url" | "search" | "date" | "time" | "datetime-local" | "month" | "week" | "color" | "select" | "checkbox" | "radio" | "textarea" | "radioGroup" | "checkboxGroup" | "combobox" | "custom";
+    readonly: boolean;
+    props: [{
+        type: PropType<Partial<z.infer<Schema> | undefined | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined)>>;
+        default: () => {};
+    }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('@vue/shared').IfAny<V, V, D> : V : V : {
+        type: PropType<Partial<z.infer<Schema> | undefined | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined)>>;
+        default: () => {};
+    };
+    is: string | Component;
+    showValid: boolean;
+    defaultValue: string | number | boolean | unknown[] | Record<string, any>;
+    lazyLoad: boolean;
+}, SlotsType<{
+    [key: string]: any;
+    default: {
+        errors: DeepReadonly<z.inferFormattedError<Schema>>;
+        formData?: undefined extends Type ? Partial<z.infer<Schema>> : Type;
+        formErrors?: DeepReadonly<z.inferFormattedError<Schema, string>>;
+        invalid: boolean;
+        invalidLabel?: string[];
+        modelValue: any;
+        readonly: boolean;
+        onUpdate: (value: unknown) => void;
+        submit?: InjectedFormData<Schema, Type>["submit"];
+        validate?: InjectedFormData<Schema, Type>["validate"];
+    };
+}>, {}, {}, "invalid" | "type" | "errors" | "component" | "hasProps" | "invalidLabel" | "is", import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/VvFormFieldsGroup.d.ts

@@ -0,0 +1,109 @@
+import { Component, DeepReadonly, InjectionKey, PropType, Ref, SlotsType } from 'vue';
+import { z } from 'zod';
+import { FormSchema, InjectedFormData, InjectedFormFieldsGroupData, InjectedFormWrapperData, Path } from './types';
+export declare function defineFormFieldsGroup<Schema extends FormSchema, Type = undefined>(formProvideKey: InjectionKey<InjectedFormData<Schema, Type>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>, formFieldsGroupInjectionKey: InjectionKey<InjectedFormFieldsGroupData<Schema>>): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    is: {
+        type: PropType<Component | string>;
+        default: undefined;
+    };
+    names: {
+        type: PropType<Path<z.infer<Schema>>[] | Record<string, Path<z.infer<Schema>>>>;
+        required: true;
+    };
+    props: {
+        type: PropType<Partial<z.infer<Schema> | undefined | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined)>>;
+        default: () => {};
+    };
+    showValid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    defaultValues: {
+        type: PropType<Record<Path<z.infer<Schema>>, any>>;
+        default: undefined;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>, {
+    component: import('vue').ComputedRef<{
+        render(): import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>;
+    hasProps: import('vue').ComputedRef<{
+        names: {};
+        invalid: boolean;
+        invalids: Record<string, boolean>;
+        valid: boolean | undefined;
+        invalidLabels: Record<string, string[]> | undefined;
+        modelValue: Record<string, any>;
+        readonly: boolean;
+    }>;
+    invalid: import('vue').ComputedRef<boolean>;
+}, {}, {}, {}, 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<{
+    is: {
+        type: PropType<Component | string>;
+        default: undefined;
+    };
+    names: {
+        type: PropType<Path<z.infer<Schema>>[] | Record<string, Path<z.infer<Schema>>>>;
+        required: true;
+    };
+    props: {
+        type: PropType<Partial<z.infer<Schema> | undefined | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined)>>;
+        default: () => {};
+    };
+    showValid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    defaultValues: {
+        type: PropType<Record<Path<z.infer<Schema>>, any>>;
+        default: undefined;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onInvalid?: ((...args: any[]) => any) | undefined;
+    onValid?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:formData"?: ((...args: any[]) => any) | undefined;
+}>, {
+    readonly: boolean;
+    props: [{
+        type: PropType<Partial<z.infer<Schema> | undefined | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined)>>;
+        default: () => {};
+    }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('@vue/shared').IfAny<V, V, D> : V : V : {
+        type: PropType<Partial<z.infer<Schema> | undefined | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined)>>;
+        default: () => {};
+    };
+    is: string | Component;
+    showValid: boolean;
+    defaultValues: [{
+        type: PropType<Record<Path<z.infer<Schema>>, any>>;
+        default: undefined;
+    }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('@vue/shared').IfAny<V, V, D> : V : V : {
+        type: PropType<Record<Path<z.infer<Schema>>, any>>;
+        default: undefined;
+    };
+}, SlotsType<{
+    [key: string]: any;
+    default: {
+        errors?: Record<Path<z.infer<Schema>>, z.inferFormattedError<Schema>>;
+        formData?: undefined extends Type ? Partial<z.infer<Schema>> : Type;
+        formErrors?: DeepReadonly<z.inferFormattedError<Schema>>;
+        invalid: boolean;
+        invalids: Record<string, boolean>;
+        invalidLabels?: Record<string, string[]>;
+        modelValue: Record<string, any>;
+        onUpdate: (value: Record<string, any>) => void;
+        onUpdateField: (name: string, value: any) => void;
+        readonly: boolean;
+        submit?: InjectedFormData<Schema, Type>["submit"];
+        validate?: InjectedFormData<Schema, Type>["validate"];
+    };
+}>, {}, {}, "invalid" | "errors" | "component" | "hasProps" | "is" | "invalidLabels", import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/VvFormTemplate.d.ts

@@ -0,0 +1,40 @@
+import { Component, DeepReadonly, InjectionKey, PropType, SlotsType, VNode } from 'vue';
+import { FormSchema, InjectedFormData, FormTemplate } from './types';
+import { z } from 'zod';
+import { FormStatus } from './enums';
+export declare function defineFormTemplate<Schema extends FormSchema, Type = undefined>(formProvideKey: InjectionKey<InjectedFormData<Schema, Type>>, VvFormField: Component): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    schema: {
+        type: PropType<FormTemplate<Schema, Type>>;
+        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, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    schema: {
+        type: PropType<FormTemplate<Schema, Type>>;
+        required: true;
+    };
+    scope: {
+        type: PropType<Record<string, unknown>>;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    scope: Record<string, unknown>;
+}, SlotsType<{
+    default: {
+        errors?: DeepReadonly<z.inferFormattedError<Schema>>;
+        formData?: undefined extends Type ? Partial<z.infer<Schema>> : Type;
+        invalid: boolean;
+        status?: FormStatus;
+        submit?: InjectedFormData<Schema, Type>["submit"];
+        validate?: InjectedFormData<Schema, Type>["validate"];
+        clear?: InjectedFormData<Schema, Type>["clear"];
+        reset?: InjectedFormData<Schema, Type>["reset"];
+    };
+}>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/VvFormWrapper.d.ts

@@ -0,0 +1,65 @@
+import { DeepReadonly, InjectionKey, Ref, SlotsType } from 'vue';
+import { z } from 'zod';
+import { FormSchema, InjectedFormData, InjectedFormWrapperData, Path } from './types';
+export declare function defineFormWrapper<Schema extends FormSchema, Type = undefined>(formProvideKey: InjectionKey<InjectedFormData<Schema, Type>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    tag: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {
+    errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema, string>> | undefined, DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>> | undefined;
+    fields: Ref<Map<string, Path<z.TypeOf<Schema>>>, Map<string, Path<z.TypeOf<Schema>>>>;
+    fieldsErrors: Ref<Map<string, z.inferFormattedError<Schema, string>>, Map<string, z.inferFormattedError<Schema, string>>>;
+    formData: Ref<(undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined, (undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined> | undefined;
+    invalid: import('vue').ComputedRef<boolean>;
+    readonly: import('vue').ComputedRef<boolean>;
+    clear: (() => void) | undefined;
+    reset: (() => void) | undefined;
+    submit: (() => Promise<boolean>) | undefined;
+    validate: ((formData?: (undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined, options?: {
+        fields?: Set<Path<z.TypeOf<Schema>>> | undefined;
+        superRefine?: ((arg: z.TypeOf<Schema>, ctx: z.RefinementCtx) => void | Promise<void>) | undefined;
+    } | undefined) => Promise<boolean>) | undefined;
+    validateWrapper: () => Promise<boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid")[], "invalid" | "valid", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    tag: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onInvalid?: ((...args: any[]) => any) | undefined;
+    onValid?: ((...args: any[]) => any) | undefined;
+}>, {
+    readonly: boolean;
+    tag: string;
+}, SlotsType<{
+    default: {
+        errors?: DeepReadonly<z.inferFormattedError<Schema>>;
+        fieldsErrors: Map<string, z.inferFormattedError<Schema>>;
+        formData?: undefined extends Type ? Partial<z.infer<Schema>> : Type;
+        formErrors?: DeepReadonly<z.inferFormattedError<Schema>>;
+        invalid: boolean;
+        readonly: boolean;
+        clear?: InjectedFormData<Schema, Type>["clear"];
+        reset?: InjectedFormData<Schema, Type>["reset"];
+        submit?: InjectedFormData<Schema, Type>["submit"];
+        validate?: InjectedFormData<Schema, Type>["validate"];
+        validateWrapper?: () => Promise<boolean>;
+    };
+}>, {}, {}, "invalid" | "reset" | "readonly" | "clear" | "submit" | "errors" | "tag" | "validate" | "formData" | "fields" | "fieldsErrors" | "validateWrapper", import('vue').ComponentProvideOptions, true, {}, any>;

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

@@ -25,6 +25,7 @@ export declare enum FormStatus {
     invalid = "invalid",
     valid = "valid",
     submitting = "submitting",
+    reset = "reset",
     updated = "updated",
     unknown = "unknown"
 }