import { ClassValue } from "clsx";
import { Control, FieldError, FieldValues, Path, RegisterOptions } from "react-hook-form";
import { ReactNode } from "react";

//#region src/utils.d.ts
/**
 * Utility function to merge CSS classes with Tailwind CSS conflict resolution.
 *
 * Combines `clsx` for conditional class handling with `tailwind-merge`
 * for proper Tailwind CSS class conflict resolution.
 *
 * @param inputs - Class values to merge (strings, arrays, objects, or conditionals)
 * @returns Merged and deduplicated class string
 *
 * @example
 * ```tsx
 * // Basic usage
 * cn("px-2 py-1", "px-4") // "py-1 px-4"
 *
 * // Conditional classes
 * cn("base", isActive && "active", { "disabled": isDisabled })
 *
 * // Arrays
 * cn(["flex", "items-center"], "gap-2")
 * ```
 */
declare function cn(...inputs: ClassValue[]): string;
//#endregion
//#region src/types.d.ts
/**
 * Field type identifier.
 * Can be built-in types or custom string identifiers.
 */
type FieldType = "text" | "email" | "password" | "number" | "tel" | "phone" | "url" | "textarea" | "slug" | "select" | "combobox" | "multiselect" | "dependentSelect" | "checkbox" | "radio" | "switch" | "date" | "time" | "datetime" | "rich-text" | "color" | "rating" | "tags" | "json" | "file" | "hidden" | "group" | "array" | "custom" | (string & {});
/**
 * Layout type identifier.
 */
type LayoutType = "section" | "grid" | "default" | (string & {});
/**
 * Variant identifier for component styling.
 */
type Variant = "default" | "compact" | "inline" | (string & {}) | undefined;
interface ConditionRule<TFieldValues extends FieldValues = FieldValues> {
  watch: Path<TFieldValues>;
  operator: "===" | "!==" | "in" | "not-in" | "truthy" | "falsy";
  value?: unknown;
}
/**
 * Condition configuration with explicit logic operator.
 * Allows combining rules with AND or OR logic.
 *
 * @example
 * ```ts
 * // Show field if country is "US" OR "CA"
 * condition: {
 *   rules: [
 *     { watch: "country", operator: "===", value: "US" },
 *     { watch: "country", operator: "===", value: "CA" },
 *   ],
 *   logic: "or",
 * }
 * ```
 */
interface ConditionConfig<TFieldValues extends FieldValues = FieldValues> {
  /** Array of condition rules to evaluate */
  rules: ConditionRule<TFieldValues>[];
  /** Logic operator: "and" (all must match) or "or" (any must match). Defaults to "and". */
  logic?: "and" | "or";
}
/**
 * Single option for select/radio/checkbox fields.
 */
interface FieldOption<TValue = string> {
  /** Display label */
  label: string;
  /** Option value */
  value: TValue;
  /** Whether option is disabled */
  disabled?: boolean;
  /** Optional description */
  description?: string;
  /** Optional icon */
  icon?: ReactNode;
}
/**
 * Option group for select fields.
 */
interface FieldOptionGroup<TValue = string> {
  /** Group label */
  label: string;
  /** Group options */
  options: FieldOption<TValue>[];
  /** Whether group is disabled */
  disabled?: boolean;
}
/**
 * Object form for length/range validation rules with a custom message.
 */
interface ValidationRuleObject<TValue = number> {
  value: TValue;
  message: string;
}
/**
 * Object form for pattern validation with a custom message.
 */
interface PatternRuleObject {
  /** Regex string (will be compiled with `new RegExp(regex)`) */
  regex: string;
  /** Custom error message */
  message: string;
}
/**
 * AI-friendly metadata attached to any field.
 * Consumed by LLM coding assistants, documentation generators, and
 * schema-introspection tools — never by the form renderer itself.
 */
interface FieldMeta {
  /** Human-readable description of what this field collects */
  description?: string;
  /** Representative example value (for documentation / AI context) */
  example?: unknown;
  /** Logical category for grouping fields in documentation or tooling */
  category?: string;
  /** Arbitrary tags for filtering, search, or feature-flagging */
  tags?: string[];
  /** Whether this field is considered PII */
  pii?: boolean;
  /** Arbitrary extension point — anything extra you want to carry */
  [key: string]: unknown;
}
/**
 * Base field configuration shared by all field types.
 * @template TFieldValues - Form field values type for type-safe field names
 */
