notform 2.1.1 → 2.1.2

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import * as _$vue from "vue";
-import { ComputedRef, MaybeRefOrGetter, Raw, Ref, useAttrs } from "vue";
+import { Component, ComputedRef, MaybeRefOrGetter, Raw, Ref } from "vue";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 import { Get, PartialDeep, Paths as Paths$1 } from "type-fest";
 
@@ -18,14 +17,14 @@ type ValidationMode = 'eager' | 'lazy';
  * - onMount: Trigger validation when the field is mounted.
  * - onFocus: Trigger validation when the field gains focus.
  */
-type ValidationTrigger = 'onBlur' | 'onChange' | 'onInput' | 'onMount' | 'onFocus';
+type ValidationTrigger = 'onBlur' | 'onChange' | 'onFocus' | 'onInput' | 'onMount';
 /**
  * Constructs a type where all properties of the input type are optional recursively.
  * @template TData The base data structure to transform.
  */
 type DeepPartial<TData> = PartialDeep<TData, {
-  recurseIntoArrays: true;
   allowUndefinedInNonTupleArrays: true;
+  recurseIntoArrays: true;
 }>;
 /**
  * Constructs a type representing all possible dot-separated paths within an object.
@@ -49,12 +48,15 @@ type ObjectSchema = StandardSchemaV1 & {
 //#region src/types/use-not-form.d.ts
 /**
  * Configuration options for initializing a new form instance.
- * @template TSchema The validation schema type derived from ObjectSchema.
+ * @template TSchema The form schema.
  */
