@dragonmastery/zinia-forms-core 0.4.7 → 0.5.0

package/dist/index.d.ts

@@ -1,9 +1,64 @@
 import * as vue from 'vue';
-import { FunctionalComponent, Ref, App } from 'vue';
+import { FunctionalComponent, App, Ref, ComputedRef } from 'vue';
 import { z } from 'zod';
 
+/**
+ * Types for registered styles
+ * This allows for autocomplete of registered style names
+ */
+/**
+ * Union type of all registered style names
+ * Update this when adding new built-in styles
+ */
+type BuiltInStyleName = 'daisy_ui';
+/**
+ * Type for custom registered style names
+ * This is a string literal type that can be extended by users
+ */
+type CustomStyleName = string;
+/**
+ * Union type of all possible style names
+ * This includes both built-in styles and custom styles
+ */
+type RegisteredStyleName = BuiltInStyleName | CustomStyleName;
+
+/**
+ * Create base form components for a schema
+ *
+ * @param schema The Zod schema for the form
+ * @param renderStyle The style to use for rendering
+ * @returns Base form components (Form, SubmitButton, ResetButton)
+ */
+declare function createBaseComponents<T extends z.ZodObject<any>>(schema: T, styleName?: RegisteredStyleName): {
+    Form: vue.FunctionalComponent<FormProps<z.TypeOf<T>>, {}, any, {}>;
+    SubmitButton: vue.FunctionalComponent<SubmitButtonProps<z.TypeOf<T>>, {}, any, {}>;
+    ResetButton: vue.FunctionalComponent<ResetButtonProps<z.TypeOf<T>>, {}, any, {}>;
+    FormErrorsSummary: vue.FunctionalComponent<FormErrorsSummaryProps, {}, any, {}>;
+};
+
+/**
+ * Create base display components using registered styles
+ *
+ * @param schema The Zod schema for the data
+ * @param styleName The style to use for rendering
+ * @returns Base display components
+ */
+declare function createBaseDisplayComponents<T extends z.ZodObject<any>>(schema: T, styleName?: RegisteredStyleName): {
+    ZiniaDisplay: vue.FunctionalComponent<DisplayProps<z.TypeOf<T>>, {}, any, {}>;
+};
+
 type BrowserNativeObject = Date | FileList | File;
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+/**
+ * Checks whether the type is any
+ * See {@link https://stackoverflow.com/a/49928360/3406963}
+ * @typeParam T - type which may be any
+ * ```
+ * IsAny<any> = true
+ * IsAny<string> = false
+ * ```
+ */
+type IsAny<T> = 0 extends 1 & T ? true : false;
 /**
  * Checks whether T1 can be exactly (mutually) assigned to T2
  * @typeParam T1 - type to check
@@ -67,6 +122,46 @@ type PathInternal<T, TraversedTypes = T> = T extends ReadonlyArray<infer V> ? Is
 }[TupleKeys<T>] : PathImpl<ArrayKey, V, TraversedTypes> : {
     [K in keyof T]-?: PathImpl<K & string, T[K], TraversedTypes>;
 }[keyof T];
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This actually constructs the strings and recurses into nested
+ * object types.
+ *
+ * See {@link ArrayPath}
+ */
+type ArrayPathImpl<K extends string | number, V, TraversedTypes> = V extends Primitive | BrowserNativeObject ? IsAny<V> extends true ? string : never : V extends ReadonlyArray<infer U> ? U extends Primitive | BrowserNativeObject ? IsAny<V> extends true ? string : never : true extends AnyIsEqual<TraversedTypes, V> ? never : `${K}` | `${K}.${ArrayPathInternal<V, TraversedTypes | V>}` : true extends AnyIsEqual<TraversedTypes, V> ? never : `${K}.${ArrayPathInternal<V, TraversedTypes | V>}`;
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This obscures the internal type param TraversedTypes from ed contract.
+ *
+ * See {@link ArrayPath}
+ */
+type ArrayPathInternal<T, TraversedTypes = T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
+    [K in TupleKeys<T>]-?: ArrayPathImpl<K & string, T[K], TraversedTypes>;
+}[TupleKeys<T>] : ArrayPathImpl<ArrayKey, V, TraversedTypes> : {
+    [K in keyof T]-?: ArrayPathImpl<K & string, T[K], TraversedTypes>;
+}[keyof T];
+/**
+ * Type which eagerly collects all paths through a type which point to an array
+ * type.
+ * @typeParam T - type which should be introspected.
+ * @example
+ * ```
+ * Path<{foo: {bar: string[], baz: number[]}}> = 'foo.bar' | 'foo.baz'
+ * ```
+ */
+type ArrayPath<T> = T extends any ? ArrayPathInternal<T> : never;
+/**
+ * Type to evaluate the type which the given path points to.
+ * @typeParam T - deeply nested type which is indexed by the path
+ * @typeParam P - path into the deeply nested type
+ * @example
+ * ```
+ * PathValue<{foo: {bar: string}}, 'foo.bar'> = string
+ * PathValue<[number, string], '1'> = string
+ * ```
+ */
+type PathValue<T, P extends Path<T> | ArrayPath<T>> = T extends any ? P extends `${infer K}.${infer R}` ? K extends keyof T ? R extends Path<T[K]> ? PathValue<T[K], R> : never : K extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? PathValue<V, R & Path<V>> : never : never : P extends keyof T ? T[P] : P extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? V : never : never : never;
 /**
  * Type which eagerly collects all paths through a type
  * @typeParam T - type which should be introspected
@@ -525,6 +620,10 @@ type SegmentToPascalCase<S extends string> = S extends `${infer First}_${infer R
  * Also handles underscores by removing them and capitalizing each segment
  */
 type PathToPascalCase<P extends string> = P extends `${infer A}.${infer B}` ? `${SegmentToPascalCase<A>}${PathToPascalCase<B>}` : `${SegmentToPascalCase<P>}Field`;
+/**
+ * Helper type to extract enum type from a schema path
+ */
+type ExtractEnumType<T, P extends Path<T>> = P extends keyof T ? T[P] extends string ? T[P] : string : string;
 /**
  * Type that maps field paths to their corresponding enum types
  */