interface BaseField<TFieldValues extends FieldValues = FieldValues> {
  /**
   * Field name — a path into TFieldValues (e.g. `"email"`, `"address.street"`).
   *
   * Accepts any string so that:
   * - Namespaced sections can use relative names (`"street"` → prefixed to `"address.street"`)
   * - Group/array `itemFields` can use relative names (`"email"` → prefixed at render time)
   *
   * Use `field.for<T>()` builder for call-site enforcement that names are valid paths.
   */
  name: Path<TFieldValues> | (string & {});
  /** Field type identifier */
  type: FieldType;
  /** Field label */
  label?: string;
  /** Placeholder text */
  placeholder?: string;
  /** Helper text shown below the field */
  helperText?: string;
  /** Whether field is disabled */
  disabled?: boolean;
  /** Whether field is required */
  required?: boolean;
  /** Whether field is read-only */
  readOnly?: boolean;
  /** Field variant */
  variant?: Variant;
  /** Whether field should span full width in grid */
  fullWidth?: boolean;
  /** Custom CSS class name */
  className?: string;
  /**
   * Conditional rendering function, declarative rules, or a condition config with logic.
   * Return true to show the field, false to hide.
   */
  condition?: ((formValues: Partial<TFieldValues>) => boolean) | ConditionRule<TFieldValues> | ConditionRule<TFieldValues>[] | ConditionConfig<TFieldValues>;
  /** Default value */
  defaultValue?: unknown;
  /** Options for select/radio/checkbox fields */
  options?: (FieldOption | FieldOptionGroup)[];
  /**
   * Minimum value (for number/date fields).
   * Pass an object `{ value, message }` to provide a custom error message.
   */
  min?: number | string | ValidationRuleObject<number | string>;
  /**
   * Maximum value (for number/date fields).
   * Pass an object `{ value, message }` to provide a custom error message.
   */
  max?: number | string | ValidationRuleObject<number | string>;
  /** Step value (for number fields) */
  step?: number;
  /**
   * Pattern for validation.
   * Pass a regex string or `{ regex, message }` for a custom error message.
   *
   * @example
   * ```ts
   * // simple
   * pattern: "^[a-z]+$"
   * // with custom message
   * pattern: { regex: "^[a-z]+$", message: "Only lowercase letters allowed" }
   * ```
   */
  pattern?: string | PatternRuleObject;
  /**
   * Minimum length.
   * Pass an object `{ value, message }` to provide a custom error message.
   */
  minLength?: number | ValidationRuleObject<number>;
  /**
   * Maximum length.
   * Pass an object `{ value, message }` to provide a custom error message.
   */
  maxLength?: number | ValidationRuleObject<number>;
  /** Number of rows (for textarea) */
  rows?: number;
  /** Multiple selection (for select/file) */
  multiple?: boolean;
  /** Accepted file types (for file input) */
  accept?: string;
  /** Auto-complete attribute */
  autoComplete?: string;
  /** Auto-focus on mount */
  autoFocus?: boolean;
  /** Debounce loadOptions requests in milliseconds, helps prevent API storms */
  debounceMs?: number;
  /**
   * Dynamic options loaded based on current form values.
   * Useful for dependent selects (e.g., state depends on country).
   */
  loadOptions?: (formValues: Partial<TFieldValues>) => Promise<(FieldOption | FieldOptionGroup)[]> | (FieldOption | FieldOptionGroup)[];
  /**
   * Error callback for loadOptions failures.
   * Called when loadOptions rejects. Defaults to console.error.
   */
  onLoadError?: (error: unknown) => void;
  /**
   * Sub-fields for `group` and `array` field types.
   *
   * These fields use **relative** names (`"street"`, `"email"`) — FormGenerator
   * prefixes them with the parent field name at render time (`"address.street"`).
   * They are intentionally untyped to TFieldValues for this reason.
   */
  itemFields?: BaseField[];
  /**
   * Custom render function to override the component registry for this specific field.
   * Completely bypasses the globally registered FieldComponent for this type.
   */
  render?: (props: FieldComponentProps<TFieldValues>) => ReactNode;
  /**
   * Cross-field validation function.
   * Receives the field value and all form values for cross-field checks.
   * Return `true` for valid, a string error message for invalid, or a Promise of either
   * for async validation (e.g., checking server-side uniqueness).
   *
   * @example
   * ```ts
   * validate: (value, formValues) =>
   *   value > formValues.minPrice || "Must be greater than min price"
   *
   * // Async example
   * validate: async (value) => {
   *   const taken = await checkUsernameAvailability(value as string);
   *   return taken ? "Username already taken" : true;
   * }
   * ```
   */
  validate?: (value: unknown, formValues: Partial<TFieldValues>) => string | true | Promise<string | true>;
  /**
   * Dependencies for optimizing conditionally rendered fields.
   * Allows specifying specific field names to watch, preventing full form re-renders.
   */
  watchNames?: Path<TFieldValues> | Path<TFieldValues>[];
  /** Additional field-specific props for custom components */
  customProps?: Record<string, unknown>;
  /**
   * AI / agent-friendly metadata for this field.
   *
   * Provides hints that help LLM coding assistants generate correct field
   * configs without needing to inspect the schema at runtime.
   *
   * @example
   * ```ts
   * field.text("companyName", "Company", {
   *   meta: {
   *     description: "Legal entity name of the organization",
   *     example: "Acme Corp",
   *     category: "identity",
   *     tags: ["crm", "required-for-billing"],
   *   }
   * })
   * ```
   */
  meta?: FieldMeta;
  /**
   * Escape hatch for adapter-specific or custom props.
   * Allows passing arbitrary props directly on the field object so they
   * flow through the adapter spread (`{...field}`) without needing `customProps`.
   * Intentionally broad to support diverse UI component libraries.
   */
  [key: string]: unknown;
}
/**
 * Props passed to field components.
 *
 * Components receive both:
 * 1. A `field` object with the complete field configuration
 * 2. All field properties spread at the top level
 *
 * @template TFieldValues - Form field values type
 *
 * @example
 * ```tsx
 * // Schema
 * { name: "email", type: "email", label: "Email", placeholder: "user@example.com" }
 *
 * // Your component receives:
 * {
 *   field: { name: "email", type: "email", label: "Email", placeholder: "..." },
 *   control: {...},
 *   disabled: false,
 *   variant: undefined,
 *   // PLUS all field props at top level:
 *   name: "email",
 *   type: "email",
 *   label: "Email",
 *   placeholder: "user@example.com"
 * }
 * ```
 */
