@effect-app/vue-components 4.0.0-beta.31 → 4.0.0-beta.310

package/dist/types/components/OmegaForm/meta/walker.d.ts

@@ -0,0 +1,18 @@
+import * as S from "effect-app/Schema";
+import type { FieldMeta, MetaRecord } from "./types";
+export type WalkerContext<T> = {
+    acc: Partial<MetaRecord<T>>;
+    unionMeta: Record<string, MetaRecord<T>>;
+};
+export type ParentMeta = {
+    required: boolean;
+    nullableOrUndefined: false | "null" | "undefined";
+    /** Set when iterating the members of a nullable discriminated union */
+    isNullableDiscriminatedUnion?: boolean;
+    /** Set when this property was declared with S.optionalKey */
+    isOptionalKey?: boolean;
+};
+export declare const leafMetaForAst: (ast: S.AST.AST, parentMeta: ParentMeta) => FieldMeta;
+export declare const walkStruct: <T>(propertySignatures: readonly S.AST.PropertySignature[], parent: string, parentMeta: ParentMeta, ctx: WalkerContext<T>) => void;
+export declare const classifyAndWalkUnion: <T>(unionAst: S.AST.Union, key: string, parentMeta: ParentMeta, ctx: WalkerContext<T>) => void;
+export declare const walk: <T>(ast: S.AST.AST, key: string, parentMeta: ParentMeta, ctx: WalkerContext<T>) => void;

package/dist/types/components/OmegaForm/persistency.d.ts

@@ -0,0 +1,58 @@
+import { type ComputedRef } from "vue";
+import { type MetaRecord } from "./meta/types";
+export type Policies = "local" | "session" | "querystring";
+export type DefaultValuesPriorityUnion = "tanstack" | "persistency" | "schema";
+export type defaultValuesPriorityUnion = DefaultValuesPriorityUnion;
+export interface PersistencyConfig {
+    /** Order of importance:
+     * - "querystring": Highest priority when persisting
+     * - "local" and then "session": Lower priority storage options
+     */
+    policies?: ReadonlyArray<Policies>;
+    overrideDefaultValues?: "deprecated: use defaultValuesPriority";
+    id?: string;
+    keys?: ReadonlyArray<string> | "You should only use one of banKeys or keys, not both, moron";
+    banKeys?: ReadonlyArray<string> | "You should only use one of banKeys or keys, not both, moron";
+}
+export declare function deepMerge(target: any, source: any): any;
+export interface UsePersistencyOptions<From> {
+    meta: MetaRecord<From>;
+    persistency?: PersistencyConfig;
+    preventWindowExit?: "prevent" | "prevent-and-reset" | "nope";
+    defaultValuesPriority?: DefaultValuesPriorityUnion[] | readonly DefaultValuesPriorityUnion[];
+    /** Tanstack-provided default values (highest priority by default). */
+    tanstackDefaultValues?: any;
+    /** Lazy schema-derived defaults factory. */
+    schemaDefaultValues: () => any;
+    /**
+     * Lazy accessor for the form. Lazy because persistency is created BEFORE
+     * the form (its `defaultValues` are passed into `useForm`), but the
+     * persistence callbacks (`persistData`, `saveDataInUrl`, the
+     * `beforeunload` listener) only run later and need the live form.
+     */
+    getForm: () => {
+        store: {
+            state: {
+                values: any;
+                isDirty: boolean;
+            };
+        };
+        getFieldValue: (path: any) => any;
+    };
+}
+export interface UsePersistencyReturn {
+    defaultValues: ComputedRef;
+    persistencyKey: ComputedRef<string>;
+    persistData: () => void;
+    saveDataInUrl: () => void;
+    clearUrlParams: () => void;
+}
+/**
+ * Encapsulates form-data persistency: loading default values from
+ * localStorage / sessionStorage / querystring, persisting them on unmount
+ * or window blur, and the optional `preventWindowExit` warning listener.
+ *
+ * The `prevent-and-reset` reset-on-success behavior is intentionally NOT
+ * owned here — the consumer wires that to its own form submit lifecycle.
+ */
+export declare const usePersistency: <From>(opts: UsePersistencyOptions<From>) => UsePersistencyReturn;

package/dist/types/components/OmegaForm/submit.d.ts

