rhf-dynamic-forms 1.1.0

package/dist/index.d.mts

@@ -0,0 +1,1124 @@
+import * as react0 from "react";
+import React$1, { CSSProperties, ReactNode } from "react";
+import { ControllerFieldState, ControllerRenderProps, FieldErrors, FieldPath, FieldValues, Resolver, UseFormReturn } from "react-hook-form";
+import { ZodObject, ZodRawShape, ZodTypeAny, z } from "zod";
+
+//#region src/types/validation.d.ts
+/**
+ * JSON Logic rule type - a generic record for JSON Logic expressions.
+ * Used for visibility and validation conditions.
+ */
+type JsonLogicRule = Record<string, unknown>;
+/**
+ * Validation configuration for form fields.
+ * Phase 1 supports: required, minLength, maxLength, pattern
+ * Phase 3 will add: condition (JSON Logic)
+ */
+interface ValidationConfig {
+  /** Field is required - must have a non-empty value */
+  required?: boolean;
+  /** Type-specific validation (for future use) */
+  type?: "number" | "email" | "date";
+  /** Minimum length for text fields */
+  minLength?: number;
+  /** Maximum length for text fields */
+  maxLength?: number;
+  /** Regular expression pattern for validation */
+  pattern?: string;
+  /** Custom error message for pattern/condition failure */
+  message?: string;
+  /** JSON Logic condition for complex validation (Phase 3) */
+  condition?: JsonLogicRule;
+}
+/**
+ * Controls validation behavior for invisible fields.
+ * - 'skip': Do not validate invisible fields (default)
+ * - 'validate': Validate all fields regardless of visibility
+ * - 'warn': Validate but treat errors as warnings (non-blocking)
+ */
+type InvisibleFieldValidation = "skip" | "validate" | "warn";
+//#endregion
+//#region src/types/elements.d.ts
+/**
+ * All supported element types in the form configuration.
+ * Phase 1: text, email, boolean, phone, date, custom
+ * Phase 2 adds: container, column
+ * Phase 3 adds: select, array
+ */
+type ElementType = "text" | "email" | "boolean" | "phone" | "date" | "select" | "array" | "container" | "column" | "custom";
+/**
+ * Field types that render input controls.
+ */
+type FieldType = "text" | "email" | "boolean" | "phone" | "date" | "select" | "array";
+/**
+ * Base interface for all field elements.
+ */
+interface BaseFieldElement {
+  type: ElementType;
+  /** Unique identifier for form data binding (supports dot notation like 'source.name') */
+  name: string;
+  /** Display label for the field */
+  label?: string;
+  /** Placeholder text (for text-based inputs) */
+  placeholder?: string;
+  /** Default value for the field (arrays for multi-select, records for complex fields) */
+  defaultValue?: string | number | boolean | null | unknown[] | Record<string, unknown>;
+  /** Validation configuration */
+  validation?: ValidationConfig;
+  /** Conditional visibility rules using JSON Logic (Phase 4) */
+  visible?: JsonLogicRule;
+  /** Field path this field depends on (for cascading selects, etc.) */
+  dependsOn?: string;
+  /** Reset this field when parent changes (default: true) */
+  resetOnParentChange?: boolean;
+}
+/**
+ * Text input field element.
+ */
+interface TextFieldElement extends BaseFieldElement {
+  type: "text";
+}
+/**
+ * Email input field element.
+ */
+interface EmailFieldElement extends BaseFieldElement {
+  type: "email";
+}
+/**
+ * Boolean (checkbox/toggle) field element.
+ */
+interface BooleanFieldElement extends BaseFieldElement {
+  type: "boolean";
+}
+/**
+ * Phone number input field element.
+ */
+interface PhoneFieldElement extends BaseFieldElement {
+  type: "phone";
+}
+/**
+ * Date picker field element.
+ */
+interface DateFieldElement extends BaseFieldElement {
+  type: "date";
+}
+/**
+ * Option for select field elements.
+ */
+interface SelectOption {
+  /** Option value (stored in form data) */
+  value: string | number;
+  /** Display label */
+  label: string;
+  /** Disable this option */
+  disabled?: boolean;
+}
+/**
+ * Static options source - use config.options directly.
+ */
+interface StaticOptionsSource {
+  type: "static";
+}
+/**
+ * Map options source - lookup from provided options map.
+ */
+interface MapOptionsSource {
+  type: "map";
+  /** Key in the options map */
+  key: string;
+}
+/**
+ * API options source - fetch from endpoint.
+ */
+interface ApiOptionsSource {
+  type: "api";
+  /** API endpoint URL */
+  endpoint: string;
+}
+/**
+ * Search options source - search as you type.
+ */
+interface SearchOptionsSource {
+  type: "search";
+  /** API endpoint for search */
+  endpoint: string;
+  /** Minimum characters before searching (default: 2) */
+  minChars?: number;
+}
+/**
+ * Resolver options source - custom resolver function.
+ */
+interface ResolverOptionsSource {
+  type: "resolver";
+  /** Name of the registered resolver */
+  name: string;
+}
+/**
+ * Describes how to resolve options for a select field.
+ * This is declarative - describes intent, not implementation.
+ * Actual data fetching is done by field component.
+ */
+type OptionsSource = StaticOptionsSource | MapOptionsSource | ApiOptionsSource | SearchOptionsSource | ResolverOptionsSource;
+/**
+ * Select field element for dropdowns and multi-selects.
+ */
+interface SelectFieldElement extends BaseFieldElement {
+  type: "select";
+  /** Available options (required when optionsSource is not provided) */
+  options?: SelectOption[];
+  /** Describes how to resolve options (when provided, options become optional) */
+  optionsSource?: OptionsSource;
+  /** Allow selecting multiple values (default: false) */
+  multiple?: boolean;
+  /** Allow clearing selection (default: true) */
+  clearable?: boolean;
+  /** Allow searching/filtering options (default: false) */
+  searchable?: boolean;
+  /** Allow creating new options not in the list (default: false) */
+  creatable?: boolean;
+}
+/**
+ * Custom component field element.
+ * Allows rendering user-defined components.
+ */
+interface CustomFieldElement extends BaseFieldElement {
+  type: "custom";
+  /** Name of the registered custom component */
+  component: string;
+  /** Props to pass to the custom component */
+  componentProps?: Record<string, unknown>;
+}
+/**
+ * Array/repeater field element.
+ * Contains repeatable group of fields.
+ */
+interface ArrayFieldElement extends BaseFieldElement {
+  type: "array";
+  /** Fields template for each item (can contain any field type) */
+  itemFields: FieldElement[];
+  /** Minimum items required */
+  minItems?: number;
+  /** Maximum items allowed */
+  maxItems?: number;
+  /** Label for add button */
+  addButtonLabel?: string;
+  /** Allow reordering items */
+  sortable?: boolean;
+}
+/**
+ * Container element for grouping fields in columns (Phase 2).
+ */
+interface ContainerElement {
+  type: "container";
+  /** Array of column elements */
+  columns: ColumnElement[];
+  /** Conditional visibility rules using JSON Logic */
+  visible?: JsonLogicRule;
+}
+/**
+ * Column element within a container (Phase 2).
+ */
+interface ColumnElement {
+  type: "column";
+  /** Column width (e.g., '50%', '200px') */
+  width: string;
+  /** Nested elements within the column */
+  elements: FormElement[];
+  /** Conditional visibility rules using JSON Logic */
+  visible?: JsonLogicRule;
+}
+/**
+ * Union of all field element types.
+ */
+type FieldElement = TextFieldElement | EmailFieldElement | BooleanFieldElement | PhoneFieldElement | DateFieldElement | SelectFieldElement | ArrayFieldElement | CustomFieldElement;
+/**
+ * Union of all layout element types.
+ */
+type LayoutElement = ContainerElement | ColumnElement;
+/**
+ * Union of all form element types.
+ */
+type FormElement = FieldElement | LayoutElement;
+/**
+ * Type guard to check if an element is a field element.
+ */
+declare const isFieldElement: (element: FormElement) => element is FieldElement;
+/**
+ * Type guard to check if an element is an array field element.
+ */
+declare const isArrayFieldElement: (element: FormElement) => element is ArrayFieldElement;
+/**
+ * Type guard to check if an element is a container element.
+ */
+declare const isContainerElement: (element: FormElement) => element is ContainerElement;
+/**
+ * Type guard to check if an element is a column element.
+ */
+declare const isColumnElement: (element: FormElement) => element is ColumnElement;
+/**
+ * Type guard to check if an element is a custom field element.
+ */
+declare const isCustomFieldElement: (element: FormElement) => element is CustomFieldElement;
+//#endregion
+//#region src/types/events.d.ts
+/**
+ * Form data type - a generic record for form values.
+ * Values are nested according to dot-notation field names.
+ *
+ * @example
+ * ```typescript
+ * // For field name "source.name", data will be:
+ * { source: { name: "John" } }
+ * ```
+ */
+type FormData = Record<string, unknown>;
+/**
+ * Handler called when form is submitted with valid data.
+ */
+type OnSubmitHandler = (data: FormData) => void | Promise<void>;
+/**
+ * Handler called when form values change.
+ *
+ * @param data - Current form data
+ * @param changedField - The name of the field that changed
+ */
+type OnChangeHandler = (data: FormData, changedField: string) => void;
+/**
+ * Handler called when validation state changes.
+ *
+ * @param errors - Current validation errors
+ * @param isValid - Whether the form is currently valid
+ */
+type OnValidationChangeHandler = (errors: FieldErrors, isValid: boolean) => void;
+/**
+ * Handler called when form is reset.
+ */
+type OnResetHandler = () => void;
+/**
+ * Handler called on form submission errors.
+ *
+ * @param errors - Validation errors that prevented submission
+ */
+type OnErrorHandler = (errors: FieldErrors) => void;
+//#endregion
+//#region src/customComponents/types.d.ts
+interface CustomComponentRenderProps<TProps extends Record<string, unknown> = Record<string, unknown>> {
+  field: ControllerRenderProps;
+  fieldState: ControllerFieldState;
+  config: CustomFieldElement;
+  componentProps: TProps;
+  formValues: FormData;
+  setValue: (name: string, value: unknown) => void;
+}
+interface CustomComponentDefinition<TProps extends Record<string, unknown> = Record<string, unknown>> {
+  component: React.ComponentType<CustomComponentRenderProps<TProps>>;
+  propsSchema?: ZodObject<ZodRawShape>;
+  defaultProps?: Partial<TProps>;
+  description?: string;
+  displayName?: string;
+}
+type CustomComponentRegistry = Record<string, CustomComponentDefinition<any> | React.ComponentType<any>>;
+//#endregion
+//#region src/customComponents/defineCustomComponent.d.ts
+/**
+ * Type-safe helper for defining custom components.
+ * Provides TypeScript inference for component props based on propsSchema.
+ *
+ * @example
+ * ```ts
+ * const RatingField = defineCustomComponent({
+ *   component: RatingFieldComponent,
+ *   propsSchema: z.object({ maxStars: z.number() }),
+ *   defaultProps: { maxStars: 5 },
+ * });
+ * ```
+ */
+declare function defineCustomComponent<TProps extends Record<string, unknown> = Record<string, unknown>>(definition: CustomComponentDefinition<TProps>): CustomComponentDefinition<TProps>;
+//#endregion
+//#region src/types/fields.d.ts
+/**
+ * Base props passed to all field components.
+ * Field components receive react-hook-form controller props.
+ *
+ * @example
+ * ```tsx
+ * const MyTextField: TextFieldComponent = ({ field, fieldState, config, formValues }) => (
+ *   <div>
+ *     <label>{config.label}</label>
+ *     <input {...field} />
+ *     {fieldState.error && <span>{fieldState.error.message}</span>}
+ *   </div>
+ * );
+ * ```
+ */
+interface BaseFieldProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TConfig extends BaseFieldElement = BaseFieldElement> {
+  /** react-hook-form field props (value, onChange, onBlur, name, ref) */
+  field: ControllerRenderProps<TFieldValues, TName>;
+  /** react-hook-form field state (invalid, isTouched, isDirty, error) */
+  fieldState: ControllerFieldState;
+  /** Field configuration from form config */
+  config: TConfig;
+  /** All current form values (for reading other fields, dependent logic) */
+  formValues: FormData;
+  /** Set any field value (for dependent field logic, cascading updates) */
+  setValue: (name: string, value: unknown) => void;
+}
+/**
+ * Props for text input field component.
+ */
+type TextFieldProps = BaseFieldProps<FieldValues, FieldPath<FieldValues>, TextFieldElement>;
+/**
+ * Props for email input field component.
+ */
+type EmailFieldProps = BaseFieldProps<FieldValues, FieldPath<FieldValues>, EmailFieldElement>;
+/**
+ * Props for boolean (checkbox/toggle) field component.
+ */
+type BooleanFieldProps = BaseFieldProps<FieldValues, FieldPath<FieldValues>, BooleanFieldElement>;
+/**
+ * Props for phone input field component.
+ */
+type PhoneFieldProps = BaseFieldProps<FieldValues, FieldPath<FieldValues>, PhoneFieldElement>;
+/**
+ * Props for date input field component.
+ */
+type DateFieldProps = BaseFieldProps<FieldValues, FieldPath<FieldValues>, DateFieldElement>;
+/**
+ * Props for select field component.
+ */
+type SelectFieldProps = BaseFieldProps<FieldValues, FieldPath<FieldValues>, SelectFieldElement>;
+/**
+ * Props for array field component.
+ */
+type ArrayFieldProps = BaseFieldProps<FieldValues, FieldPath<FieldValues>, ArrayFieldElement>;
+/**
+ * Props for custom field components.
+ * Custom components receive additional componentProps from configuration.
+ */
+type CustomFieldProps = BaseFieldProps<FieldValues, FieldPath<FieldValues>, CustomFieldElement>;
+/**
+ * Base component type that accepts any field configuration.
+ * Used internally for dynamic field rendering where the specific
+ * field type is determined at runtime.
+ */
+type BaseFieldComponent<TProps extends BaseFieldProps = BaseFieldProps> = React.ComponentType<TProps>;
+/**
+ * Component type for text fields.
+ */
+type TextFieldComponent = BaseFieldComponent<TextFieldProps>;
+/**
+ * Component type for email fields.
+ */
+type EmailFieldComponent = BaseFieldComponent<EmailFieldProps>;
+/**
+ * Component type for boolean fields.
+ */
+type BooleanFieldComponent = BaseFieldComponent<BooleanFieldProps>;
+/**
+ * Component type for phone fields.
+ */
+type PhoneFieldComponent = BaseFieldComponent<PhoneFieldProps>;
+/**
+ * Component type for date fields.
+ */
+type DateFieldComponent = BaseFieldComponent<DateFieldProps>;
+/**
+ * Component type for select fields.
+ */
+type SelectFieldComponent = BaseFieldComponent<SelectFieldProps>;
+/**
+ * Component type for array fields.
+ */
+type ArrayFieldComponent = BaseFieldComponent<ArrayFieldProps>;
+/**
+ * Component type for custom fields.
+ */
+type CustomFieldComponent = BaseFieldComponent<CustomFieldProps>;
+type StandardFieldComponent = TextFieldComponent | EmailFieldComponent | BooleanFieldComponent | PhoneFieldComponent | DateFieldComponent | SelectFieldComponent | ArrayFieldComponent;
+type StandardFieldComponentType = Exclude<ElementType, "custom">;
+interface FieldComponentRegistry extends Partial<Record<StandardFieldComponentType, StandardFieldComponent>> {
+  text: TextFieldComponent;
+  email: EmailFieldComponent;
+  boolean: BooleanFieldComponent;
+  phone: PhoneFieldComponent;
+  date: DateFieldComponent;
+  select: SelectFieldComponent;
+  array: ArrayFieldComponent;
+}
+/**
+ * Union type for all field props.
+ */
+type FieldProps = TextFieldProps | EmailFieldProps | BooleanFieldProps | PhoneFieldProps | DateFieldProps | SelectFieldProps | ArrayFieldProps | CustomFieldProps;
+/**
+ * Props for container components.
+ * Containers wrap columns and provide layout structure.
+ */
+interface ContainerProps {
+  /** Container configuration from form config */
+  config: ContainerElement;
+  /** Column elements rendered as children */
+  children: React.ReactNode;
+}
+/**
+ * Props for column components.
+ * Columns wrap form elements and apply width styling.
+ */
+interface ColumnProps {
+  /** Column configuration from form config */
+  config: ColumnElement;
+  /** Form elements rendered as children */
+  children: React.ReactNode;
+}
+/**
+ * Component type for container layouts.
+ */
+type ContainerComponent = React.ComponentType<ContainerProps>;
+/**
+ * Component type for column layouts.
+ */
+type ColumnComponent = React.ComponentType<ColumnProps>;
+/**
+ * Registry for custom container components referenced by name.
+ * Allows users to provide custom container implementations.
+ *
+ * @example
+ * ```tsx
+ * const customContainers: CustomContainerRegistry = {
+ *   card: CardContainer,
+ *   section: SectionContainer,
+ * };
+ * ```
+ */
+type CustomContainerRegistry = Record<string, ContainerComponent>;
+//#endregion
+//#region src/types/config.d.ts
+/**
+ * Props passed to the fieldWrapper function.
+ * Contains field metadata for custom wrapper implementations.
+ */
+interface FieldWrapperProps {
+  /** Field path (e.g., "contact.email") */
+  name: string;
+  /** Raw field configuration from form config */
+  config: FieldElement;
+  /** react-hook-form field state (error, isDirty, isTouched, invalid) */
+  fieldState: ControllerFieldState;
+  /** Current field value */
+  value: unknown;
+  /** All current form values (for reading other fields) */
+  formValues: FormData;
+  /** Set any field value (for dependent field logic) */
+  setValue: (name: string, value: unknown) => void;
+}
+/**
+ * Function type for wrapping field components.
+ * Receives field metadata and the rendered field element.
+ *
+ * @example
+ * ```tsx
+ * const myFieldWrapper: FieldWrapperFunction = (props, children) => (
+ *   <div className="field-wrapper">
+ *     <Badge>{props.name}</Badge>
+ *     {children}
+ *   </div>
+ * );
+ * ```
+ */
+type FieldWrapperFunction = (props: FieldWrapperProps, children: ReactNode) => ReactNode;
+/**
+ * Root form configuration object.
+ * This is the JSON structure that defines the entire form.
+ *
+ * @example
+ * ```json
+ * {
+ *   "name": "Contact Form",
+ *   "elements": [
+ *     { "type": "text", "name": "source.name", "label": "Name" },
+ *     { "type": "email", "name": "source.email", "label": "Email" }
+ *   ]
+ * }
+ * ```
+ */
+interface FormConfiguration {
+  /** Optional name/identifier for the form */
+  name?: string;
+  /** Array of form elements (fields and layouts) */
+  elements: FormElement[];
+  /** Custom component definitions (for advanced use) */
+  customComponents?: Record<string, CustomComponentDefinition>;
+}
+/**
+ * Props for the DynamicForm component.
+ *
+ * @example
+ * ```tsx
+ * <DynamicForm
+ *   config={formConfig}
+ *   fieldComponents={myFieldComponents}
+ *   onSubmit={(data) => console.log(data)}
+ *   onChange={(data, field) => console.log(`${field} changed`)}
+ * />
+ * ```
+ */
+interface DynamicFormProps {
+  /** Form configuration - defines structure, fields, and validation */
+  config: FormConfiguration;
+  /** Initial form data to populate fields */
+  initialData?: FormData;
+  /** Required: Field component implementations for each field type */
+  fieldComponents: FieldComponentRegistry;
+  /** Optional: Custom field components referenced by name in config */
+  customComponents?: CustomComponentRegistry;
+  /** Optional: Custom container components for layout customization (Phase 2) */
+  customContainers?: CustomContainerRegistry;
+  /** Called on successful form submission with valid data */
+  onSubmit: OnSubmitHandler;
+  /** Called when any field value changes */
+  onChange?: OnChangeHandler;
+  /** Called when validation state changes */
+  onValidationChange?: OnValidationChangeHandler;
+  /** Called when form is reset */
+  onReset?: OnResetHandler;
+  /** Called on submission errors (validation failures) */
+  onError?: OnErrorHandler;
+  /**
+       * Validation mode for react-hook-form.
+       * - 'onChange': Validate on every change (default)
+       * - 'onBlur': Validate on blur
+       * - 'onSubmit': Only validate on submit
+       * - 'onTouched': Validate on blur, then on every change
+       * - 'all': Validate on blur and change
+       */
+  mode?: "onChange" | "onBlur" | "onSubmit" | "onTouched" | "all";
+  /**
+       * Controls validation behavior for invisible fields.
+       * Only applies when using `schema` prop (not custom `resolver`).
+       * - 'skip': Do not validate invisible fields (default)
+       * - 'validate': Validate all fields regardless of visibility
+       * - 'warn': Validate but treat errors as warnings (non-blocking)
+       */
+  invisibleFieldValidation?: InvisibleFieldValidation;
+  /** CSS class name for the form element */
+  className?: string;
+  /** Inline styles for the form element */
+  style?: CSSProperties;
+  /** HTML id attribute for the form element */
+  id?: string;
+  /** Content to render after all form fields (e.g., submit button) */
+  children?: React.ReactNode;
+  /**
+       * Optional wrapper function for each field.
+       * Receives field metadata and children, returns wrapped element.
+       * Use this for adding confidence indicators, status badges, edit tracking, etc.
+       *
+       * @example
+       * ```tsx
+       * <DynamicForm
+       *   fieldWrapper={(props, children) => (
+       *     <div className="field-wrapper">
+       *       <Badge>{props.config.label}</Badge>
+       *       {children}
+       *     </div>
+       *   )}
+       * />
+       * ```
+       */
+  fieldWrapper?: FieldWrapperFunction;
+}
+/**
+ * Ref interface for external form control.
+ * Access form methods from outside the component.
+ *
+ * @example
+ * ```tsx
+ * const formRef = useRef<DynamicFormRef>(null);
+ *
+ * // Reset city when country changes externally
+ * const handleCountryChange = (country: string) => {
+ *   formRef.current?.setValue('country', country);
+ *   formRef.current?.setValue('city', null);
+ * };
+ *
+ * <DynamicForm ref={formRef} ... />
+ * ```
+ */
+interface DynamicFormRef {
+  /** Get all form values */
+  getValues: () => FormData;
+  /** Set a specific field value */
+  setValue: (name: string, value: unknown) => void;
+  /** Watch all form values reactively */
+  watchAll: () => FormData;
+  /** Watch a specific field value reactively */
+  watchField: (name: string) => unknown;
+  /** Reset form to initial values or provided values */
+  reset: (values?: FormData) => void;
+  /** Trigger validation for a specific field or all fields */
+  trigger: (name?: string) => Promise<boolean>;
+}
+//#endregion
+//#region src/context/DynamicFormContext.d.ts
+/**
+ * Value provided by the DynamicFormContext.
+ * Contains everything needed by child components to render and interact with the form.
+ */
+interface DynamicFormContextValue {
+  /**
+       * react-hook-form methods.
+       * Provides access to form state, validation, and control.
+       */
+  form: UseFormReturn<FormData>;
+  /**
+       * Parsed and validated form configuration.
+       */
+  config: FormConfiguration;
+  /**
+       * Registered field components for each field type.
+       * These are provided by the consuming application.
+       */
+  fieldComponents: FieldComponentRegistry;
+  /**
+       * Registered custom components.
+       * These are referenced by name in 'custom' type elements.
+       */
+  customComponents: CustomComponentRegistry;
+  /**
+       * Registered custom container components (Phase 2).
+       * These can be used to customize container layout rendering.
+       */
+  customContainers: CustomContainerRegistry;
+  /**
+       * Current visibility state for all fields (Phase 4).
+       * Maps field names to their visibility (true = visible).
+       * For Phase 1, all fields are always visible.
+       */
+  visibility: Record<string, boolean>;
+  /**
+       * Optional wrapper function for each field.
+       * When provided, every field is wrapped with this function.
+       */
+  fieldWrapper?: FieldWrapperFunction;
+}
+/**
+ * Context for sharing form state and configuration with child components.
+ *
+ * This context is set up by the DynamicForm component and consumed by
+ * field renderers and other internal components.
+ */
+declare const DynamicFormContext: react0.Context<DynamicFormContextValue | null>;
+//#endregion
+//#region src/DynamicForm.d.ts
+interface DynamicFormPropsWithRef extends DynamicFormProps {
+  ref?: React$1.Ref<DynamicFormRef>;
+}
+declare const DynamicForm: {
+  ({
+    config,
+    initialData,
+    fieldComponents,
+    customComponents,
+    customContainers,
+    onSubmit,
+    onChange,
+    onValidationChange,
+    onReset,
+    onError,
+    mode,
+    invisibleFieldValidation,
+    className,
+    style,
+    id,
+    children,
+    fieldWrapper,
+    ref
+  }: DynamicFormPropsWithRef): React$1.ReactElement;
+  displayName: string;
+};
+//#endregion
+//#region src/hooks/useDynamicFormContext.d.ts
+/**
+ * Hook to access the DynamicForm context.
+ *
+ * Must be used within a DynamicForm component.
+ * Throws an error if used outside of the form context.
+ *
+ * @returns The DynamicFormContext value
+ * @throws Error if used outside of DynamicForm
+ *
+ * @example
+ * ```tsx
+ * function MyCustomField({ config }) {
+ *   const { form, fieldComponents } = useDynamicFormContext();
+ *
+ *   const value = form.watch(config.name);
+ *   // ... render field
+ * }
+ * ```
+ */
+declare const useDynamicFormContext: () => DynamicFormContextValue;
+/**
+ * Hook to safely access the DynamicForm context.
+ * Returns null if used outside of the form context instead of throwing.
+ *
+ * @returns The DynamicFormContext value or null
+ *
+ * @example
+ * ```tsx
+ * function MaybeInForm() {
+ *   const context = useDynamicFormContextSafe();
+ *
+ *   if (!context) {
+ *     return <span>Not in a form</span>;
+ *   }
+ *
+ *   return <span>In a form!</span>;
+ * }
+ * ```
+ */
+declare const useDynamicFormContextSafe: () => DynamicFormContextValue | null;
+//#endregion
+//#region src/parser/configParser.d.ts
+/**
+ * Error thrown when configuration parsing fails.
+ */
+declare class ConfigurationError extends Error {
+  /** The original validation errors */
+  readonly errors: unknown[];
+  constructor(message: string, errors: unknown[]);
+}
+/**
+ * Result of parsing a configuration.
+ */
+interface ParseResult {
+  success: boolean;
+  config?: FormConfiguration;
+  errors?: string[];
+}
+/**
+ * Parses and validates a form configuration.
+ *
+ * @param config - Raw configuration object (typically from JSON)
+ * @returns Validated FormConfiguration
+ * @throws ConfigurationError if validation fails
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const config = parseConfiguration({
+ *     elements: [
+ *       { type: 'text', name: 'name', label: 'Name' }
+ *     ]
+ *   });
+ *   // config is now typed as FormConfiguration
+ * } catch (error) {
+ *   if (error instanceof ConfigurationError) {
+ *     console.error('Invalid configuration:', error.errors);
+ *   }
+ * }
+ * ```
+ */
+declare const parseConfiguration: (config: unknown) => FormConfiguration;
+/**
+ * Safely parses and validates a form configuration without throwing.
+ *
+ * @param config - Raw configuration object
+ * @returns ParseResult with success status and config or errors
+ *
+ * @example
+ * ```typescript
+ * const result = safeParseConfiguration(rawConfig);
+ * if (result.success) {
+ *   // result.config is available
+ *   renderForm(result.config);
+ * } else {
+ *   // result.errors contains validation messages
+ *   showErrors(result.errors);
+ * }
+ * ```
+ */
+declare const safeParseConfiguration: (config: unknown) => ParseResult;
+//#endregion
+//#region src/resolver/visibilityAwareResolver.d.ts
+/**
+ * Options for creating a visibility-aware resolver.
+ */
+interface VisibilityAwareResolverOptions<T extends ZodRawShape> {
+  /** Zod schema for validation */
+  schema: ZodObject<T>;
+  /** Function that returns current visibility state for all fields */
+  getVisibility: () => Record<string, boolean>;
+  /** How to handle validation for invisible fields */
+  invisibleFieldValidation: InvisibleFieldValidation;
+}
+/**
+ * Creates a resolver that respects field visibility.
+ *
+ * This resolver wraps the standard zodResolver and filters validation
+ * errors based on field visibility. This is useful when fields are
+ * conditionally shown/hidden and you want to skip validation for
+ * hidden fields.
+ *
+ * @param options - Configuration for the resolver
+ * @returns A react-hook-form resolver
+ *
+ * @example
+ * ```typescript
+ * const resolver = createVisibilityAwareResolver({
+ *   schema: myZodSchema,
+ *   getVisibility: () => ({ name: true, phone: false }),
+ *   invisibleFieldValidation: "skip",
+ * });
+ *
+ * const form = useForm({ resolver });
+ * ```
+ */
+declare const createVisibilityAwareResolver: <T extends ZodRawShape>(options: VisibilityAwareResolverOptions<T>) => Resolver<FieldValues>;
+//#endregion
+//#region src/schema/fieldSchemas.d.ts
+/**
+ * Build a complete Zod schema for a single field.
+ *
+ * @param field - Field element configuration
+ * @returns Zod schema for the field
+ *
+ * @example
+ * ```typescript
+ * const textField = {
+ *   type: 'text',
+ *   name: 'name',
+ *   validation: { required: true, minLength: 3 }
+ * };
+ *
+ * const schema = buildFieldSchema(textField);
+ * // schema is z.string().min(1, 'required').min(3, '...')
+ * ```
+ */
+declare const buildFieldSchema: (field: FieldElement) => ZodTypeAny;
+//#endregion
+//#region src/schema/generateSchema.d.ts
+/**
+ * Generated schema type - a Zod object schema.
+ */
+type GeneratedSchema = ZodObject<Record<string, ZodTypeAny>>;
+/**
+ * Generate a Zod schema from form configuration.
+ * Supports nested field paths via dot notation.
+ *
+ * This function is called once when the form initializes and the schema
+ * is memoized. Visibility changes are handled at validation time, not
+ * by regenerating the schema.
+ *
+ * @param config - Form configuration object
+ * @returns Zod object schema for validating form data
+ *
+ * @example
+ * ```typescript
+ * const config = {
+ *   elements: [
+ *     { type: 'text', name: 'source.name', validation: { required: true } },
+ *     { type: 'email', name: 'source.email' },
+ *     { type: 'boolean', name: 'active' }
+ *   ]
+ * };
+ *
+ * const schema = generateZodSchema(config);
+ *
+ * // The generated schema is equivalent to:
+ * // z.object({
+ * //   source: z.object({
+ * //     name: z.string().min(1, 'required'),
+ * //     email: z.string().email()
+ * //   }),
+ * //   active: z.boolean()
+ * // })
+ *
+ * schema.parse({
+ *   source: { name: 'John', email: 'john@example.com' },
+ *   active: true
+ * }); // Valid
+ * ```
+ */
+declare const generateZodSchema: (config: FormConfiguration) => GeneratedSchema;
+/**
+ * Infer the TypeScript type from a generated schema.
+ * Useful for typing form data in the consuming application.
+ *
+ * @example
+ * ```typescript
+ * const schema = generateZodSchema(config);
+ * type FormData = InferSchemaType<typeof schema>;
+ *
+ * const onSubmit = (data: FormData) => {
+ *   // data is fully typed based on configuration
+ * };
+ * ```
+ */
+type InferSchemaType<T extends GeneratedSchema> = z.infer<T>;
+/**
+ * Extract field paths from a generated schema.
+ * Returns all top-level and nested paths.
+ *
+ * @param schema - Generated Zod schema
+ * @param prefix - Current path prefix (used in recursion)
+ * @returns Array of all field paths
+ */
+declare const getSchemaFieldPaths: (schema: ZodObject<Record<string, ZodTypeAny>>, prefix?: string) => string[];
+//#endregion
+//#region src/utils/calculateVisibility.d.ts
+/**
+ * Visibility state for all fields in the form.
+ * Maps field names to their visibility (true = visible).
+ */
+type VisibilityState = Record<string, boolean>;
+/**
+ * Calculate visibility state for all fields based on their visibility rules.
+ * Evaluates JSON Logic rules against current form data.
+ *
+ * @param elements - Array of form elements
+ * @param formData - Current form values
+ * @returns Visibility state for all fields
+ *
+ * @example
+ * ```typescript
+ * const elements = [
+ *   { type: 'text', name: 'reason', visible: { "==": [{ "var": "type" }, "other"] } },
+ *   { type: 'text', name: 'name' }
+ * ];
+ *
+ * const visibility = calculateVisibility(elements, { type: 'other' });
+ * // Returns: { reason: true, name: true }
+ *
+ * const visibility2 = calculateVisibility(elements, { type: 'standard' });
+ * // Returns: { reason: false, name: true }
+ * ```
+ */
+declare const calculateVisibility: (elements: FormElement[], formData: Record<string, unknown>) => VisibilityState;
+//#endregion
+//#region src/utils/flattenFields.d.ts
+/**
+ * Recursively extracts all field elements from a form configuration.
+ * Traverses containers and columns to find nested fields.
+ *
+ * @param elements - Array of form elements (may include containers/columns)
+ * @returns Flat array of all field elements
+ *
+ * @example
+ * ```typescript
+ * const config = {
+ *   elements: [
+ *     { type: 'text', name: 'name' },
+ *     {
+ *       type: 'container',
+ *       columns: [{
+ *         type: 'column',
+ *         width: '50%',
+ *         elements: [{ type: 'email', name: 'email' }]
+ *       }]
+ *     }
+ *   ]
+ * };
+ *
+ * const fields = flattenFields(config.elements);
+ * // Returns: [{ type: 'text', name: 'name' }, { type: 'email', name: 'email' }]
+ * ```
+ */
+declare const flattenFields: (elements: FormElement[]) => FieldElement[];
+/**
+ * Gets all field names from a form configuration.
+ * Useful for initializing form state or visibility tracking.
+ *
+ * @param elements - Array of form elements
+ * @returns Array of field names (including nested paths like 'source.name')
+ */
+declare const getFieldNames: (elements: FormElement[]) => string[];
+//#endregion
+//#region src/utils/mergeDefaults.d.ts
+/**
+ * Sets a value in a nested object using dot notation path.
+ *
+ * @param obj - Object to modify
+ * @param path - Dot-notation path (e.g., 'source.name')
+ * @param value - Value to set
+ *
+ * @example
+ * ```typescript
+ * const obj = {};
+ * setNestedValue(obj, 'source.name', 'John');
+ * // obj is now { source: { name: 'John' } }
+ * ```
+ */
+declare const setNestedValue: (obj: Record<string, unknown>, path: string, value: unknown) => void;
+/**
+ * Gets a value from a nested object using dot notation path.
+ *
+ * @param obj - Object to read from
+ * @param path - Dot-notation path (e.g., 'source.name')
+ * @returns The value at the path, or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const obj = { source: { name: 'John' } };
+ * getNestedValue(obj, 'source.name'); // 'John'
+ * getNestedValue(obj, 'source.email'); // undefined
+ * ```
+ */
+declare const getNestedValue: (obj: Record<string, unknown>, path: string) => unknown;
+/**
+ * Merges configuration default values with initial data.
+ * Priority: initialData > config.defaultValue > type default
+ *
+ * @param config - Form configuration containing field definitions
+ * @param initialData - Initial data provided by the user
+ * @returns Merged default values for react-hook-form
+ *
+ * @example
+ * ```typescript
+ * const config = {
+ *   elements: [
+ *     { type: 'text', name: 'source.name', defaultValue: 'Default Name' },
+ *     { type: 'boolean', name: 'source.active' }
+ *   ]
+ * };
+ *
+ * const initialData = { source: { name: 'Provided Name' } };
+ * const defaults = mergeDefaults(config, initialData);
+ * // Result: { source: { name: 'Provided Name', active: false } }
+ * ```
+ */
+declare const mergeDefaults: (config: FormConfiguration, initialData?: FormData) => FormData;
+//#endregion
+//#region src/validation/jsonLogic.d.ts
+/**
+ * Evaluate a JSON Logic rule against form data.
+ *
+ * @param rule - JSON Logic rule to evaluate
+ * @param data - Form data to evaluate against
+ * @returns Result of the evaluation
+ *
+ * @example
+ * ```typescript
+ * const rule = { "==": [{ var: "status" }, "active"] };
+ * const data = { status: "active" };
+ * applyJsonLogic(rule, data); // true
+ * ```
+ */
+declare const applyJsonLogic: (rule: JsonLogicRule, data: Record<string, unknown>) => unknown;
+/**
+ * Evaluate a JSON Logic rule and return boolean result.
+ * Returns true if rule evaluates to a truthy value.
+ *
+ * @param rule - JSON Logic condition
+ * @param data - Form data
+ * @returns true if condition passes, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const rule = { "and": [{ var: "active" }, { var: "confirmed" }] };
+ * evaluateCondition(rule, { active: true, confirmed: true }); // true
+ * evaluateCondition(rule, { active: true, confirmed: false }); // false
+ * ```
+ */
+declare const evaluateCondition: (rule: JsonLogicRule, data: Record<string, unknown>) => boolean;
+//#endregion
+export { type ApiOptionsSource, type ArrayFieldComponent, type ArrayFieldElement, type ArrayFieldProps, type BaseFieldProps, type BooleanFieldComponent, type BooleanFieldElement, type BooleanFieldProps, type ColumnComponent, type ColumnElement, type ColumnProps, ConfigurationError, type ContainerComponent, type ContainerElement, type ContainerProps, type CustomComponentDefinition, type CustomComponentRegistry, type CustomComponentRenderProps, type CustomContainerRegistry, type CustomFieldComponent, type CustomFieldElement, type CustomFieldProps, type DateFieldComponent, type DateFieldElement, type DateFieldProps, DynamicForm, DynamicForm as default, DynamicFormContext, type DynamicFormContextValue, type DynamicFormProps, type DynamicFormRef, type ElementType, type EmailFieldComponent, type EmailFieldElement, type EmailFieldProps, type FieldComponentRegistry, type FieldElement, type FieldProps, type FieldType, type FieldWrapperFunction, type FieldWrapperProps, type FormConfiguration, type FormData, type FormElement, type GeneratedSchema, type InferSchemaType, type InvisibleFieldValidation, type JsonLogicRule, type LayoutElement, type MapOptionsSource, type OnChangeHandler, type OnErrorHandler, type OnResetHandler, type OnSubmitHandler, type OnValidationChangeHandler, type OptionsSource, type ParseResult, type PhoneFieldComponent, type PhoneFieldElement, type PhoneFieldProps, type ResolverOptionsSource, type SearchOptionsSource, type SelectFieldComponent, type SelectFieldElement, type SelectFieldProps, type SelectOption, type StaticOptionsSource, type TextFieldComponent, type TextFieldElement, type TextFieldProps, type ValidationConfig, type VisibilityAwareResolverOptions, type VisibilityState, applyJsonLogic, buildFieldSchema, calculateVisibility, createVisibilityAwareResolver, defineCustomComponent, evaluateCondition, flattenFields, generateZodSchema, getFieldNames, getNestedValue, getSchemaFieldPaths, isArrayFieldElement, isColumnElement, isContainerElement, isCustomFieldElement, isFieldElement, mergeDefaults, parseConfiguration, safeParseConfiguration, setNestedValue, useDynamicFormContext, useDynamicFormContextSafe };