-type UseNotFormConfig<TSchema extends ObjectSchema> = {
-  /** The validation schema used to parse and validate form data */schema: MaybeRefOrGetter<TSchema>; /** The initial values of the form */
-  initialValues?: DeepPartial<StandardSchemaV1.InferInput<TSchema>>; /** The initial errors of the form */
-  initialErrors?: StandardSchemaV1.Issue[];
+interface UseNotFormConfig<TSchema extends ObjectSchema> {
+  /** The validation schema used to parse and validate form data */
+  schema: MaybeRefOrGetter<TSchema>;
+  /** The initial values of the form */
+  initialValues?: DeepPartial<StandardSchemaV1.InferInput<TSchema>>;
+  /** The initial errors of the form */
+  initialErrors?: Array<StandardSchemaV1.Issue>;
   /**
    * The validation triggers of the form.
    * @default { onBlur: true, onChange: true, onInput: true }
@@ -69,13 +71,13 @@ type UseNotFormConfig<TSchema extends ObjectSchema> = {
    * Callback triggered when form validation passes and the form is submitted.
    * @param values The validated output data from the schema.
    */
-  onSubmit?: (values: StandardSchemaV1.InferOutput<TSchema>) => void | Promise<void>;
-};
+  onSubmit?: (values: StandardSchemaV1.InferOutput<TSchema>) => Promise<void> | void;
+}
 //#endregion
 //#region src/types/not-form.d.ts
 /**
  * The complete state and API of a form instance returned by `useNotForm`.
- * @template TSchema The validation schema type derived from `ObjectSchema`.
+ * @template TSchema The form schema.
  */
 type NotFormInstance<TSchema extends ObjectSchema> = Raw<{
   /** The values the form was initialised or last reset with. */readonly initialValues: UseNotFormConfig<TSchema>['initialValues']; /** The errors the form was initialised or last reset with. */
@@ -84,13 +86,13 @@ type NotFormInstance<TSchema extends ObjectSchema> = Raw<{
   readonly validationMode: Required<NonNullable<UseNotFormConfig<TSchema>['validationMode']>>;
   /**
    * Deeply reactive object of field values.
-   *
-   * Access directly — no `.value` needed:
+   * @example
+   * - Access directly — no `.value` needed:
    * ```ts
    * form.values.email
    * ```
    *
-   * Use with `v-model` for two-way binding:
+   * - Use with `v-model` for two-way binding:
    * ```vue
    * <template>
    *   <input v-model="form.values.email" />
@@ -103,7 +105,7 @@ type NotFormInstance<TSchema extends ObjectSchema> = Raw<{
    *
    * Useful for deeply nested paths or custom inputs that do not use `v-model`.
    * Does **not** trigger validation — the field's event handlers are responsible for that.
-   *
+   * @example
    * ```ts
    * form.setValue('address.city', 'Lagos')
    * ```
@@ -119,21 +121,22 @@ type NotFormInstance<TSchema extends ObjectSchema> = Raw<{
   isTouched: ComputedRef<boolean>;
   /**
    * Marks a field as touched.
-   * Typically called automatically by the field's `onBlur` handler.
+   * Called automatically by the field's `onBlur` handler.
    */
   touchField: (path: Paths<StandardSchemaV1.InferInput<TSchema>>) => void; /** The set of field paths whose current value differs from the initial value. */
   dirtyFields: Set<Paths<StandardSchemaV1.InferInput<TSchema>>>; /** Whether any field value differs from its initial value. */
   isDirty: ComputedRef<boolean>;
   /**
    * Marks a field as dirty.
-   * Typically called automatically when a field value changes.
+   * Called automatically when a field value changes.
    */
   dirtyField: (path: Paths<StandardSchemaV1.InferInput<TSchema>>) => void; /** The raw validation issues produced by the last validation run. */
-  errors: StandardSchemaV1.Issue[];
+  errors: Array<StandardSchemaV1.Issue>;
   /**
    * A flat map of field path to its first error message.
    *
-   * Convenient for direct template access without calling `getFieldErrors`:
+   * Convenient for direct template access without calling `getFieldErrors`
+   * @example
    * ```vue
    * <template>
    *   <p>{{ form.errorsMap['address.city'] }}</p>
@@ -146,16 +149,16 @@ type NotFormInstance<TSchema extends ObjectSchema> = Raw<{
    * Useful for setting server-side errors after submission.
    */
   setError: (error: StandardSchemaV1.Issue) => void; /** Replaces all current errors with the provided issues. */
-  setErrors: (errors: StandardSchemaV1.Issue[]) => void; /** Removes all active validation errors. */
+  setErrors: (errors: Array<StandardSchemaV1.Issue>) => void; /** Removes all active validation errors. */
   clearErrors: () => void;
   /**
    * Returns all validation issues for a specific field path.
-   *
+   * @example
    * ```ts
    * form.getFieldErrors('address.city')
    * ```
    */
-  getFieldErrors: (path: Paths<StandardSchemaV1.InferInput<TSchema>>) => StandardSchemaV1.Issue[]; /** Whether a validation run is currently in progress. */
+  getFieldErrors: (path: Paths<StandardSchemaV1.InferInput<TSchema>>) => Array<StandardSchemaV1.Issue>; /** Whether a validation run is currently in progress. */
   isValidating: Ref<boolean>;
   /**
    * Validates the entire form against the schema.
@@ -175,10 +178,10 @@ type NotFormInstance<TSchema extends ObjectSchema> = Raw<{
    * Marks all fields as touched and dirty before validating so all errors surface.
    * If validation fails, submission is aborted.
    * Bind to the native form's `@submit` event:
-   *
+   * @example
    * ```vue
    * <template>
-   *   <form @submit="form.submit">
+   *   <form v-on:submit="form.submit">
    *   </form>
    * </template>
    * ```
@@ -189,7 +192,7 @@ type NotFormInstance<TSchema extends ObjectSchema> = Raw<{
    *
    * Clears all touched and dirty tracking. If `values` or `errors` are passed,
    * they replace the stored baseline so subsequent resets return to the new state.
-   *
+   * @example
    * ```ts
    * // Reset to original initial values
    * form.reset()
@@ -198,40 +201,169 @@ type NotFormInstance<TSchema extends ObjectSchema> = Raw<{
    * form.reset({ name: 'Jane' })
    * ```
    */
-  reset: (values?: DeepPartial<StandardSchemaV1.InferInput<TSchema>>, errors?: StandardSchemaV1.Issue[]) => void;
+  reset: (values?: DeepPartial<StandardSchemaV1.InferInput<TSchema>>, errors?: Array<StandardSchemaV1.Issue>) => void;
 }>;
 /** Props for the `NotForm` component. */
-type NotFormProps = {
-  /** The form instance to provide to all descendant `NotField` components. */form: NotFormInstance<any>;
-};
+interface NotFormProps {
+  /** The form instance to provide to all descendant `NotField` components. */
+  form: NotFormInstance<any>;
+}
 /** Slots for the `NotForm` component. */
-type NotFormSlots = {
-  /** The default slot receives the full form instance */default: [];
-};
+interface NotFormSlots {
+  /** The default slot receives the full form instance */
+  default?: () => any;
+}
 //#endregion
-//#region src/composables/use-not-form.d.ts
-declare function useNotForm<TSchema extends ObjectSchema>(config: UseNotFormConfig<TSchema>): NotFormInstance<TSchema>;
+//#region src/types/not-array-field.d.ts
+/**
+ * Props for the `NotArrayField` component.
+ * @template TItemSchema The schema for a single array item.
+ */
+interface NotArrayFieldProps<TItemSchema extends StandardSchemaV1 = StandardSchemaV1> {
+  /** Dot-separated path to the array within the form values. */
+  path: string;
+  /**
+   * Schema for a single array item — used purely for type inference.
+   * Enables typed `append`, `prepend`, `insert`, and `update` methods in the slot.
+   * @example
+   * ```vue
+   * <template>
+   *   <NotArrayField path="tags" :item-schema="z.string()">
+   *     <!-- append now expects a string -->
+   *   </NotArrayField>
+   * </template>
+   * ```
+   */
+  itemSchema?: TItemSchema;
+  /**
+   * Explicit form instance override.
+   * Takes priority over the instance provided by a `NotForm` ancestor.
+   * Required when using `NotArrayField` outside of a `NotForm`.
+   */
+  form?: NotFormInstance<any>;
+  /**
+   * Per-field validation trigger overrides applied to the array as a whole.
+   * Merged over the form-wide `validateOn` — only the keys you specify are overridden.
+   */
+  validateOn?: Partial<Record<Extract<ValidationTrigger, 'onChange' | 'onMount'>, boolean>>;
+}
+/**
+ * Represents a single item in the array field.
+ * Use `key` for `v-for` tracking and `path` to pass to a nested `NotField`.
+ * @example
+ * ```vue
+ * <template>
+ *   <NotArrayField path="tags" v-slot="{ items }">
+ *     <NotField v-for="item in items" :key="item.key" :path="item.path" v-slot="{ events }">
+ *       <input v-model="form.values.tags[item.index]" v-bind="events" />
+ *     </NotField>
+ *   </NotArrayField>
+ * </template>
+ * ```
+ */
+interface NotArrayFieldItem {
+  /** Stable key for `v-for` — does not change when items are reordered. */
+  key: string;
+  /** Current index of this item in the array. */
+  index: number;
+  /** Full dot-separated path to this item — pass directly to `NotField`. */
+  path: string;
+}
+/**
+ * Slots for the `NotArrayField` component.
+ * @template TSchema The form schema.
+ * @template TItem An array field item.
+ */
+interface NotArrayFieldSlots<TSchema extends ObjectSchema, TItem = any> {
+  /** The default slot receives the full array state and manipulation methods. */
+  default: (props: {
+    /** The dot-separated path to this array field. */path: string; /** The array items with stable keys and paths for use with `v-for`. */
+    items: Array<NotArrayFieldItem>; /** All validation issues for this array field from the last validation run. */
+    errors: Array<StandardSchemaV1.Issue>; /** Whether this array field currently has no validation errors. */
+    isValid: boolean;
+    /**
+     * Whether any item in this array has been touched.
+     * Derived from the form's `touchedFields` set.
+     */
+    isTouched: boolean;
+    /**
+     * Whether any item in this array differs from its initial value.
+     * Derived from the form's `dirtyFields` set.
+     */
+    isDirty: boolean; /** Whether validation is currently running for this array field. */
+    isValidating: boolean;
+    /**
+     * Manually triggers validation for this array field.
+     * Useful when mutations are performed programmatically outside of the normal flow.
+     */
+    validate: () => ReturnType<NotFormInstance<TSchema>['validateField']>;
+    /**
+     * Appends a new item to the end of the array.
+     * @param value The value to append.
+     */
+    append: (value: TItem) => void;
+    /**
+     * Prepends a new item to the beginning of the array.
+     * @param value The value to prepend.
+     */
+    prepend: (value: TItem) => void;
+    /**
+     * Removes the item at the given index.
+     * @param index The index of the item to remove.
+     */
+    remove: (index: number) => void;
+    /**
+     * Inserts a new item at the given index, shifting subsequent items forward.
+     * @param index The index to insert the item at.
+     * @param value The value to insert.
+     */
+    insert: (index: number, value: TItem) => void;
+    /**
+     * Replaces the value at the given index.
+     * @param index The index of the item to replace.
+     * @param value The value to replace with.
+     */
+    update: (index: number, value: TItem) => void;
+    /**
+     * Swaps the positions of two items in the array.
+     * @param indexA The index of the first item.
+     * @param indexB The index of the second item.
+     */
+    swap: (indexA: number, indexB: number) => void;
+    /**
+     * Moves an item from one index to another, shifting items between them.
+     * @param from The current index of the item.
+     * @param to The target index.
+     */
+    move: (from: number, to: number) => void;
+  }) => any;
+}
 //#endregion
-//#region src/components/not-form.vue.d.ts
-type __VLS_Slots$1 = NotFormSlots;
-declare const __VLS_base$1: _$vue.DefineComponent<NotFormProps, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<NotFormProps> & Readonly<{}>, {}, {}, {}, {}, string, _$vue.ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export$3: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
-declare const _default$2: typeof __VLS_export$3;
-type __VLS_WithSlots$1<T, S> = T & {
-  new (): {
-    $slots: S;
-  };
+//#region src/components/not-array-field.vue.d.ts
+declare const __VLS_export$3: <TSchema extends ObjectSchema, TItemSchema extends StandardSchemaV1 = StandardSchemaV1, TItem = StandardSchemaV1.InferInput<TItemSchema>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$1<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$1<NotArrayFieldProps<TItemSchema>> & (typeof globalThis extends {
+    __VLS_PROPS_FALLBACK: infer P;
+  } ? P : {});
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: NotArrayFieldSlots<TSchema, TItem>;
+  emit: {};
+}>) => import("vue").VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
 };
