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

package/src/utils.ts

@@ -1,104 +1,125 @@
 import {
-	type z,
-	type AnyZodObject,
-	type ZodTypeAny,
-	ZodDefault,
-	ZodObject,
-	ZodEffects,
-	ZodSchema,
-	ZodNullable,
-	ZodOptional,
-	ZodArray,
+
+    ZodDefault,
+    ZodObject,
+    ZodEffects,
+    ZodSchema,
+    ZodNullable,
+    ZodOptional,
+    ZodRecord,
+    ZodArray,
 } from 'zod'
-import type { FormSchema } from './types'
+import type { z, AnyZodObject, ZodTypeAny } from 'zod'
+import type { EffectType, FormSchema } from './types'
 
-export const defaultObjectBySchema = <Schema extends FormSchema>(
-	schema: Schema,
-	original: Partial<z.infer<Schema>> & Record<string, unknown> = {},
-): Partial<z.infer<Schema>> => {
-	const getInnerType = <Type extends ZodTypeAny>(
-		schema:
-			| Type
-			| ZodEffects<Type>
-			| ZodEffects<ZodEffects<Type>>
-			| ZodOptional<Type>,
-	) => {
-		let toReturn = schema
-		while (toReturn instanceof ZodEffects) {
-			toReturn = toReturn.innerType()
-		}
-		if (toReturn instanceof ZodOptional) {
-			toReturn = toReturn._def.innerType
-		}
-		return toReturn
-	}
-	const innerType = getInnerType<AnyZodObject>(schema)
-	const unknownKeys =
-		innerType instanceof ZodObject
-			? innerType._def.unknownKeys === 'passthrough'
-			: false
-	return {
-		...(unknownKeys ? original : {}),
-		...Object.fromEntries(
-			(Object.entries(innerType.shape) as [string, ZodTypeAny][]).map(
-				([key, subSchema]) => {
-					const originalValue = original[key]
-					let innerType = getInnerType(subSchema)
-					let defaultValue: Partial<z.infer<Schema>> | undefined =
-						undefined
-					if (innerType instanceof ZodDefault) {
-						defaultValue = innerType._def.defaultValue()
-						innerType = innerType._def.innerType
-					}
-					if (
-						originalValue === null &&
-						innerType instanceof ZodNullable
-					) {
-						return [key, originalValue]
-					}
-					if (innerType instanceof ZodSchema) {
-						const parse = subSchema.safeParse(originalValue)
-						if (parse.success) {
-							return [key, parse.data ?? defaultValue]
-						}
-					}
-					if (
-						innerType instanceof ZodArray &&
-						Array.isArray(originalValue) &&
-						originalValue.length
-					) {
-						const arrayType = getInnerType(innerType._def.type)
-						if (arrayType instanceof ZodObject) {
-							return [
-								key,
-								originalValue.map((element: unknown) =>
-									defaultObjectBySchema(
-										arrayType,
-										(element && typeof element === 'object'
-											? element
-											: undefined) as Partial<
-											typeof arrayType
-										>,
-									),
-								) ?? defaultValue,
-							]
-						}
-					}
-					if (innerType instanceof ZodObject) {
-						return [
-							key,
-							defaultObjectBySchema(
-								innerType,
-								originalValue &&
-									typeof originalValue === 'object'
-									? originalValue
-									: defaultValue,
-							),
-						]
-					}
-					return [key, defaultValue]
-				},
-			),
-		),
-	} as Partial<z.infer<Schema>>
+export function defaultObjectBySchema<Schema extends FormSchema>(schema: Schema, original: Partial<z.infer<Schema>> & Record<string, unknown> = {}): Partial<z.infer<Schema>> {
+    const getSchemaInnerType = <Type extends ZodTypeAny>(
+        schema: EffectType<Type>,
+    ) => {
+        let toReturn = schema
+        while (toReturn instanceof ZodEffects) {
+            toReturn = toReturn.innerType()
+        }
+        if (toReturn instanceof ZodOptional) {
+            toReturn = toReturn._def.innerType
+        }
+        return toReturn
+    }
+    const isSchemaOptional = <Type extends ZodTypeAny>(
+        schema:
+            | Type
+            | ZodEffects<Type>
+            | ZodEffects<ZodEffects<Type>>
+            | ZodOptional<Type>,
+    ) => {
+        let toReturn = schema
+        while (toReturn instanceof ZodEffects) {
+            toReturn = toReturn.innerType()
+        }
+        if (toReturn instanceof ZodOptional) {
+            return true
+        }
+        return false
+    }
+    const innerType = getSchemaInnerType<AnyZodObject>(schema)
+    const unknownKeys
+        = innerType instanceof ZodObject
+            ? innerType._def.unknownKeys === 'passthrough'
+            : false
+    return {
+        ...(unknownKeys ? original : {}),
+        ...Object.fromEntries(
+            (Object.entries(innerType.shape) as [string, ZodTypeAny][]).map(
+                ([key, subSchema]) => {
+                    const originalValue = original[key]
+                    const isOptional = isSchemaOptional(subSchema)
+                    let innerType = getSchemaInnerType(subSchema)
+                    let defaultValue: Partial<z.infer<Schema>> | undefined
+                    if (innerType instanceof ZodDefault) {
+                        defaultValue = innerType._def.defaultValue()
+                        innerType = innerType._def.innerType
+                    }
+                    if (
+                        originalValue === null
+                        && innerType instanceof ZodNullable
+                    ) {
+                        return [key, originalValue]
+                    }
+                    if ((originalValue === undefined || originalValue === null) && isOptional) {
+                        return [key, defaultValue]
+                    }
+                    if (innerType instanceof ZodSchema) {
+                        const parse = subSchema.safeParse(originalValue)
+                        if (parse.success) {
+                            return [key, parse.data ?? defaultValue]
+                        }
+                    }
+                    if (
+                        innerType instanceof ZodArray
+                        && Array.isArray(originalValue)
+                        && originalValue.length
+                    ) {
+                        const arrayType = getSchemaInnerType(innerType._def.type)
+                        if (arrayType instanceof ZodObject) {
+                            return [
+                                key,
+                                originalValue.map((element: unknown) =>
+                                    defaultObjectBySchema(
+                                        arrayType,
+                                        (element && typeof element === 'object'
+                                            ? element
+                                            : undefined) as Partial<
+                                                typeof arrayType
+                                        >,
+                                    ),
+                                ),
+                            ]
+                        }
+                    }
+                    if (innerType instanceof ZodRecord && originalValue) {
+                        const valueType = getSchemaInnerType(innerType._def.valueType)
+                        if (valueType instanceof ZodObject) {
+                            return [key, Object.keys(originalValue).reduce((acc: Record<string, unknown>, recordKey: string) => {
+                                acc[recordKey] = defaultObjectBySchema(valueType, (originalValue as Record<string, unknown>)[recordKey] as Partial<any> & Record<string, unknown>)
+                                return acc
+                            }, {})]
+                        }
+                    }
+                    if (innerType instanceof ZodObject) {
+                        return [
+                            key,
+                            defaultObjectBySchema(
+                                innerType,
+                                originalValue
+                                && typeof originalValue === 'object'
+                                    ? (originalValue as Partial<z.infer<Schema>> & Record<string, unknown>)
+                                    : defaultValue,
+                            ),
+                        ]
+                    }
+                    return [key, defaultValue]
+                },
+            ),
+        ),
+    } as Partial<z.infer<Schema>>
 }

package/dist/src/VvForm.d.ts

@@ -1,202 +0,0 @@
-import { type Component, type InjectionKey, type DeepReadonly, type Ref, type PropType, type WatchStopHandle } from 'vue';
-import { type IgnoredUpdater } from '@vueuse/core';
-import { type z, type TypeOf } from 'zod';
-import type { FormComponentOptions, FormSchema, FormTemplate, InjectedFormData } from './types';
-import { FormStatus } from './enums';
-export declare const defineForm: <Schema extends FormSchema>(schema: Schema, provideKey: InjectionKey<InjectedFormData<Schema>>, options?: FormComponentOptions<Schema> | undefined, 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<{
-            continuosValidation: {
-                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<{
-            continuosValidation: {
-                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>;
-            continuosValidation: boolean;
-            tag: string;
-        }, true, {}, {}, {
-            P: {};
-            B: {};
-            D: {};
-            C: {};
-            M: {};
-            Defaults: {};
-        }, Readonly<import("vue").ExtractPropTypes<{
-            continuosValidation: {
-                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>;
-            continuosValidation: boolean;
-            tag: string;
-        }>;
-        __isFragment?: undefined;
-        __isTeleport?: undefined;
-        __isSuspense?: undefined;
-    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-        continuosValidation: {
-            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>;
-        continuosValidation: 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, string>>>>;
-                status: Ref<DeepReadonly<`${FormStatus}` | undefined>>;
-                invalid: Ref<DeepReadonly<boolean>>;
-                readonly: Ref<boolean>;
-            }) => any;
-        };
-    });
-};

package/dist/src/VvFormField.d.ts

@@ -1,116 +0,0 @@
-import { type Component, type InjectionKey, type PropType, type Ref, type ConcreteComponent } from 'vue';
-import type { z } from 'zod';
-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<{
-    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;
-        default: FormFieldType;
-    };
-    is: {
-        type: PropType<Component>;
-        default: undefined;
-    };
-    name: {
-        type: PropType<Path<z.TypeOf<Schema>>>;
-        required: true;
-    };
-    props: {
-        type: PropType<Partial<z.TypeOf<Schema> | ((formData?: Ref<ObjectConstructor>) => Partial<z.TypeOf<Schema>> | undefined) | undefined>>;
-        default: () => {};
-    };
-    showValid: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    defaultValue: {
-        type: (StringConstructor | ObjectConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor)[];
-        default: undefined;
-    };
-    lazyLoad: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly: {
-        type: BooleanConstructor;
-        default: undefined;
-    };
-}, {
-    component: import("vue").ComputedRef<{
-        new (...args: any[]): any;
-        __isFragment?: undefined;
-        __isTeleport?: undefined;
-        __isSuspense?: undefined;
-    } | ConcreteComponent>;
-    hasProps: import("vue").ComputedRef<{
-        name: {} | ([{
-            type: PropType<Path<z.TypeOf<Schema>>>;
-            required: true;
-        }] extends [import("vue").Prop<infer V, infer D>] ? unknown extends V ? import("@vue/shared").IfAny<V, V, D> : V : {
-            type: PropType<Path<z.TypeOf<Schema>>>;
-            required: true;
-        });
-        invalid: boolean;
-        valid: boolean | undefined;
-        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").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;
-        default: FormFieldType;
-    };
-    is: {
-        type: PropType<Component>;
-        default: undefined;
-    };
-    name: {
-        type: PropType<Path<z.TypeOf<Schema>>>;
-        required: true;
-    };
-    props: {
-        type: PropType<Partial<z.TypeOf<Schema> | ((formData?: Ref<ObjectConstructor>) => Partial<z.TypeOf<Schema>> | undefined) | undefined>>;
-        default: () => {};
-    };
-    showValid: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    defaultValue: {
-        type: (StringConstructor | ObjectConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor)[];
-        default: undefined;
-    };
-    lazyLoad: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly: {
-        type: BooleanConstructor;
-        default: undefined;
-    };
-}>> & {
-    onInvalid?: ((...args: any[]) => any) | undefined;
-    onValid?: ((...args: any[]) => any) | undefined;
-    "onUpdate:formData"?: ((...args: any[]) => any) | undefined;
-    "onUpdate:modelValue"?: ((...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";
-    props: [{
-        type: PropType<Partial<z.TypeOf<Schema> | ((formData?: Ref<ObjectConstructor>) => Partial<z.TypeOf<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>>;
-        default: () => {};
-    };
-    is: Component;
-    showValid: boolean;
-    defaultValue: string | number | boolean | unknown[] | Record<string, any>;
-    lazyLoad: boolean;
-    readonly: boolean;
-}, {}>;

package/dist/src/VvFormTemplate.d.ts

@@ -1,60 +0,0 @@
-import { type Component, type PropType, type InjectionKey, type DeepReadonly, type Ref, type VNode } from 'vue';
-import type { TypeOf, z } from 'zod';
-import type { FormSchema, InjectedFormData, FormTemplate } from './types';
-import type { FormStatus } from './enums';
-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;
-        };
-    }>>, (() => (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;
-        };
-    }>>, {}, true, {}, {}, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<import("vue").ExtractPropTypes<{
-        schema: {
-            type: PropType<FormTemplate<Schema>>;
-            required: true;
-        };
-    }>>, {} | (() => (VNode<import("vue").RendererNode, import("vue").RendererElement, {
-        [key: string]: any;
-    }> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
-        [key: string]: any;
-    }>[] | undefined)[]), {}, {}, {}, {}>;
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
-} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-    schema: {
-        type: PropType<FormTemplate<Schema>>;
-        required: true;
-    };
-}>>, (() => (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, {}, {}, 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, string>>>>;
-            status: Ref<DeepReadonly<`${FormStatus}` | undefined>>;
-            invalid: Ref<DeepReadonly<boolean>>;
-        }) => any;
-    };
-});