@effect-app/vue-components 4.0.0-beta.157 → 4.0.0-beta.159

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

@@ -1,5 +1,5 @@
 import { type DeepKeys } from "@tanstack/vue-form";
-import { type OmegaArrayProps } from "./OmegaFormStuff";
+import { type OmegaArrayProps } from "./types";
 declare const __VLS_export: <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<OmegaArrayProps<From, To, Name>> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;

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

@@ -1,6 +1,6 @@
 import { type DeepKeys } from "@tanstack/vue-form";
 import { Order } from "effect-app";
-import { type OmegaAutoGenMeta, type OmegaInputProps } from "./OmegaFormStuff";
+import { type OmegaAutoGenMeta, type OmegaInputProps } from "./types";
 declare const __VLS_export: <From extends Record<PropertyKey, string>, To extends Record<PropertyKey, string>, Name extends DeepKeys<From>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<{
         form: OmegaInputProps<From, To, Name>["form"];

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

@@ -1,5 +1,5 @@
 import type { StandardSchemaV1Issue } from "@tanstack/vue-form";
-import { type OmegaError } from "./OmegaFormStuff";
+import { type OmegaError } from "./types";
 type __VLS_Props = {
     generalErrors: (Record<string, StandardSchemaV1Issue[]> | undefined)[];
     errors: OmegaError[];

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

@@ -1,6 +1,6 @@
 import { type DeepKeys } from "@tanstack/vue-form";
 import type { MergedInputProps } from "./InputProps";
-import type { BaseProps, DefaultTypeProps } from "./OmegaFormStuff";
+import type { BaseProps, DefaultTypeProps } from "./types";
 declare const __VLS_export: <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<BaseProps<From, Name> & DefaultTypeProps> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;

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

@@ -1,5 +1,5 @@
 import { type DeepKeys } from "@tanstack/vue-form";
-import { type OmegaInputPropsBase } from "./OmegaFormStuff";
+import { type OmegaInputPropsBase } from "./types";
 declare const __VLS_export: <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<OmegaInputPropsBase<From, To, Name>> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;

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

@@ -1,7 +1,8 @@
 import { type DeepKeys } from "@tanstack/vue-form";
 import { type ComputedRef } from "vue";
 import type { OmegaFieldInternalApi } from "./InputProps";
-import type { FieldValidators, MetaRecord, NestedKeyOf, TypeOverride } from "./OmegaFormStuff";
+import type { MetaRecord, NestedKeyOf } from "./meta/types";
+import type { FieldValidators, TypeOverride } from "./types";
 declare const __VLS_export: <From extends Record<PropertyKey, any>, Name extends DeepKeys<From>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<{
         field: OmegaFieldInternalApi<From, Name>;

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

@@ -1,4 +1,4 @@
-import { type DefaultTypeProps, type OmegaFormState } from "./OmegaFormStuff";
+import { type DefaultTypeProps, type OmegaFormState } from "./types";
 import { type OmegaFormReturn } from "./useOmegaForm";
 declare const __VLS_export: <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, K extends keyof OmegaFormState<From, To> = keyof OmegaFormState<From, To>, Props = DefaultTypeProps>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<{

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

@@ -1,4 +1,4 @@
 import { type Component } from "vue";
-import { type DefaultTypeProps } from "./OmegaFormStuff";
+import { type DefaultTypeProps } from "./types";
 import { useOmegaForm } from "./useOmegaForm";
-export declare const createUseFormWithCustomInput: <TypeProps = DefaultTypeProps>(CustomInputComponent: Component) => <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>>(...args: Parameters<typeof useOmegaForm<From, To>>) => import("./useOmegaForm").OmegaFormReturn<From, To, TypeProps>;
+export declare const createUseFormWithCustomInput: <TypeProps = DefaultTypeProps>(CustomInputComponent: Component) => <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>>(...args: Parameters<typeof useOmegaForm<From, To>>) => import("./types").OmegaFormReturn<From, To, TypeProps>;

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

@@ -0,0 +1,33 @@
+import { type Component, type ComputedRef, type ConcreteComponent, type Ref } from "vue";
+import type { OF } from "./useOmegaForm";
+export declare const useErrorLabel: (form: OF<any, any>) => (propsName: string) => string;
+export declare const eHoc: (errorProps: {
+    form: OF<any, any>;
+    fieldMap: Ref<Map<string, {
+        id: string;
+        label: string;
+    }>>;
+}) => <P>(WrappedComponent: Component<P>) => ConcreteComponent<P>;
+export declare const makeFieldMap: () => {
+    fieldMap: Ref<Map<string, {
+        label: string;
+        id: string;
+    }> & Omit<Map<string, {
+        label: string;
+        id: string;
+    }>, keyof Map<any, any>>, Map<string, {
+        label: string;
+        id: string;
+    }> | (Map<string, {
+        label: string;
+        id: string;
+    }> & Omit<Map<string, {
+        label: string;
+        id: string;
+    }>, keyof Map<any, any>>)>;
+    registerField: (field: ComputedRef<{
+        name: string;
+        label: string;
+        id: string;
+    }>) => void;
+};

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

@@ -1,3 +1,3 @@
 import { type Ref } from "vue";
-import type { OmegaFormApi, OmegaFormState } from "./OmegaFormStuff";
+import type { OmegaFormApi, OmegaFormState } from "./types";
 export declare function getOmegaStore<To, From, K extends keyof OmegaFormState<To, From> = keyof OmegaFormState<To, From>>(form: OmegaFormApi<To, From>, subscribe?: K[]): Ref<K[] extends undefined[] ? Record<string, never> : Pick<OmegaFormState<To, From>, K>>;

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

@@ -0,0 +1,3 @@
+import { type Component, type ConcreteComponent } from "vue";
+import type { OF } from "./useOmegaForm";
+export declare const fHoc: (form: OF<any, any>) => <P>(WrappedComponent: Component<P>) => ConcreteComponent<P>;

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

@@ -1,10 +1,20 @@
-export * from "./OmegaFormStuff";
-export { type OmegaConfig, type OmegaFormReturn, useOmegaForm } from "./useOmegaForm";
+import type { S } from "effect-app";
+export { getInputType, type SupportedInputs } from "./inputs";
+export { createMeta, generateMetaFromSchema, isNullableOrUndefined, metadataFromAst } from "./meta/createMeta";
+export type { CreateMeta, FilterItems } from "./meta/createMeta";
+export { defaultsValueFromSchema } from "./meta/defaults";
+export { toFormSchema } from "./meta/redacted";
+export type { BaseFieldMeta, BooleanFieldMeta, DateFieldMeta, FieldMeta, MetaRecord, MultipleFieldMeta, NestedKeyOf, NumberFieldMeta, SelectFieldMeta, StringFieldMeta, UnknownFieldMeta } from "./meta/types";
+export { deepMerge } from "./persistency";
+export type { BaseProps, DefaultTypeProps, FieldPath, FieldPath_, FieldValidators, FormComponent, FormProps, FormType, OmegaArrayProps, OmegaAutoGenMeta, OmegaError, OmegaFormApi, OmegaFormParams, OmegaFormState, OmegaInputProps, OmegaInputPropsBase, PrefixFromDepth, TypeOverride, TypesWithOptions } from "./types";
+export { makeStandardSchemaV1Hooks, toLocalizedStandardSchemaV1 } from "./validation/localized";
+export { FormErrors, OmegaFormKey, useErrorLabel, useOmegaForm } from "./useOmegaForm";
+export type { defaultValuesPriorityUnion, OF, OmegaConfig, OmegaFormReturn, Policies } from "./useOmegaForm";
 export { type ExtractTagValue, type ExtractUnionBranch, type InputProps, type MergedInputProps, type TaggedUnionOption, type TaggedUnionOptionsArray, type TaggedUnionProps } from "./InputProps";
 export { default as OmegaInput } from "./OmegaInput.vue";
 export { default as OmegaVuetifyInput } from "./OmegaInternalInput.vue";
 export { default as OmegaTaggedUnion } from "./OmegaTaggedUnion.vue";
 export { default as OmegaTaggedUnionInternal } from "./OmegaTaggedUnionInternal.vue";
 export { useOnClose, usePreventClose } from "./blockDialog";
-export { getInputType } from "./OmegaFormStuff";
 export { createUseFormWithCustomInput } from "./createUseFormWithCustomInput";
+export declare const duplicateSchema: <From, To>(schema: S.Codec<To, From, never>) => S.Codec<To, From, never, never>;

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

@@ -0,0 +1,4 @@
+declare const supportedInputs: readonly ["button", "checkbox", "color", "date", "email", "number", "password", "radio", "range", "search", "submit", "tel", "text", "time", "url"];
+export type SupportedInputs = typeof supportedInputs[number];
+export declare const getInputType: (input: string) => SupportedInputs;
+export {};

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

@@ -0,0 +1,4 @@
+import { S } from "effect-app";
+import type { FieldMeta } from "./types";
+export declare const getCheckMetas: (property: S.AST.AST) => Array<Record<string, any>>;
+export declare const getFieldMetadataFromAst: (property: S.AST.AST) => Partial<FieldMeta> & Record<string, unknown>;

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

@@ -0,0 +1,32 @@
+import { type Effect, S } from "effect-app";
+import type { FieldMeta, MetaRecord } from "./types";
+export type FilterItems = {
+    items: readonly [string, ...string[]];
+    message: string | Effect.Effect<string, never, never> | {
+        readonly message: string | Effect.Effect<string>;
+    };
+};
+export type CreateMeta = {
+    parent?: string;
+    meta?: Record<string, any>;
+    nullableOrUndefined?: false | "undefined" | "null";
+} & ({
+    propertySignatures: readonly S.AST.PropertySignature[];
+    property?: never;
+} | {
+    propertySignatures?: never;
+    property: S.AST.AST;
+});
+export declare const unwrapDeclaration: (property: S.AST.AST) => S.AST.AST;
+export declare const isNullableOrUndefined: (property: false | S.AST.AST | undefined) => false | "undefined" | "null";
+export declare const createMeta: <T = any>({ meta, parent, property, propertySignatures }: CreateMeta, acc?: Partial<MetaRecord<T>>) => MetaRecord<T> | FieldMeta;
+export declare const metadataFromAst: <From, To>(schema: S.Codec<To, From, never>) => {
+    meta: MetaRecord<To>;
+    defaultValues: Record<string, any>;
+    unionMeta: Record<string, MetaRecord<To>>;
+};
+export declare const generateMetaFromSchema: <From, To>(schema: S.Codec<To, From, never>) => {
+    schema: S.Codec<To, From, never>;
+    meta: MetaRecord<To>;
+    unionMeta: Record<string, MetaRecord<To>>;
+};

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

@@ -0,0 +1,2 @@
+import { S } from "effect-app";
+export declare const defaultsValueFromSchema: (schema: S.Schema<any>, record?: Record<string, any>) => any;

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

@@ -0,0 +1,2 @@
+import { S } from "effect-app";
+export declare const toFormSchema: <From, To>(schema: S.Codec<To, From, never>) => S.Codec<To, From, never>;

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

@@ -0,0 +1,56 @@
+import type { DeepKeys } from "@tanstack/vue-form";
+import type { S } from "effect-app";
+import type { Redacted } from "effect/Redacted";
+type StripRedacted<T> = T extends Redacted<any> ? string : T extends ReadonlyArray<infer U> ? ReadonlyArray<StripRedacted<U>> : T extends Record<string, any> ? {
+    [K in keyof T]: StripRedacted<T[K]>;
+} : T;
+export type NestedKeyOf<T> = DeepKeys<StripRedacted<T>>;
+export type BaseFieldMeta = {
+    required: boolean;
+    nullableOrUndefined?: false | "undefined" | "null";
+    /**
+     * True when the schema property is `S.optionalKey` (AST
+     * `context.isOptional`) — i.e. the key should be ABSENT from the submitted
+     * object when empty, not present with `undefined`. Distinct from
+     * `required: false`, which may also mean "empty string is valid" for
+     * unconstrained `S.String` fields.
+     */
+    isOptionalKey?: boolean;
+};
+export type StringFieldMeta = BaseFieldMeta & {
+    type: "string";
+    maxLength?: number;
+    minLength?: number;
+    format?: string;
+};
+export type NumberFieldMeta = BaseFieldMeta & {
+    type: "number";
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    refinement?: "int";
+};
+export type SelectFieldMeta = BaseFieldMeta & {
+    type: "select";
+    members: any[];
+};
+export type MultipleFieldMeta = BaseFieldMeta & {
+    type: "multiple";
+    members: any[];
+    rest: readonly S.AST.AST[];
+};
+export type BooleanFieldMeta = BaseFieldMeta & {
+    type: "boolean";
+};
+export type DateFieldMeta = BaseFieldMeta & {
+    type: "date";
+};
+export type UnknownFieldMeta = BaseFieldMeta & {
+    type: "unknown";
+};
+export type FieldMeta = StringFieldMeta | NumberFieldMeta | SelectFieldMeta | MultipleFieldMeta | BooleanFieldMeta | DateFieldMeta | UnknownFieldMeta;
+export type MetaRecord<T = string> = {
+    [K in NestedKeyOf<T>]?: FieldMeta;
+};
+export {};

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

@@ -0,0 +1,18 @@
+import { S } from "effect-app";
+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<any>;
+    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 { Effect } from "effect-app";
+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, never>;
+export type RunPromise = <A, E>(eff: Effect.Effect<A, E, never>) => 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, never>, 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 {};