interface FieldComponentProps<TFieldValues extends FieldValues = FieldValues> extends BaseField<TFieldValues> {
  /** Field configuration object (contains all field props) */
  field: BaseField<TFieldValues>;
  /** React Hook Form control for Controller integration */
  control: Control<TFieldValues>;
  /** Whether field is globally disabled */
  disabled?: boolean;
  /** Component variant */
  variant?: Variant;
  /** Field validation error from react-hook-form */
  error?: FieldError;
  /** Field state from react-hook-form */
  fieldState?: {
    invalid: boolean;
    isDirty: boolean;
    isTouched: boolean;
    isValidating: boolean; /** True after the enclosing form's submit handler has been called at least once. */
    isSubmitted: boolean;
    error?: FieldError;
  };
  /**
   * Generated field ID for label-input association (e.g. `formkit-field-email`).
   * Use as `id` on the input element and `htmlFor` on the `<label>`.
   */
  fieldId: string;
  /**
   * Generated error container ID for ARIA association (e.g. `formkit-field-email-error`).
   * Use as `id` on the error message element and as the value for `aria-errormessage`
   * (preferred) or `aria-describedby` (broader support) on the input.
   *
   * @example
   * ```tsx
   * <input
   *   id={fieldId}
   *   aria-invalid={shouldShowError || undefined}
   *   aria-errormessage={shouldShowError ? errorId : undefined}
   * />
   * <p id={errorId} role="alert" aria-live="polite">
   *   {shouldShowError ? error?.message : null}
   * </p>
   * ```
   */
  errorId: string;
  /**
   * Whether to display the field error right now.
   *
   * Aligns with the CSS `:user-invalid` timing model: `true` only after the
   * user has interacted with the field (blur) **or** the form has been
   * submitted. This prevents premature "required" errors on untouched fields.
   *
   * Use this — not `!!error` — to drive `aria-invalid`, error message
   * visibility, and destructive ring/border styles.
   *
   * @example
   * ```tsx
   * <input aria-invalid={shouldShowError || undefined} />
   * {shouldShowError && <p id={errorId} role="alert">{error?.message}</p>}
   * ```
   */
  shouldShowError: boolean;
  /** Whether dynamic options are currently loading */
  isLoading?: boolean;
  /**
   * Pre-computed react-hook-form validation rules for this field.
   * Equivalent to calling `buildValidationRules(field)` — provided here so
   * adapter components can pass `rules={rules}` directly to `<Controller>`
   * without importing or calling `buildValidationRules` themselves.
   *
   * @example
   * ```tsx
   * function TextInput({ field, control, rules }: FieldComponentProps) {
   *   return (
   *     <Controller name={field.name} control={control} rules={rules} render={...} />
   *   );
   * }
   * ```
   */
  rules: ValidationRules;
}
/**
 * Validation rules compatible with react-hook-form's RegisterOptions.
 * Returned by `buildValidationRules()`.
 */