+declare const _default: typeof __VLS_export$3;
+type __VLS_PrettifyLocal$1<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
 //#endregion
 //#region src/types/not-field.d.ts
 /** Props for the `NotField` component. */
-type NotFieldProps = {
-  /** Dot-separated path to this field within the form values. */path: string;
+interface NotFieldProps {
+  /** Dot-separated path to this field within the form values. */
+  path: string;
   /**
    * Explicit form instance override.
    * Takes priority over the instance provided by a `NotForm` ancestor.
    * Required when using `NotField` outside of a `NotForm` (singleton fields).
-   *
+   * @example
    * ```vue
    * <template>
    *   <NotField :form="form" path="email" v-slot="{ events }">
@@ -244,7 +376,7 @@ type NotFieldProps = {
   /**
    * Per-field validation trigger overrides.
    * Merged over the form-wide `validateOn` — only the keys you specify are overridden.
-   *
+   * @example
    * ```vue
    * <template>
    *   <!-- form validates on blur only, but this field also validates on every input -->
@@ -263,7 +395,7 @@ type NotFieldProps = {
    *
    * Blur- and submit-triggered validation always runs immediately, regardless
    * of this setting, so the field never feels unresponsive when the user leaves.
-   *
+   * @example
    * ```vue
    * <template>
    *   <!-- validate 400ms after the user stops typing -->
@@ -276,83 +408,95 @@ type NotFieldProps = {
    * Omit or set to `0` to disable debouncing (default behaviour).
    */
   debounce?: number;
-};
-/**
- * Everything available inside the `NotField` default slot.
- * @template TSchema The validation schema type derived from `ObjectSchema`.
- */
-type NotFieldSlotProps<TSchema extends ObjectSchema> = {
-  /** The dot-separated path to this field. */path: string;
-  /**
-   * The current value of this field — read-only snapshot for display purposes.
-   * Do not mutate directly or use with `v-model`.
-   * For two-way binding use `v-model="form.values.fieldName"` instead.
-   */
-  value: any; /** All validation issues for this field from the last validation run. */
-  errors: StandardSchemaV1.Issue[]; /** Whether this field currently has no validation errors. */
-  isValid: boolean; /** Whether the user has interacted with this field, or the form has been submitted. */
-  isTouched: boolean; /** Whether this field's current value differs from its initial value. */
-  isDirty: boolean; /** Whether an async validator is currently running for this field. */
-  isValidating: boolean;
-  /**
-   * Manually triggers validation for this field.
-   * Useful for custom inputs that manage their own interaction events.
-   */
-  validate: () => ReturnType<NotFormInstance<TSchema>['validateField']>;
-  /**
-   * Native DOM event handlers exposed by a field.
-   * Spread onto a native input or bind individually to custom components.
-   *
-   * ```vue
-   * <template>
-   *   <!-- spread -->
-   *   <input v-bind="events" />
-   *
-   *   <!-- individual -->
-   *   <CustomCombobox @focusout="events.onBlur" @pick="events.onChange" />
-   * </template>
-   * ```
-   */
-  events: {
-    /** Triggered when the field loses focus. */onBlur: () => void; /** Triggered on every keystroke or value change. */
-    onInput: () => void; /** Triggered when the field value is committed. */
-    onChange: () => void; /** Triggered when the field gains focus. */
-    onFocus: () => void;
-  };
-};
+}
 /**
  * Slots for the `NotField` component.
- * @template TSchema The validation schema type derived from `ObjectSchema`.
+ * @template TSchema The form schema.
  */
