@tanstack/svelte-form 1.33.3 → 2.0.0-alpha.0

package/src/createForm.svelte.ts

@@ -1,350 +1,76 @@
-import { FormApi } from '@tanstack/form-core'
+import { InternalFormApi } from '@tanstack/form-core/internals'
 import { useSelector } from '@tanstack/svelte-store'
 import { onMount } from 'svelte'
 import Field from './Field.svelte'
 import FormGroup from './FormGroup.svelte'
 import Subscribe from './Subscribe.svelte'
-import type {
-  Component,
-  ComponentConstructorOptions,
-  Snippet,
-  SvelteComponent,
-} from 'svelte'
-import type {
-  FormAsyncValidateOrFn,
-  FormOptions,
-  FormState,
-  FormValidateOrFn,
-} from '@tanstack/form-core'
-import type {
-  FieldComponent,
-  FormGroupComponent,
-  WithoutFunction,
-} from './types.js'
+import { withComponentProps } from './utils.lib.js'
+import type { FormOptions } from '@tanstack/form-core'
+import type { Component } from 'svelte'
+import type { AnyInternalFormApi } from '@tanstack/form-core/internals'
+import type { SvelteTanStackFormComponents } from './Components.public'
 
-export interface SvelteFormApi<
-  TParentData,
-  TFormOnMount extends undefined | FormValidateOrFn<TParentData>,
-  TFormOnChange extends undefined | FormValidateOrFn<TParentData>,
-  TFormOnChangeAsync extends undefined | FormAsyncValidateOrFn<TParentData>,
-  TFormOnBlur extends undefined | FormValidateOrFn<TParentData>,
-  TFormOnBlurAsync extends undefined | FormAsyncValidateOrFn<TParentData>,
-  TFormOnSubmit extends undefined | FormValidateOrFn<TParentData>,
-  TFormOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TParentData>,
-  TFormOnDynamic extends undefined | FormValidateOrFn<TParentData>,
-  TFormOnDynamicAsync extends undefined | FormAsyncValidateOrFn<TParentData>,
-  TFormOnServer extends undefined | FormAsyncValidateOrFn<TParentData>,
-  TSubmitMeta,
-> {
-  Field: FieldComponent<
-    TParentData,
-    TFormOnMount,
-    TFormOnChange,
-    TFormOnChangeAsync,
-    TFormOnBlur,
-    TFormOnBlurAsync,
-    TFormOnSubmit,
-    TFormOnSubmitAsync,
-    TFormOnDynamic,
-    TFormOnDynamicAsync,
-    TFormOnServer,
-    TSubmitMeta
-  >
-  FormGroup: FormGroupComponent<
-    TParentData,
-    TFormOnMount,
-    TFormOnChange,
-    TFormOnChangeAsync,
-    TFormOnBlur,
-    TFormOnBlurAsync,
-    TFormOnSubmit,
-    TFormOnSubmitAsync,
-    TFormOnDynamic,
-    TFormOnDynamicAsync,
-    TFormOnServer,
-    TSubmitMeta
-  >
-  useSelector: <
-    TSelected = NoInfer<
-      FormState<
-        TParentData,
-        TFormOnMount,
-        TFormOnChange,
-        TFormOnChangeAsync,
-        TFormOnBlur,
-        TFormOnBlurAsync,
-        TFormOnSubmit,
-        TFormOnSubmitAsync,
-        TFormOnDynamic,
-        TFormOnDynamicAsync,
-        TFormOnServer
-      >
-    >,
-  >(
-    selector?: (
-      state: NoInfer<
-        FormState<
-          TParentData,
-          TFormOnMount,
-          TFormOnChange,
-          TFormOnChangeAsync,
-          TFormOnBlur,
-          TFormOnBlurAsync,
-          TFormOnSubmit,
-          TFormOnSubmitAsync,
-          TFormOnDynamic,
-          TFormOnDynamicAsync,
-          TFormOnServer
-        >
-      >,
-    ) => TSelected,
-  ) => { current: TSelected }
-  /**
-   * @deprecated Use `form.useSelector` instead.
-   */
-  useStore: <
-    TSelected = NoInfer<
-      FormState<
-        TParentData,
-        TFormOnMount,
-        TFormOnChange,
-        TFormOnChangeAsync,
-        TFormOnBlur,
-        TFormOnBlurAsync,
-        TFormOnSubmit,
-        TFormOnSubmitAsync,
-        TFormOnDynamic,
-        TFormOnDynamicAsync,
-        TFormOnServer
-      >
-    >,
-  >(
-    selector?: (
-      state: NoInfer<
-        FormState<
-          TParentData,
-          TFormOnMount,
-          TFormOnChange,
-          TFormOnChangeAsync,
-          TFormOnBlur,
-          TFormOnBlurAsync,
-          TFormOnSubmit,
-          TFormOnSubmitAsync,
-          TFormOnDynamic,
-          TFormOnDynamicAsync,
-          TFormOnServer
-        >
-      >,
-    ) => TSelected,
-  ) => { current: TSelected }
-  // This giant type allows the type
-  // - to be used as a function (which they are now in Svelte 5)
-  // - to be used as a class (which they were in Svelte 4, and which Svelte intellisense still uses for backwards compat)
-  // - to preserve the generics correctly
-  // Once Svelte intellisense no longer has/needs backwards compat, we can remove the class constructor part
-  Subscribe: (<
-    TSelected = NoInfer<
-      FormState<
-        TParentData,
-        TFormOnMount,
-        TFormOnChange,
-        TFormOnChangeAsync,
-        TFormOnBlur,
-        TFormOnBlurAsync,
-        TFormOnSubmit,
-        TFormOnSubmitAsync,
-        TFormOnDynamic,
-        TFormOnDynamicAsync,
-        TFormOnServer
-      >
-    >,
-  >(
-    internal: any,
-    props: {
-      selector?: (
-        state: NoInfer<
-          FormState<
-            TParentData,
-            TFormOnMount,
-            TFormOnChange,
-            TFormOnChangeAsync,
-            TFormOnBlur,
-            TFormOnBlurAsync,
-            TFormOnSubmit,
-            TFormOnSubmitAsync,
-            TFormOnDynamic,
-            TFormOnDynamicAsync,
-            TFormOnServer
-          >
-        >,
-      ) => TSelected
-      children: Snippet<[NoInfer<TSelected>]>
-    },
-  ) => {}) &
-    (new <
-      TSelected = NoInfer<
-        FormState<
-          TParentData,
-          TFormOnMount,
-          TFormOnChange,
-          TFormOnChangeAsync,
-          TFormOnBlur,
-          TFormOnBlurAsync,
-          TFormOnSubmit,
-          TFormOnSubmitAsync,
-          TFormOnDynamic,
-          TFormOnDynamicAsync,
-          TFormOnServer
-        >
-      >,
-    >(
-      opts: ComponentConstructorOptions<{
-        selector?: (
-          state: NoInfer<
-            FormState<
-              TParentData,
-              TFormOnMount,
-              TFormOnChange,
-              TFormOnChangeAsync,
-              TFormOnBlur,
-              TFormOnBlurAsync,
-              TFormOnSubmit,
-              TFormOnSubmitAsync,
-              TFormOnDynamic,
-              TFormOnDynamicAsync,
-              TFormOnServer
-            >
-          >,
-        ) => TSelected
-        children: Snippet<[NoInfer<TSelected>]>
-      }>,
-    ) => SvelteComponent) &
-    WithoutFunction<Component>
+export interface InternalSvelteFormApi
+  extends AnyInternalFormApi, SvelteTanStackFormComponents<any, any, any> {
+  _Subscribe: Component<any>
+  useSelector: <TSelected = any>(
+    selector?: (state: any) => TSelected,
+  ) => { readonly current: TSelected }
 }
 
-/**
- * An extended version of the `FormApi` class that includes Svelte-specific functionalities from `SvelteFormApi`
- */
-export type SvelteFormExtendedApi<
-  TFormData,
-  TOnMount extends undefined | FormValidateOrFn<TFormData>,
-  TOnChange extends undefined | FormValidateOrFn<TFormData>,
-  TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
-  TOnBlur extends undefined | FormValidateOrFn<TFormData>,
-  TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
-  TOnSubmit extends undefined | FormValidateOrFn<TFormData>,
-  TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
-  TOnDynamic extends undefined | FormValidateOrFn<TFormData>,
-  TOnDynamicAsync extends undefined | FormAsyncValidateOrFn<TFormData>,
-  TOnServer extends undefined | FormAsyncValidateOrFn<TFormData>,
-  TSubmitMeta,
-> = FormApi<
-  TFormData,
-  TOnMount,
-  TOnChange,
-  TOnChangeAsync,
-  TOnBlur,
-  TOnBlurAsync,
-  TOnSubmit,
-  TOnSubmitAsync,
-  TOnDynamic,
-  TOnDynamicAsync,
-  TOnServer,
-  TSubmitMeta
-> &
-  SvelteFormApi<
-    TFormData,
-    TOnMount,
-    TOnChange,
-    TOnChangeAsync,
-    TOnBlur,
-    TOnBlurAsync,
-    TOnSubmit,
-    TOnSubmitAsync,
-    TOnDynamic,
-    TOnDynamicAsync,
-    TOnServer,
-    TSubmitMeta
-  >
+export function attachSvelteFormComponents(
+  form: AnyInternalFormApi,
+  fieldComponents: Record<string, Component<any>> | null,
+): InternalSvelteFormApi {
+  const result = form as InternalSvelteFormApi
 
-export function createForm<
-  TParentData,
-  TFormOnMount extends undefined | FormValidateOrFn<TParentData>,
-  TFormOnChange extends undefined | FormValidateOrFn<TParentData>,
-  TFormOnChangeAsync extends undefined | FormAsyncValidateOrFn<TParentData>,
-  TFormOnBlur extends undefined | FormValidateOrFn<TParentData>,
-  TFormOnBlurAsync extends undefined | FormAsyncValidateOrFn<TParentData>,
-  TFormOnSubmit extends undefined | FormValidateOrFn<TParentData>,
-  TFormOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TParentData>,
-  TFormOnDynamic extends undefined | FormValidateOrFn<TParentData>,
-  TFormOnDynamicAsync extends undefined | FormAsyncValidateOrFn<TParentData>,
-  TFormOnServer extends undefined | FormAsyncValidateOrFn<TParentData>,
-  TSubmitMeta,
->(
-  opts?: () => FormOptions<
-    TParentData,
-    TFormOnMount,
-    TFormOnChange,
-    TFormOnChangeAsync,
-    TFormOnBlur,
-    TFormOnBlurAsync,
-    TFormOnSubmit,
-    TFormOnSubmitAsync,
-    TFormOnDynamic,
-    TFormOnDynamicAsync,
-    TFormOnServer,
-    TSubmitMeta
-  >,
-) {
-  const options = opts?.()
-  const api = new FormApi<
-    TParentData,
-    TFormOnMount,
-    TFormOnChange,
-    TFormOnChangeAsync,
-    TFormOnBlur,
-    TFormOnBlurAsync,
-    TFormOnSubmit,
-    TFormOnSubmitAsync,
-    TFormOnDynamic,
-    TFormOnDynamicAsync,
-    TFormOnServer,
-    TSubmitMeta
-  >(options)
-  const extendedApi: typeof api &
-    SvelteFormApi<
-      TParentData,
-      TFormOnMount,
-      TFormOnChange,
-      TFormOnChangeAsync,
-      TFormOnBlur,
-      TFormOnBlurAsync,
-      TFormOnSubmit,
-      TFormOnSubmitAsync,
-      TFormOnDynamic,
-      TFormOnDynamicAsync,
-      TFormOnServer,
-      TSubmitMeta
-    > = api as never
+  result.Field = ((internals: any, props: any) =>
+    Field(
+      internals,
+      withComponentProps(props, {
+        form,
+        fieldComponents: fieldComponents ?? {},
+      }),
+    )) as never
+  result.ArrayField = ((internals: any, props: any) =>
+    Field(
+      internals,
+      withComponentProps(props, {
+        form,
+        array: true,
+        fieldComponents: fieldComponents ?? {},
+      }),
+    )) as never
+  result._Subscribe = (internals, props) => Subscribe(internals, props)
+  result.Subscribe = ((internals: any, props: any) =>
+    Subscribe(
+      internals,
+      withComponentProps(props, { source: form.atom }),
+    )) as never
+  result.FormGroup = ((internals: any, props: any) =>
+    FormGroup(internals, withComponentProps(props, { form }))) as never
+  result.useSelector = ((selector?: (state: any) => any) =>
+    useSelector(form.atom, selector)) as never
 
-  // @ts-expect-error constructor definition exists only on a type level
-  extendedApi.Field = (internal, props) =>
-    Field(internal, { ...props, form: api as never } as never)
-  // @ts-expect-error constructor definition exists only on a type level
-  extendedApi.FormGroup = (internal, props) =>
-    FormGroup(internal, { ...props, form: api as never } as never)
-  extendedApi.useSelector = (selector) => useSelector(api.store, selector)
-  /** @deprecated Use `form.useSelector` instead. */
-  extendedApi.useStore = extendedApi.useSelector
-  // @ts-expect-error constructor definition exists only on a type level
-  extendedApi.Subscribe = (internal, props) =>
-    Subscribe(internal, { ...props, store: api.store })
+  return result
+}
+
+export function initializeForm(
+  options: FormOptions<any, any, any>,
+): InternalSvelteFormApi {
+  return attachSvelteFormComponents(new InternalFormApi(options), null)
+}
 
-  onMount(api.mount)
+export function createInternalForm(
+  options: () => FormOptions<any, any, any>,
+  initialize: (options: FormOptions<any, any, any>) => InternalSvelteFormApi,
+): InternalSvelteFormApi {
+  const form = initialize(options())
 
-  // formApi.update should not have any side effects. Think of it like a `useRef`
-  // that we need to keep updated every render with the most up-to-date information.
-  $effect.pre(() => api.update(opts?.()))
+  $effect.pre(() => {
+    form._update(options())
+  })
+  onMount(() => form.mount())
 
-  return extendedApi
+  return form
 }

package/src/formApiTypes.public.ts

@@ -0,0 +1,48 @@
+import type {
+  AnyFormApi,
+  FormApi,
+  FormErrorTypes,
+  FormState,
+} from '@tanstack/form-core'
+import type { Component } from 'svelte'
+import type { SvelteTanStackFormComponents } from './Components.public'
+import type {
+  AnySvelteFormComponentMap,
+  DefaultSvelteFormComponentMap,
+} from './AppForm/componentMap.public'
+
+export interface SvelteFormSelectors<
+  TFormData,
+  TFormErrorTypes extends FormErrorTypes,
+> {
+  useSelector: <TSelected = FormState<TFormData, TFormErrorTypes>>(
+    selector?: (state: FormState<TFormData, TFormErrorTypes>) => TSelected,
+  ) => { readonly current: TSelected }
+}
+
+type ExtendedFormApi<
+  TFormData,
+  TFormErrorTypes extends FormErrorTypes,
+  TFieldComponents extends Record<string, Component<any>>,
+> = FormApi<TFormData, TFormErrorTypes> &
+  SvelteTanStackFormComponents<TFormData, TFormErrorTypes, TFieldComponents> &
+  SvelteFormSelectors<TFormData, TFormErrorTypes>
+
+export type SvelteFormApi<
+  TFormData,
+  TFormErrorTypes extends FormErrorTypes,
+  TComponents extends AnySvelteFormComponentMap = DefaultSvelteFormComponentMap,
+> = unknown extends TComponents['formComponents']
+  ? ExtendedFormApi<TFormData, TFormErrorTypes, TComponents['fieldComponents']>
+  : ExtendedFormApi<
+      TFormData,
+      TFormErrorTypes,
+      TComponents['fieldComponents']
+    > &
+      TComponents['formComponents']
+
+export type AnySvelteFormApi = AnyFormApi &
+  SvelteTanStackFormComponents<any, any, any> &
+  SvelteFormSelectors<any, any>
+
+export type { SvelteFormComponentMap } from './AppForm/componentMap.public'

package/src/formType.public.ts

@@ -0,0 +1,46 @@
+import type {
+  AnyFormOptions,
+  FormOptions,
+  FormValidators,
+  ToFormErrorTypes,
+} from '@tanstack/form-core'
+import type { AppFormOptions } from './AppForm/appFormOptions.public'
+import type {
+  AnySvelteFormComponentMap,
+  DefaultSvelteFormComponentMap,
+} from './AppForm/componentMap.public'
+import type { SvelteFormApi } from './formApiTypes.public'
+
+type SvelteFormTypeErrorTypes<
+  TValidators extends FormValidators<any>,
+  TSubmitReturn,
+> = unknown extends TSubmitReturn
+  ? any
+  : ToFormErrorTypes<TValidators, TSubmitReturn>
+
+export type SvelteFormType<
+  TOptions extends
+    AnyFormOptions | AppFormOptions<any, any, any, AnySvelteFormComponentMap>,
+> =
+  TOptions extends AppFormOptions<
+    infer TData,
+    infer TValidators,
+    infer TSubmitReturn,
+    infer TComponents
+  >
+    ? SvelteFormApi<
+        TData,
+        SvelteFormTypeErrorTypes<TValidators, TSubmitReturn>,
+        TComponents
+      >
+    : TOptions extends FormOptions<
+          infer TData,
+          infer TValidators,
+          infer TSubmitReturn
+        >
+      ? SvelteFormApi<
+          TData,
+          SvelteFormTypeErrorTypes<TValidators, TSubmitReturn>,
+          DefaultSvelteFormComponentMap
+        >
+      : never

package/src/index.ts

@@ -1,16 +1,17 @@
 export * from '@tanstack/form-core'
+export * from '@tanstack/svelte-store'
 
-export { useSelector, useStore } from '@tanstack/svelte-store'
-
-export { createForm, type SvelteFormApi } from './createForm.svelte.js'
-
+export * from './createForm.public'
+export * from './formApiTypes.public'
+export * from './formType.public'
+export * from './Components.public'
 export { default as Field, createField } from './Field.svelte'
-
 export { default as FormGroup, createFormGroup } from './FormGroup.svelte'
-
-export type { FieldComponent, FormGroupComponent } from './types.js'
-
-export {
-  createFormCreator,
-  createFormCreatorContexts,
-} from './createFormCreator.svelte.js'
+export * from './FieldGroup/FieldGroupApi.public'
+export * from './FieldGroup/withFields.public'
+export * from './AppForm/SvelteAppFormApi.public'
+export * from './AppForm/appFormOptions.public'
+export * from './AppForm/componentMap.public'
+export * from './AppForm/createFormHook.public'
+export * from './AppForm/createFormHookTypes.public'
+export * from './AppForm/getFormHookHelpers.public'

package/src/utils.lib.ts

@@ -0,0 +1,30 @@
+export function withComponentProps<
+  TProps extends object,
+  TExtra extends object,
+>(props: TProps, extra: TExtra): TProps & TExtra {
+  return new Proxy(props as TProps & TExtra, {
+    get(target, property, receiver) {
+      if (Reflect.has(extra, property)) return Reflect.get(extra, property)
+      return Reflect.get(target, property, receiver)
+    },
+    has(target, property) {
+      return Reflect.has(extra, property) || Reflect.has(target, property)
+    },
+    ownKeys(target) {
+      return [
+        ...new Set([...Reflect.ownKeys(target), ...Reflect.ownKeys(extra)]),
+      ]
+    },
+    getOwnPropertyDescriptor(target, property) {
+      if (Reflect.has(extra, property)) {
+        return {
+          configurable: true,
+          enumerable: true,
+          value: Reflect.get(extra, property),
+          writable: false,
+        }
+      }
+      return Reflect.getOwnPropertyDescriptor(target, property)
+    },
+  })
+}

package/dist/AppField.svelte

@@ -1,19 +0,0 @@
-<!-- Take "form" as an prop, pass it to context, and render children -->
-<script lang="ts">
-  import type { Snippet } from 'svelte'
-  import InnerAppField from './InnerAppField.svelte'
-
-  interface Props {
-    form: any
-    fieldComponents: any
-    children: Snippet
-    fieldProps: any
-  }
-  const { children: childrenProp, form, fieldComponents, fieldProps }: Props = $props()
-</script>
-
-<form.Field {...fieldProps}>
-  {#snippet children(field: any)}
-    <InnerAppField field={field} children={childrenProp} fieldComponents={fieldComponents}/>
-  {/snippet}
-</form.Field>

package/dist/AppField.svelte.d.ts

@@ -1,10 +0,0 @@
-import type { Snippet } from 'svelte';
-interface Props {
-    form: any;
-    fieldComponents: any;
-    children: Snippet;
-    fieldProps: any;
-}
-declare const AppField: import("svelte").Component<Props, {}, "">;
-type AppField = ReturnType<typeof AppField>;
-export default AppField;

package/dist/AppForm.svelte

@@ -1,16 +0,0 @@
-<!-- Take "form" as an prop, pass it to context, and render children -->
-<script lang="ts">
-  import { setContext, type Snippet } from 'svelte'
-  import { formContextKey } from './context-keys.js'
-
-  interface Props {
-    form: any
-    children: Snippet
-  }
-
-  const { children, form }: Props = $props()
-
-  setContext(formContextKey, form)
-</script>
-
-{@render children?.()}

package/dist/InnerAppField.svelte

@@ -1,17 +0,0 @@
-<!-- Take "form" as an prop, pass it to context, and render children -->
-<script lang="ts">
-  import { setContext, type Snippet } from 'svelte'
-  import { fieldContextKey } from './context-keys.js'
-
-  interface Props {
-    field: any
-    fieldComponents: any
-    children: Snippet<[any]>
-  }
-
-  const { children, field, fieldComponents }: Props = $props()
-
-  setContext(fieldContextKey, field)
-</script>
-
-{@render children?.(Object.assign(field, fieldComponents))}

package/dist/InnerAppField.svelte.d.ts

@@ -1,9 +0,0 @@
-import { type Snippet } from 'svelte';
-interface Props {
-    field: any;
-    fieldComponents: any;
-    children: Snippet<[any]>;
-}
-declare const InnerAppField: import("svelte").Component<Props, {}, "">;
-type InnerAppField = ReturnType<typeof InnerAppField>;
-export default InnerAppField;

package/dist/createFormCreator.svelte.d.ts

@@ -1,26 +0,0 @@
-import type { FieldApi, FormAsyncValidateOrFn, FormOptions, FormValidateOrFn } from '@tanstack/form-core';
-import type { FieldComponent } from './types.js';
-import type { SvelteFormExtendedApi } from './createForm.svelte';
-import type { Component, Snippet } from 'svelte';
-export declare function createFormCreatorContexts(): {
-    useFieldContext: <TData>() => FieldApi<any, string, TData, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>;
-    useFormContext: () => SvelteFormExtendedApi<Record<string, never>, any, any, any, any, any, any, any, any, any, any, any>;
-};
-interface CreateFormRuneProps<TFieldComponents extends Record<string, Component<any, any>>, TFormComponents extends Record<string, Component<any, any>>> {
-    fieldComponents: TFieldComponents;
-    formComponents: TFormComponents;
-}
-/**
- * @private
- */
-type AppFieldExtendedSvelteFormApi<TFormData, TOnMount extends undefined | FormValidateOrFn<TFormData>, TOnChange extends undefined | FormValidateOrFn<TFormData>, TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnBlur extends undefined | FormValidateOrFn<TFormData>, TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnSubmit extends undefined | FormValidateOrFn<TFormData>, TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnDynamic extends undefined | FormValidateOrFn<TFormData>, TOnDynamicAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnServer extends undefined | FormAsyncValidateOrFn<TFormData>, TSubmitMeta, TFieldComponents extends Record<string, Component<any, any>>, TFormComponents extends Record<string, Component<any, any>>> = SvelteFormExtendedApi<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta> & NoInfer<TFormComponents> & {
-    AppField: FieldComponent<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta, NoInfer<TFieldComponents>>;
-    AppForm: Component<{
-        children: Snippet;
-    }>;
-};
-export declare function createFormCreator<const TComponents extends Record<string, Component<any, any>>, const TFormComponents extends Record<string, Component<any, any>>>({ fieldComponents, formComponents, }: CreateFormRuneProps<TComponents, TFormComponents>): {
-    createAppForm: <TFormData, TOnMount extends undefined | FormValidateOrFn<TFormData>, TOnChange extends undefined | FormValidateOrFn<TFormData>, TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnBlur extends undefined | FormValidateOrFn<TFormData>, TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnSubmit extends undefined | FormValidateOrFn<TFormData>, TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnDynamic extends undefined | FormValidateOrFn<TFormData>, TOnDynamicAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnServer extends undefined | FormAsyncValidateOrFn<TFormData>, TSubmitMeta>(props: () => FormOptions<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta>) => AppFieldExtendedSvelteFormApi<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta, TComponents, TFormComponents>;
-    getFormType: <TFormData, TOnMount extends undefined | FormValidateOrFn<TFormData>, TOnChange extends undefined | FormValidateOrFn<TFormData>, TOnChangeAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnBlur extends undefined | FormValidateOrFn<TFormData>, TOnBlurAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnSubmit extends undefined | FormValidateOrFn<TFormData>, TOnSubmitAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnDynamic extends undefined | FormValidateOrFn<TFormData>, TOnDynamicAsync extends undefined | FormAsyncValidateOrFn<TFormData>, TOnServer extends undefined | FormAsyncValidateOrFn<TFormData>, TSubmitMeta>(_formProps: FormOptions<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta>) => AppFieldExtendedSvelteFormApi<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta, TComponents, TFormComponents>;
-};
-export {};