type ValidationRules = Pick<RegisterOptions, "required" | "min" | "max" | "minLength" | "maxLength" | "pattern" | "validate">;
/**
 * Section configuration for grouping fields.
 * @template TFieldValues - Form field values type
 */
interface Section<TFieldValues extends FieldValues = FieldValues> {
  /** Unique section identifier */
  id?: string;
  /** Section title */
  title?: string;
  /** Section description */
  description?: string;
  /** Section icon */
  icon?: ReactNode;
  /** Namespace to prepend to all field names in this section */
  nameSpace?: string;
  /** Fields in this section */
  fields?: BaseField<TFieldValues>[];
  /** Number of columns in grid layout */
  cols?: 1 | 2 | 3 | 4 | 5 | 6 | number;
  /** Gap between grid items (Tailwind spacing scale) */
  gap?: number;
  /**
   * Custom render function for complete control.
   * When provided, fields array is ignored.
   */
  render?: (props: SectionRenderProps<TFieldValues>) => ReactNode;
  /** Section variant */
  variant?: Variant;
  /** Custom CSS class name */
  className?: string;
  /**
   * Conditional rendering function, declarative rules, or a condition config with logic.
   * Return true to show the section, false to hide.
   */
  condition?: ((formValues?: Partial<TFieldValues>) => boolean) | ConditionRule<TFieldValues> | ConditionRule<TFieldValues>[] | ConditionConfig<TFieldValues>;
  /** Whether section is collapsible */
  collapsible?: boolean;
  /** Default collapsed state */
  defaultCollapsed?: boolean;
  /**
   * Defer rendering of this section until it scrolls near the viewport.
   * Applies `content-visibility: auto` + `contain-intrinsic-size` to the
   * section container, skipping layout/paint work while off-screen.
   *
   * **Only use for sections that are below the initial fold.** Applying this
   * to above-fold sections has no benefit and slightly increases overhead.
   *
   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/content-visibility
   */
  deferRender?: boolean;
}
/**
 * Props passed to section render function.
 */
interface SectionRenderProps<TFieldValues extends FieldValues = FieldValues> {
  control?: Control<TFieldValues>;
  disabled?: boolean;
  section: Section<TFieldValues>;
}
/**
 * Section layout component props.
 */
interface SectionLayoutProps {
  /** Section title */
  title?: string;
  /** Section description */
  description?: string;
  /** Section icon */
  icon?: ReactNode;
  /** Layout variant */
  variant?: Variant;
  /** Custom CSS class name */
  className?: string;
  /** Whether section is collapsible */
  collapsible?: boolean;
  /** Default collapsed state */
  defaultCollapsed?: boolean;
  /**
   * When true the section is below the initial fold and should defer
   * browser layout/paint work until it nears the viewport.
   * Layout components may apply `content-visibility: auto` here.
   */
  deferRender?: boolean;
  /** Children content */
  children: ReactNode;
}
/**
 * Grid layout component props.
 */