@@ -0,0 +1,60 @@
+import * as api from "@opentelemetry/api";
+import type { DeepKeys, StandardSchemaV1Issue, ValidationError, ValidationErrorMap } from "@tanstack/vue-form";
+import * as Effect from "effect-app/Effect";
+import type { Fiber as EffectFiber } from "effect/Fiber";
+import type { OmegaFormApi, OmegaFormParams } from "./types";
+declare const FormErrors_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FormErrors";
+} & Readonly<A>;
+export declare class FormErrors<From> extends FormErrors_base<{
+    form: {
+        errors: (Record<string, StandardSchemaV1Issue[]> | undefined)[];
+        errorMap: ValidationErrorMap<undefined, undefined, Record<string, StandardSchemaV1Issue[]>, undefined, undefined, undefined, undefined, undefined, undefined, undefined>;
+    };
+    fields: Record<DeepKeys<From>, {
+        errors: ValidationError[];
+        errorMap: ValidationErrorMap;
+    }>;
+}> {
+}
+export declare const wrapWithSpan: (span: api.Span | undefined, toWrap: () => any) => any;
+export type UserOnSubmit<From, To> = (props: {
+    formApi: OmegaFormParams<From, To>;
+    meta: any;
+    value: To;
+}) => Promise<any> | EffectFiber<any, any> | Effect.Effect<unknown, any>;
+export type RunPromise = <A, E>(eff: Effect.Effect<A, E>) => Promise<A>;
+/**
+ * Wraps the user's `onSubmit` to:
+ * - run inside the OpenTelemetry span passed via `meta.currentSpan`
+ * - decode the raw form `value` (validators only validate, they don't transform)
+ * - normalize Promise / Effect / Fiber return values to a Promise
+ *
+ * Returns `undefined` when `userOnSubmit` is `undefined` (so callers can pass it
+ * directly to `useForm({ onSubmit })` without changing semantics).
+ */
+export declare const wrapOnSubmit: <From, To>(userOnSubmit: UserOnSubmit<From, To> | undefined, decode: (value: From) => Effect.Effect<To, any>, runPromise: RunPromise) => (({ formApi, meta, value }: {
+    formApi: OmegaFormParams<From, To>;
+    meta: any;
+    value: From;
+}) => any) | undefined;
+/**
+ * Builds the public submit handlers from a `useForm`-returned `form`:
+ * - `handleSubmit` injects the current OpenTelemetry span as `meta.currentSpan`.
+ * - `handleSubmitEffect` runs `handleSubmit` inside an Effect that picks up the
+ *   ambient `Effect.currentSpan`. With `checkErrors: true`, it fails with
+ *   `FormErrors<From>` when validation produced errors.
+ */
+export declare const makeSubmitHandlers: <From, To>(form: OmegaFormApi<From, To>) => {
+    handleSubmit: (meta?: Record<string, any>) => Promise<void>;
+    handleSubmitEffect: {
+        (options: {
+            checkErrors: true;
+            meta?: Record<string, any>;
+        }): Effect.Effect<void, FormErrors<From>>;
+        (options?: {
+            meta?: Record<string, any>;
+        }): Effect.Effect<void>;
+    };
+};
+export {};

package/dist/types/components/OmegaForm/types.d.ts