-type NotFieldSlots<TSchema extends ObjectSchema> = {
-  /** The default slot receives the full field state and event handlers. */default: (props: NotFieldSlotProps<TSchema>) => [];
-};
+interface NotFieldSlots<TSchema extends ObjectSchema> {
+  /** The default slot receives the full field state and event handlers. */
+  default?: (props: {
+    /** The dot-separated path to this field. */path: string;
+    /**
+     * The current value of this field — read-only snapshot for display purposes.
+     * Do not mutate directly or use with `v-model`.
+     * For two-way binding use `v-model="form.values.fieldName"` instead.
+     */
+    value: any; /** All validation issues for this field from the last validation run. */
+    errors: Array<StandardSchemaV1.Issue>; /** Whether this field currently has no validation errors. */
+    isValid: boolean; /** Whether the user has interacted with this field, or the form has been submitted. */
+    isTouched: boolean; /** Whether this field's current value differs from its initial value. */
+    isDirty: boolean; /** Whether an async validator is currently running for this field. */
+    isValidating: boolean;
+    /**
+     * Manually triggers validation for this field.
+     * Useful for custom inputs that manage their own interaction events.
+     */
+    validate: () => ReturnType<NotFormInstance<TSchema>['validateField']>;
+    /**
+     * Native DOM event handlers exposed by a field.
+     * Spread onto a native input or bind individually to custom components.
+     * @example
+     * ```vue
+     * <template>
+     *   <!-- spread -->
+     *   <input v-bind="events" />
+     *
+     *   <!-- individual -->
+     *   <CustomCombobox v-on:focusout="events.onBlur" v-on:pick="events.onChange" />
+     * </template>
+     * ```
+     */
+    events: {
+      /** Triggered when the field loses focus. */onBlur: () => void; /** Triggered on every keystroke or value change. */
+      onInput: () => void; /** Triggered when the field value is committed. */
+      onChange: () => void; /** Triggered when the field gains focus. */
+      onFocus: () => void;
+    };
+  }) => any;
+}
 //#endregion
 //#region src/components/not-field.vue.d.ts