interface GridLayoutProps {
  /** Number of columns */
  cols?: number;
  /** Gap between items */
  gap?: number;
  /** Custom CSS class name */
  className?: string;
  /** Children content */
  children: ReactNode;
}
/**
 * Default layout component props.
 */
interface DefaultLayoutProps {
  /** Custom CSS class name */
  className?: string;
  /** Children content */
  children: ReactNode;
}
/**
 * Union of all layout component props.
 */
type LayoutComponentProps = SectionLayoutProps | GridLayoutProps | DefaultLayoutProps;
/**
 * Complete form schema configuration.
 * @template TFieldValues - Form field values type for type-safe schemas
 */
interface FormSchema<TFieldValues extends FieldValues = FieldValues> {
  /** Optional schema identifier — useful for serialization, analytics, and AI context */
  id?: string;
  /** Human-readable form title (AI / documentation use) */
  title?: string;
  /** Human-readable description of the form's purpose */
  description?: string;
  /** Form sections */
  sections: Section<TFieldValues>[];
}
/**
 * Extract field names from a schema.
 */
type SchemaFieldNames<TSchema extends FormSchema> = TSchema extends FormSchema<infer T> ? keyof T : never;
/**
 * Infer field values type from a schema.
 */
type InferSchemaValues<TSchema extends FormSchema> = TSchema extends FormSchema<infer T> ? T : FieldValues;
/**
 * Helper type for creating type-safe field definitions.
 */
type DefineField<TFieldValues extends FieldValues, TType extends FieldType = FieldType> = BaseField<TFieldValues> & {
  type: TType;
};
//#endregion
//#region src/schema.d.ts
/**
 * All supported condition shapes.
 */
type Condition<TFieldValues extends FieldValues = FieldValues> = ((formValues: Partial<TFieldValues>) => boolean) | ConditionRule<TFieldValues> | ConditionRule<TFieldValues>[] | ConditionConfig<TFieldValues> | undefined;
/**
 * Evaluates a conditional rule, array of rules, or a ConditionConfig against form values.
 * Supports AND (default) and OR logic via ConditionConfig.
 *
 * @param condition - The condition function, rule(s), or config
 * @param formValues - The form values to evaluate against
 * @returns boolean indicating if condition matches
 */
declare function evaluateCondition<TFieldValues extends FieldValues = FieldValues>(condition: Condition<TFieldValues>, formValues: Partial<TFieldValues>): boolean;
/**
 * Extracts all watch names from a condition to optimize `useWatch`.
 * Handles single rules, arrays, and ConditionConfig objects.
 */
declare function extractWatchNames<TFieldValues extends FieldValues = FieldValues>(condition: Condition<TFieldValues>): string[];
/**
 * Strictly types a comprehensive form schema, granting exact intellisense bounds across conditions and nested watches.
 */
declare function defineSchema<TFieldValues extends FieldValues = FieldValues>(schema: FormSchema<TFieldValues>): FormSchema<TFieldValues>;
/**
 * Standard utility to strictly type a standalone field out-of-bounds, useful for externalizing massive schema structures.
 */
declare function defineField<TFieldValues extends FieldValues = FieldValues>(field: BaseField<TFieldValues>): BaseField<TFieldValues>;
/**
 * Standard utility to strictly type a standalone logic section layout block.
 */
declare function defineSection<TFieldValues extends FieldValues = FieldValues>(section: Section<TFieldValues>): Section<TFieldValues>;
/**
 * Extracts default values from a form schema.
 * Walks all sections and fields, respecting nameSpace prefixes and group nesting.
 * Array fields default to `[]` when no explicit `defaultValue` is provided.
 *
 * @example
 * ```ts
 * const defaults = extractDefaultValues(schema);
 * const form = useForm({ defaultValues: defaults });
 * ```
 */