@@ -635,7 +734,7 @@ type ComponentsType<T> = {
  * Metadata about a form field
  * This interface defines all the properties that describe a field's behavior and appearance
  */
-interface FieldMetadata {
+interface FieldMetadata$1 {
     /** The full path to the field (e.g., 'user.firstName') */
     path: string;
     /** Whether the field is required (false if optional) */
@@ -664,9 +763,9 @@ interface FieldMetadata {
     /** Whether the field is an array */
     isArray?: boolean;
     /** Metadata for array element type */
-    arrayOf?: FieldMetadata;
+    arrayOf?: FieldMetadata$1;
     /** Child field metadata for object types */
-    children?: Record<string, FieldMetadata>;
+    children?: Record<string, FieldMetadata$1>;
     /** Available items for array fields */
     availableItems?: any[];
     /** Help text to display with the field */
@@ -691,132 +790,309 @@ interface FieldMetadata {
     autocomplete?: string;
 }
 
+interface ArrayFieldSlots<ItemType> {
+    itemRenderer: (props: {
+        item: ItemType;
+        index: number;
+        fields: FieldNames<ItemType>;
+    }) => any;
+    availableItemRenderer: (props: {
+        item: ItemType;
+        index: number;
+    }) => any;
+    itemActions: (props: {
+        item: ItemType;
+        index: number;
+        fields: FieldNames<ItemType>;
+    }) => any;
+    fieldSummary: (props: {
+        items: ItemType[];
+    }) => any;
+    default: () => any;
+}
+
 /**
- * Types for schema metadata in the form system
+ * Functions for creating type-safe array fields
  */
 
 /**
- * Additional metadata that can be associated with schema fields
- * This interface defines properties that can be attached to schema fields
- * to customize their behavior and appearance
+ * Create a factory function that returns a properly typed ArrayField based on the field path
+ * This preserves the ItemType so that Vue's template slots are properly typed
+ *
+ * @param baseArrayField The base array field component
+ * @param fieldPath The field path to create an array field for
+ * @param metadata Optional metadata to apply to the field
+ * @returns A properly typed array field component with slot types preserved
  */
-interface SchemaFieldMetadata {
-    /** The input type for rendering the field */
-    inputType?: 'text' | 'email' | 'tel' | 'number' | 'select' | 'checkbox' | 'radio' | 'textarea' | 'password' | 'currency' | 'date' | 'time' | 'datetime-local' | 'combobox' | 'array';
-    /** Placeholder text for the field */
-    placeholder?: string;
-    /** The display label for the field */
-    label?: string;
-    /** Help text to display with the field */
-    helpText?: string;
-    /** For textarea fields, number of rows to display */
-    rows?: number;
-    /** For textarea fields, number of columns to display */
-    cols?: number;
-    /** For enum fields, map values to display labels */
-    valueToLabel?: Record<string, string>;
-    /** Whether to hide validation errors */
-    hideError?: boolean;
-    /** Step value for numeric fields */
-    step?: number;
-    /** Any other custom properties */
-    [key: string]: any;
-}
+declare function createTypedArrayField<T, P extends Path<T>>(baseArrayField: FunctionalComponent<ArrayFieldProps<T, any>, {}, any, {}>, fieldPath: P, metadata?: FieldMetadata$1): FunctionalComponent<Omit<ArrayFieldProps<T, ArrayItemType<T, P>>, "name">, {}, ArrayFieldSlots<ArrayItemType<T, P>>, {}>;
+
 /**
- * Type for the registry mapping field paths to their metadata
+ * Functions for creating type-safe combobox fields
  */
-type MetadataRegistry = Record<string, SchemaFieldMetadata>;
+
 /**
- * Type helper to extract all possible paths from a Zod schema
+ * Create a factory function that returns a properly typed ComboboxField based on the field path
+ *
+ * @param baseComboboxField The base combobox field component
+ * @param fieldPath The field path to create a combobox field for
+ * @returns A factory function that creates a type-safe combobox field
+ *
+ * This preserves path-specific typing for features like dependsOn (cascading dropdowns)
+ * and ensures type safety between selectOptions and optionFilterFn
  */
-type PathsOf<T extends z.ZodTypeAny> = Path<z.infer<T>>;
-
-interface CurrencyFieldProps<FormType> {
-    name: FlexiblePath<FormType>;
-    label?: string;
-    hideLabel?: boolean;
-    description?: string;
-    required?: boolean;
-    placeholder?: string;
-    disabled?: boolean;
-    readonly?: boolean;
-    class?: string | string[];
-    size?: string;
-    variant?: string;
-    min?: number;
-    max?: number;
-    step?: number;
-}
+declare function createTypedComboboxField<T, P extends Path<T>>(baseComboboxField: FunctionalComponent<ComboboxFieldProps<T>>, fieldPath: P): <TData = any>(props: Omit<ComboboxFieldProps<T, P, TData>, "name">, context?: any) => any;
 
-interface DateTimeLocalFieldProps<FormType> {
-    name: FlexiblePath<FormType>;
-    label?: string;
-    hideLabel?: boolean;
-    description?: string;
-    required?: boolean;
-    placeholder?: string;
-    disabled?: boolean;
-    readonly?: boolean;
-    class?: string | string[];
-    size?: string;
-    variant?: string;
-    min?: string;
-    max?: string;
-    step?: number;
-}
+/**
+ * Functions for creating type-safe select fields
+ */
 
-interface EmailFieldProps<FormType> {
-    name: FlexiblePath<FormType>;
-    label?: string;
-    hideLabel?: boolean;
-    description?: string;
-    required?: boolean;
-    placeholder?: string;
-    disabled?: boolean;
-    readonly?: boolean;
-    autocomplete?: string;
-    class?: string | string[];
-    size?: string;
-    variant?: string;
+/**
+ * Create a factory function that returns a properly typed SelectField based on the field path
+ *
+ * @param baseSelectField The base select field component
+ * @param fieldPath The field path to create a select field for
+ * @returns A factory function that creates a type-safe select field
+ */
+declare function createTypedSelectField<T, P extends Path<T>>(baseSelectField: FunctionalComponent<SelectFieldProps<T>>, fieldPath: P): <E extends FieldPathToEnum<T, P> = FieldPathToEnum<T, P>>(props: Omit<SelectFieldProps<T>, "name" | "valueToLabel"> & {
+    valueToLabel: Record<E, string>;
+}, context?: any) => any;
+/**
+ * Type-safe select field component with valueToLabel based on field path
+ */
+interface TypedSelectFieldComponent<T> {
+    <P extends Path<T>>(props: Omit<SelectFieldProps<T>, 'valueToLabel'> & {
+        name: P;
+        valueToLabel?: Record<string, string>;
+    }): ReturnType<FunctionalComponent>;
 }
 
-interface FileFieldProps<FormType> {
-    name: FlexiblePath<FormType>;
+/**
+ * Type for display field components
+ */
+type DisplayFieldComponent<T, P extends Path<T>, _FieldType extends string = 'string'> = (props: {
+    name?: P;
     label?: string;
     hideLabel?: boolean;
     description?: string;
-    required?: boolean;
-    disabled?: boolean;
-    readonly?: boolean;
+    format?: 'default' | 'currency' | 'date' | 'datetime' | 'boolean' | 'email' | 'url' | 'phone' | 'number';
+    emptyText?: string;
     class?: string | string[];
     size?: string;
     variant?: string;
-    accept?: string;
-    multiple?: boolean;
-}
-
+    copyable?: boolean;
+    valueToLabel?: Record<string, string>;
+    separator?: string;
+    itemRenderer?: (item: any, index: number) => string;
+    maxItems?: number;
+}, context?: any) => any;
 /**
- * Props for the FormErrorsSummary component
+ * Type for the display components object with PascalCase keys derived from field paths
+ * This mirrors the ComponentsType from the form system but with Display suffix
  */
-interface FormErrorsSummaryProps {
-    /**
-     * Custom title for the errors section
-     */
-    title?: string;
-    /**
-     * Whether to show the component only after form submission has been attempted
-     * @default true
-     */
-    showOnlyAfterSubmitAttempt?: boolean;
-    /**
-     * Custom CSS class for the container
-     */
-    className?: string;
-    /**
-     * Icon to display next to the title
-     * @default 'exclamation-circle'
-     */
-    icon?: string;
+type DisplayComponentsType<T> = {
+    [K in Path<T> as `${PathToPascalCase<K & string>}` extends `${infer Base}Field` ? `${Base}Display` : `${PathToPascalCase<K & string>}Display`]: DisplayFieldComponent<T, K>;
+};
+/**
+ * Generate display field components for a schema based on metadata
+ *
+ * @param schema The Zod schema for the data
+ * @param fieldsMetadata Metadata for fields
+ * @param renderStyle The style to use for rendering
+ * @returns Generated display field components
+ */
+declare function generateDisplayComponents<T extends z.ZodObject<any>>(schema: T, fieldsMetadata: Record<string, FieldMetadata$1>, styleName?: RegisteredStyleName): {
+    generic: {
+        DisplayField: vue.FunctionalComponent<DisplayFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        fields: { [K in Path<z.TypeOf<T>>]: DisplayFieldComponent<z.TypeOf<T>, K, string>; };
+        field: <P extends Path<z.TypeOf<T>>>(path: P) => any;
+    };
+    typed: DisplayComponentsType<z.TypeOf<T>>;
+};
+
+/**
+ * Generate field components for a schema based on metadata
+ *
+ * @param schema The Zod schema for the form
+ * @param fieldsMetadata Metadata for form fields
+ * @param renderStyle The style to use for rendering
+ * @returns Generated field components
+ */
+declare function generateFieldComponents<T extends z.ZodObject<any>>(schema: T, fieldsMetadata: Record<string, FieldMetadata$1>, styleName?: RegisteredStyleName): {
+    generic: {
+        TextField: vue.FunctionalComponent<TextFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        NumberField: vue.FunctionalComponent<NumberFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        SelectField: vue.FunctionalComponent<SelectFieldProps<z.TypeOf<T>, Path<z.TypeOf<T>>, any>, {}, any, {}>;
+        CheckboxField: vue.FunctionalComponent<CheckboxFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        TextareaField: vue.FunctionalComponent<TextareaFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        RadioField: vue.FunctionalComponent<RadioFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        FileField: vue.FunctionalComponent<FileFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        DateField: vue.FunctionalComponent<DateFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        TimeField: vue.FunctionalComponent<TimeFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        DateTimeLocalField: vue.FunctionalComponent<DateTimeLocalFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        RangeField: vue.FunctionalComponent<RangeFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        PasswordField: vue.FunctionalComponent<PasswordFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        EmailField: vue.FunctionalComponent<EmailFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        UrlField: vue.FunctionalComponent<UrlFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        TelField: vue.FunctionalComponent<TelFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        SearchField: vue.FunctionalComponent<SearchFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        ComboboxField: vue.FunctionalComponent<ComboboxFieldProps<z.TypeOf<T>, Path<z.TypeOf<T>>, any>, {}, any, {}>;
+        ArrayField: vue.FunctionalComponent<ArrayFieldProps<z.TypeOf<T>, any>, {}, {
+            itemRenderer: (props: {
+                item: any;
+                index: number;
+                fields: Record<string, string> | {
+                    [x: string]: string;
+                };
+            }) => any;
+            availableItemRenderer: (props: {
+                item: any;
+                index: number;
+            }) => any;
+            itemActions: (props: {
+                item: any;
+                index: number;
+                fields: Record<string, string> | {
+                    [x: string]: string;
+                };
+            }) => any;
+            fieldSummary: (props: {
+                items: any[];
+            }) => any;
+            default: () => any;
+        }, {}>;
+        TransferListField: vue.FunctionalComponent<TransferListFieldProps<z.TypeOf<T>, any>, {}, {
+            itemRenderer: (props: {
+                item: any;
+                index: number;
+                getFieldName: (fieldPath: string) => string;
+            }) => any;
+            availableItemRenderer: (props: {
+                item: any;
+                index: number;
+            }) => any;
+            selectedItemRenderer: (props: {
+                item: any;
+                index: number;
+                getFieldName: (fieldPath: string) => string;
+            }) => any;
+            default: () => any;
+        }, {}>;
+        ToppingsField: vue.FunctionalComponent<ToppingsFieldProps<z.TypeOf<T>, any>, {}, {
+            itemRenderer: (props: {
+                item: any;
+                index: number;
+                getFieldName: (fieldPath: string) => string;
+            }) => any;
+            availableItemRenderer: (props: {
+                item: any;
+                index: number;
+            }) => any;
+            toppingRenderer: (props: {
+                topping: any;
+                isSelected: boolean;
+                placement: string;
+                isExtra: boolean;
+            }) => any;
+            default: () => any;
+        }, {}>;
+        createTypedSelectField: <P extends Path<z.TypeOf<T>>>(fieldPath: P) => <E extends FieldPathToEnum<z.TypeOf<T>, P> = FieldPathToEnum<z.TypeOf<T>, P>>(props: Omit<SelectFieldProps<z.TypeOf<T>, Path<z.TypeOf<T>>, any>, "name" | "valueToLabel"> & {
+            valueToLabel: Record<E, string>;
+        }, context?: any) => any;
+        typedSelectFields: { [K in Path<z.TypeOf<T>>]?: (<E extends FieldPathToEnum<z.TypeOf<T>, K> = FieldPathToEnum<z.TypeOf<T>, K>>(props: Omit<SelectFieldProps<z.TypeOf<T>, Path<z.TypeOf<T>>, any>, "name" | "valueToLabel"> & {
+            valueToLabel: Record<E, string>;
+        }, context?: any) => any) | undefined; };
+        fields: Record<Path<z.TypeOf<T>>, any>;
+        field: <P extends Path<z.TypeOf<T>>>(path: P) => any;
+    };
+    typed: ComponentsType<z.TypeOf<T>>;
+};
+
+interface CurrencyFieldProps<FormType> {
+    name: FlexiblePath<FormType>;
+    label?: string;
+    hideLabel?: boolean;
+    description?: string;
+    required?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    class?: string | string[];
+    size?: string;
+    variant?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+
+interface DateTimeLocalFieldProps<FormType> {
+    name: FlexiblePath<FormType>;
+    label?: string;
+    hideLabel?: boolean;
+    description?: string;
+    required?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    class?: string | string[];
+    size?: string;
+    variant?: string;
+    min?: string;
+    max?: string;
+    step?: number;
+}
+
+interface EmailFieldProps<FormType> {
+    name: FlexiblePath<FormType>;
+    label?: string;
+    hideLabel?: boolean;
+    description?: string;
+    required?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    autocomplete?: string;
+    class?: string | string[];
+    size?: string;
+    variant?: string;
+}
+
+interface FileFieldProps<FormType> {
+    name: FlexiblePath<FormType>;
+    label?: string;
+    hideLabel?: boolean;
+    description?: string;
+    required?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    class?: string | string[];
+    size?: string;
+    variant?: string;
+    accept?: string;
+    multiple?: boolean;
+}
+
+/**
+ * Props for the FormErrorsSummary component
+ */
+interface FormErrorsSummaryProps {
+    /**
+     * Custom title for the errors section
+     */
+    title?: string;
+    /**
+     * Whether to show the component only after form submission has been attempted
+     * @default true
+     */
+    showOnlyAfterSubmitAttempt?: boolean;
+    /**
+     * Custom CSS class for the container
+     */
+    className?: string;
+    /**
+     * Icon to display next to the title
+     * @default 'exclamation-circle'
+     */
+    icon?: string;
 }
 
 interface FormProps<FormType> {
@@ -1197,6 +1473,33 @@ interface DataTableProps<FormType> {
     height?: 'auto' | 'fixed' | number | string;
 }
 
+/**
+ * Common action icons as SVG strings
+ * These are Heroicons (heroicons.com) in SVG format for easy use in actions
+ */
+declare const ActionIcons: {
+    readonly edit: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z\" /></svg>";
+    readonly pencil: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M15.232 5.232l3.536 3.536m-2.036-5.036a2.5 2.5 0 113.536 3.536L6.5 21.036H3v-3.572L16.732 3.732z\" /></svg>";
+    readonly delete: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16\" /></svg>";
+    readonly trash: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16\" /></svg>";
+    readonly view: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M15 12a3 3 0 11-6 0 3 3 0 016 0z\" /><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M2.458 12C3.732 7.943 7.523 5 12 5c4.478 0 8.268 2.943 9.542 7-1.274 4.057-5.064 7-9.542 7-4.477 0-8.268-2.943-9.542-7z\" /></svg>";
+    readonly eye: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M15 12a3 3 0 11-6 0 3 3 0 016 0z\" /><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M2.458 12C3.732 7.943 7.523 5 12 5c4.478 0 8.268 2.943 9.542 7-1.274 4.057-5.064 7-9.542 7-4.477 0-8.268-2.943-9.542-7z\" /></svg>";
+    readonly copy: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z\" /></svg>";
+    readonly duplicate: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z\" /></svg>";
+    readonly download: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M12 10v6m0 0l-3-3m3 3l3-3m2 8H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z\" /></svg>";
+    readonly share: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M8.684 13.342C8.886 12.938 9 12.482 9 12c0-.482-.114-.938-.316-1.342m0 2.684a3 3 0 110-2.684m0 2.684l6.632 3.316m-6.632-6l6.632-3.316m0 0a3 3 0 105.367-2.684 3 3 0 00-5.367 2.684zm0 9.316a3 3 0 105.367 2.684 3 3 0 00-5.367-2.684z\" /></svg>";
+    readonly settings: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M10.325 4.317c.426-1.756 2.924-1.756 3.35 0a1.724 1.724 0 002.573 1.066c1.543-.94 3.31.826 2.37 2.37a1.724 1.724 0 001.065 2.572c1.756.426 1.756 2.924 0 3.35a1.724 1.724 0 00-1.066 2.573c.94 1.543-.826 3.31-2.37 2.37a1.724 1.724 0 00-2.572 1.065c-.426 1.756-2.924 1.756-3.35 0a1.724 1.724 0 00-2.573-1.066c-1.543.94-3.31-.826-2.37-2.37a1.724 1.724 0 00-1.065-2.572c-1.756-.426-1.756-2.924 0-3.35a1.724 1.724 0 001.066-2.573c-.94-1.543.826-3.31 2.37-2.37.996.608 2.296.07 2.572-1.065z\" /><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M15 12a3 3 0 11-6 0 3 3 0 016 0z\" /></svg>";
+    readonly plus: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M12 6v6m0 0v6m0-6h6m-6 0H6\" /></svg>";
+    readonly external: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M10 6H6a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2v-4M14 4h6m0 0v6m0-6L10 14\" /></svg>";
+    readonly arrowRight: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M13 7l5 5m0 0l-5 5m5-5H6\" /></svg>";
+    readonly check: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M5 13l4 4L19 7\" /></svg>";
+    readonly checkCircle: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z\" /></svg>";
+    readonly save: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" aria-hidden=\"true\" data-slot=\"icon\" fill=\"none\" class=\"size-6\">\n  <path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M6 20.25h12A2.25 2.25 0 0 0 20.25 18V7.5L16.5 3.75H6A2.25 2.25 0 0 0 3.75 6v12A2.25 2.25 0 0 0 6 20.25zm9.75-16.5v5h-9.5v-5zM13 5.5V7m-6.75 4.25h11.5v6.5H6.25Z\"></path>\n</svg>";
+    readonly spinner: "<svg class=\"animate-spin\" fill=\"none\" viewBox=\"0 0 24 24\"><circle class=\"opacity-25\" cx=\"12\" cy=\"12\" r=\"10\" stroke=\"currentColor\" stroke-width=\"4\"></circle><path class=\"opacity-75\" fill=\"currentColor\" d=\"M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z\"></path></svg>";
+    readonly dots: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M12 5v.01M12 12v.01M12 19v.01M12 6a1 1 0 110-2 1 1 0 010 2zm0 7a1 1 0 110-2 1 1 0 010 2zm0 7a1 1 0 110-2 1 1 0 010 2z\" /></svg>";
+    readonly dotsHorizontal: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M5 12h.01M12 12h.01M19 12h.01M6 12a1 1 0 11-2 0 1 1 0 012 0zm7 0a1 1 0 11-2 0 1 1 0 012 0zm7 0a1 1 0 11-2 0 1 1 0 012 0z\" /></svg>";
+};
+
 /**
  * Types for style creators in the form system
  */
@@ -1305,705 +1608,384 @@ interface StyleCreators {
 }
 
 /**
- * Form state management hook
- * Provides reactive form state with proper reactivity handling
+ * Zinia Forms Plugin
+ * Allows registering custom render styles at the application level
  */
 
 /**
- * Form state interface
+ * Plugin options for Zinia
  */
-interface FormState<T, CalcType = any, ExtraDataType = any> {
-    data: T;
-    calculatedValues: CalcType;
-    touched: Record<string, boolean>;
-    dirty: Record<string, boolean>;
-    errors: Record<string, string>;
-    focused: Record<string, boolean>;
-    displayText: Record<string, string>;
-    selectedIndex: Record<string, number>;
-    collapsedFields: Record<string, {
-        isFieldCollapsed: boolean;
-        collapsedItems: number[];
-        defaultCollapsedInitialized: boolean;
-    }>;
-    undoHistory: Record<string, {
-        type: 'add' | 'remove' | 'swap';
-        previousState: any;
-        currentState: any;
-        timestamp: number;
-    }[]>;
-    redoHistory: Record<string, {
-        type: 'add' | 'remove' | 'swap';
-        previousState: any;
-        currentState: any;
-        timestamp: number;
-    }[]>;
-    pendingOperations: Record<string, {
-        type: 'add' | 'remove' | 'swap';
-        index?: number;
-        indexA?: number;
-        indexB?: number;
-        item?: any;
-        previousState: any;
-        currentState: any;
-        timestamp: number;
-        timeoutId?: number;
-    }[]>;
-    arrayItemIds: Record<string, string[]>;
-    isSubmitting: boolean;
-    hasAttemptedSubmit: boolean;
-    submitAttemptsCount: number;
-    submitError: string | null;
-    isReady: boolean;
-    isLoading: boolean;
-    loadError: string | null;
-    extraData: ExtraDataType;
-    fetchedOptions: Record<string, any[]>;
-    loadingOptions: Record<string, boolean>;
-    asyncCascadingParents: Record<string, string>;
-    loadingAutoPopulate: Record<string, boolean>;
-    populatingFields: Record<string, boolean>;
+interface ZiniaPluginOptions {
+    /**
+     * Map of style names to style creators
+     */
+    styles?: Record<string, StyleCreators>;
+    /**
+     * Default style to use if none specified in useForm
+     */
+    defaultStyle?: string;
 }
-
 /**
- * Type definitions for async cascading selection and auto-population
+ * Vue plugin for Zinia Forms
+ */
+declare const ZiniaPlugin: {
+    install(app: App, options?: ZiniaPluginOptions): void;
+};
+/**
+ * Get a registered style by name
+ *
+ * @param styleName Name of the style to get
+ * @returns Style creators for the requested style or undefined if not found
+ */
+declare function getRegisteredStyle(styleName?: string): StyleCreators | undefined;
+/**
+ * Check if a style is registered
+ *
+ * @param styleName Name of the style to check
+ * @returns True if the style is registered
+ */
+declare function hasRegisteredStyle(styleName: string): boolean;
+/**
+ * Get the default style name
+ *
+ * @returns Name of the default style
  */
+declare function getDefaultStyle(): string;
+/**
+ * Get all registered style names
+ *
+ * @returns Array of registered style names
+ */
+declare function getRegisteredStyleNames(): string[];
+/**
+ * Register a style at runtime
+ * Useful for dynamically loading styles
+ *
+ * @param styleName Name of the style to register
+ * @param creators Style creators for the style
+ */
+declare function registerStyle(styleName: string, creators: StyleCreators): void;
 
 /**
- * Helper type to get the value type of a field path
+ * Types for schema metadata in the form system
  */
-type FieldValue<FormType, P extends Path<FormType>> = P extends keyof FormType ? FormType[P] : P extends `${infer K}.${infer Rest}` ? K extends keyof FormType ? FormType[K] extends Record<string, any> ? FieldValue<FormType[K], Rest & Path<FormType[K]>> : never : never : never;
+
 /**
- * Configuration for async cascading selection (parent → child options fetching via API)
+ * Additional metadata that can be associated with schema fields
+ * This interface defines properties that can be attached to schema fields
+ * to customize their behavior and appearance
  */
-interface AsyncCascadingSelectConfig<FormType, ParentField extends Path<FormType> = Path<FormType>, ChildField extends Path<FormType> = Path<FormType>> {
-    /** Parent field that triggers child options fetch */
-    parentField: ParentField;
-    /** Child field that will be populated with fetched options */
-    childField: ChildField;
-    /** Async function to fetch child options based on parent value */
-    fetchOptionsFn: (parentValue: FieldValue<FormType, ParentField>) => Promise<Array<SelectOption>>;
-    /** Whether to clear child field when parent changes (default: true) */
-    clearOnParentChange?: boolean;
+interface SchemaFieldMetadata {
+    /** The input type for rendering the field */
+    inputType?: 'text' | 'email' | 'tel' | 'number' | 'select' | 'checkbox' | 'radio' | 'textarea' | 'password' | 'currency' | 'date' | 'time' | 'datetime-local' | 'combobox' | 'array';
+    /** Placeholder text for the field */
+    placeholder?: string;
+    /** The display label for the field */
+    label?: string;
+    /** Help text to display with the field */
+    helpText?: string;
+    /** For textarea fields, number of rows to display */
+    rows?: number;
+    /** For textarea fields, number of columns to display */
+    cols?: number;
+    /** For enum fields, map values to display labels */
+    valueToLabel?: Record<string, string>;
+    /** Whether to hide validation errors */
+    hideError?: boolean;
+    /** Step value for numeric fields */
+    step?: number;
+    /** Any other custom properties */
+    [key: string]: any;
 }
 /**
- * Type for the async cascading selects configuration object
- * Uses a mapped type to preserve field path type safety
+ * Type for the registry mapping field paths to their metadata
  */
-type AsyncCascadingSelectsConfig<FormType> = {
-    [K in string]: AsyncCascadingSelectConfig<FormType, Path<FormType>, Path<FormType>>;
-};
+type MetadataRegistry = Record<string, SchemaFieldMetadata>;
 /**
- * Configuration for auto-population (select/combobox → other fields)
+ * Type helper to extract all possible paths from a Zod schema
  */
-interface AutoPopulateConfig<FormType, TData = any, SourceField extends Path<FormType> = Path<FormType>> {
-    /**
-     * Optional async function to fetch data when option is selected.
-     * If provided, this will be called instead of using option.data.
-     * Receives the selected option value and returns the data object.
-     */
-    fetchDataFn?: (selectedValue: FieldValue<FormType, SourceField>) => Promise<TData>;
-    /** Mapping of form fields to data properties for auto-population */
-    fields: {
-        [TargetField in Path<FormType>]?: string | ((data: TData) => FieldValue<FormType, TargetField>);
-    };
-}
+type PathsOf<T extends z.ZodTypeAny> = Path<z.infer<T>>;
+
 /**
- * Type for the auto-populate configuration object
- * Key is the select/combobox field name, value is the auto-populate config
+ * Registry for storing schema metadata
  */
-type AutoPopulateConfigs<FormType> = Partial<{
-    [SourceField in Path<FormType>]: AutoPopulateConfig<FormType, any>;
-}>;
 
 /**
- * Options for merging server data with local changes
+ * Get metadata for a specific field in a schema
+ *
+ * @param schemaId Unique identifier for the schema
+ * @param path Path to the field
+ * @returns Metadata for the field or undefined if not found
  */
-interface MergeOptions<T> {
-    /**
-     * Fields to preserve from local storage when merging with server data
-     * If not provided, all fields will be merged with local data taking precedence
-     */
-    preserveLocalFields?: (keyof T)[];
-    /**
-     * Custom merge function to handle complex merging logic
-     * If provided, this will be used instead of the default merge strategy
-     */
-    customMergeFunction?: (serverData: T, localData: T) => T;
-}
+declare function getFieldMetadata(schemaId: string, path: string): SchemaFieldMetadata | undefined;
+/**
+ * Get all metadata for a schema
+ *
+ * @param schemaId Unique identifier for the schema
+ * @returns All metadata for the schema or an empty object if not found
+ */
+declare function getAllSchemaMetadata(schemaId: string): MetadataRegistry;
+/**
+ * Set metadata for a schema
+ *
+ * @param schemaId Unique identifier for the schema
+ * @param metadata Object mapping field paths to their metadata
+ */
+declare function setSchemaMetadata(schemaId: string, metadata: MetadataRegistry): void;
+/**
+ * Check if a schema has metadata
+ *
+ * @param schemaId Unique identifier for the schema
+ * @returns True if the schema has metadata, false otherwise
+ */
+declare function hasSchemaMetadata(schemaId: string): boolean;
+/**
+ * Clear metadata for a schema
+ *
+ * @param schemaId Unique identifier for the schema
+ */
+declare function clearSchemaMetadata(schemaId: string): void;
+/**
+ * Clear all metadata from the registry
+ */
+declare function clearAllMetadata(): void;
 
 /**
- * Types for registered styles
- * This allows for autocomplete of registered style names
+ * Functions for registering schema metadata
  */
+
 /**
- * Union type of all registered style names
- * Update this when adding new built-in styles
+ * Register metadata for a schema
+ *
+ * @param schemaId Unique identifier for the schema
+ * @param metadata Object mapping field paths to their metadata
  */
-type BuiltInStyleName = 'daisy_ui';
+declare function registerSchemaMetadata(schemaId: string, metadata: MetadataRegistry): void;
 /**
- * Type for custom registered style names
- * This is a string literal type that can be extended by users
+ * Register metadata for a schema with type checking for field paths
+ *
+ * @param schema The Zod schema
+ * @param schemaId Unique identifier for the schema
+ * @param metadata Object mapping field paths to their metadata
  */
-type CustomStyleName = string;
+declare function registerSchemaMetadata<T extends z.ZodObject<any>>(schema: T, schemaId: string, metadata: {
+    [K in PathsOf<T>]?: SchemaFieldMetadata;
+}): void;
+
 /**
- * Union type of all possible style names
- * This includes both built-in styles and custom styles
+ * Functions for attaching metadata to schemas
  */
-type RegisteredStyleName = BuiltInStyleName | CustomStyleName;
 
-declare const ZINIA_FORM_KEY = "ziniaForm";
-declare const ZINIA_FIELDS_KEY = "ziniaFields";
-declare const ZINIA_FIELDS_GENERIC_KEY = "ziniaFieldsGeneric";
-declare const ZINIA_FORM_SCHEMA_KEY = "ziniaFormSchema";
-type DataLoaderReturnTypes<T> = {
-    [K in keyof T]: T[K] extends () => Promise<infer R> ? R : never;
-};
+declare const SCHEMA_ID_SYMBOL: unique symbol;
 /**
- * Create a type-safe form system using functional components
+ * Helper function to get the schema ID from a schema object
  *
- * @param schema The Zod schema for the form
- * @param options Form options
- * @returns Form API and components
+ * @param schema Zod schema that might have a schema ID attached
+ * @returns The schema ID or undefined if not found
  */
-declare function useForm<T extends z.ZodObject<any>, CalcType = (values: z.infer<T>, extraData?: DataLoaderReturnTypes<Record<string, () => Promise<any>>>) => any, ExtraDataType = DataLoaderReturnTypes<Record<string, () => Promise<any>>>>(schema: T, options: {
-    storeName: string;
-    schemaId?: string;
-    persistToLocalStorage?: boolean;
-    initialValues?: Partial<z.infer<typeof schema>>;
-    renderStyle?: RegisteredStyleName;
-    autoProvide?: boolean;
-    validateOnMount?: boolean;
-    mergeOptions?: MergeOptions<z.infer<typeof schema>>;
-    dataLoaders?: {
-        [K in keyof ExtraDataType]?: () => Promise<ExtraDataType[K]>;
-    };
-    fetchData?: () => Promise<z.infer<typeof schema>>;
-    asyncCascadingSelects?: AsyncCascadingSelectsConfig<z.infer<T>>;
-    autoPopulate?: AutoPopulateConfigs<z.infer<T>>;
-    calculationFn?: (values: z.infer<T>, extraData?: ExtraDataType) => CalcType;
-    debug?: {
-        all?: boolean;
-        formState?: boolean;
-        validation?: boolean;
-        calculations?: boolean;
-        persistence?: boolean;
-        reactivity?: boolean;
-    };
-}): {
-    form: {
-        storeName: string;
-        values: z.TypeOf<T>;
-        state: FormState<z.TypeOf<T>, CalcType, ExtraDataType>;
-        readonly calculatedValues: CalcType;
-        readonly extraData: ExtraDataType;
-        readonly isValid: boolean;
-        readonly isDirty: boolean;
-        isSubmitting: boolean;
-        readonly hasAttemptedSubmit: boolean;
-        readonly submitAttemptsCount: number;
-        readonly errors: Record<string, string>;
-        readonly touched: Record<string, boolean>;
-        readonly dirty: Record<string, boolean>;
-        readonly collapsedFields: Record<string, {
-            isFieldCollapsed: boolean;
-            collapsedItems: number[];
-            defaultCollapsedInitialized: boolean;
-        }>;
-        readonly undoHistory: Record<string, {
-            type: "add" | "remove" | "swap";
-            previousState: any;
-            currentState: any;
-            timestamp: number;
-        }[]>;
-        readonly redoHistory: Record<string, {
-            type: "add" | "remove" | "swap";
-            previousState: any;
-            currentState: any;
-            timestamp: number;
-        }[]>;
-        readonly pendingOperations: Record<string, {
-            type: "add" | "remove" | "swap";
-            index?: number;
-            indexA?: number;
-            indexB?: number;
-            item?: any;
-            previousState: any;
-            currentState: any;
-            timestamp: number;
-            timeoutId?: number;
-        }[]>;
-        readonly fieldsMetadata: Record<string, FieldMetadata>;
-        validate: (options?: {
-            markErrorsAsTouched: boolean;
-        }) => boolean;
-        validateField: (path: string) => boolean;
-        reset: (newInitialData?: z.TypeOf<T> | undefined) => void;
-        setSubmitting: (value: boolean) => void;
-        incrementSubmitAttempts: () => void;
-        setSubmitError: (error: string | null) => void;
-        readonly isReady: boolean;
-        readonly isLoading: boolean;
-        readonly loadError: string | null;
-        readonly submitError: string | null;
-        setLoading: (value: boolean) => void;
-        setReady: (value: boolean) => void;
-        setLoadError: (error: string | null) => void;
-        getValue: (path: string) => any;
-        setValue: (path: string, value: any) => void;
-        touchField: (path: string) => void;
-        isTouched: (path: string) => boolean;
-        isDirtyField: (path: string) => boolean;
-        resetField: (path: string) => void;
-        hasError: (path: string) => boolean;
-        getError: (path: string) => string;
-        setFocus: (path: string, value: boolean) => void;
-        isFocused: (path: string) => boolean;
-        setDisplayText: (path: string, text: string) => void;
-        getDisplayText: (path: string) => string;
-        setSelectedIndex: (path: string, index: number) => void;
-        getSelectedIndex: (path: string) => number;
-        getArrayItemId: (path: string, index: number) => string;
-        addArrayItemId: (path: string, index?: number) => string;
-        removeArrayItemId: (path: string, index: number) => void;
-        swapArrayItemIds: (path: string, indexA: number, indexB: number) => void;
-        syncArrayItemIds: (path: string) => void;
-    };
-    ZiniaForm: vue.FunctionalComponent<FormProps<z.TypeOf<T>>, {}, any, {}>;
-    ZiniaSubmitButton: vue.FunctionalComponent<SubmitButtonProps<z.TypeOf<T>>, {}, any, {}>;
-    ZiniaResetButton: vue.FunctionalComponent<ResetButtonProps<z.TypeOf<T>>, {}, any, {}>;
-    ZiniaFormErrorsSummary: vue.FunctionalComponent<FormErrorsSummaryProps, {}, any, {}>;
-    zinia: ComponentsType<z.TypeOf<T>>;
-    ziniaGeneric: {
-        TextField: vue.FunctionalComponent<TextFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        NumberField: vue.FunctionalComponent<NumberFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        SelectField: vue.FunctionalComponent<SelectFieldProps<z.TypeOf<T>, Path<z.TypeOf<T>>, any>, {}, any, {}>;
-        CheckboxField: vue.FunctionalComponent<CheckboxFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        TextareaField: vue.FunctionalComponent<TextareaFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        RadioField: vue.FunctionalComponent<RadioFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        FileField: vue.FunctionalComponent<FileFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        DateField: vue.FunctionalComponent<DateFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        TimeField: vue.FunctionalComponent<TimeFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        DateTimeLocalField: vue.FunctionalComponent<DateTimeLocalFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        RangeField: vue.FunctionalComponent<RangeFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        PasswordField: vue.FunctionalComponent<PasswordFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        EmailField: vue.FunctionalComponent<EmailFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        UrlField: vue.FunctionalComponent<UrlFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        TelField: vue.FunctionalComponent<TelFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        SearchField: vue.FunctionalComponent<SearchFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        ComboboxField: vue.FunctionalComponent<ComboboxFieldProps<z.TypeOf<T>, Path<z.TypeOf<T>>, any>, {}, any, {}>;
-        ArrayField: vue.FunctionalComponent<ArrayFieldProps<z.TypeOf<T>, any>, {}, {
-            itemRenderer: (props: {
-                item: any;
-                index: number;
-                fields: Record<string, string> | {
-                    [x: string]: string;
-                };
-            }) => any;
-            availableItemRenderer: (props: {
-                item: any;
-                index: number;
-            }) => any;
-            itemActions: (props: {
-                item: any;
-                index: number;
-                fields: Record<string, string> | {
-                    [x: string]: string;
-                };
-            }) => any;
-            fieldSummary: (props: {
-                items: any[];
-            }) => any;
-            default: () => any;
-        }, {}>;
-        TransferListField: vue.FunctionalComponent<TransferListFieldProps<z.TypeOf<T>, any>, {}, {
-            itemRenderer: (props: {
-                item: any;
-                index: number;
-                getFieldName: (fieldPath: string) => string;
-            }) => any;
-            availableItemRenderer: (props: {
-                item: any;
-                index: number;
-            }) => any;
-            selectedItemRenderer: (props: {
-                item: any;
-                index: number;
-                getFieldName: (fieldPath: string) => string;
-            }) => any;
-            default: () => any;
-        }, {}>;
-        ToppingsField: vue.FunctionalComponent<ToppingsFieldProps<z.TypeOf<T>, any>, {}, {
-            itemRenderer: (props: {
-                item: any;
-                index: number;
-                getFieldName: (fieldPath: string) => string;
-            }) => any;
-            availableItemRenderer: (props: {
-                item: any;
-                index: number;
-            }) => any;
-            toppingRenderer: (props: {
-                topping: any;
-                isSelected: boolean;
-                placement: string;
-                isExtra: boolean;
-            }) => any;
-            default: () => any;
-        }, {}>;
-        createTypedSelectField: <P extends Path<z.TypeOf<T>>>(fieldPath: P) => <E extends FieldPathToEnum<z.TypeOf<T>, P> = FieldPathToEnum<z.TypeOf<T>, P>>(props: Omit<SelectFieldProps<z.TypeOf<T>, Path<z.TypeOf<T>>, any>, "name" | "valueToLabel"> & {
-            valueToLabel: Record<E, string>;
-        }, context?: any) => any;
-        typedSelectFields: { [K in Path<z.TypeOf<T>>]?: (<E extends FieldPathToEnum<z.TypeOf<T>, K> = FieldPathToEnum<z.TypeOf<T>, K>>(props: Omit<SelectFieldProps<z.TypeOf<T>, Path<z.TypeOf<T>>, any>, "name" | "valueToLabel"> & {
-            valueToLabel: Record<E, string>;
-        }, context?: any) => any) | undefined; };
-        fields: Record<Path<z.TypeOf<T>>, any>;
-        field: <P extends Path<z.TypeOf<T>>>(path: P) => any;
-    };
-    load: () => Promise<void>;
-    loadAllData: () => Promise<void>;
-    refreshFormData: () => Promise<void>;
-    clearSavedFormState: () => void;
-    refreshData: (keys?: Array<keyof ExtraDataType>) => Promise<void>;
-};
-type UseFormType = ReturnType<typeof useForm>;
-type ZiniaForm = UseFormType['form'];
-type ZiniaFormFields = UseFormType['zinia'];
-type ZiniaFormGenericFields = UseFormType['ziniaGeneric'];
-type UseFormTyped<T extends z.ZodObject<any>, CalcType = any, ExtraDataType extends Record<string, any> = Record<string, any>> = ReturnType<typeof useForm<T, CalcType, ExtraDataType>>;
-
-/**
- * Create base form components for a schema
- *
- * @param schema The Zod schema for the form
- * @param renderStyle The style to use for rendering
- * @returns Base form components (Form, SubmitButton, ResetButton)
- */
-declare function createBaseComponents<T extends z.ZodObject<any>>(schema: T, styleName?: RegisteredStyleName): {
-    Form: vue.FunctionalComponent<FormProps<z.TypeOf<T>>, {}, any, {}>;
-    SubmitButton: vue.FunctionalComponent<SubmitButtonProps<z.TypeOf<T>>, {}, any, {}>;
-    ResetButton: vue.FunctionalComponent<ResetButtonProps<z.TypeOf<T>>, {}, any, {}>;
-    FormErrorsSummary: vue.FunctionalComponent<FormErrorsSummaryProps, {}, any, {}>;
-};
-
-/**
- * Create base display components using registered styles
- *
- * @param schema The Zod schema for the data
- * @param styleName The style to use for rendering
- * @returns Base display components
- */
-declare function createBaseDisplayComponents<T extends z.ZodObject<any>>(schema: T, styleName?: RegisteredStyleName): {
-    ZiniaDisplay: vue.FunctionalComponent<DisplayProps<z.TypeOf<T>>, {}, any, {}>;
-};
-
-interface ArrayFieldSlots<ItemType> {
-    itemRenderer: (props: {
-        item: ItemType;
-        index: number;
-        fields: FieldNames<ItemType>;
-    }) => any;
-    availableItemRenderer: (props: {
-        item: ItemType;
-        index: number;
-    }) => any;
-    itemActions: (props: {
-        item: ItemType;
-        index: number;
-        fields: FieldNames<ItemType>;
-    }) => any;
-    fieldSummary: (props: {
-        items: ItemType[];
-    }) => any;
-    default: () => any;
-}
-
-/**
- * Functions for creating type-safe array fields
- */
-
+declare function getSchemaId(schema: z.ZodTypeAny): string | undefined;
 /**
- * Create a factory function that returns a properly typed ArrayField based on the field path
- * This preserves the ItemType so that Vue's template slots are properly typed
+ * Helper function to create a schema with associated metadata
  *
- * @param baseArrayField The base array field component
- * @param fieldPath The field path to create an array field for
- * @param metadata Optional metadata to apply to the field
- * @returns A properly typed array field component with slot types preserved
- */
-declare function createTypedArrayField<T, P extends Path<T>>(baseArrayField: FunctionalComponent<ArrayFieldProps<T, any>, {}, any, {}>, fieldPath: P, metadata?: FieldMetadata): FunctionalComponent<Omit<ArrayFieldProps<T, ArrayItemType<T, P>>, "name">, {}, ArrayFieldSlots<ArrayItemType<T, P>>, {}>;
-
-/**
- * Functions for creating type-safe combobox fields
+ * @param schema Zod schema
+ * @param schemaId Unique identifier for the schema
+ * @param metadata Metadata for the schema fields
+ * @returns The original schema with the schema ID attached
  */
+declare function withMetadata<T extends z.ZodObject<any>>(schema: T, schemaId: string, metadata: {
+    [K in PathsOf<T>]?: SchemaFieldMetadata;
+}): T;
 
 /**
- * Create a factory function that returns a properly typed ComboboxField based on the field path
- *
- * @param baseComboboxField The base combobox field component
- * @param fieldPath The field path to create a combobox field for
- * @returns A factory function that creates a type-safe combobox field
- *
- * This preserves path-specific typing for features like dependsOn (cascading dropdowns)
- * and ensures type safety between selectOptions and optionFilterFn
+ * DaisyUI style package
+ * Provides all component creators for the DaisyUI style
  */
-declare function createTypedComboboxField<T, P extends Path<T>>(baseComboboxField: FunctionalComponent<ComboboxFieldProps<T>>, fieldPath: P): <TData = any>(props: Omit<ComboboxFieldProps<T, P, TData>, "name">, context?: any) => any;
 
 /**
- * Functions for creating type-safe select fields
+ * Complete set of DaisyUI style creators
+ * Can be registered with the Zinia plugin
  */
+declare const daisyUIStyle: StyleCreators;
 
 /**
- * Create a factory function that returns a properly typed SelectField based on the field path
- *
- * @param baseSelectField The base select field component
- * @param fieldPath The field path to create a select field for
- * @returns A factory function that creates a type-safe select field
- */
-declare function createTypedSelectField<T, P extends Path<T>>(baseSelectField: FunctionalComponent<SelectFieldProps<T>>, fieldPath: P): <E extends FieldPathToEnum<T, P> = FieldPathToEnum<T, P>>(props: Omit<SelectFieldProps<T>, "name" | "valueToLabel"> & {
-    valueToLabel: Record<E, string>;
-}, context?: any) => any;
-/**
- * Type-safe select field component with valueToLabel based on field path
+ * Helper functions for creating and extending render styles
  */
-interface TypedSelectFieldComponent<T> {
-    <P extends Path<T>>(props: Omit<SelectFieldProps<T>, 'valueToLabel'> & {
-        name: P;
-        valueToLabel?: Record<string, string>;
-    }): ReturnType<FunctionalComponent>;
-}
 
 /**
- * Type for display field components
- */
-type DisplayFieldComponent<T, P extends Path<T>, _FieldType extends string = 'string'> = (props: {
-    name?: P;
-    label?: string;
-    hideLabel?: boolean;
-    description?: string;
-    format?: 'default' | 'currency' | 'date' | 'datetime' | 'boolean' | 'email' | 'url' | 'phone' | 'number';
-    emptyText?: string;
-    class?: string | string[];
-    size?: string;
-    variant?: string;
-    copyable?: boolean;
-    valueToLabel?: Record<string, string>;
-    separator?: string;
-    itemRenderer?: (item: any, index: number) => string;
-    maxItems?: number;
-}, context?: any) => any;
-/**
- * Type for the display components object with PascalCase keys derived from field paths
- * This mirrors the ComponentsType from the form system but with Display suffix
- */
-type DisplayComponentsType<T> = {
-    [K in Path<T> as `${PathToPascalCase<K & string>}` extends `${infer Base}Field` ? `${Base}Display` : `${PathToPascalCase<K & string>}Display`]: DisplayFieldComponent<T, K>;
-};
-/**
- * Generate display field components for a schema based on metadata
+ * Extend an existing style with custom overrides
  *
- * @param schema The Zod schema for the data
- * @param fieldsMetadata Metadata for fields
- * @param renderStyle The style to use for rendering
- * @returns Generated display field components
+ * @param baseStyle The base style to extend
+ * @param overrides Custom overrides for specific components
+ * @returns A new style that combines the base style with the overrides
  */
-declare function generateDisplayComponents<T extends z.ZodObject<any>>(schema: T, fieldsMetadata: Record<string, FieldMetadata>, styleName?: RegisteredStyleName): {
-    generic: {
-        DisplayField: vue.FunctionalComponent<DisplayFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        fields: { [K in Path<z.TypeOf<T>>]: DisplayFieldComponent<z.TypeOf<T>, K, string>; };
-        field: <P extends Path<z.TypeOf<T>>>(path: P) => any;
-    };
-    typed: DisplayComponentsType<z.TypeOf<T>>;
-};
-
+declare function extendStyle(baseStyle: StyleCreators, overrides: Partial<StyleCreators>): StyleCreators;
 /**
- * Generate field components for a schema based on metadata
+ * Merge multiple styles together
+ * Later styles will override earlier ones for any overlapping components
  *
- * @param schema The Zod schema for the form
- * @param fieldsMetadata Metadata for form fields
- * @param renderStyle The style to use for rendering
- * @returns Generated field components
+ * @param styles Array of styles to merge
+ * @returns A new style that combines all the provided styles
  */
-declare function generateFieldComponents<T extends z.ZodObject<any>>(schema: T, fieldsMetadata: Record<string, FieldMetadata>, styleName?: RegisteredStyleName): {
-    generic: {
-        TextField: vue.FunctionalComponent<TextFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        NumberField: vue.FunctionalComponent<NumberFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        SelectField: vue.FunctionalComponent<SelectFieldProps<z.TypeOf<T>, Path<z.TypeOf<T>>, any>, {}, any, {}>;
-        CheckboxField: vue.FunctionalComponent<CheckboxFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        TextareaField: vue.FunctionalComponent<TextareaFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        RadioField: vue.FunctionalComponent<RadioFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        FileField: vue.FunctionalComponent<FileFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        DateField: vue.FunctionalComponent<DateFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        TimeField: vue.FunctionalComponent<TimeFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        DateTimeLocalField: vue.FunctionalComponent<DateTimeLocalFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        RangeField: vue.FunctionalComponent<RangeFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        PasswordField: vue.FunctionalComponent<PasswordFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        EmailField: vue.FunctionalComponent<EmailFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        UrlField: vue.FunctionalComponent<UrlFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        TelField: vue.FunctionalComponent<TelFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        SearchField: vue.FunctionalComponent<SearchFieldProps<z.TypeOf<T>>, {}, any, {}>;
-        ComboboxField: vue.FunctionalComponent<ComboboxFieldProps<z.TypeOf<T>, Path<z.TypeOf<T>>, any>, {}, any, {}>;
-        ArrayField: vue.FunctionalComponent<ArrayFieldProps<z.TypeOf<T>, any>, {}, {
-            itemRenderer: (props: {
-                item: any;
-                index: number;
-                fields: Record<string, string> | {
-                    [x: string]: string;
-                };
-            }) => any;
-            availableItemRenderer: (props: {
-                item: any;
-                index: number;
-            }) => any;
-            itemActions: (props: {
-                item: any;
-                index: number;
-                fields: Record<string, string> | {
-                    [x: string]: string;
-                };
-            }) => any;
-            fieldSummary: (props: {
-                items: any[];
-            }) => any;
-            default: () => any;
-        }, {}>;
-        TransferListField: vue.FunctionalComponent<TransferListFieldProps<z.TypeOf<T>, any>, {}, {
-            itemRenderer: (props: {
-                item: any;
-                index: number;
-                getFieldName: (fieldPath: string) => string;
-            }) => any;
-            availableItemRenderer: (props: {
-                item: any;
-                index: number;
-            }) => any;
-            selectedItemRenderer: (props: {
-                item: any;
-                index: number;
-                getFieldName: (fieldPath: string) => string;
-            }) => any;
-            default: () => any;
-        }, {}>;
-        ToppingsField: vue.FunctionalComponent<ToppingsFieldProps<z.TypeOf<T>, any>, {}, {
-            itemRenderer: (props: {
-                item: any;
-                index: number;
-                getFieldName: (fieldPath: string) => string;
-            }) => any;
-            availableItemRenderer: (props: {
-                item: any;
-                index: number;
-            }) => any;
-            toppingRenderer: (props: {
-                topping: any;
-                isSelected: boolean;
-                placement: string;
-                isExtra: boolean;
-            }) => any;
-            default: () => any;
-        }, {}>;
-        createTypedSelectField: <P extends Path<z.TypeOf<T>>>(fieldPath: P) => <E extends FieldPathToEnum<z.TypeOf<T>, P> = FieldPathToEnum<z.TypeOf<T>, P>>(props: Omit<SelectFieldProps<z.TypeOf<T>, Path<z.TypeOf<T>>, any>, "name" | "valueToLabel"> & {
-            valueToLabel: Record<E, string>;
-        }, context?: any) => any;
-        typedSelectFields: { [K in Path<z.TypeOf<T>>]?: (<E extends FieldPathToEnum<z.TypeOf<T>, K> = FieldPathToEnum<z.TypeOf<T>, K>>(props: Omit<SelectFieldProps<z.TypeOf<T>, Path<z.TypeOf<T>>, any>, "name" | "valueToLabel"> & {
-            valueToLabel: Record<E, string>;
-        }, context?: any) => any) | undefined; };
-        fields: Record<Path<z.TypeOf<T>>, any>;
-        field: <P extends Path<z.TypeOf<T>>>(path: P) => any;
-    };
-    typed: ComponentsType<z.TypeOf<T>>;
+declare function mergeStyles(...styles: Array<Partial<StyleCreators>>): StyleCreators;
+/**
+ * Create a partial style with only the components you need
+ * Useful when you want to override just a few components in a base style
+ *
+ * @param creators Object containing only the component creators you want to override
+ * @returns A partial style object that can be used with extendStyle
+ */
+declare function createPartialStyle<T extends Partial<StyleCreators>>(creators: T): T;
+/**
+ * Create a style template with placeholder implementations
+ * Useful as a starting point for creating a completely new style
+ *
+ * @returns A style object with placeholder implementations that throw errors
+ */
+declare function createStyleTemplate(): StyleCreators;
+
+/**
+ * Types for render styles in the form system
+ */
+/**
+ * Available rendering styles for form components
+ */
+type RenderStyle = 'daisy_ui';
+
+/**
+ * Valid operators for each data type
+ */
+declare const OPERATORS_BY_TYPE: {
+    string: readonly ["eq", "ne", "contains", "sw", "ew", "in", "notIn"];
+    number: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "between"];
+    date: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "between", "isEmpty", "isNotEmpty"];
+    boolean: readonly ["eq", "ne"];
+    enum: readonly ["eq", "ne", "in", "notIn"];
+    money: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "between"];
+    percentage: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "between"];
 };
+/**
+ * Infer DataType from OPERATORS_BY_TYPE keys
+ */
+type DataType = keyof typeof OPERATORS_BY_TYPE;
+/**
+ * Infer operator types from OPERATORS_BY_TYPE
+ */
+type ExtractOperatorType<T> = T extends readonly (infer U)[] ? U : never;
+type StringOperator = ExtractOperatorType<typeof OPERATORS_BY_TYPE.string>;
+type NumberOperator = ExtractOperatorType<typeof OPERATORS_BY_TYPE.number>;
+type DateOperator = ExtractOperatorType<typeof OPERATORS_BY_TYPE.date>;
+type BooleanOperator = ExtractOperatorType<typeof OPERATORS_BY_TYPE.boolean>;
+type EnumOperator = ExtractOperatorType<typeof OPERATORS_BY_TYPE.enum>;
+/**
+ * Union type of all operators
+ */
+type Operator = StringOperator | NumberOperator | DateOperator | BooleanOperator | EnumOperator;
+/**
+ * Check if an operator is valid for a given data type
+ */
+declare function isValidOperatorForType(operator: string, type: DataType): boolean;
 
-interface NoDataDisplayProps {
-    message?: string;
-    class?: string;
-    variant?: 'info' | 'warning';
-}
-declare const NoDataDisplay: FunctionalComponent<NoDataDisplayProps>;
+/**
+ * Filtering Types - Matching Client-Side Data Table Filtering Specification v1.0.0
+ */
+/**
+ * Data types supported by the filtering system - inferred from OPERATORS_BY_TYPE keys
+ */
 
-interface ErrorDisplayProps {
-    error: string | Error | unknown;
-    class?: string;
-    variant?: 'error' | 'warning' | 'info';
+/**
+ * Field metadata entry in the registry
+ */
+interface FieldMetadata {
+    type: DataType;
+    filterable?: boolean;
+    searchable?: boolean;
+    sortable?: boolean;
 }
-declare const ErrorDisplay: FunctionalComponent<ErrorDisplayProps>;
-
-interface LoadingDisplayProps {
-    message?: string;
-    size?: 'sm' | 'md' | 'lg';
-    class?: string;
+/**
+ * Field registry - single source of truth for field metadata
+ * Maps field names to their metadata
+ */
+interface FieldRegistry {
+    [fieldName: string]: FieldMetadata;
 }
-declare const LoadingDisplay: FunctionalComponent<LoadingDisplayProps>;
-
-declare const ZINIA_DISPLAY_KEY = "ziniaDisplay";
-declare const ZINIA_DISPLAY_FIELDS_KEY = "ziniaDisplayFields";
-declare const ZINIA_DISPLAY_FIELDS_GENERIC_KEY = "ziniaDisplayFieldsGeneric";
-declare const ZINIA_DISPLAY_SCHEMA_KEY = "ziniaDisplaySchema";
-interface DisplayOptions<TData, TExtra extends Record<string, any>> {
-    data?: TData | Ref<TData>;
-    schemaId?: string;
-    storeName?: string;
-    renderStyle?: RegisteredStyleName;
-    autoProvide?: boolean;
-    loading?: boolean | Ref<boolean>;
-    error?: string | null | Ref<string | null>;
-    fetchData?: () => Promise<TData>;
-    dataLoaders?: {
-        [K in keyof TExtra]?: () => Promise<TExtra[K]>;
-    };
-    autoLoad?: boolean;
-    onLoad?: (data: TData) => void;
-    onError?: (error: Error) => void;
-    debug?: boolean;
+/**
+ * Filter value object - represents a filtering condition for a specific field
+ * Field name is the key in FilterConfiguration, type comes from registry
+ */
+interface FilterValueObject {
+    operator: string;
+    value?: any;
+    values?: any[];
+    caseSensitive?: boolean;
 }
-declare function useDisplay<TSchema extends z.ZodObject<any>, TExtra extends Record<string, any> = Record<string, any>>(schema: TSchema, options?: DisplayOptions<z.infer<TSchema>, TExtra>): {
-    display: {
-        storeName: string;
-        readonly data: z.TypeOf<TSchema> | null;
-        readonly extraData: TExtra;
-        readonly isLoading: boolean;
-        readonly isReady: boolean;
-        readonly error: string | null;
-        readonly lastLoadTime: number | null;
-        fieldsMetadata: Record<string, FieldMetadata>;
-        readonly isAsyncMode: boolean;
-        load: (options_?: {
-            data?: boolean;
-            extra?: boolean;
-            specificLoaders?: Array<keyof TExtra>;
-        }) => Promise<void>;
-        loadData: () => Promise<void>;
-        loadExtraData: (keys?: Array<keyof TExtra>) => Promise<void>;
-        loadAllData: () => Promise<void>;
-        refreshData: () => Promise<void>;
-        clear: () => void;
-        getValue: (path: string) => any;
-    };
-    ZiniaDisplay: vue.FunctionalComponent<DisplayProps<z.TypeOf<TSchema>>, {}, any, {}>;
-    LoadingDisplay: vue.FunctionalComponent<LoadingDisplayProps, {}, any, {}>;
-    ErrorDisplay: vue.FunctionalComponent<ErrorDisplayProps, {}, any, {}>;
-    NoDataDisplay: vue.FunctionalComponent<NoDataDisplayProps, {}, any, {}>;
-    zinia: DisplayComponentsType<z.TypeOf<TSchema>>;
-    ziniaGeneric: {
-        DisplayField: vue.FunctionalComponent<DisplayFieldProps<z.TypeOf<TSchema>>, {}, any, {}>;
-        fields: { [K in Path<z.TypeOf<TSchema>>]: DisplayFieldComponent<z.TypeOf<TSchema>, K, string>; };
-        field: <P extends Path<z.TypeOf<TSchema>>>(path: P) => any;
-    };
-    load: (options_?: {
-        data?: boolean;
-        extra?: boolean;
-        specificLoaders?: Array<keyof TExtra>;
-    }) => Promise<void>;
-    loadData: () => Promise<void>;
-    loadExtraData: (keys?: Array<keyof TExtra>) => Promise<void>;
-    loadAllData: () => Promise<void>;
-    refreshData: () => Promise<void>;
-    clear: () => void;
-};
-type UseDisplayType<TSchema extends z.ZodObject<any>, TExtra extends Record<string, any> = Record<string, any>> = ReturnType<typeof useDisplay<TSchema, TExtra>>;
-type ZiniaDisplay<TSchema extends z.ZodObject<any> = z.ZodObject<any>, TExtra extends Record<string, any> = Record<string, any>> = UseDisplayType<TSchema, TExtra>['display'];
-type ZiniaDisplayFields<TSchema extends z.ZodObject<any>, TExtra extends Record<string, any> = Record<string, any>> = UseDisplayType<TSchema, TExtra>['zinia'];
-type ZiniaDisplayGenericFields<TSchema extends z.ZodObject<any>, TExtra extends Record<string, any> = Record<string, any>> = UseDisplayType<TSchema, TExtra>['ziniaGeneric'];
+/**
+ * Filter configuration - flat object mapping field names to filter conditions
+ * All filters are combined with implicit AND logic
+ */
+interface FilterConfiguration {
+    [fieldName: string]: FilterValueObject;
+}
+/**
+ * Validation result
+ */
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+/**
+ * Validation error
+ */
+interface ValidationError {
+    field?: string;
+    message: string;
+    code: string;
+}
+
+/**
+ * Filter Validation - Registry-based validation per spec
+ */
+
+/**
+ * Validate field registry structure
+ */
+declare function validateFieldRegistry(registry: FieldRegistry): ValidationResult;
+/**
+ * Validate filter configuration against field registry
+ */
+declare function validateFilterConfiguration(config: FilterConfiguration, registry: FieldRegistry): ValidationResult;
+
+/**
+ * Field Registry Building - Convert Zod schemas and metadata to filter registry format
+ */
+
+/**
+ * Build field registry from Zod schema and form metadata
+ *
+ * @param schema Zod schema object
+ * @param fieldsMetadata Form field metadata (from useFormMetadata)
+ * @returns FieldRegistry for filtering
+ */
+declare function buildFieldRegistryFromSchema(schema: z.ZodObject<any>, fieldsMetadata: Record<string, FieldMetadata$1>): FieldRegistry;
+
+/**
+ * Filter Serialization - Query string and JSON serialization/deserialization
+ * Uses compact DrizzleORM-style format: flt[field]=value or flt[field][op]=value
+ */
+
+/**
+ * Serialize filter configuration to URL-safe query string
+ * Returns a plain query string (NOT URL-encoded) that can be used directly in URLSearchParams or Vue Router
+ * Format: filters[name][operator]=contains&filters[name][value]=john
+ *
+ * Note: This returns the raw query string. If you need it URL-encoded, use encodeURIComponent().
+ */
+declare function serializeFiltersToQueryString(config: FilterConfiguration): string;
+/**
+ * Deserialize filter configuration from query string
+ * Supports both URLSearchParams format and legacy base64 format for backward compatibility
+ * Validates against registry before returning
+ */
+declare function deserializeFiltersFromQueryString(queryString: string, registry: FieldRegistry): FilterConfiguration;
 
 declare const ZINIA_DATA_TABLE_KEY = "ziniaDataTable";
 declare const ZINIA_DATA_TABLE_COLUMNS_KEY = "ziniaDataTableColumns";
@@ -2012,6 +1994,7 @@ declare const ZINIA_DATA_TABLE_ACTIONS_KEY = "ziniaDataTableActions";
 declare const ZINIA_DATA_TABLE_SEARCH_INPUT_KEY = "ziniaDataTableSearchInput";
 declare const ZINIA_DATA_TABLE_FILTER_INPUTS_KEY = "ziniaDataTableFilterInputs";
 declare const ZINIA_DATA_TABLE_FILTER_OPERATORS_KEY = "ziniaDataTableFilterOperators";
+declare const ZINIA_DATA_TABLE_FILTER_CASE_SENSITIVE_KEY = "ziniaDataTableFilterCaseSensitive";
 declare const ZINIA_DATA_TABLE_FILTER_OPTIONS_STATE_KEY = "ziniaDataTableFilterOptionsState";
 declare const ZINIA_DATA_TABLE_FILTER_OPTIONS_LOADING_KEY = "ziniaDataTableFilterOptionsLoading";
 declare const ZINIA_DATA_TABLE_NAME_KEY = "ziniaDataTableName";
@@ -2075,7 +2058,7 @@ interface ColumnDefinition<TData, TField extends keyof TData> {
     textWrap?: 'truncate' | 'wrap';
     format?: (value: TData[TField], row: TData) => string;
     render?: (value: TData[TField], row: TData) => any;
-    filterType?: 'text' | 'select' | 'number' | 'boolean' | 'combobox';
+    filterType?: 'text' | 'select' | 'number' | 'boolean' | 'combobox' | 'date';
     filterOptions?: FilterOptionItem[];
     filterOptionsLoader?: () => Promise<FilterOptionItem[]>;
     filterAllowCreate?: boolean;
@@ -2093,7 +2076,7 @@ interface FetchDataParams<TData> {
         field: keyof TData;
         direction: 'asc' | 'desc';
     } | null;
-    filters: Record<string, FilterValue>;
+    filters: FilterConfiguration;
     search: {
         query: string;
         searchableFields: Array<keyof TData>;
@@ -2133,6 +2116,7 @@ interface DataTableOptions<TData> {
     schemaId?: string;
     name?: string;
     autoProvide?: boolean;
+    autoLoad?: boolean;
     debug?: boolean;
     onLoad?: (data: TData[]) => void;
     onError?: (error: Error) => void;
@@ -2167,9 +2151,12 @@ declare function useDataTable<TSchema extends z.ZodObject<any>>(schema: TSchema,
             readonly direction: "asc" | "desc";
         };
         filters: {
-            readonly active: Record<string, FilterValue>;
+            readonly active: FilterConfiguration;
             readonly count: number;
+            readonly queryParams: Record<string, string>;
+            readonly queryString: string;
         };
+        readonly fieldRegistry: FieldRegistry;
         search: {
             readonly query: string;
             readonly searchableFields: Array<keyof z.TypeOf<TSchema>>;
@@ -2184,9 +2171,11 @@ declare function useDataTable<TSchema extends z.ZodObject<any>>(schema: TSchema,
         refresh: () => Promise<void>;
         sort: (field: keyof z.TypeOf<TSchema>, direction?: "asc" | "desc") => Promise<void>;
         clearSort: () => Promise<void>;
-        setFilter: (field: keyof z.TypeOf<TSchema>, value: any, operator?: FilterValue["operator"]) => Promise<void>;
+        setFilter: (field: keyof z.TypeOf<TSchema>, filter: FilterValueObject) => Promise<void>;
         clearFilter: (field: keyof z.TypeOf<TSchema>) => Promise<void>;
         clearAllFilters: () => Promise<void>;
+        setFiltersFromQueryParams: (params: Record<string, string | string[]>) => Promise<void>;
+        setFiltersFromQueryString: (queryString: string) => Promise<void>;
         setSearch: (query: string) => Promise<void>;
         clearSearch: () => Promise<void>;
         goToPage: (page: number) => Promise<void>;
@@ -2206,7 +2195,7 @@ declare function useDataTable<TSchema extends z.ZodObject<any>>(schema: TSchema,
             openFilterDrawer: () => boolean;
             closeFilterDrawer: () => boolean;
         };
-        fieldsMetadata: Record<string, FieldMetadata>;
+        fieldsMetadata: Record<string, FieldMetadata$1>;
         columns: (z.TypeOf<TSchema> extends infer T ? { [K in keyof T]?: ColumnDefinition<z.TypeOf<TSchema>, K> | undefined; } : never) & {
             [key: string]: ColumnDefinition<z.TypeOf<TSchema>, any>;
         };
@@ -2231,9 +2220,10 @@ declare function useDataTable<TSchema extends z.ZodObject<any>>(schema: TSchema,
     refresh: () => Promise<void>;
     sort: (field: keyof z.TypeOf<TSchema>, direction?: "asc" | "desc") => Promise<void>;
     clearSort: () => Promise<void>;
-    setFilter: (field: keyof z.TypeOf<TSchema>, value: any, operator?: FilterValue["operator"]) => Promise<void>;
+    setFilter: (field: keyof z.TypeOf<TSchema>, filter: FilterValueObject) => Promise<void>;
     clearFilter: (field: keyof z.TypeOf<TSchema>) => Promise<void>;
     clearAllFilters: () => Promise<void>;
+    setFiltersFromQueryString: (queryString: string) => Promise<void>;
     setSearch: (query: string) => Promise<void>;
     clearSearch: () => Promise<void>;
     goToPage: (page: number) => Promise<void>;
@@ -2258,7 +2248,7 @@ interface CursorFetchParams<TData> {
         field: keyof TData;
         direction: 'asc' | 'desc';
     } | null;
-    filters: Record<string, any>;
+    filters: FilterConfiguration;
     search: {
         query: string;
         searchableFields: Array<keyof TData>;
@@ -2302,6 +2292,7 @@ interface CursorDataTableOptions<TData> {
     schemaId?: string;
     name?: string;
     autoProvide?: boolean;
+    autoLoad?: boolean;
     debug?: boolean;
     onLoad?: (data: TData[]) => void;
     onError?: (error: Error) => void;
@@ -2336,9 +2327,12 @@ declare function useCursorDataTable<TSchema extends z.ZodObject<any>>(schema: TS
             readonly direction: "asc" | "desc";
         };
         filters: {
-            readonly active: Record<string, any>;
+            readonly active: FilterConfiguration;
             readonly count: number;
+            readonly queryParams: Record<string, string>;
+            readonly queryString: string;
         };
+        readonly fieldRegistry: FieldRegistry;
         search: {
             readonly query: string;
             readonly searchableFields: Array<keyof z.TypeOf<TSchema>>;
@@ -2353,9 +2347,11 @@ declare function useCursorDataTable<TSchema extends z.ZodObject<any>>(schema: TS
         refresh: () => Promise<void>;
         sort: (field: keyof z.TypeOf<TSchema>, direction?: "asc" | "desc") => Promise<void>;
         clearSort: () => Promise<void>;
-        setFilter: (field: keyof z.TypeOf<TSchema>, value: any, operator?: any) => Promise<void>;
+        setFilter: (field: keyof z.TypeOf<TSchema>, filter: FilterValueObject) => Promise<void>;
         clearFilter: (field: keyof z.TypeOf<TSchema>) => Promise<void>;
         clearAllFilters: () => Promise<void>;
+        setFiltersFromQueryParams: (params: Record<string, string | string[]>) => Promise<void>;
+        setFiltersFromQueryString: (queryString: string) => Promise<void>;
         setSearch: (query: string) => Promise<void>;
         clearSearch: () => Promise<void>;
         nextPage: () => Promise<void>;
@@ -2375,7 +2371,7 @@ declare function useCursorDataTable<TSchema extends z.ZodObject<any>>(schema: TS
             openFilterDrawer: () => boolean;
             closeFilterDrawer: () => boolean;
         };
-        fieldsMetadata: Record<string, FieldMetadata>;
+        fieldsMetadata: Record<string, FieldMetadata$1>;
         columns: (z.TypeOf<TSchema> extends infer T ? { [K in keyof T]?: ColumnDefinition<z.TypeOf<TSchema>, K> | undefined; } : never) & {
             [key: string]: ColumnDefinition<z.TypeOf<TSchema>, any>;
         };
@@ -2400,9 +2396,10 @@ declare function useCursorDataTable<TSchema extends z.ZodObject<any>>(schema: TS
     refresh: () => Promise<void>;
     sort: (field: keyof z.TypeOf<TSchema>, direction?: "asc" | "desc") => Promise<void>;
     clearSort: () => Promise<void>;
-    setFilter: (field: keyof z.TypeOf<TSchema>, value: any, operator?: any) => Promise<void>;
+    setFilter: (field: keyof z.TypeOf<TSchema>, filter: FilterValueObject) => Promise<void>;
     clearFilter: (field: keyof z.TypeOf<TSchema>) => Promise<void>;
     clearAllFilters: () => Promise<void>;
+    setFiltersFromQueryString: (queryString: string) => Promise<void>;
     setSearch: (query: string) => Promise<void>;
     clearSearch: () => Promise<void>;
     nextPage: () => Promise<void>;
@@ -2416,6 +2413,27 @@ declare function useCursorDataTable<TSchema extends z.ZodObject<any>>(schema: TS
 };
 type UseCursorDataTableType<TSchema extends z.ZodObject<any>> = ReturnType<typeof useCursorDataTable<TSchema>>;
 
+interface NoDataDisplayProps {
+    message?: string;
+    class?: string;
+    variant?: 'info' | 'warning';
+}
+declare const NoDataDisplay: FunctionalComponent<NoDataDisplayProps>;
+
+interface ErrorDisplayProps {
+    error: string | Error | unknown;
+    class?: string;
+    variant?: 'error' | 'warning' | 'info';
+}
+declare const ErrorDisplay: FunctionalComponent<ErrorDisplayProps>;
+
+interface LoadingDisplayProps {
+    message?: string;
+    size?: 'sm' | 'md' | 'lg';
+    class?: string;
+}
+declare const LoadingDisplay: FunctionalComponent<LoadingDisplayProps>;
+
 declare const ZINIA_DELETE_MODAL_KEY = "ziniaDeleteModal";
 declare const ZINIA_DELETE_MODAL_FIELDS_KEY = "ziniaDeleteModalFields";
 declare const ZINIA_DELETE_MODAL_FIELDS_GENERIC_KEY = "ziniaDeleteModalFieldsGeneric";
@@ -2437,7 +2455,7 @@ declare function useDeleteModal<TSchema extends z.ZodObject<any>>(schema: TSchem
         readonly data: z.TypeOf<TSchema>;
         readonly isLoading: boolean;
         readonly error: string | null;
-        fieldsMetadata: Record<string, FieldMetadata>;
+        fieldsMetadata: Record<string, FieldMetadata$1>;
         confirmDelete: () => Promise<void>;
         clearError: () => void;
         getValue: (path: string) => any;
@@ -2460,228 +2478,532 @@ type ZiniaDeleteModal<TSchema extends z.ZodObject<any>> = UseDeleteModalType<TSc
 type ZiniaDeleteModalFields<TSchema extends z.ZodObject<any>> = UseDeleteModalType<TSchema>['zinia'];
 type ZiniaDeleteModalGenericFields<TSchema extends z.ZodObject<any>> = UseDeleteModalType<TSchema>['ziniaGeneric'];
 
+declare const ZINIA_DISPLAY_KEY = "ziniaDisplay";
+declare const ZINIA_DISPLAY_FIELDS_KEY = "ziniaDisplayFields";
+declare const ZINIA_DISPLAY_FIELDS_GENERIC_KEY = "ziniaDisplayFieldsGeneric";
+declare const ZINIA_DISPLAY_SCHEMA_KEY = "ziniaDisplaySchema";
+interface DisplayOptions<TData, TExtra extends Record<string, any>> {
+    data?: TData | Ref<TData>;
+    schemaId?: string;
+    storeName?: string;
+    renderStyle?: RegisteredStyleName;
+    autoProvide?: boolean;
+    loading?: boolean | Ref<boolean>;
+    error?: string | null | Ref<string | null>;
+    fetchData?: () => Promise<TData>;
+    dataLoaders?: {
+        [K in keyof TExtra]?: () => Promise<TExtra[K]>;
+    };
+    autoLoad?: boolean;
+    onLoad?: (data: TData) => void;
+    onError?: (error: Error) => void;
+    debug?: boolean;
+}
+declare function useDisplay<TSchema extends z.ZodObject<any>, TExtra extends Record<string, any> = Record<string, any>>(schema: TSchema, options?: DisplayOptions<z.infer<TSchema>, TExtra>): {
+    display: {
+        storeName: string;
+        readonly data: z.TypeOf<TSchema> | null;
+        readonly extraData: TExtra;
+        readonly isLoading: boolean;
+        readonly isReady: boolean;
+        readonly error: string | null;
+        readonly lastLoadTime: number | null;
+        fieldsMetadata: Record<string, FieldMetadata$1>;
+        readonly isAsyncMode: boolean;
+        load: (options_?: {
+            data?: boolean;
+            extra?: boolean;
+            specificLoaders?: Array<keyof TExtra>;
+        }) => Promise<void>;
+        loadData: () => Promise<void>;
+        loadExtraData: (keys?: Array<keyof TExtra>) => Promise<void>;
+        loadAllData: () => Promise<void>;
+        refreshData: () => Promise<void>;
+        clear: () => void;
+        getValue: (path: string) => any;
+    };
+    ZiniaDisplay: vue.FunctionalComponent<DisplayProps<z.TypeOf<TSchema>>, {}, any, {}>;
+    LoadingDisplay: vue.FunctionalComponent<LoadingDisplayProps, {}, any, {}>;
+    ErrorDisplay: vue.FunctionalComponent<ErrorDisplayProps, {}, any, {}>;
+    NoDataDisplay: vue.FunctionalComponent<NoDataDisplayProps, {}, any, {}>;
+    zinia: DisplayComponentsType<z.TypeOf<TSchema>>;
+    ziniaGeneric: {
+        DisplayField: vue.FunctionalComponent<DisplayFieldProps<z.TypeOf<TSchema>>, {}, any, {}>;
+        fields: { [K in Path<z.TypeOf<TSchema>>]: DisplayFieldComponent<z.TypeOf<TSchema>, K, string>; };
+        field: <P extends Path<z.TypeOf<TSchema>>>(path: P) => any;
+    };
+    load: (options_?: {
+        data?: boolean;
+        extra?: boolean;
+        specificLoaders?: Array<keyof TExtra>;
+    }) => Promise<void>;
+    loadData: () => Promise<void>;
+    loadExtraData: (keys?: Array<keyof TExtra>) => Promise<void>;
+    loadAllData: () => Promise<void>;
+    refreshData: () => Promise<void>;
+    clear: () => void;
+};
+type UseDisplayType<TSchema extends z.ZodObject<any>, TExtra extends Record<string, any> = Record<string, any>> = ReturnType<typeof useDisplay<TSchema, TExtra>>;
+type ZiniaDisplay<TSchema extends z.ZodObject<any> = z.ZodObject<any>, TExtra extends Record<string, any> = Record<string, any>> = UseDisplayType<TSchema, TExtra>['display'];
+type ZiniaDisplayFields<TSchema extends z.ZodObject<any>, TExtra extends Record<string, any> = Record<string, any>> = UseDisplayType<TSchema, TExtra>['zinia'];
+type ZiniaDisplayGenericFields<TSchema extends z.ZodObject<any>, TExtra extends Record<string, any> = Record<string, any>> = UseDisplayType<TSchema, TExtra>['ziniaGeneric'];
+
 /**
- * Registry for storing schema metadata
+ * Type definitions for async cascading selection and auto-population
  */
 
 /**
- * Get metadata for a specific field in a schema
- *
- * @param schemaId Unique identifier for the schema
- * @param path Path to the field
- * @returns Metadata for the field or undefined if not found
+ * Helper type to get the value type of a field path
  */
-declare function getFieldMetadata(schemaId: string, path: string): SchemaFieldMetadata | undefined;
+type FieldValue<FormType, P extends Path<FormType>> = P extends keyof FormType ? FormType[P] : P extends `${infer K}.${infer Rest}` ? K extends keyof FormType ? FormType[K] extends Record<string, any> ? FieldValue<FormType[K], Rest & Path<FormType[K]>> : never : never : never;
 /**
- * Get all metadata for a schema
- *
- * @param schemaId Unique identifier for the schema
- * @returns All metadata for the schema or an empty object if not found
+ * Configuration for async cascading selection (parent → child options fetching via API)
  */
-declare function getAllSchemaMetadata(schemaId: string): MetadataRegistry;
+interface AsyncCascadingSelectConfig<FormType, ParentField extends Path<FormType> = Path<FormType>, ChildField extends Path<FormType> = Path<FormType>> {
+    /** Parent field that triggers child options fetch */
+    parentField: ParentField;
+    /** Child field that will be populated with fetched options */
+    childField: ChildField;
+    /** Async function to fetch child options based on parent value */
+    fetchOptionsFn: (parentValue: FieldValue<FormType, ParentField>) => Promise<Array<SelectOption>>;
+    /** Whether to clear child field when parent changes (default: true) */
+    clearOnParentChange?: boolean;
+}
 /**
- * Set metadata for a schema
- *
- * @param schemaId Unique identifier for the schema
- * @param metadata Object mapping field paths to their metadata
+ * Type for the async cascading selects configuration object
+ * Uses a mapped type to preserve field path type safety
  */
-declare function setSchemaMetadata(schemaId: string, metadata: MetadataRegistry): void;
+type AsyncCascadingSelectsConfig<FormType> = {
+    [K in string]: AsyncCascadingSelectConfig<FormType, Path<FormType>, Path<FormType>>;
+};
 /**
- * Check if a schema has metadata
- *
- * @param schemaId Unique identifier for the schema
- * @returns True if the schema has metadata, false otherwise
+ * Configuration for auto-population (select/combobox → other fields)
  */
-declare function hasSchemaMetadata(schemaId: string): boolean;
+interface AutoPopulateConfig<FormType, TData = any, SourceField extends Path<FormType> = Path<FormType>> {
+    /**
+     * Optional async function to fetch data when option is selected.
+     * If provided, this will be called instead of using option.data.
+     * Receives the selected option value and returns the data object.
+     */
+    fetchDataFn?: (selectedValue: FieldValue<FormType, SourceField>) => Promise<TData>;
+    /** Mapping of form fields to data properties for auto-population */
+    fields: {
+        [TargetField in Path<FormType>]?: string | ((data: TData) => FieldValue<FormType, TargetField>);
+    };
+}
 /**
- * Clear metadata for a schema
- *
- * @param schemaId Unique identifier for the schema
+ * Type for the auto-populate configuration object
+ * Key is the select/combobox field name, value is the auto-populate config
  */
-declare function clearSchemaMetadata(schemaId: string): void;
+type AutoPopulateConfigs<FormType> = Partial<{
+    [SourceField in Path<FormType>]: AutoPopulateConfig<FormType, any>;
+}>;
+
 /**
- * Clear all metadata from the registry
+ * Options for merging server data with local changes
  */
-declare function clearAllMetadata(): void;
+interface MergeOptions<T> {
+    /**
+     * Fields to preserve from local storage when merging with server data
+     * If not provided, all fields will be merged with local data taking precedence
+     */
+    preserveLocalFields?: (keyof T)[];
+    /**
+     * Custom merge function to handle complex merging logic
+     * If provided, this will be used instead of the default merge strategy
+     */
+    customMergeFunction?: (serverData: T, localData: T) => T;
+}
 
+declare const ZINIA_FORM_KEY = "ziniaForm";
+declare const ZINIA_FIELDS_KEY = "ziniaFields";
+declare const ZINIA_FIELDS_GENERIC_KEY = "ziniaFieldsGeneric";
+declare const ZINIA_FORM_SCHEMA_KEY = "ziniaFormSchema";
+type DataLoaderReturnTypes<T> = {
+    [K in keyof T]: T[K] extends () => Promise<infer R> ? R : never;
+};
 /**
- * Functions for registering schema metadata
+ * Create a type-safe form system using functional components
+ *
+ * @param schema The Zod schema for the form
+ * @param options Form options
+ * @returns Form API and components
  */
+declare function useForm<T extends z.ZodObject<any>, CalcType = (values: z.infer<T>, extraData?: DataLoaderReturnTypes<Record<string, () => Promise<any>>>) => any, ExtraDataType = DataLoaderReturnTypes<Record<string, () => Promise<any>>>>(schema: T, options: {
+    storeName: string;
+    schemaId?: string;
+    persistToLocalStorage?: boolean;
+    initialValues?: Partial<z.infer<typeof schema>>;
+    renderStyle?: RegisteredStyleName;
+    autoProvide?: boolean;
+    validateOnMount?: boolean;
+    mergeOptions?: MergeOptions<z.infer<typeof schema>>;
+    dataLoaders?: {
+        [K in keyof ExtraDataType]?: () => Promise<ExtraDataType[K]>;
+    };
+    fetchData?: () => Promise<z.infer<typeof schema>>;
+    asyncCascadingSelects?: AsyncCascadingSelectsConfig<z.infer<T>>;
+    autoPopulate?: AutoPopulateConfigs<z.infer<T>>;
+    calculationFn?: (values: z.infer<T>, extraData?: ExtraDataType) => CalcType;
+    debug?: {
+        all?: boolean;
+        formState?: boolean;
+        validation?: boolean;
+        calculations?: boolean;
+        persistence?: boolean;
+        reactivity?: boolean;
+    };
+}): {
+    form: {
+        storeName: string;
+        values: z.TypeOf<T>;
+        state: FormState<z.TypeOf<T>, CalcType, ExtraDataType>;
+        readonly calculatedValues: CalcType;
+        readonly extraData: ExtraDataType;
+        readonly isValid: boolean;
+        readonly isDirty: boolean;
+        isSubmitting: boolean;
+        readonly hasAttemptedSubmit: boolean;
+        readonly submitAttemptsCount: number;
+        readonly errors: Record<string, string>;
+        readonly touched: Record<string, boolean>;
+        readonly dirty: Record<string, boolean>;
+        readonly collapsedFields: Record<string, {
+            isFieldCollapsed: boolean;
+            collapsedItems: number[];
+            defaultCollapsedInitialized: boolean;
+        }>;
+        readonly undoHistory: Record<string, {
+            type: "add" | "remove" | "swap";
+            previousState: any;
+            currentState: any;
+            timestamp: number;
+        }[]>;
+        readonly redoHistory: Record<string, {
+            type: "add" | "remove" | "swap";
+            previousState: any;
+            currentState: any;
+            timestamp: number;
+        }[]>;
+        readonly pendingOperations: Record<string, {
+            type: "add" | "remove" | "swap";
+            index?: number;
+            indexA?: number;
+            indexB?: number;
+            item?: any;
+            previousState: any;
+            currentState: any;
+            timestamp: number;
+            timeoutId?: number;
+        }[]>;
+        readonly fieldsMetadata: Record<string, FieldMetadata$1>;
+        validate: (options?: {
+            markErrorsAsTouched: boolean;
+        }) => boolean;
+        validateField: (path: string) => boolean;
+        reset: (newInitialData?: z.TypeOf<T> | undefined) => void;
+        setSubmitting: (value: boolean) => void;
+        incrementSubmitAttempts: () => void;
+        setSubmitError: (error: string | null) => void;
+        readonly isReady: boolean;
+        readonly isLoading: boolean;
+        readonly loadError: string | null;
+        readonly submitError: string | null;
+        setLoading: (value: boolean) => void;
+        setReady: (value: boolean) => void;
+        setLoadError: (error: string | null) => void;
+        getValue: (path: string) => any;
+        setValue: (path: string, value: any) => void;
+        touchField: (path: string) => void;
+        isTouched: (path: string) => boolean;
+        isDirtyField: (path: string) => boolean;
+        resetField: (path: string) => void;
+        hasError: (path: string) => boolean;
+        getError: (path: string) => string;
+        setFocus: (path: string, value: boolean) => void;
+        isFocused: (path: string) => boolean;
+        setDisplayText: (path: string, text: string) => void;
+        getDisplayText: (path: string) => string;
+        setSelectedIndex: (path: string, index: number) => void;
+        getSelectedIndex: (path: string) => number;
+        getArrayItemId: (path: string, index: number) => string;
+        addArrayItemId: (path: string, index?: number) => string;
+        removeArrayItemId: (path: string, index: number) => void;
+        swapArrayItemIds: (path: string, indexA: number, indexB: number) => void;
+        syncArrayItemIds: (path: string) => void;
+    };
+    ZiniaForm: vue.FunctionalComponent<FormProps<z.TypeOf<T>>, {}, any, {}>;
+    ZiniaSubmitButton: vue.FunctionalComponent<SubmitButtonProps<z.TypeOf<T>>, {}, any, {}>;
+    ZiniaResetButton: vue.FunctionalComponent<ResetButtonProps<z.TypeOf<T>>, {}, any, {}>;
+    ZiniaFormErrorsSummary: vue.FunctionalComponent<FormErrorsSummaryProps, {}, any, {}>;
+    zinia: ComponentsType<z.TypeOf<T>>;
+    ziniaGeneric: {
+        TextField: vue.FunctionalComponent<TextFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        NumberField: vue.FunctionalComponent<NumberFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        SelectField: vue.FunctionalComponent<SelectFieldProps<z.TypeOf<T>, Path<z.TypeOf<T>>, any>, {}, any, {}>;
+        CheckboxField: vue.FunctionalComponent<CheckboxFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        TextareaField: vue.FunctionalComponent<TextareaFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        RadioField: vue.FunctionalComponent<RadioFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        FileField: vue.FunctionalComponent<FileFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        DateField: vue.FunctionalComponent<DateFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        TimeField: vue.FunctionalComponent<TimeFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        DateTimeLocalField: vue.FunctionalComponent<DateTimeLocalFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        RangeField: vue.FunctionalComponent<RangeFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        PasswordField: vue.FunctionalComponent<PasswordFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        EmailField: vue.FunctionalComponent<EmailFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        UrlField: vue.FunctionalComponent<UrlFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        TelField: vue.FunctionalComponent<TelFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        SearchField: vue.FunctionalComponent<SearchFieldProps<z.TypeOf<T>>, {}, any, {}>;
+        ComboboxField: vue.FunctionalComponent<ComboboxFieldProps<z.TypeOf<T>, Path<z.TypeOf<T>>, any>, {}, any, {}>;
+        ArrayField: vue.FunctionalComponent<ArrayFieldProps<z.TypeOf<T>, any>, {}, {
+            itemRenderer: (props: {
+                item: any;
+                index: number;
+                fields: Record<string, string> | {
+                    [x: string]: string;
+                };
+            }) => any;
+            availableItemRenderer: (props: {
+                item: any;
+                index: number;
+            }) => any;
+            itemActions: (props: {
+                item: any;
+                index: number;
+                fields: Record<string, string> | {
+                    [x: string]: string;
+                };
+            }) => any;
+            fieldSummary: (props: {
+                items: any[];
+            }) => any;
+            default: () => any;
+        }, {}>;
+        TransferListField: vue.FunctionalComponent<TransferListFieldProps<z.TypeOf<T>, any>, {}, {
+            itemRenderer: (props: {
+                item: any;
+                index: number;
+                getFieldName: (fieldPath: string) => string;
+            }) => any;
+            availableItemRenderer: (props: {
+                item: any;
+                index: number;
+            }) => any;
+            selectedItemRenderer: (props: {
+                item: any;
+                index: number;
+                getFieldName: (fieldPath: string) => string;
+            }) => any;
+            default: () => any;
+        }, {}>;
+        ToppingsField: vue.FunctionalComponent<ToppingsFieldProps<z.TypeOf<T>, any>, {}, {
+            itemRenderer: (props: {
+                item: any;
+                index: number;
+                getFieldName: (fieldPath: string) => string;
+            }) => any;
+            availableItemRenderer: (props: {
+                item: any;
+                index: number;
+            }) => any;
+            toppingRenderer: (props: {
+                topping: any;
+                isSelected: boolean;
+                placement: string;
+                isExtra: boolean;
+            }) => any;
+            default: () => any;
+        }, {}>;
+        createTypedSelectField: <P extends Path<z.TypeOf<T>>>(fieldPath: P) => <E extends FieldPathToEnum<z.TypeOf<T>, P> = FieldPathToEnum<z.TypeOf<T>, P>>(props: Omit<SelectFieldProps<z.TypeOf<T>, Path<z.TypeOf<T>>, any>, "name" | "valueToLabel"> & {
+            valueToLabel: Record<E, string>;
+        }, context?: any) => any;
+        typedSelectFields: { [K in Path<z.TypeOf<T>>]?: (<E extends FieldPathToEnum<z.TypeOf<T>, K> = FieldPathToEnum<z.TypeOf<T>, K>>(props: Omit<SelectFieldProps<z.TypeOf<T>, Path<z.TypeOf<T>>, any>, "name" | "valueToLabel"> & {
+            valueToLabel: Record<E, string>;
+        }, context?: any) => any) | undefined; };
+        fields: Record<Path<z.TypeOf<T>>, any>;
+        field: <P extends Path<z.TypeOf<T>>>(path: P) => any;
+    };
+    load: () => Promise<void>;
+    loadAllData: () => Promise<void>;
+    refreshFormData: () => Promise<void>;
+    clearSavedFormState: () => void;
+    refreshData: (keys?: Array<keyof ExtraDataType>) => Promise<void>;
+};
+type UseFormType = ReturnType<typeof useForm>;
+type ZiniaForm = UseFormType['form'];
+type ZiniaFormFields = UseFormType['zinia'];
+type ZiniaFormGenericFields = UseFormType['ziniaGeneric'];
+type UseFormTyped<T extends z.ZodObject<any>, CalcType = any, ExtraDataType extends Record<string, any> = Record<string, any>> = ReturnType<typeof useForm<T, CalcType, ExtraDataType>>;
 
 /**
- * Register metadata for a schema
- *
- * @param schemaId Unique identifier for the schema
- * @param metadata Object mapping field paths to their metadata
- */
-declare function registerSchemaMetadata(schemaId: string, metadata: MetadataRegistry): void;
-/**
- * Register metadata for a schema with type checking for field paths
+ * useDataTableUrlSync - Syncs data table filters with URL query parameters
  *
- * @param schema The Zod schema
- * @param schemaId Unique identifier for the schema
- * @param metadata Object mapping field paths to their metadata
- */
-declare function registerSchemaMetadata<T extends z.ZodObject<any>>(schema: T, schemaId: string, metadata: {
-    [K in PathsOf<T>]?: SchemaFieldMetadata;
-}): void;
-
-/**
- * Functions for attaching metadata to schemas
- */
-
-declare const SCHEMA_ID_SYMBOL: unique symbol;
-/**
- * Helper function to get the schema ID from a schema object
+ * Usage:
+ * ```ts
+ * import { useRouter } from 'vue-router';
  *
- * @param schema Zod schema that might have a schema ID attached
- * @returns The schema ID or undefined if not found
+ * const router = useRouter();
+ * const table = useCursorDataTable({ ... });
+ * useDataTableUrlSync(table.table, router);
+ * ```
  */
-declare function getSchemaId(schema: z.ZodTypeAny): string | undefined;
+/** Minimal router interface (compatible with Vue Router's useRouter()) */
+interface Router {
+    currentRoute: {
+        value: {
+            query: Record<string, any>;
+        };
+    };
+    push: (options: {
+        query: Record<string, any>;
+    }) => void;
+}
+interface UrlSyncOptions {
+    /** Whether to load filters from URL on mount (default: true) */
+    loadOnMount?: boolean;
+}
+interface DataTable {
+    setFilter: (field: any, filter: any) => Promise<void>;
+    clearAllFilters: () => Promise<void>;
+    setFiltersFromQueryParams: (params: Record<string, string | string[]>) => Promise<void>;
+    load: () => Promise<void>;
+    filters: {
+        queryParams: Record<string, string>;
+    };
+}
 /**
- * Helper function to create a schema with associated metadata
+ * Syncs a data table's filters with URL query parameters.
+ * Handles back/forward navigation and updates URL when filters change.
  *
- * @param schema Zod schema
- * @param schemaId Unique identifier for the schema
- * @param metadata Metadata for the schema fields
- * @returns The original schema with the schema ID attached
+ * @param table - The data table instance (from useCursorDataTable or useDataTable)
+ * @param router - Vue Router instance (from useRouter())
+ * @param options - Optional configuration
  */
-declare function withMetadata<T extends z.ZodObject<any>>(schema: T, schemaId: string, metadata: {
-    [K in PathsOf<T>]?: SchemaFieldMetadata;
-}): T;
+declare function useDataTableUrlSync(table: DataTable, router: Router, options?: UrlSyncOptions): void;
 
 /**
- * Zinia Forms Plugin
- * Allows registering custom render styles at the application level
+ * Form state management hook
+ * Provides reactive form state with proper reactivity handling
  */
 
 /**
- * Plugin options for Zinia
+ * Form state interface
  */
-interface ZiniaPluginOptions {
-    /**
-     * Map of style names to style creators
-     */
-    styles?: Record<string, StyleCreators>;
-    /**
-     * Default style to use if none specified in useForm
-     */
-    defaultStyle?: string;
+interface FormState<T, CalcType = any, ExtraDataType = any> {
+    data: T;
+    calculatedValues: CalcType;
+    touched: Record<string, boolean>;
+    dirty: Record<string, boolean>;
+    errors: Record<string, string>;
+    focused: Record<string, boolean>;
+    displayText: Record<string, string>;
+    selectedIndex: Record<string, number>;
+    collapsedFields: Record<string, {
+        isFieldCollapsed: boolean;
+        collapsedItems: number[];
+        defaultCollapsedInitialized: boolean;
+    }>;
+    undoHistory: Record<string, {
+        type: 'add' | 'remove' | 'swap';
+        previousState: any;
+        currentState: any;
+        timestamp: number;
+    }[]>;
+    redoHistory: Record<string, {
+        type: 'add' | 'remove' | 'swap';
+        previousState: any;
+        currentState: any;
+        timestamp: number;
+    }[]>;
+    pendingOperations: Record<string, {
+        type: 'add' | 'remove' | 'swap';
+        index?: number;
+        indexA?: number;
+        indexB?: number;
+        item?: any;
+        previousState: any;
+        currentState: any;
+        timestamp: number;
+        timeoutId?: number;
+    }[]>;
+    arrayItemIds: Record<string, string[]>;
+    isSubmitting: boolean;
+    hasAttemptedSubmit: boolean;
+    submitAttemptsCount: number;
+    submitError: string | null;
+    isReady: boolean;
+    isLoading: boolean;
+    loadError: string | null;
+    extraData: ExtraDataType;
+    fetchedOptions: Record<string, any[]>;
+    loadingOptions: Record<string, boolean>;
+    asyncCascadingParents: Record<string, string>;
+    loadingAutoPopulate: Record<string, boolean>;
+    populatingFields: Record<string, boolean>;
 }
 /**
- * Vue plugin for Zinia Forms
- */
-declare const ZiniaPlugin: {
-    install(app: App, options?: ZiniaPluginOptions): void;
-};
-/**
- * Get a registered style by name
- *
- * @param styleName Name of the style to get
- * @returns Style creators for the requested style or undefined if not found
- */
-declare function getRegisteredStyle(styleName?: string): StyleCreators | undefined;
-/**
- * Check if a style is registered
- *
- * @param styleName Name of the style to check
- * @returns True if the style is registered
- */
-declare function hasRegisteredStyle(styleName: string): boolean;
-/**
- * Get the default style name
- *
- * @returns Name of the default style
- */
-declare function getDefaultStyle(): string;
-/**
- * Get all registered style names
- *
- * @returns Array of registered style names
- */
-declare function getRegisteredStyleNames(): string[];
-/**
- * Register a style at runtime
- * Useful for dynamically loading styles
+ * Create and manage form state with proper reactivity
  *
- * @param styleName Name of the style to register
- * @param creators Style creators for the style
- */
-declare function registerStyle(styleName: string, creators: StyleCreators): void;
-
-/**
- * DaisyUI style package
- * Provides all component creators for the DaisyUI style
+ * @param initialData Initial form data
+ * @param options Options for form state
+ * @returns Form state and methods
  */
-
+declare function useFormState<T, CalcType = any, ExtraDataType = any>(initialData: T, options?: {
+    hasFetchData?: boolean;
+    calculationFn?: (data: T, extraData?: ExtraDataType) => CalcType;
+    storeName: string;
+    debug?: boolean;
+    extraData?: ExtraDataType;
+}): {
+    state: FormState<T, CalcType, ExtraDataType>;
+    calculatedValues: ComputedRef<CalcType>;
+    isValid: ComputedRef<boolean>;
+    isDirty: ComputedRef<boolean>;
+    isSubmitting: ComputedRef<boolean>;
+    hasAttemptedSubmit: ComputedRef<boolean>;
+    submitAttemptsCount: ComputedRef<number>;
+    submitError: ComputedRef<string | null>;
+    isReady: ComputedRef<boolean>;
+    isLoading: ComputedRef<boolean>;
+    loadError: ComputedRef<string | null>;
+    reset: (newInitialData?: T) => void;
+    setSubmitting: (value: boolean) => void;
+    incrementSubmitAttempts: () => void;
+    setSubmitError: (error: string | null) => void;
+    setLoading: (value: boolean) => void;
+    setReady: (value: boolean) => void;
+    setLoadError: (error: string | null) => void;
+    updateExtraData: <E = ExtraDataType>(updates: Partial<E>) => void;
+};
 /**
- * Complete set of DaisyUI style creators
- * Can be registered with the Zinia plugin
+ * Result of the useFormState hook
  */
-declare const daisyUIStyle: StyleCreators;
+type FormStateResult<T, CalcType = any, ExtraDataType = any> = ReturnType<typeof useFormState<T, CalcType, ExtraDataType>>;
 
 /**
- * Helper functions for creating and extending render styles
+ * Form validation hook
+ * Provides validation functions for form data
  */
 
 /**
- * Extend an existing style with custom overrides
- *
- * @param baseStyle The base style to extend
- * @param overrides Custom overrides for specific components
- * @returns A new style that combines the base style with the overrides
- */
-declare function extendStyle(baseStyle: StyleCreators, overrides: Partial<StyleCreators>): StyleCreators;
-/**
- * Merge multiple styles together
- * Later styles will override earlier ones for any overlapping components
- *
- * @param styles Array of styles to merge
- * @returns A new style that combines all the provided styles
- */
-declare function mergeStyles(...styles: Array<Partial<StyleCreators>>): StyleCreators;
-/**
- * Create a partial style with only the components you need
- * Useful when you want to override just a few components in a base style
- *
- * @param creators Object containing only the component creators you want to override
- * @returns A partial style object that can be used with extendStyle
- */
-declare function createPartialStyle<T extends Partial<StyleCreators>>(creators: T): T;
-/**
- * Create a style template with placeholder implementations
- * Useful as a starting point for creating a completely new style
+ * Create form validation functions
  *
- * @returns A style object with placeholder implementations that throw errors
+ * @param schema The Zod schema for validation
+ * @param formState The form state to validate
+ * @returns Validation functions
  */
-declare function createStyleTemplate(): StyleCreators;
-
+declare function useFormValidation<T>(schema: z.ZodObject<any>, formState: FormState<T>, options?: {
+    debug?: boolean;
+}): {
+    validate: (options?: {
+        markErrorsAsTouched: boolean;
+    }) => boolean;
+    validateField: (path: string) => boolean;
+};
 /**
- * Common action icons as SVG strings
- * These are Heroicons (heroicons.com) in SVG format for easy use in actions
+ * Result of the useFormValidation hook
  */
-declare const ActionIcons: {
-    readonly edit: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z\" /></svg>";
-    readonly pencil: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M15.232 5.232l3.536 3.536m-2.036-5.036a2.5 2.5 0 113.536 3.536L6.5 21.036H3v-3.572L16.732 3.732z\" /></svg>";
-    readonly delete: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16\" /></svg>";
-    readonly trash: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16\" /></svg>";
-    readonly view: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M15 12a3 3 0 11-6 0 3 3 0 016 0z\" /><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M2.458 12C3.732 7.943 7.523 5 12 5c4.478 0 8.268 2.943 9.542 7-1.274 4.057-5.064 7-9.542 7-4.477 0-8.268-2.943-9.542-7z\" /></svg>";
-    readonly eye: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M15 12a3 3 0 11-6 0 3 3 0 016 0z\" /><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M2.458 12C3.732 7.943 7.523 5 12 5c4.478 0 8.268 2.943 9.542 7-1.274 4.057-5.064 7-9.542 7-4.477 0-8.268-2.943-9.542-7z\" /></svg>";
-    readonly copy: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z\" /></svg>";
-    readonly duplicate: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z\" /></svg>";
-    readonly download: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M12 10v6m0 0l-3-3m3 3l3-3m2 8H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z\" /></svg>";
-    readonly share: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M8.684 13.342C8.886 12.938 9 12.482 9 12c0-.482-.114-.938-.316-1.342m0 2.684a3 3 0 110-2.684m0 2.684l6.632 3.316m-6.632-6l6.632-3.316m0 0a3 3 0 105.367-2.684 3 3 0 00-5.367 2.684zm0 9.316a3 3 0 105.367 2.684 3 3 0 00-5.367-2.684z\" /></svg>";
-    readonly settings: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M10.325 4.317c.426-1.756 2.924-1.756 3.35 0a1.724 1.724 0 002.573 1.066c1.543-.94 3.31.826 2.37 2.37a1.724 1.724 0 001.065 2.572c1.756.426 1.756 2.924 0 3.35a1.724 1.724 0 00-1.066 2.573c.94 1.543-.826 3.31-2.37 2.37a1.724 1.724 0 00-2.572 1.065c-.426 1.756-2.924 1.756-3.35 0a1.724 1.724 0 00-2.573-1.066c-1.543.94-3.31-.826-2.37-2.37a1.724 1.724 0 00-1.065-2.572c-1.756-.426-1.756-2.924 0-3.35a1.724 1.724 0 001.066-2.573c-.94-1.543.826-3.31 2.37-2.37.996.608 2.296.07 2.572-1.065z\" /><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M15 12a3 3 0 11-6 0 3 3 0 016 0z\" /></svg>";
-    readonly plus: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M12 6v6m0 0v6m0-6h6m-6 0H6\" /></svg>";
-    readonly external: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M10 6H6a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2v-4M14 4h6m0 0v6m0-6L10 14\" /></svg>";
-    readonly arrowRight: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M13 7l5 5m0 0l-5 5m5-5H6\" /></svg>";
-    readonly check: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M5 13l4 4L19 7\" /></svg>";
-    readonly checkCircle: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z\" /></svg>";
-    readonly save: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" aria-hidden=\"true\" data-slot=\"icon\" fill=\"none\" class=\"size-6\">\n  <path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M6 20.25h12A2.25 2.25 0 0 0 20.25 18V7.5L16.5 3.75H6A2.25 2.25 0 0 0 3.75 6v12A2.25 2.25 0 0 0 6 20.25zm9.75-16.5v5h-9.5v-5zM13 5.5V7m-6.75 4.25h11.5v6.5H6.25Z\"></path>\n</svg>";
-    readonly spinner: "<svg class=\"animate-spin\" fill=\"none\" viewBox=\"0 0 24 24\"><circle class=\"opacity-25\" cx=\"12\" cy=\"12\" r=\"10\" stroke=\"currentColor\" stroke-width=\"4\"></circle><path class=\"opacity-75\" fill=\"currentColor\" d=\"M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z\"></path></svg>";
-    readonly dots: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M12 5v.01M12 12v.01M12 19v.01M12 6a1 1 0 110-2 1 1 0 010 2zm0 7a1 1 0 110-2 1 1 0 010 2zm0 7a1 1 0 110-2 1 1 0 010 2z\" /></svg>";
-    readonly dotsHorizontal: "<svg fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M5 12h.01M12 12h.01M19 12h.01M6 12a1 1 0 11-2 0 1 1 0 012 0zm7 0a1 1 0 11-2 0 1 1 0 012 0zm7 0a1 1 0 11-2 0 1 1 0 012 0z\" /></svg>";
-};
+type FormValidationResult<T> = ReturnType<typeof useFormValidation<T>>;
 
 /**
  * Debug configuration for Zinia Forms
@@ -2702,4 +3024,4 @@ declare const DEBUG_CONFIG: {
  */
 declare function isDebugEnabled(area: keyof Omit<typeof DEBUG_CONFIG, 'all'>): boolean;
 
-export { ActionIcons, type ActionItem, type ActionsConfig, type ArrayFieldProps, type ArrayFieldSlots, type ButtonActionItem, COMBOBOX_FIELD_PROP_NAMES, type CheckboxFieldProps, type ColumnDefinition, type ComboboxFieldProps, type CurrencyFieldProps, type CursorDataTableOptions, type CursorFetchParams, type CursorFetchResult, DEBUG_CONFIG, type DataTableColumns, type DataTableOptions, type DataTableProps, type DateFieldProps, type DateTimeLocalFieldProps, type DeleteModalProps, type DisplayComponentsType, type DisplayFieldComponent, type DisplayFieldProps, type DisplayProps, type EmailFieldProps, type EnumValueToLabelMap, type EnumValuesFromField, ErrorDisplay, type FetchDataParams, type FetchDataResult, type FieldPathToEnum$1 as FieldPathToEnum, type FieldType, type FileFieldProps, type FilterOptionItem, type FilterValue, type FormErrorsSummaryProps, type FormProps, type LinkActionItem, LoadingDisplay, NoDataDisplay, type NumberFieldProps, type PasswordFieldProps, type RadioFieldProps, type RangeFieldProps, type ResetButtonProps, SCHEMA_ID_SYMBOL, SELECT_FIELD_PROP_NAMES, type SearchFieldProps, type SelectFieldProps, type SelectOption, type SubmitButtonProps, type TelFieldProps, type TextFieldProps, type TextareaFieldProps, type TimeFieldProps, type ToppingsFieldProps, type TransferListFieldProps, type TypedSelectFieldComponent, type UrlFieldProps, type UseCursorDataTableType, type UseDataTableType, type UseDeleteModalType, type UseDisplayType, type UseFormType, type UseFormTyped, type ValueToLabelMapping, ZINIA_DATA_TABLE_ACTIONS_KEY, ZINIA_DATA_TABLE_COLUMNS_KEY, ZINIA_DATA_TABLE_FILTER_INPUTS_KEY, ZINIA_DATA_TABLE_FILTER_OPERATORS_KEY, ZINIA_DATA_TABLE_FILTER_OPTIONS_LOADING_KEY, ZINIA_DATA_TABLE_FILTER_OPTIONS_STATE_KEY, ZINIA_DATA_TABLE_KEY, ZINIA_DATA_TABLE_NAME_KEY, ZINIA_DATA_TABLE_OPTIONS_KEY, ZINIA_DATA_TABLE_SEARCH_INPUT_KEY, ZINIA_DELETE_MODAL_FIELDS_GENERIC_KEY, ZINIA_DELETE_MODAL_FIELDS_KEY, ZINIA_DELETE_MODAL_KEY, ZINIA_DELETE_MODAL_SCHEMA_KEY, ZINIA_DISPLAY_FIELDS_GENERIC_KEY, ZINIA_DISPLAY_FIELDS_KEY, ZINIA_DISPLAY_KEY, ZINIA_DISPLAY_SCHEMA_KEY, ZINIA_FIELDS_GENERIC_KEY, ZINIA_FIELDS_KEY, ZINIA_FORM_KEY, ZINIA_FORM_SCHEMA_KEY, type ZiniaDataTable, type ZiniaDeleteModal, type ZiniaDeleteModalFields, type ZiniaDeleteModalGenericFields, type ZiniaDisplay, type ZiniaDisplayFields, type ZiniaDisplayGenericFields, type ZiniaForm, type ZiniaFormFields, type ZiniaFormGenericFields, ZiniaPlugin, type ZiniaPluginOptions, type ZodEnumValues, clearAllMetadata, clearSchemaMetadata, createBaseComponents, createBaseDisplayComponents, createPartialStyle, createStyleTemplate, createTypedArrayField, createTypedComboboxField, createTypedSelectField, daisyUIStyle, extendStyle, generateDisplayComponents, generateFieldComponents, getAllSchemaMetadata, getDefaultStyle, getFieldMetadata, getRegisteredStyle, getRegisteredStyleNames, getSchemaId, hasRegisteredStyle, hasSchemaMetadata, isDebugEnabled, mergeStyles, registerSchemaMetadata, registerStyle, setSchemaMetadata, useCursorDataTable, useDataTable, useDeleteModal, useDisplay, useForm, withMetadata };
+export { ActionIcons, type ActionItem, type ActionsConfig, type ArrayFieldProps, type ArrayFieldSlots, type ArrayItemType, type AsyncCascadingSelectsConfig, type AutoPopulateConfigs, type ButtonActionItem, COMBOBOX_FIELD_PROP_NAMES, type CheckboxFieldProps, type ColumnDefinition, type ComboboxFieldProps, type ComponentsType, type CurrencyFieldProps, type CursorDataTableOptions, type CursorFetchParams, type CursorFetchResult, DEBUG_CONFIG, type DataTableColumns, type DataTableOptions, type DataTableProps, type DataType, type DateFieldProps, type DateTimeLocalFieldProps, type DeleteModalProps, type DisplayComponentsType, type DisplayFieldComponent, type DisplayFieldProps, type DisplayProps, type EmailFieldProps, type EnumValueToLabelMap, type EnumValuesFromField, ErrorDisplay, type ExtractEnumType, type FetchDataParams, type FetchDataResult, type FieldMetadata$1 as FieldMetadata, type FieldNames, type FieldPathToEnum, type FieldRegistry, type FieldType, type FileFieldProps, type FilterConfiguration, type FilterOptionItem, type FilterValue, type FilterValueObject, type FormErrorsSummaryProps, type FormProps, type FormState, type FormStateResult, type FormValidationResult, type LinkActionItem, LoadingDisplay, type MergeOptions, type MetadataRegistry, NoDataDisplay, type NumberFieldProps, type Operator, type PasswordFieldProps, type Path, type PathToPascalCase, type PathValue, type PathsOf, type RadioFieldProps, type RangeFieldProps, type RenderStyle, type ResetButtonProps, SCHEMA_ID_SYMBOL, SELECT_FIELD_PROP_NAMES, type SchemaFieldMetadata, type SearchFieldProps, type SelectFieldProps, type SelectOption, type StyleCreators, type SubmitButtonProps, type TelFieldProps, type TextFieldProps, type TextareaFieldProps, type TimeFieldProps, type ToppingsFieldProps, type TransferListFieldProps, type TypedSelectFieldComponent, type UrlFieldProps, type UseCursorDataTableType, type UseDataTableType, type UseDeleteModalType, type UseDisplayType, type UseFormType, type UseFormTyped, type ValidationError, type ValidationResult, type ValueToLabelMapping, ZINIA_DATA_TABLE_ACTIONS_KEY, ZINIA_DATA_TABLE_COLUMNS_KEY, ZINIA_DATA_TABLE_FILTER_CASE_SENSITIVE_KEY, ZINIA_DATA_TABLE_FILTER_INPUTS_KEY, ZINIA_DATA_TABLE_FILTER_OPERATORS_KEY, ZINIA_DATA_TABLE_FILTER_OPTIONS_LOADING_KEY, ZINIA_DATA_TABLE_FILTER_OPTIONS_STATE_KEY, ZINIA_DATA_TABLE_KEY, ZINIA_DATA_TABLE_NAME_KEY, ZINIA_DATA_TABLE_OPTIONS_KEY, ZINIA_DATA_TABLE_SEARCH_INPUT_KEY, ZINIA_DELETE_MODAL_FIELDS_GENERIC_KEY, ZINIA_DELETE_MODAL_FIELDS_KEY, ZINIA_DELETE_MODAL_KEY, ZINIA_DELETE_MODAL_SCHEMA_KEY, ZINIA_DISPLAY_FIELDS_GENERIC_KEY, ZINIA_DISPLAY_FIELDS_KEY, ZINIA_DISPLAY_KEY, ZINIA_DISPLAY_SCHEMA_KEY, ZINIA_FIELDS_GENERIC_KEY, ZINIA_FIELDS_KEY, ZINIA_FORM_KEY, ZINIA_FORM_SCHEMA_KEY, type ZiniaDataTable, type ZiniaDeleteModal, type ZiniaDeleteModalFields, type ZiniaDeleteModalGenericFields, type ZiniaDisplay, type ZiniaDisplayFields, type ZiniaDisplayGenericFields, type ZiniaForm, type ZiniaFormFields, type ZiniaFormGenericFields, ZiniaPlugin, type ZiniaPluginOptions, type ZodEnumValues, buildFieldRegistryFromSchema, clearAllMetadata, clearSchemaMetadata, createBaseComponents, createBaseDisplayComponents, createPartialStyle, createStyleTemplate, createTypedArrayField, createTypedComboboxField, createTypedSelectField, daisyUIStyle, deserializeFiltersFromQueryString, extendStyle, generateDisplayComponents, generateFieldComponents, getAllSchemaMetadata, getDefaultStyle, getFieldMetadata, getRegisteredStyle, getRegisteredStyleNames, getSchemaId, hasRegisteredStyle, hasSchemaMetadata, isDebugEnabled, isValidOperatorForType, mergeStyles, registerSchemaMetadata, registerStyle, serializeFiltersToQueryString, setSchemaMetadata, useCursorDataTable, useDataTable, useDataTableUrlSync, useDeleteModal, useDisplay, useForm, validateFieldRegistry, validateFilterConfiguration, withMetadata };