@@ -0,0 +1,312 @@
+import type { DeepKeys, DeepValue, FieldApi, FieldAsyncValidateOrFn, FieldState, FieldValidateOrFn, FormApi, FormAsyncValidateOrFn, FormOptions, FormState, FormValidateOrFn, StandardSchemaV1, VueFormApi } from "@tanstack/vue-form";
+import type * as Effect from "effect-app/Effect";
+import type * as S from "effect-app/Schema";
+import type { UnionToTuples } from "effect-app/utils";
+import type { Fiber as EffectFiber } from "effect/Fiber";
+import type * as Order from "effect/Order";
+import type { Redacted } from "effect/Redacted";
+import type { AllowedComponentProps, Component, ComponentCustomProps, ComputedRef, PublicProps, ShallowUnwrapRef, VNode, VNodeProps } from "vue";
+import type { MergedInputProps, OmegaFieldInternalApi, TaggedUnionOptionsArray } from "./InputProps";
+import type { MetaRecord, NestedKeyOf } from "./meta/types";
+import type { defaultValuesPriorityUnion as PersistencyPriority, Policies as PersistencyPolicies } from "./persistency";
+import type { FormErrors } from "./submit";
+export type FieldPath<T> = unknown extends T ? string : T extends string | boolean | number | null | undefined | symbol | bigint | Redacted<any> ? "" : T extends ReadonlyArray<infer U> ? FieldPath_<U, `[${number}]`> : {
+    [K in keyof T]: FieldPath_<T[K], K & string>;
+}[keyof T];
+export type FieldPath_<T, Path extends string> = unknown extends T ? string : T extends string | boolean | number | null | undefined | symbol | bigint | Redacted<any> ? Path : T extends ReadonlyArray<infer U> ? FieldPath_<U, `${Path}[${number}]`> | Path : {
+    [K in keyof T]: FieldPath_<T[K], `${Path}.${K & string}`>;
+}[keyof T];
+export type BaseProps<From, TName extends FieldPath<From>> = {
+    /**
+     * Will fallback to i18n when not specified.
+     * Can also be provided via #label slot for custom HTML labels.
+     * When using the slot, it receives bindings: { required, id, label }
+     */
+    label?: string;
+    validators?: FieldValidators<From>;
+    /**
+     * Overrides the schema-derived `meta.required`.
+     * When omitted, requiredness is inferred from the schema.
+     */
+    required?: boolean;
+    name: TName;
+    /**
+     * Optional class to apply to the input element.
+     * - If a string is provided, it will be used instead of the general class
+     * - If null is provided, no class will be applied (neither inputClass nor general class)
+     * - If undefined (not provided), the general class will be used
+     */
+    inputClass?: string | null;
+};
+export type TypesWithOptions = "radio" | "select" | "multiple" | "autocomplete" | "autocompletemultiple";
+export type DefaultTypeProps = {
+    type?: TypeOverride;
+    options?: undefined;
+} | {
+    type?: TypesWithOptions;
+    options?: {
+        title: string;
+        value: unknown;
+    }[];
+};
+/** Registered `omegaConfig.inputs` keys as valid `type` values; `never` when nothing is registered. */
+export type CustomTypeProps<TInputs> = string extends keyof TInputs ? never : keyof TInputs extends never ? never : {
+    type: keyof TInputs & string;
+    options?: {
+        title: string;
+        value: unknown;
+    }[];
+};
+/** `form.Input` `type`/`options`: built-ins plus types registered via `omegaConfig.inputs`. */
+export type TypePropsFor<TInputs> = DefaultTypeProps | CustomTypeProps<TInputs>;
+export type OmegaInputPropsBase<From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>> = {
+    form: OF<From, To> & {
+        meta: MetaRecord<From>;
+        i18nNamespace?: string;
+    };
+} & BaseProps<From, Name> & DefaultTypeProps;
+export type OmegaInputProps<From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>, TypeProps = DefaultTypeProps> = {
+    form: OmegaFormReturn<From, To, TypeProps> & {
+        meta: MetaRecord<From>;
+        i18nNamespace?: string;
+    };
+} & BaseProps<From, Name>;
+export type OmegaArrayProps<From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>> = Omit<OmegaInputProps<From, To, Name>, "validators" | "options" | "label" | "type" | "items" | "name"> & {
+    name: DeepKeys<From>;
+    defaultItems?: DeepValue<From, DeepKeys<From>>;
+    items?: "please use `defaultItems` instead";
+};
+export declare const typeOverrides: readonly ["string", "text", "number", "select", "multiple", "boolean", "radio", "autocomplete", "autocompletemultiple", "switch", "range", "password", "email", "date", "tel", "url", "color", "time", "search"];
+export type TypeOverride = typeof typeOverrides[number];
+export interface OmegaError {
+    label: string;
+    inputId: string;
+    errors: readonly string[];
+}
+export type FormProps<From, To> = Omit<FormOptions<From, FormValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, StandardSchemaV1<From, To>, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, Record<string, any> | undefined>, "onSubmit" | "defaultValues"> & {
+    defaultValues?: Partial<From>;
+    onSubmit?: (props: {
+        formApi: OmegaFormParams<From, To>;
+        meta: any;
+        value: To;
+    }) => Promise<any> | EffectFiber<any, any> | Effect.Effect<unknown, any>;
+};
+export type OmegaFormParams<From, To> = FormApi<From, FormValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, StandardSchemaV1<From, To>, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, Record<string, any> | undefined>;
+export type OmegaFormState<From, To> = FormState<From, FormValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, StandardSchemaV1<From, To>, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined>;
+export type OmegaFormApi<From, To, TSubmitMeta = Record<string, any> | undefined> = OmegaFormParams<From, To> & VueFormApi<From, FormValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, StandardSchemaV1<From, To>, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, TSubmitMeta>;
+export type FormComponent<T, S> = VueFormApi<T, FormValidateOrFn<T> | undefined, FormValidateOrFn<T> | undefined, StandardSchemaV1<T, S>, FormValidateOrFn<T> | undefined, FormAsyncValidateOrFn<T> | undefined, FormValidateOrFn<T> | undefined, FormAsyncValidateOrFn<T> | undefined, FormValidateOrFn<T> | undefined, FormAsyncValidateOrFn<T> | undefined, FormAsyncValidateOrFn<T> | undefined, Record<string, any> | undefined>;
+export type FormType<From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>> = OmegaFormApi<From, To> & {
+    Field: OmegaFieldInternalApi<From, Name>;
+};
+export type PrefixFromDepth<K extends string | number, _TDepth extends any[]> = K;
+export type FieldValidators<T> = {
+    onChangeAsync?: FieldAsyncValidateOrFn<T, any, any>;
+    onChange?: FieldValidateOrFn<T, any, any>;
+    onBlur?: FieldValidateOrFn<T, any, any>;
+    onBlurAsync?: FieldAsyncValidateOrFn<T, any, any>;
+};
+export type OmegaAutoGenMeta<From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>> = Omit<OmegaInputProps<From, To, Name>, "form">;
+type keysRule<T> = {
+    keys?: NestedKeyOf<T>[];
+    banKeys?: "You should only use one of banKeys or keys, not both, moron";
+} | {
+    keys?: "You should only use one of banKeys or keys, not both, moron";
+    banKeys?: NestedKeyOf<T>[];
+};
+export type Policies = PersistencyPolicies;
+export type defaultValuesPriorityUnion = PersistencyPriority;
+export type OmegaConfig<T> = {
+    i18nNamespace?: string;
+    persistency?: {
+        /** Order of importance:
+         * - "querystring": Highest priority when persisting
+         * - "local" and then "session": Lower priority storage options
+         */
+        policies?: UnionToTuples<Policies>;
+        overrideDefaultValues?: "deprecated: use defaultValuesPriority";
+        id?: string;
+    } & keysRule<T>;
+    ignorePreventCloseEvents?: boolean;
+    /**
+     * Prevents browser window/tab exit when form has unsaved changes.
+     * Shows native browser "Leave site?" dialog.
+     *
+     * @remarks
+     * - Opt-in only: Must explicitly enable
+     * - Independent from data persistence feature
+     */
+    preventWindowExit?: "prevent" | "prevent-and-reset" | "nope";
+    input?: any;
+    /**
+     * Register a custom input component per `type` (new types or overrides). Each
+     * key becomes a valid `<form.Input type="...">` value; components receive the
+     * `OmegaRendererProps` contract (`{ inputProps, field, state }`).
+     */
+    inputs?: Record<string, Component>;
+    /**
+     * Default values order is: Tanstack default values passed as second parameter to useOmegaForm, then persistency
+     * default values from querystring or local/session storage, then defaults from schema
+     * You can customize the order and  with omegaConfig.defaultValuesPriority
+     * default value = ['tanstack', 'persistency', 'schema']
+     */
+    defaultValuesPriority?: UnionToTuples<defaultValuesPriorityUnion>;
+    defaultFromSchema?: "deprecated: use defaultValuesPriority";
+};
+export interface OF<From, To> extends OmegaFormApi<From, To> {
+    meta: MetaRecord<From>;
+    unionMeta: Record<string, MetaRecord<From>>;
+    inputs?: Record<string, Component>;
+    clear: () => void;
+    /**
+     * Backfills the untouched children of any materialised nullable struct with
+     * their schema default (or `null`), so the live `values` matches what
+     * validation and decoding see. Called after a field change.
+     */
+    normalizeNullableStructs: () => void;
+    i18nNamespace?: string;
+    ignorePreventCloseEvents?: boolean;
+    registerField: (field: ComputedRef<{
+        name: string;
+        label: string;
+        id: string;
+    }>) => void;
+    /** @experimental */
+    handleSubmitEffect: {
+        /**
+         * when `checkErrors` is true, the Effect will fail with `FormErrors<From>` when there are validation errors
+         * @experimental */
+        (options: {
+            checkErrors: true;
+            meta?: Record<string, any>;
+        }): Effect.Effect<void, FormErrors<From>>;
+        /** @experimental */
+        (options?: {
+            meta?: Record<string, any>;
+        }): Effect.Effect<void>;
+    };
+}
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type CachedFieldApi<From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, TypeProps = DefaultTypeProps> = FieldApi<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>, FieldValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FieldValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FieldAsyncValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FieldValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FieldAsyncValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FieldValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FieldAsyncValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FieldValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FieldAsyncValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FormValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, StandardSchemaV1<From, To>, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, Record<string, any> | undefined>;
+type CachedFieldState<From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, TypeProps = DefaultTypeProps> = FieldState<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>, FieldValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FieldValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FieldAsyncValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FieldValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FieldAsyncValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FieldValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FieldAsyncValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FieldValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FieldAsyncValidateOrFn<From, OmegaFormReturn<From, To, TypeProps>["_keys"], DeepValue<From, OmegaFormReturn<From, To, TypeProps>["_keys"]>> | undefined, FormValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, StandardSchemaV1<From, To>, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined>;
+export interface OmegaFormReturn<From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, TypeProps = DefaultTypeProps> extends OF<From, To> {
+    _paths: FieldPath<From>;
+    _keys: NestedKeyOf<From>;
+    _schema: S.Codec<To, From>;
+    Input: <Name extends OmegaFormReturn<From, To, TypeProps>["_paths"]>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, never> & TypeProps & Partial<{}>> & BaseProps<From, Name> & PublicProps;
+        expose(exposed: ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {
+            default?(props: MergedInputProps<From, Name>): void;
+            label?: (props: {
+                required: boolean;
+                id: string;
+                label: string;
+            }) => void;
+        };
+        emit: {};
+    }>) => VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    Errors: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, never> & Partial<{}>> & PublicProps;
+        expose(exposed: ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {
+            default: (props: {
+                errors: readonly OmegaError[];
+                showedGeneralErrors: string[];
+            }) => void;
+        };
+        emit: {};
+    }>) => VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    TaggedUnion: <Name extends OmegaFormReturn<From, To, TypeProps>["_keys"]>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, never> & {
+            name?: Name;
+            type?: "select" | "radio";
+            options: TaggedUnionOptionsArray<From, Name>;
+            _debugName?: [NoInfer<Name>];
+            label?: string;
+        } & {}> & PublicProps;
+        expose(exposed: ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: Record<string, (props: {
+            field: FieldApi<From, Name, DeepValue<From, Name>, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>;
+            state: FieldState<From, Name, DeepValue<From, Name>, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>;
+        }) => any>;
+        emit: {};
+    }>) => VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    Array: <Name extends OmegaFormReturn<From, To, TypeProps>["_keys"]>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, never> & (Omit<OmegaArrayProps<From, To, Name>, "form">) & {}> & PublicProps;
+        expose(exposed: ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {
+            "pre-array"?: (props: {
+                field: CachedFieldApi<From, To, TypeProps>;
+                state: CachedFieldState<From, To, TypeProps>;
+            }) => any;
+        } & {
+            default?: (props: {
+                subField: CachedFieldApi<From, To, TypeProps>;
+                subState: CachedFieldState<From, To, TypeProps>;
+                index: number;
+                field: CachedFieldApi<From, To, TypeProps>;
+            }) => any;
+        } & {
+            "post-array"?: (props: {
+                field: CachedFieldApi<From, To, TypeProps>;
+                state: CachedFieldState<From, To, TypeProps>;
+            }) => any;
+        } & {
+            field?: (props: {
+                field: CachedFieldApi<From, To, TypeProps>;
+            }) => any;
+        };
+        emit: {};
+    }>) => VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    AutoGen: <Name extends OmegaFormReturn<From, To, TypeProps>["_keys"]>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, never> & {
+            pick?: OmegaFormReturn<From, To, TypeProps>["_keys"][];
+            omit?: OmegaFormReturn<From, To, TypeProps>["_keys"][];
+            labelMap?: (key: OmegaFormReturn<From, To, TypeProps>["_keys"]) => string | undefined;
+            filterMap?: <M extends OmegaAutoGenMeta<From, To, Name>>(key: OmegaFormReturn<From, To, TypeProps>["_keys"], meta: M) => boolean | M;
+            order?: OmegaFormReturn<From, To, TypeProps>["_keys"][];
+            sort?: Order.Order<OmegaAutoGenMeta<From, To, Name>>;
+        } & {}> & PublicProps;
+        expose(exposed: ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {
+            default(props: {
+                child: OmegaAutoGenMeta<From, To, Name>;
+            }): void;
+        };
+        emit: {};
+    }>) => VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    Form: <K extends keyof OmegaFormState<To, From>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, never> & {
+            disabled?: boolean;
+            subscribe?: K[];
+        } & {}> & PublicProps;
+        expose(exposed: ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {
+            default(props: {
+                subscribedValues: K[] extends undefined[] ? Record<string, never> : Pick<OmegaFormState<From, To>, K>;
+            }): void;
+        };
+        emit: {};
+    }>) => VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+}
+export {};