declare function extractDefaultValues<TFieldValues extends FieldValues = FieldValues>(schema: FormSchema<TFieldValues>): Partial<TFieldValues>;
/**
 * Generates react-hook-form `RegisterOptions`-compatible validation rules
 * from a field's schema props. Maps `required`, `min`, `max`, `minLength`,
 * `maxLength`, `pattern`, and `validate` to RHF rules.
 *
 * Supports both shorthand scalars and `{ value, message }` objects for all
 * numeric/length rules, and `{ regex, message }` for pattern.
 *
 * @example
 * ```tsx
 * import { buildValidationRules } from '@classytic/formkit';
 *
 * function FormInput({ field, control }: FieldComponentProps) {
 *   const rules = buildValidationRules(field);
 *   return <Controller name={field.name} control={control} rules={rules} render={...} />;
 * }
 * ```
 */
declare function buildValidationRules<TFieldValues extends FieldValues = FieldValues>(field: BaseField<TFieldValues>): ValidationRules;
/** Returns true for fields that carry an `options` array (select, radio, etc.) */
declare function isChoiceField(field: BaseField): boolean;
/** Returns true for free-text input fields */
declare function isTextField(field: BaseField): boolean;
/** Returns true for numeric input fields */
declare function isNumericField(field: BaseField): boolean;
/** Returns true for date / time fields */
declare function isDateField(field: BaseField): boolean;
/** Returns true for structural fields that contain sub-fields (`itemFields`) */
declare function isContainerField(field: BaseField): boolean;
/** Returns true for array fields that render a repeatable list */
declare function isArrayField(field: BaseField): boolean;
/** Returns true for fields that load options asynchronously */
declare function isDynamicField(field: BaseField): boolean;
/** Returns true for fields with conditional rendering */
declare function isConditionalField(field: BaseField): boolean;
/**
 * Merge two or more schemas into one, concatenating their sections.
 *
 * @example
 * ```ts
 * const full = mergeSchemas(personalSchema, addressSchema, billingSchema);
 * ```
 */
declare function mergeSchemas<TFieldValues extends FieldValues = FieldValues>(...schemas: FormSchema<TFieldValues>[]): FormSchema<TFieldValues>;
/**
 * Add fields to a section identified by `sectionId`.
 * Returns a new schema — the original is not mutated.
 *
 * @example
 * ```ts
 * const extended = extendSection(schema, "personal", [
 *   field.text("middleName", "Middle Name"),
 * ]);
 * ```
 */
declare function extendSection<TFieldValues extends FieldValues = FieldValues>(schema: FormSchema<TFieldValues>, sectionId: string, fields: BaseField<TFieldValues>[], position?: "start" | "end"): FormSchema<TFieldValues>;
/**
 * Create a new schema that includes only the named fields.
 *
 * @example
 * ```ts
 * const slim = pickFields(schema, ["email", "password"]);
 * ```
 */
declare function pickFields<TFieldValues extends FieldValues = FieldValues>(schema: FormSchema<TFieldValues>, names: string[]): FormSchema<TFieldValues>;
/**
 * Create a new schema that excludes the named fields.
 *
 * @example
 * ```ts
 * const withoutInternal = omitFields(schema, ["__id", "__createdAt"]);
 * ```
 */
declare function omitFields<TFieldValues extends FieldValues = FieldValues>(schema: FormSchema<TFieldValues>, names: string[]): FormSchema<TFieldValues>;
/**
 * Collect every field from every section into a flat array.
 * Useful for validation, documentation, and AI schema introspection.
 *
 * @example
 * ```ts
 * const allFields = flattenSchema(schema);
 * const required = allFields.filter(f => f.required);
 * ```
 */
declare function flattenSchema<TFieldValues extends FieldValues = FieldValues>(schema: FormSchema<TFieldValues>): BaseField<TFieldValues>[];
//#endregion
//#region src/builders.d.ts
/**
 * Additional field props accepted by builder helpers.
 * Accepts all BaseField properties except `name`, `type`, and `label`
 * which are provided by the builder method directly.
 */
type FieldProps<TFieldValues extends FieldValues = FieldValues> = Omit<BaseField<TFieldValues>, "name" | "type" | "label">;
/**
 * Section configuration props.
 */