-declare const __VLS_export$2: <TSchema extends ObjectSchema>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$1<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-  props: _$vue.PublicProps & __VLS_PrettifyLocal$1<NotFieldProps> & (typeof globalThis extends {
+declare const __VLS_export$2: <TSchema extends ObjectSchema>(__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<NotFieldProps> & (typeof globalThis extends {
     __VLS_PROPS_FALLBACK: infer P;
   } ? P : {});
   expose: (exposed: {}) => void;
   attrs: any;
   slots: NotFieldSlots<TSchema>;
   emit: {};
-}>) => _$vue.VNode & {
+}>) => import("vue").VNode & {
   __ctx?: Awaited<typeof __VLS_setup>;
 };
 declare const _default$1: typeof __VLS_export$2;
-type __VLS_PrettifyLocal$1<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
+type __VLS_PrettifyLocal<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
+//#endregion
+//#region src/components/not-form.vue.d.ts
+type __VLS_Slots$1 = NotFormSlots;
+declare const __VLS_base$1: import("vue").DefineComponent<NotFormProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NotFormProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
+declare const _default$2: typeof __VLS_export$1;
+type __VLS_WithSlots$1<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
 //#endregion
 //#region src/types/not-message.d.ts
 /** Props for the `NotMessage` component. */
