@effect-app/vue-components 0.12.19 → 0.12.21

package/src/components/OmegaForm/InputProps.ts

@@ -1,68 +1,41 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type { FieldApi, DeepValue, ValidationError } from "@tanstack/vue-form"
-import { type NestedKeyOf } from "./OmegaFormStuff"
+import type {
+  DeepValue,
+  DeepKeys,
+  FieldApi,
+  ValidationError,
+  FormAsyncValidateOrFn,
+  FormValidateOrFn,
+  StandardSchemaV1,
+  FieldValidateOrFn,
+  FieldValidateFn,
+  FieldValidateAsyncFn,
+  FieldAsyncValidateOrFn,
+} from "@tanstack/vue-form"
 
-// Placeholder types for validator function shapes
-type ValidatorFnSync = (opts: {
-  value: any
-  fieldApi: any
-}) => ValidationError | undefined
-type ValidatorFnAsync = (opts: {
-  value: any
-  fieldApi: any
-}) => Promise<ValidationError | undefined>
-// Assuming form validators have a similar structure but might operate on the whole form data (any for simplicity)
-type FormValidatorFnSync = (opts: {
-  value: any
-  formApi: any
-}) => ValidationError | undefined
-type FormValidatorFnAsync = (opts: {
-  value: any
-  formApi: any
-}) => Promise<ValidationError | undefined>
-// Placeholder for other form-related types
-type FormServerError = any
-type SubmitMeta = any
+export type OmegaFieldInternalApi<From, To> = FieldApi<
+  From,
+  DeepKeys<From>,
+  DeepValue<From, any>,
+  FieldValidateOrFn<From, DeepKeys<From>, DeepValue<From, any>> | undefined,
+  StandardSchemaV1<unknown, To> | FieldValidateFn<From, any, To>,
+  StandardSchemaV1<unknown, To> | FieldValidateAsyncFn<From, any, To>,
+  FieldValidateOrFn<From, DeepKeys<From>, DeepValue<From, any>>,
+  FieldAsyncValidateOrFn<From, DeepKeys<From>, DeepValue<From, any>>,
+  FieldValidateOrFn<From, DeepKeys<From>, DeepValue<From, any>> | undefined,
+  FieldAsyncValidateOrFn<From, DeepKeys<From>, DeepValue<From, any>> | undefined,
+  FormValidateOrFn<From> | undefined,
+  FormValidateOrFn<From> | undefined,
+  any,
+  FormValidateOrFn<From> | undefined,
+  FormAsyncValidateOrFn<From> | undefined,
+  FormValidateOrFn<From> | undefined,
+  FormAsyncValidateOrFn<From> | undefined,
+  FormAsyncValidateOrFn<From> | undefined,
+  FormAsyncValidateOrFn<From> | undefined
+>
 