interface SectionProps<TFieldValues extends FieldValues = FieldValues> extends Omit<Section<TFieldValues>, "id" | "title" | "fields" | "cols"> {
  cols?: number;
}
/**
 * Type-safe field builder helpers for schema-driven forms.
 *
 * All methods are generic over TFieldValues, defaulting to FieldValues (any string)
 * when no type argument is provided. Specify the generic to enforce that field
 * names are valid paths in your form values type.
 *
 * For fully-typed schemas where every field name is checked, prefer
 * `field.for<MyForm>()` which fixes the generic once for the whole schema:
 *
 * @example
 * ```ts
 * // Untyped — any string accepted (backwards compatible)
 * field.text("email", "Email")
 *
 * // Per-call generic — name is checked against MyForm
 * field.text<MyForm>("email", "Email")
 *
 * // Typed factory — name checked on every call without repeating the generic
 * const f = field.for<MyForm>()
 * f.text("email", "Email")        // ✓
 * f.text("typo", "Email")         // ✗ TypeScript error
 * ```
 */
declare const field: {
  /** Text input field. */text: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>; /** Email input field with default placeholder. */
  email: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>; /** URL input field with default placeholder. */
  url: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>; /** Phone/tel input field with default placeholder. */
  tel: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>; /** Password input field. */
  password: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>; /** Number input field with min: 0 default (overrideable via props). */
  number: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>; /** Textarea field with default 3 rows. */
  textarea: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>; /** Select dropdown field. */
  select: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, options: (FieldOption | FieldOptionGroup)[], props?: FieldProps<T>) => BaseField<T>; /** Searchable combobox field. */
  combobox: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, options: (FieldOption | FieldOptionGroup)[], props?: FieldProps<T>) => BaseField<T>; /** Multi-select field. */
  multiselect: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, options: (FieldOption | FieldOptionGroup)[], props?: FieldProps<T>) => BaseField<T>; /** Dependent select field that reacts to parent field changes. */
  dependentSelect: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>; /** Switch/toggle field. */
  switch: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>; /** Boolean field (alias for switch). */
  boolean: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>; /** Checkbox field. */
  checkbox: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>; /** Radio button group field. */
  radio: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, options: FieldOption[], props?: FieldProps<T>) => BaseField<T>; /** Date picker field. */
  date: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>; /** Tag input field. */
  tags: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>; /** Slug field. */
  slug: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>; /** File upload field. */
  file: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>; /** Hidden field (no UI). */
  hidden: <T extends FieldValues = FieldValues>(name: Path<T>, props?: FieldProps<T>) => BaseField<T>;
  /**
   * Group field for nested objects.
   * Renders itemFields as a sub-grid. Child names are relative (e.g. "street"),
   * FormGenerator prefixes them with the group name at render time.
   *
   * @example
   * ```ts
   * field.group("address", "Address", [
   *   field.text("street", "Street"),
   *   field.text("city", "City"),
   * ], { cols: 2 })
   * ```
   */
  group: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, itemFields: BaseField[], props?: FieldProps<T>) => BaseField<T>;
  /**
   * Array/repeatable field backed by react-hook-form's useFieldArray.
   *
   * @example
   * ```ts
   * field.array("contacts", "Contacts", [
   *   field.text("name", "Name"),
   *   field.email("email", "Email"),
   * ])
   * ```
   */
  array: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, itemFields: BaseField[], props?: FieldProps<T>) => BaseField<T>;
  /**
   * Custom field with a render function.
   * Bypasses the component registry — full control over rendering.
   *
   * The render callback receives the complete `FieldComponentProps` including
   * `fieldId`, `errorId`, `shouldShowError`, `error`, `rules`, and `control`.
   *
   * Use `shouldShowError` (not `!!error`) to drive `aria-invalid` and error
   * visibility so timing mirrors the CSS `:user-invalid` pseudo-class.
   *
   * @example
   * ```tsx
   * field.custom("skills", "Skills", ({ control, shouldShowError, errorId, error, fieldId }) => (
   *   <div>
   *     <SkillSelector
   *       id={fieldId}
   *       control={control}
   *       aria-invalid={shouldShowError || undefined}
   *       aria-errormessage={shouldShowError ? errorId : undefined}
   *     />
   *     {shouldShowError && (
   *       <p id={errorId} role="alert" className="text-sm text-destructive">
   *         {error?.message}
   *       </p>
   *     )}
   *   </div>
   * ))
   * ```
   */
  custom: <T extends FieldValues = FieldValues>(name: Path<T>, label: string, render: (props: FieldComponentProps<T>) => ReactNode, props?: FieldProps<T>) => BaseField<T>;
  /**
   * Returns a typed field builder with `TFieldValues` fixed.
   * Every field name is validated against `Path<TFieldValues>` at the call site —
   * no need to repeat the generic on each individual builder call.
   *
   * @example
   * ```ts
   * interface ContactForm {
   *   firstName: string;
   *   email: string;
   *   address: { street: string; city: string };
   * }
   *
   * const f = field.for<ContactForm>()
   *
   * const schema = defineSchema<ContactForm>({
   *   sections: [{
   *     fields: [
   *       f.text("firstName", "First Name"),     // ✓
   *       f.email("email", "Email"),              // ✓
   *       f.text("typo", "Label"),                // ✗ TypeScript error
   *     ],
   *   }],
   * })
   * ```
   */
  for: <T extends FieldValues>() => {
    text: (name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>;
    email: (name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>;
    url: (name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>;
    tel: (name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>;
    password: (name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>;
    number: (name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>;
    textarea: (name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>;
    select: (name: Path<T>, label: string, options: (FieldOption | FieldOptionGroup)[], props?: FieldProps<T>) => BaseField<T>;
    combobox: (name: Path<T>, label: string, options: (FieldOption | FieldOptionGroup)[], props?: FieldProps<T>) => BaseField<T>;
    multiselect: (name: Path<T>, label: string, options: (FieldOption | FieldOptionGroup)[], props?: FieldProps<T>) => BaseField<T>;
    dependentSelect: (name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>;
    switch: (name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>;
    boolean: (name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>;
    checkbox: (name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>;
    radio: (name: Path<T>, label: string, options: FieldOption[], props?: FieldProps<T>) => BaseField<T>;
    date: (name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>;
    tags: (name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>;
    slug: (name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>;
    file: (name: Path<T>, label: string, props?: FieldProps<T>) => BaseField<T>;
    hidden: (name: Path<T>, props?: FieldProps<T>) => BaseField<T>;
    group: (name: Path<T>, label: string, itemFields: BaseField[], props?: FieldProps<T>) => BaseField<T>;
    array: (name: Path<T>, label: string, itemFields: BaseField[], props?: FieldProps<T>) => BaseField<T>;
    custom: (name: Path<T>, label: string, render: (props: FieldComponentProps<T>) => ReactNode, builderProps?: FieldProps<T>) => BaseField<T>;
  };
};
/**
 * Create a section definition with sensible defaults.
 *
 * @example
 * ```ts
 * section("personal", "Personal Info", [
 *   field.text("name", "Name", { required: true }),
 *   field.email("email", "Email"),
 * ], { cols: 2 })
 * ```
 */
declare function section<TFieldValues extends FieldValues = FieldValues>(id: string, title: string, fields: BaseField<TFieldValues>[], props?: SectionProps<TFieldValues>): Section<TFieldValues>;
/**
 * Create a section without a title (transparent section).
 * Useful for grouping fields without visual separation.
 *
 * Accepts `BaseField[]` (no generic) so mixed-type field arrays don't trigger
 * conflicting type inference across different field name generics.
 */
declare function sectionUntitled(fields: BaseField[], props?: Omit<SectionProps, "variant">): Section;
//#endregion
export { type BaseField, type ClassValue, type Condition, type ConditionConfig, type ConditionRule, type DefaultLayoutProps, type DefineField, type FieldMeta, type FieldOption, type FieldOptionGroup, type FieldType, type FormSchema, type GridLayoutProps, type InferSchemaValues, type LayoutComponentProps, type LayoutType, type PatternRuleObject, type SchemaFieldNames, type Section, type SectionLayoutProps, type SectionRenderProps, type ValidationRuleObject, type Variant, buildValidationRules, cn, defineField, defineSchema, defineSection, evaluateCondition, extendSection, extractDefaultValues, extractWatchNames, field, flattenSchema, isArrayField, isChoiceField, isConditionalField, isContainerField, isDateField, isDynamicField, isNumericField, isTextField, mergeSchemas, omitFields, pickFields, section, sectionUntitled };