-type NotMessageProps = {
-  /** The name/path of the field whose error message should be displayed */path: string; /** HTML Tag `NotMessage` should render as - default is `span`. */
-  as?: string;
+interface NotMessageProps {
+  /**
+   * HTML Tag or component to render as
+   * @default span
+   */
+  as?: Component | string;
+  /** The name/path of the field whose error message should be displayed */
+  path: string;
   /**
    * Explicit form instance override.
    * Takes priority over the instance provided by a `NotForm` ancestor.
    * Required when using `NotMessage` outside of a `NotForm` (singleton fields).
-   *
+   * @example
    * ```vue
    * <template>
    *   <NotMessage :form="form" path="email" />
@@ -360,166 +504,35 @@ type NotMessageProps = {
    * ```
    */
   form?: NotFormInstance<any>;
-};
-/** Everything available inside the `NotMessage` default slot. */
-type NotMessageSlotProps = {
-  /** The first active validation error message for the specified field */message?: string; /** Attributes passed to the `NotMessage` component */
-  attributes?: ReturnType<typeof useAttrs>;
-};
+}
 /** Slots for the `NotMessage` component. */
-type NotMessageSlots = {
-  /** The default slot receives the error message context for custom rendering */default: (props: NotMessageSlotProps) => [];
-};
+interface NotMessageSlots {
+  /** The default slot receives the error message context for custom rendering */
+  default?: (props: {
+    /** The first active validation error message for the specified field */message?: string;
+  }) => any;
+}
 //#endregion
 //#region src/components/not-message.vue.d.ts
 type __VLS_Slots = NotMessageSlots;