-// Define a more flexible Updater type that can accept direct values
-type FlexibleUpdater<T> = ((prev: T) => T) | T
-
-export type OmegaFieldInternalApi<To> = Omit<
-  FieldApi<
-    To, // TParentData
-    NestedKeyOf<To>, // TName
-    DeepValue<To, NestedKeyOf<To>>, // TData
-    // Field Validators (approximated typqes)
-    ValidatorFnSync, // TOnMount
-    ValidatorFnSync, // TOnChange
-    ValidatorFnAsync, // TOnChangeAsync
-    ValidatorFnSync, // TOnBlur
-    ValidatorFnAsync, // TOnBlurAsync
-    ValidatorFnSync, // TOnSubmit
-    ValidatorFnAsync, // TOnSubmitAsync
-    // Form Validators (approximated types)
-    FormValidatorFnSync, // TFormOnMount
-    FormValidatorFnSync, // TFormOnChange
-    FormValidatorFnAsync, // TFormOnChangeAsync
-    FormValidatorFnSync, // TFormOnBlur
-    FormValidatorFnAsync, // TFormOnBlurAsync
-    FormValidatorFnSync, // TFormOnSubmit
-    FormValidatorFnAsync, // TFormOnSubmitAsync
-    // Other Form types (placeholders)
-    FormServerError, // TFormOnServer
-    SubmitMeta // TParentSubmitMeta
-  >,
-  "handleChange" | "setValue"
-> & {
-  handleChange: (
-    updater: FlexibleUpdater<DeepValue<To, NestedKeyOf<To>>> | any,
-  ) => void
-  setValue: (
-    updater: FlexibleUpdater<DeepValue<To, NestedKeyOf<To>>> | any,
-  ) => void
-}
-
-export type InputProps<T> = {
+export type InputProps<T, S = unknown> = {
   id: string
   required?: boolean
   minLength?: number | false
@@ -70,10 +43,10 @@ export type InputProps<T> = {
   max?: number | false
   min?: number | false
   name: string
-  modelValue: unknown
+  modelValue: S
   errorMessages: string[]
   error: boolean
-  field: OmegaFieldInternalApi<T>
+  field: OmegaFieldInternalApi<T, S>
   setRealDirty: () => void
   type: string
   label: string

package/src/components/OmegaForm/OmegaArray.vue

@@ -4,8 +4,10 @@
       <component
         :is="form.Field"
         v-for="(_, i) of field.state.value"
-        :key="i"
-        :name="`${name}[${i}]`"
+        :key="`${name}[${Number(i)}]`"
+        :name="
+          `${name}[${Number(i)}]` as DeepKeys<From>
+        "
       >
         <template #default="{ field: subField, state: subState }">
           <slot
@@ -13,7 +15,7 @@
               field,
               subField,
               subState,
-              index: i,
+              index: Number(i),
             }"
           />
         </template>

package/src/components/OmegaForm/OmegaAutoGen.vue

@@ -18,6 +18,8 @@ import {
 } from "./OmegaFormStuff"
 import { pipe, Order, Array as A } from "effect-app"
 import OmegaInput from "./OmegaInput.vue"
+import { DeepKeys } from "@tanstack/vue-form"
+import { OmegaFormReturn } from "./useOmegaForm"
 
 export type OmegaAutoGenMeta<From, To> = Omit<OmegaInputProps<From, To>, "form">
 type NewMeta = OmegaAutoGenMeta<From, To>
@@ -51,18 +53,16 @@ const filterMapRecord =
     )
 
 const props = defineProps<{
-  form: FormType<From, To> & {
-    meta: MetaRecord<To>
-  }
-  pick?: NestedKeyOf<To>[]
-  omit?: NestedKeyOf<To>[]
-  labelMap?: (key: NestedKeyOf<To>) => string | undefined
-  filterMap?: <M extends NewMeta>(key: NestedKeyOf<To>, meta: M) => boolean | M
-  order?: NestedKeyOf<To>[]
+  form: OmegaInputProps<From, To>['form']
+  pick?: DeepKeys<From>[]
+  omit?: DeepKeys<From>[]
+  labelMap?: (key: DeepKeys<From>) => string | undefined
+  filterMap?: <M extends NewMeta>(key: DeepKeys<From>, meta: M) => boolean | M
+  order?: DeepKeys<From>[]
   sort?: Order.Order<NewMeta>
 }>()
 
-const namePosition = (name: NestedKeyOf<To>, order: NestedKeyOf<To>[]) => {
+const namePosition = (name: DeepKeys<From>, order: DeepKeys<From>[]) => {
   const index = order?.indexOf(name) ?? -1
   return index === -1 ? Number.MAX_SAFE_INTEGER : index
 }
@@ -74,7 +74,7 @@ const orderBy: Order.Order<NewMeta> = Order.mapInput(
 
 const children = computed<NewMeta[]>(() =>
   pipe(
-    props.form.meta as Record<NestedKeyOf<To>, FieldMeta | undefined>,
+    props.form.meta as Record<DeepKeys<From>, FieldMeta | undefined>,
     // include / exclude
     filterRecord((_, metaKey) =>
       props.pick

package/src/components/OmegaForm/OmegaFormInput.vue

@@ -18,24 +18,22 @@
 import { inject } from "vue"
 import type {
   FieldValidators,
-  NestedKeyOf,
   TypeOverride,
-  FormType,
-  MetaRecord,
+  OmegaInputProps,
 } from "./OmegaFormStuff"
 import type { InputProps } from "./InputProps"
 import OmegaInput from "./OmegaInput.vue"
 import { OmegaFormKey } from "./useOmegaForm"
+import { DeepKeys } from "@tanstack/vue-form"
 
-const form = inject(OmegaFormKey) as FormType<From, To> & {
-  meta: MetaRecord<To>
-}
+const form = inject(OmegaFormKey) as unknown as OmegaInputProps<From, To>['form']
+ 
 if (!form) {
   throw new Error("OmegaFormInput must be used within an OmegaForm context")
 }
 
 defineProps<{
-  name: NestedKeyOf<To>
+  name: DeepKeys<From>
   label: string
   validators?: FieldValidators<From>
   options?: { title: string; value: string }[]
@@ -44,6 +42,6 @@ defineProps<{
 
 defineSlots<{
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  default: (props: InputProps<To>) => any
+  default: InputProps<From, To>
 }>()
 </script>

package/src/components/OmegaForm/OmegaFormStuff.ts

@@ -6,23 +6,23 @@ import {
   type StandardSchemaV1,
   type FormApi,
   type VueFormApi,
-  type FieldComponent,
   type FormOptions,
   type DeepKeys,
   type FieldValidateOrFn,
   type FieldAsyncValidateOrFn,
   type FormState,
 } from "@tanstack/vue-form"
-import type { Component } from "vue"
 import { useIntl } from "../../utils"
+import { OmegaFormReturn } from "./useOmegaForm"
+import { OmegaFieldInternalApi } from "./InputProps"
 
 export type ShowErrorsOn = "onChange" | "onBlur" | "onSubmit"
 
 export type OmegaInputProps<From, To> = {
-  form: FormType<From, To> & {
-    meta: MetaRecord<To>
+  form: OmegaFormReturn<From, To> & {
+    meta: MetaRecord<From>
   }
-  name: NestedKeyOf<To>
+  name: NestedKeyOf<From>
   validators?: FieldValidators<From>
   label: string
   options?: { title: string; value: string }[]
@@ -49,68 +49,68 @@ export interface OmegaError {
 
 const isArrayOfString = S.NonEmptyArray(S.String)
 
-export type FormProps<To, From> = Omit<
+export type FormProps<From, To> = Omit<
   FormOptions<
-    To,
-    FormValidateOrFn<To> | undefined,
-    FormValidateOrFn<To> | undefined,
-    StandardSchemaV1<To, From>,
-    FormValidateOrFn<To> | undefined,
-    FormAsyncValidateOrFn<To> | undefined,
-    FormValidateOrFn<To> | undefined,
-    FormAsyncValidateOrFn<To> | undefined,
-    FormAsyncValidateOrFn<To> | undefined,
-    FormAsyncValidateOrFn<To> | undefined
+    From,
+    FormValidateOrFn<From> | undefined,
+    FormValidateOrFn<From> | undefined,
+    StandardSchemaV1<From, To>,
+    FormValidateOrFn<From> | undefined,
+    FormAsyncValidateOrFn<From> | undefined,
+    FormValidateOrFn<From> | undefined,
+    FormAsyncValidateOrFn<From> | undefined,
+    FormAsyncValidateOrFn<From> | undefined,
+    FormAsyncValidateOrFn<From> | undefined
   >,
   "onSubmit"
 > & {
   onSubmit?: (props: {
-    formApi: OmegaFormParams<To, From>
+    formApi: OmegaFormParams<From, To>
     meta: any
-    value: From
+    value: To
   }) => Promise<any> | any
 }
 
-export type OmegaFormParams<To, From> = FormApi<
-  To,
-  FormValidateOrFn<To> | undefined,
-  FormValidateOrFn<To> | undefined,
-  StandardSchemaV1<To, From>,
-  FormValidateOrFn<To> | undefined,
-  FormAsyncValidateOrFn<To> | undefined,
-  FormValidateOrFn<To> | undefined,
-  FormAsyncValidateOrFn<To> | undefined,
-  FormAsyncValidateOrFn<To> | undefined,
-  FormAsyncValidateOrFn<To> | undefined
+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,
+  FormAsyncValidateOrFn<From> | undefined,
+  FormAsyncValidateOrFn<From> | undefined
 >
 
-export type OmegaFormState<To, From> = FormState<
-  To,
-  FormValidateOrFn<To> | undefined,
-  FormValidateOrFn<To> | undefined,
-  StandardSchemaV1<To, From>,
-  FormValidateOrFn<To> | undefined,
-  FormAsyncValidateOrFn<To> | undefined,
-  FormValidateOrFn<To> | undefined,
-  FormAsyncValidateOrFn<To> | undefined,
-  FormAsyncValidateOrFn<To> | 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,
+  FormAsyncValidateOrFn<From> | undefined
 >
 
-export type OmegaFormApi<To, From> = OmegaFormParams<To, From> &
+export type OmegaFormApi<From, To> = OmegaFormParams<From, To> &
   VueFormApi<
-    To,
-    FormValidateOrFn<To> | undefined,
-    FormValidateOrFn<To> | undefined,
-    StandardSchemaV1<To, From>,
-    FormValidateOrFn<To> | undefined,
-    FormAsyncValidateOrFn<To> | undefined,
-    FormValidateOrFn<To> | undefined,
-    FormAsyncValidateOrFn<To> | undefined,
-    FormAsyncValidateOrFn<To> | undefined,
-    FormAsyncValidateOrFn<To> | undefined
+    From,
+    FormValidateOrFn<From> | undefined,
+    FormValidateOrFn<From> | undefined,
+    StandardSchemaV1<From, To>,
+    FormValidateOrFn<From> | undefined,
+    FormAsyncValidateOrFn<From> | undefined,
+    FormValidateOrFn<From> | undefined,
+    FormAsyncValidateOrFn<From> | undefined,
+    FormAsyncValidateOrFn<From> | undefined,
+    FormAsyncValidateOrFn<From> | undefined
   >
 
-export type FormComponent<T, S> = FieldComponent<
+export type FormComponent<T, S> = VueFormApi<
   T,
   FormValidateOrFn<T> | undefined,
   FormValidateOrFn<T> | undefined,
@@ -121,16 +121,15 @@ export type FormComponent<T, S> = FieldComponent<
   FormAsyncValidateOrFn<T> | undefined,
   FormAsyncValidateOrFn<T> | undefined,
   FormAsyncValidateOrFn<T> | undefined
-> &
-  Component
+>
 
 export type FormType<T, S = unknown> = OmegaFormApi<T, S> & {
-  Field: Component
+  Field: OmegaFieldInternalApi<T, S>
 }
 
 export type PrefixFromDepth<
   K extends string | number,
-  _TDepth extends any[],
+  _TDepth extends any[]
 > = K
 
 export type NestedKeyOf<T> = DeepKeys<T>
@@ -234,7 +233,7 @@ const isNullableOrUndefined = (property: false | S.AST.AST | undefined) => {
 
 export const createMeta = <T = any>(
   { meta = {}, parent = "", property, propertySignatures }: CreateMeta,
-  acc: Partial<MetaRecord<T>> = {},
+  acc: Partial<MetaRecord<T>> = {}
 ): MetaRecord<T> | FieldMeta => {
   if (property && property._tag === "Transformation") {
     return createMeta<T>({
@@ -260,11 +259,11 @@ export const createMeta = <T = any>(
       const typeToProcess = p.type
       if (S.AST.isUnion(p.type)) {
         const nonNullTypes = p.type.types.filter(
-          t => t._tag !== "UndefinedKeyword" && t !== S.Null.ast,
+          t => t._tag !== "UndefinedKeyword" && t !== S.Null.ast
         )
 
         const hasStructMembers = nonNullTypes.some(
-          t => "propertySignatures" in t,
+          t => "propertySignatures" in t
         )
 
         if (hasStructMembers) {
@@ -285,7 +284,7 @@ export const createMeta = <T = any>(
                   parent: key,
                   propertySignatures: nonNullType.propertySignatures,
                   meta: { required: isRequired, nullableOrUndefined },
-                }),
+                })
               )
             }
           }
@@ -306,7 +305,7 @@ export const createMeta = <T = any>(
             parent: key,
             propertySignatures: typeToProcess.propertySignatures,
             meta: { required: isRequired, nullableOrUndefined },
-          }),
+          })
         )
       } else {
         const newMeta = createMeta<T>({
@@ -329,7 +328,7 @@ export const createMeta = <T = any>(
 
     if (S.AST.isUnion(property)) {
       const nonNullType = property.types.find(
-        t => t._tag !== "UndefinedKeyword" && t !== S.Null.ast,
+        t => t._tag !== "UndefinedKeyword" && t !== S.Null.ast
       )!
 
       if ("propertySignatures" in nonNullType) {
@@ -369,7 +368,7 @@ export const createMeta = <T = any>(
 
     const JSONAnnotation = S.AST.getAnnotation(
       property,
-      S.AST.JSONSchemaAnnotationId,
+      S.AST.JSONSchemaAnnotationId
     ).pipe(Option.getOrElse(() => ({}))) as Record<string, unknown>
 
     meta = { ...meta, ...JSONAnnotation }
@@ -383,11 +382,11 @@ export const createMeta = <T = any>(
     } else {
       meta["type"] = S.AST.getAnnotation(
         property,
-        S.AST.TitleAnnotationId,
+        S.AST.TitleAnnotationId
       ).pipe(
         Option.getOrElse(() => {
           return "unknown"
-        }),
+        })
       )
     }
 
@@ -398,7 +397,7 @@ export const createMeta = <T = any>(
 }
 
 const flattenMeta = <From, To>(
-  schema: S.Schema<From, To, never>,
+  schema: S.Schema<From, To, never>
 ): MetaRecord<To> => {
   const ast = schema.ast
   const result: MetaRecord<To> = {}
@@ -418,12 +417,12 @@ const flattenMeta = <From, To>(
 
     const flattenObject = (
       obj: Record<string, any>,
-      parentKey: string = "",
+      parentKey: string = ""
     ) => {
       for (const key in obj) {
         const newKey = parentKey ? `${parentKey}.${key}` : key
         if (obj[key] && typeof obj[key] === "object" && "type" in obj[key]) {
-          result[newKey as NestedKeyOf<To>] = obj[key] as FieldMeta
+          result[newKey as DeepKeys<To>] = obj[key] as FieldMeta
         } else if (obj[key] && typeof obj[key] === "object") {
           flattenObject(obj[key], newKey)
         }
@@ -437,13 +436,13 @@ const flattenMeta = <From, To>(
 }
 
 export const duplicateSchema = <From, To>(
-  schema: S.Schema<From, To, never>,
+  schema: S.Schema<From, To, never>
 ) => {
   return S.extend(schema, S.Struct({}))
 }
 
 export const generateMetaFromSchema = <From, To>(
-  schema: S.Schema<From, To, never>,
+  schema: S.Schema<From, To, never>
 ): {
   schema: S.Schema<From, To, never>
   meta: MetaRecord<To>
@@ -457,23 +456,23 @@ export const generateMetaFromSchema = <From, To>(
     Option.flatMap(s => S.AST.getJSONSchemaAnnotation(s)),
     Option.filter(s => "items" in s),
     Option.filterMap(({ items }) =>
-      S.decodeUnknownOption(isArrayOfString)(items),
+      S.decodeUnknownOption(isArrayOfString)(items)
     ),
     Option.zipWith(
       S.AST.getMessageAnnotation(schema.ast),
       (items, message) => ({
         items,
         message: message("" as unknown as S.ParseResult.ParseIssue),
-      }),
+      })
     ),
-    Option.getOrUndefined,
+    Option.getOrUndefined
   )
 
   return { schema, meta, filterItems }
 }
 
 export const generateInputStandardSchemaFromFieldMeta = (
-  meta: FieldMeta,
+  meta: FieldMeta
 ): StandardSchemaV1<any, any> => {
   const { trans } = useIntl()
   let schema: S.Schema<any, any, never>
@@ -488,7 +487,7 @@ export const generateInputStandardSchemaFromFieldMeta = (
           schema,
           S.Email.annotations({
             message: () => trans("validation.email.invalid"),
-          }),
+          })
         )
       }
 
@@ -601,7 +600,7 @@ export const generateInputStandardSchemaFromFieldMeta = (
     schema.pipe(
       S.annotations({
         message: () => trans("validation.empty"),
-      }),
+      })
     )
   }
   const result = S.standardSchemaV1(schema)
@@ -610,11 +609,11 @@ export const generateInputStandardSchemaFromFieldMeta = (
 
 export const nullableInput = <A, I, R>(
   schema: S.Schema<A, I, R>,
-  defaultValue: () => A,
+  defaultValue: () => A
 ) =>
   S.NullOr(schema).pipe(
     S.transform(S.typeSchema(schema), {
       decode: input => input ?? defaultValue(),
       encode: input => input,
-    }),
+    })
   )

package/src/components/OmegaForm/OmegaInput.vue

@@ -7,7 +7,7 @@
       ...validators,
     }"
   >
-    <template #default="{ field }: { field: OmegaFieldInternalApi<To> }">
+  <template #default="{ field }">
       <OmegaInternalInput
         v-if="meta"
         :field="field"
@@ -33,7 +33,6 @@ import {
   type OmegaInputProps,
 } from "./OmegaFormStuff"
 import OmegaInternalInput from "./OmegaInternalInput.vue"
-import type { OmegaFieldInternalApi } from "./InputProps"
 
 const props = defineProps<OmegaInputProps<From, To>>()
 

package/src/components/OmegaForm/OmegaInputVuetify.vue

@@ -64,7 +64,7 @@
       @update:model-value="
         (e: any) => {
           if (e || e === 0) {
-            inputProps.field.handleChange(Number(e))
+              inputProps.field.handleChange(Number(e))
           } else {
             inputProps.field.handleChange(undefined)
           }
@@ -112,11 +112,11 @@
   </div>
 </template>
 
-<script setup lang="ts" generic="T">
+<script setup lang="ts" generic="T, S">
 import type { InputProps } from "./InputProps"
 
 defineProps<{
-  inputProps: InputProps<T>
+  inputProps: InputProps<T, S>
   vuetifyValue: unknown
 }>()
 

package/src/components/OmegaForm/OmegaInternalInput.vue

@@ -11,7 +11,7 @@
   </slot>
 </template>
 
-<script setup lang="ts" generic="To">
+<script setup lang="ts" generic="From, To">
 import { useStore } from "@tanstack/vue-form"
 import {
   useId,
@@ -39,12 +39,12 @@ defineOptions({
 })
 
 const props = defineProps<{
-  field: OmegaFieldInternalApi<To>
-  meta: MetaRecord<To>[NestedKeyOf<To>]
+  field: OmegaFieldInternalApi<From, To>
+  meta: MetaRecord<From>[NestedKeyOf<From>]
   label: string
   options?: { title: string; value: string }[]
   type?: TypeOverride
-  validators?: FieldValidators<To>
+  validators?: FieldValidators<From>
 }>()
 
 const instance = getCurrentInstance()
@@ -143,7 +143,7 @@ watch(
   },
 )
 
-const inputProps: ComputedRef<InputProps<To>> = computed(() => ({
+const inputProps: ComputedRef<InputProps<From, To>> = computed(() => ({
   id,
   required: props.meta?.required,
   minLength: props.meta?.type === "string" && props.meta?.minLength,

package/src/components/OmegaForm/OmegaWrapper.vue

@@ -84,7 +84,7 @@ const props = defineProps<
   } & FormProps<To, From> &
     (
       | {
-          form: OmegaFormReturn<To, From>
+          form: OmegaFormReturn<From, To>
           schema?: undefined
         }
       | {
@@ -158,7 +158,7 @@ const formIsSubmitting = useStore(
 )
 
 const subscribedValues = getOmegaStore(
-  formToUse.value as OmegaFormApi<To, From>,
+  formToUse.value as unknown as OmegaFormApi<From, To>,
   props.subscribe,
 )
 

package/src/components/OmegaForm/index.ts

@@ -1,5 +1,6 @@
 import { default as OmegaForm } from "./OmegaWrapper.vue"
 import { default as OmegaInput } from "./OmegaInput.vue"
+import { default as OmegaFormInput } from "./OmegaFormInput.vue"
 import { default as OmegaErrors } from "./OmegaErrors.vue"
 import { default as OmegaAutoGen } from "./OmegaAutoGen.vue"
 import { default as OmegaArray } from "./OmegaArray.vue"
@@ -9,4 +10,4 @@ export * from "./OmegaFormStuff"
 export { useOmegaForm, type OmegaFormReturn } from "./useOmegaForm"
 export { default } from "./OmegaWrapper.vue"
 
-export { OmegaForm, OmegaInput, OmegaErrors, OmegaAutoGen, OmegaArray }
+export { OmegaForm, OmegaInput, OmegaFormInput, OmegaErrors, OmegaAutoGen, OmegaArray }