-declare const __VLS_base: _$vue.DefineComponent<NotMessageProps, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<NotMessageProps> & Readonly<{}>, {
-  as: string;
-}, {}, {}, {}, string, _$vue.ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export$1: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default$3: typeof __VLS_export$1;
+declare const __VLS_base: import("vue").DefineComponent<NotMessageProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NotMessageProps> & Readonly<{}>, {
+  as: import("vue").Component | string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default$3: typeof __VLS_export;
 type __VLS_WithSlots<T, S> = T & {
   new (): {
     $slots: S;
   };
 };
 //#endregion
-//#region src/types/not-array-field.d.ts
-/** Props for the `NotArrayField` component. */
-type NotArrayFieldProps<TItemSchema extends StandardSchemaV1 = StandardSchemaV1> = {
-  /** Dot-separated path to the array within the form values. */path: string;
-  /**
-   * Schema for a single array item — used purely for type inference.
-   * Enables typed `append`, `prepend`, `insert`, and `update` methods in the slot.
-   *
-   * ```vue
-   * <template>
-   *   <NotArrayField path="tags" :item-schema="z.string()">
-   *     <!-- append now expects a string -->
-   *   </NotArrayField>
-   * </template>
-   * ```
-   */
-  itemSchema?: TItemSchema;
-  /**
-   * Explicit form instance override.
-   * Takes priority over the instance provided by a `NotForm` ancestor.
-   * Required when using `NotArrayField` outside of a `NotForm`.
-   */
-  form?: NotFormInstance<any>;
-  /**
-   * Per-field validation trigger overrides applied to the array as a whole.
-   * Merged over the form-wide `validateOn` — only the keys you specify are overridden.
-   */
-  validateOn?: Partial<Record<Extract<ValidationTrigger, 'onMount' | 'onChange'>, boolean>>;
-};
-/**
- * Represents a single item in the array field.
- * Use `key` for `v-for` tracking and `path` to pass to a nested `NotField`.
- *
- * ```vue
- * <template>
- *   <NotArrayField path="tags" v-slot="{ items }">
- *     <NotField v-for="item in items" :key="item.key" :path="item.path" v-slot="{ events }">
- *       <input v-model="form.values.tags[item.index]" v-bind="events" />
- *     </NotField>
- *   </NotArrayField>
- * </template>
- * ```
- */
-type NotArrayFieldItem = {
-  /** Stable key for `v-for` — does not change when items are reordered. */key: string; /** Current index of this item in the array. */
-  index: number; /** Full dot-separated path to this item — pass directly to `NotField`. */
-  path: string;
-};
-/**
- * Everything available inside the `NotArrayField` default slot.
- * @template TSchema The form schema type.
- * @template TItem The inferred type of a single array item.
- */
-type NotArrayFieldSlotProps<TSchema extends ObjectSchema, TItem = any> = {
-  /** The dot-separated path to this array field. */path: string; /** The array items with stable keys and paths for use with `v-for`. */
-  items: NotArrayFieldItem[]; /** All validation issues for this array field from the last validation run. */
-  errors: StandardSchemaV1.Issue[]; /** Whether this array field currently has no validation errors. */
-  isValid: boolean;
-  /**
-   * Whether any item in this array has been touched.
-   * Derived from the form's `touchedFields` set.
-   */
-  isTouched: boolean;
-  /**
-   * Whether any item in this array differs from its initial value.
-   * Derived from the form's `dirtyFields` set.
-   */
-  isDirty: boolean; /** Whether validation is currently running for this array field. */
-  isValidating: boolean;
-  /**
-   * Manually triggers validation for this array field.
-   * Useful when mutations are performed programmatically outside of the normal flow.
-   */
-  validate: () => ReturnType<NotFormInstance<TSchema>['validateField']>;
-  /**
-   * Appends a new item to the end of the array.
-   * @param value The value to append.
-   */
-  append: (value: TItem) => void;
-  /**
-   * Prepends a new item to the beginning of the array.
-   * @param value The value to prepend.
-   */
-  prepend: (value: TItem) => void;
-  /**
-   * Removes the item at the given index.
-   * @param index The index of the item to remove.
-   */
-  remove: (index: number) => void;
-  /**
-   * Inserts a new item at the given index, shifting subsequent items forward.
-   * @param index The index to insert the item at.
-   * @param value The value to insert.
-   */
-  insert: (index: number, value: TItem) => void;
-  /**
-   * Replaces the value at the given index.
-   * @param index The index of the item to replace.
-   * @param value The value to replace with.
-   */
-  update: (index: number, value: TItem) => void;
-  /**
-   * Swaps the positions of two items in the array.
-   * @param indexA The index of the first item.
-   * @param indexB The index of the second item.
-   */
-  swap: (indexA: number, indexB: number) => void;
-  /**
-   * Moves an item from one index to another, shifting items between them.
-   * @param from The current index of the item.
-   * @param to The target index.
-   */
-  move: (from: number, to: number) => void;
-};
+//#region src/composables/use-not-form.d.ts
 /**
- * Slots for the `NotArrayField` component.
- * @template TSchema The form schema type.
- * @template TItem The inferred type of a single array item.
+ * Creates a reactive NotFormInstance for managing form state and validation.
+ * @template TSchema The standard schema type.
+ * @param config Configuration object.
+ * @returns A reactive NotFormInstance.
  */
-type NotArrayFieldSlots<TSchema extends ObjectSchema, TItem = any> = {
-  /** The default slot receives the full array state and manipulation methods. */default: (props: NotArrayFieldSlotProps<TSchema, TItem>) => [];
-};
-//#endregion
-//#region src/components/not-array-field.vue.d.ts
-declare const __VLS_export: <TSchema extends ObjectSchema, TItemSchema extends StandardSchemaV1 = StandardSchemaV1, TItem = StandardSchemaV1.InferInput<TItemSchema>>(__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: _$vue.PublicProps & __VLS_PrettifyLocal<NotArrayFieldProps<TItemSchema>> & (typeof globalThis extends {
-    __VLS_PROPS_FALLBACK: infer P;
-  } ? P : {});
-  expose: (exposed: {}) => void;
-  attrs: any;
-  slots: NotArrayFieldSlots<TSchema, TItem>;
-  emit: {};
-}>) => _$vue.VNode & {
-  __ctx?: Awaited<typeof __VLS_setup>;
-};
-declare const _default: typeof __VLS_export;
-type __VLS_PrettifyLocal<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
+declare function useNotForm<TSchema extends ObjectSchema>(config: UseNotFormConfig<TSchema>): NotFormInstance<TSchema>;
 //#endregion
-export { DeepPartial, _default as NotArrayField, NotArrayFieldItem, NotArrayFieldProps, NotArrayFieldSlotProps, NotArrayFieldSlots, _default$1 as NotField, NotFieldProps, NotFieldSlotProps, NotFieldSlots, _default$2 as NotForm, NotFormInstance, NotFormProps, NotFormSlots, _default$3 as NotMessage, NotMessageProps, NotMessageSlotProps, NotMessageSlots, ObjectSchema, Paths, UseNotFormConfig, ValidationMode, ValidationTrigger, useNotForm };
+export { type DeepPartial, _default as NotArrayField, type NotArrayFieldItem, type NotArrayFieldProps, type NotArrayFieldSlots, _default$1 as NotField, type NotFieldProps, type NotFieldSlots, _default$2 as NotForm, type NotFormInstance, type NotFormProps, type NotFormSlots, _default$3 as NotMessage, type NotMessageProps, type NotMessageSlots, type ObjectSchema, type Paths, type UseNotFormConfig, type ValidationMode, type ValidationTrigger, useNotForm };